/* Driver program to check above functions */ int main() { int arr[] = {1, 1, 0, 0, 0, 0, 0, 0}; int n = sizeof(arr)/sizeof(arr[0]); std::cout<< "Count of zeroes is "<<countOnes(arr, n)<<std::endl; return 0; }
static void test_countOnesInBitMask(void) { unsigned int i = 0; for (i = 0; i < 32; i++) { TEST_ASSERT_EQUAL_UINT32(i, countOnes(makeBitmask(i, 0))); } }
int main(void) { int n, code; code = scanf("%d", &n); if (code != 1) return ERR_INPUT; printf("%d\n", countOnes(n)); return 0; }
void main() { //Test Variables int year, leap, num, num2, month, day, bitCount; month = 2; num = 22; num2 = 37; year = 2004; day = daysInMonth(month, year); bitCount = countOnes(num); leap = isLeap(year); //Testing countOnes printf("The number of bits in %u is %d\n", num, bitCount); //Testing isEven if (isEven(num)) { printf("%d is an even number\n", num); } else { printf("%d is not an even number\n", num); } //Testing isOdd if (isOdd(num2)) { printf("%d is an odd number\n", num2); } else { printf("%d is not an odd number\n", num2); } //Testing isLeap if (leap == 1) { printf("The year %d is a leap year\n",year); } else { printf("The year %d is not a leap year\n",year); } //Testing daysInMonth printf("Febuary has %d days in the year %d\n",day, year); //Testing packChars printf("Packing %d and %d together forms 0x%x\n", 3, 5, packChars(3,5)); getchar(); }
int main(void) { unsigned char buffer[1024]; unsigned int i = 0; unsigned int ones = 0, zeroes = 0; unsigned int pattern2[4] = {0,0,0,0}; TPM_setlog(0); printf("Counting number of '1's and '0's of the rng.\n"); while (i < 10) { uint32_t bufferSize = sizeof(buffer); unsigned int j = 0; uint32_t ret; ret = TPM_GetRandom(bufferSize, buffer, &bufferSize); if (0 != ret) { printf("Error %s from TPM_GetRandom.\n", TPM_GetErrMsg(ret)); exit (ret); } while (j < bufferSize) { unsigned int c = countOnes(buffer[j]); ones += c; zeroes += (8-c); pattern2[0] += matchPattern(buffer[j], 0x0, 2); pattern2[1] += matchPattern(buffer[j], 0x1, 2); pattern2[2] += matchPattern(buffer[j], 0x2, 2); pattern2[3] += matchPattern(buffer[j], 0x3, 2); j++; } ret = TPM_StirRandom(buffer, 10); if (0 != ret) { printf("Error %s from TPM_StirRandom.\n", TPM_GetErrMsg(ret)); exit(ret); } i++; } printf("Percentage of '1': %d percent.\n", (ones*100)/(ones+zeroes)); printf("Percentage of '00' bits: %d percent\n", (pattern2[0]*200)/(ones+zeroes)); printf("Percentage of '01' bits: %d percent\n", (pattern2[1]*200)/(ones+zeroes)); printf("Percentage of '10' bits: %d percent\n", (pattern2[2]*200)/(ones+zeroes)); printf("Percentage of '11' bits: %d percent\n", (pattern2[3]*200)/(ones+zeroes)); return 0; }
int computerPlayer::play(const playfield& field) { if (first_round) { if (countOnes(field) == 0) { colour_of_opponent = 2; colour_of_player = 1; } else { colour_of_opponent = 1; colour_of_player = 2; } first_round = false; } weighted_cols.clear(); for (int x = 0; x < width_of_field; ++x) { // Only if column isn't full. if (field.stoneat(x, 0) == 0) { int max_of_column_player {0}, max_of_column_opponent {0}; for (int y = 0; y < height_of_field; ++y) { if (field.stoneat(x, y) == 0) { max_of_column_player = std::max(max_of_column_player, weightOfPlace(x, y, colour_of_player, field)); max_of_column_opponent = std::max(max_of_column_opponent, weightOfPlace(x, y, colour_of_opponent, field)); } } if (max_of_column_player >= 3 || max_of_column_opponent >= 3) return x; weighted_cols.push_back( std::make_tuple(max_of_column_player, max_of_column_opponent, x)); } } std::random_shuffle(begin(weighted_cols), end(weighted_cols)); std::stable_sort(begin(weighted_cols), end(weighted_cols), [](const weight &left, const weight &right) {return std::get<0>(left) < std::get<0>(right);}); std::stable_sort(begin(weighted_cols), end(weighted_cols), [](const weight &left, const weight &right) {return std::get<1>(left) < std::get<1>(right);}); return std::get<2>(weighted_cols.back()); }
/* internal function! */ static UEnumeration *selectForMask(const UConverterSelector* sel, uint32_t *mask, UErrorCode *status) { // this is the context we will use. Store a table of indices to which // encodings are legit. struct Enumerator* result = (Enumerator*)uprv_malloc(sizeof(Enumerator)); if (result == NULL) { uprv_free(mask); *status = U_MEMORY_ALLOCATION_ERROR; return NULL; } result->index = NULL; // this will be allocated later! result->length = result->cur = 0; result->sel = sel; UEnumeration *en = (UEnumeration *)uprv_malloc(sizeof(UEnumeration)); if (en == NULL) { // TODO(markus): Combine Enumerator and UEnumeration into one struct. uprv_free(mask); uprv_free(result); *status = U_MEMORY_ALLOCATION_ERROR; return NULL; } memcpy(en, &defaultEncodings, sizeof(UEnumeration)); en->context = result; int32_t columns = (sel->encodingsCount+31)/32; int16_t numOnes = countOnes(mask, columns); // now, we know the exact space we need for index if (numOnes > 0) { result->index = (int16_t*) uprv_malloc(numOnes * sizeof(int16_t)); int32_t i, j; int16_t k = 0; for (j = 0 ; j < columns; j++) { uint32_t v = mask[j]; for (i = 0 ; i < 32 && k < sel->encodingsCount; i++, k++) { if ((v & 1) != 0) { result->index[result->length++] = k; } v >>= 1; } } } //otherwise, index will remain NULL (and will never be touched by
int main(void) { int t; scanf("%d", &t); while (t--) { memset(Data, 0, sizeof(Data)); Finished = 0; MaxK = 0; nResult = 0; BuildData(); LoadPuzzle(); struct str_node *r; for (r = RootNode->Right; r != RootNode; r = r->Right) r->count = countOnes(r); Search(0); if (t > 0) printf("\n"); } return 0; }
static void test_countOnes(void) { TEST_ASSERT_EQUAL_UINT32(0, countOnes(0x0)); TEST_ASSERT_EQUAL_UINT32(32, countOnes(0xffffffff)); TEST_ASSERT_EQUAL_UINT32(16, countOnes(0x5a5a5a5a)); }
void main(int argc, char* argv[]) { //二进制数位1计数算法测试入口 for (unsigned int i = 0; i < 512; i++) printf("%6d = %4X: %6d %6d %6d\n", i, i, countOnes(i), countOnes1(i), countOnes2(i)); }
int main() { printf("countOnes(0x30303)=%d\n", countOnes(0x30303)); }
/* * Create a new string with human-readable access flags. * * In the base language the access_flags fields are type u2; in Dalvik * they're u4. */ static char* createAccessFlagStr(u4 flags, AccessFor forWhat) { #define NUM_FLAGS 18 static const char* kAccessStrings[kAccessForMAX][NUM_FLAGS] = { { /* class, inner class */ "PUBLIC", /* 0x0001 */ "PRIVATE", /* 0x0002 */ "PROTECTED", /* 0x0004 */ "STATIC", /* 0x0008 */ "FINAL", /* 0x0010 */ "?", /* 0x0020 */ "?", /* 0x0040 */ "?", /* 0x0080 */ "?", /* 0x0100 */ "INTERFACE", /* 0x0200 */ "ABSTRACT", /* 0x0400 */ "?", /* 0x0800 */ "SYNTHETIC", /* 0x1000 */ "ANNOTATION", /* 0x2000 */ "ENUM", /* 0x4000 */ "?", /* 0x8000 */ "VERIFIED", /* 0x10000 */ "OPTIMIZED", /* 0x20000 */ }, { /* method */ "PUBLIC", /* 0x0001 */ "PRIVATE", /* 0x0002 */ "PROTECTED", /* 0x0004 */ "STATIC", /* 0x0008 */ "FINAL", /* 0x0010 */ "SYNCHRONIZED", /* 0x0020 */ "BRIDGE", /* 0x0040 */ "VARARGS", /* 0x0080 */ "NATIVE", /* 0x0100 */ "?", /* 0x0200 */ "ABSTRACT", /* 0x0400 */ "STRICT", /* 0x0800 */ "SYNTHETIC", /* 0x1000 */ "?", /* 0x2000 */ "?", /* 0x4000 */ "MIRANDA", /* 0x8000 */ "CONSTRUCTOR", /* 0x10000 */ "DECLARED_SYNCHRONIZED", /* 0x20000 */ }, { /* field */ "PUBLIC", /* 0x0001 */ "PRIVATE", /* 0x0002 */ "PROTECTED", /* 0x0004 */ "STATIC", /* 0x0008 */ "FINAL", /* 0x0010 */ "?", /* 0x0020 */ "VOLATILE", /* 0x0040 */ "TRANSIENT", /* 0x0080 */ "?", /* 0x0100 */ "?", /* 0x0200 */ "?", /* 0x0400 */ "?", /* 0x0800 */ "SYNTHETIC", /* 0x1000 */ "?", /* 0x2000 */ "ENUM", /* 0x4000 */ "?", /* 0x8000 */ "?", /* 0x10000 */ "?", /* 0x20000 */ }, }; const int kLongest = 21; /* strlen of longest string above */ int i, count; char* str; char* cp; /* * Allocate enough storage to hold the expected number of strings, * plus a space between each. We over-allocate, using the longest * string above as the base metric. */ count = countOnes(flags); cp = str = (char*) malloc(count * (kLongest+1) +1); for (i = 0; i < NUM_FLAGS; i++) { if (flags & 0x01) { const char* accessStr = kAccessStrings[forWhat][i]; int len = strlen(accessStr); if (cp != str) *cp++ = ' '; memcpy(cp, accessStr, len); cp += len; } flags >>= 1; } *cp = '\0'; return str; }