/****************************************
* Fonction qui tente de propager un elem
* sur toute la diagonale
***************************************/
inline int Propager(int diag, int val)
{
/* Variables */
int lig, t;
/* On place val en haut de la diagonale */
SetValueAt(val, 1, diag);
/* Cas trivial */
if(diag == 1) return TRUE;
/* On essaie de propager sur la diagonale */
for(lig = 2; lig <= diag; lig++)
{
val = abs(ValueAt(lig-1, diag-1) - ValueAt(lig-1, diag));
if(Contains(val, lig, diag))
return FALSE;
else
{
/* On place l'element */
SetValueAt(val, lig, diag);
/* Maintien de la liste des places */
/*
t = Indice(lig, diag);
if(progres < t) progres = t+1;
*/
}
}
/* On a reussi a propager jusqu'en bas */
return TRUE;
}
/****************************************
* Renvoie TRUE si la diagonale diag est
* correcte jusqu'a la ligne lig
* (Pas utilisée dans la génération)
***************************************/
int DiagonaleCorrecte(int lig, int diag)
{
if(lig == 1) return TRUE; /* Condition d'arret */
if(ValueAt(lig, diag) != abs(ValueAt(lig-1, diag-1) - ValueAt(lig-1, diag)))
return FALSE;
return DiagonaleCorrecte(lig-1, diag);
}
void
SudokuField::_ComputeValidMask(uint32 x, uint32 y, bool setSolved)
{
if (ValueAt(x, y))
return;
// check row
uint32 foundMask = 0;
for (uint32 i = 0; i < fSize; i++) {
uint32 value = ValueAt(i, y);
if (value && _ValidValueAt(i, y))
foundMask |= 1UL << (value - 1);
}
// check column
for (uint32 i = 0; i < fSize; i++) {
uint32 value = ValueAt(x, i);
if (value && _ValidValueAt(x, i))
foundMask |= 1UL << (value - 1);
}
// check block
uint32 offsetX = x / fBlockSize * fBlockSize;
uint32 offsetY = y / fBlockSize * fBlockSize;
for (uint32 partY = 0; partY < fBlockSize; partY++) {
for (uint32 partX = 0; partX < fBlockSize; partX++) {
uint32 value = ValueAt(partX + offsetX, partY + offsetY);
if (value && _ValidValueAt(partX + offsetX, partY + offsetY))
foundMask |= 1UL << (value - 1);
}
}
SetValidMaskAt(x, y, ~foundMask);
if (setSolved) {
// find the one set bit, if not more
uint32 value = 0;
for (uint32 i = 0; i < fSize; i++) {
if ((foundMask & (1UL << i)) == 0) {
if (value != 0) {
value = 0;
break;
}
value = i + 1;
}
}
if (value != 0)
SetValueAt(x, y, value, true);
}
}
/****************************************
* Procedure d'affichage de la pyramide
***************************************/
void Display(void)
{
/* Variables */
int ligne, colonne, i, nb_blancs;
/* Affichage de la pyramide */
printf("Pyramide de hauteur %d\n", hauteur);
for(ligne = 1; ligne <= hauteur; ligne++)
{
for(colonne = ligne; colonne <= hauteur; colonne++)
{
printf("%d ", ValueAt(ligne, colonne));
}
printf("\n");
for(nb_blancs = 1; nb_blancs <= ligne; nb_blancs++, printf(" "));
}
/* Affichage de la liste des places */
printf("Liste des places : ");
for(i = 0; i < nb_elem; printf(" %d",place[i++]));
printf("\n");
/* Affichage du taux de remplissage */
printf("Taux de remplissage: %f %% (indice max: %d)\n", (progres*100.0/nb_elem), progres);
}
ECode SparseBooleanArray::ToString(
/* [out] */ String* str)
{
VALIDATE_NOT_NULL(str);
if (mSize <= 0) {
*str = "{}";
return NOERROR;
}
StringBuilder buffer(mSize * 28);
buffer.AppendChar('{');
for (Int32 i = 0; i < mSize; i++) {
if (i > 0) {
buffer.Append(", ");
}
Int32 key;
KeyAt(i, &key);
buffer.Append(key);
buffer.AppendChar('=');
Boolean value;
ValueAt(i, &value);
buffer.Append(value);
}
buffer.AppendChar('}');
*str = buffer.ToString();
return NOERROR;
}
virtual void validate(skiatest::Reporter* reporter) const {
Base::validate(reporter);
const int* data = reinterpret_cast<const int*>(Recorder::GetDataForItem(this));
for (int i = 0; i < fLength; ++i) {
REPORTER_ASSERT(reporter, ValueAt(i) == data[i]);
}
}
// Int64ValueAt
int64
DriverParameter::Int64ValueAt(int32 index, int64 noValue) const
{
const char* value = ValueAt(index, NULL);
if (!value)
return noValue;
return strtoll(value, NULL, 10);
}
// Int32ValueAt
int32
DriverParameter::Int32ValueAt(int32 index, int32 noValue) const
{
const char* value = ValueAt(index, NULL);
if (!value)
return noValue;
return atol(value);
}
string sparse_vector::AsString() const {
std::stringstream out_stream;
for (int i = 0; i < vectors_.size(); i++) {
// out_stream << FeatureAt()
out_stream << FeatureAt(i) << ":" << ValueAt(i) << " ";
}
return out_stream.str();
}
int NumberEntry::RangeValueAt(int index, int length)
{
int result;
for (result = 0; length != 0; length--, index++)
{
result *= 10;
result += ValueAt(index);
}
return result;
}
// BoolValueAt
bool
DriverParameter::BoolValueAt(int32 index, bool noValue) const
{
const char* value = ValueAt(index, NULL);
if (!value)
return noValue;
for (int32 i = 0; i < kTrueValueStringCount; i++) {
if (strcmp(value, kTrueValueStrings[i]) == 0)
return true;
}
return false;
}
bool
SudokuField::IsEmpty() const
{
for (uint32 y = 0; y < fSize; y++) {
for (uint32 x = 0; x < fSize; x++) {
if (ValueAt(x, y) != 0)
return false;
}
}
return true;
}
void
SudokuField::Dump()
{
for (uint32 y = 0; y < fSize; y++) {
for (uint32 x = 0; x < fSize; x++) {
if (x != 0 && x % fBlockSize == 0)
putchar(' ');
printf("%lu", ValueAt(x, y));
}
putchar('\n');
}
}
bool
SudokuField::IsValueCompleted(uint32 value) const
{
uint32 count = 0;
for (uint32 y = 0; y < fSize; y++) {
for (uint32 x = 0; x < fSize; x++) {
if (ValueAt(x, y) == value)
count++;
}
}
return count == Size();
}
/****************************************
* Procedure qui stocke une valeur
* dans la pyramide. Gere la liste des
* places
***************************************/
inline void SetValueAt(int val, int lig, int diag)
{
/* Variables */
int t,ind;
/* S'il y a deja un nombre a cette case, on le retire de la liste des pris */
t = ValueAt(lig, diag);
ind = Indice(lig, diag);
if((t != 0) && place[t-1] == ind)
place[t-1] = OUT_OF_PYR;
/* On place l'element dans la pyramide */
elements[ind] = val;
/* On le marque comme etant pris */
place[val-1] = ind;
/* Maintien de la liste des places */
if(progres < ind+1) progres = ind+1;
}
SubclassExtraData(int length) : fLength(length) {
int* data = reinterpret_cast<int*>(Recorder::GetDataForItem(this));
for (int i = 0; i < fLength; ++i) {
data[i] = ValueAt(i);
}
}
