int collatz(int n) { if (n == 1) return 1; else if (n & 1) return collatz(3 * n + 1); else return collatz(n / 2); }
int collatz(n){ if (n==1) return i; else if (n % 2==0) {i++; return(collatz(n / 2));} else {i++; return(collatz(3*n + 1)); } }
int collatz(unsigned int i){ if (i < MAXNUM){ if (cLength[i]) return cLength[i]; else if (i % 2 == 0) return cLength[i] = 1 + collatz(i/2); else return cLength[i] = 1 + collatz(3*i+1); } else { if (i % 2 == 0) return 1 + collatz(i/2); else return 1 + collatz(3*i+1); } }
int main() { int pid; pid=fork(); int number; if(pid<0) { printf("\n Error "); exit(1); } else if(pid==0) { //This is the child process so make it do all the work number = getInput(); collatz(number); exit(0); } else { //This is the parent process so make it wait for child to finish wait(); exit(1); } }
int main() { int n,result; scanf ("%d",&n); printf("%d ",n);//ĩmprimir o primeiro termo collatz(n); return (0); }
PyObject * py_collatz(PyObject *self, PyObject *args) { int x, y; if(!PyArg_ParseTuple(args, "i", &x)) return NULL; y = collatz(x); return Py_BuildValue("i", y); }
int collatz(int n) { if (n==2)//caso base { printf ("%d ",1); return 1; } else if (n%2 == 0) { printf ("%d ",n/2); return(collatz(n/2)); } else { printf ("%d ",3*n+1); return(collatz(3*n+1)); } }
void collatz(int num){ printf("%d", num); printf(" "); if(num > 1){ if(num%2 == 0){ num = num/2;} else{num = (3*num)+1;} collatz(num); } if(num == 1){printf("\n");}//Print a new line to make answer more readable }
int collatz(long long int n){ if (n >= MAX){ if (n&1){ return collatz(3*n+1)+1; } else{ return collatz(n>>1)+1; } } else{ if (n == 1){
static int master(int argc, char *argv[]) { XBT_INFO("Launching our nice bugged recursive function..."); unsigned i = 1; do { i *= 2; unsigned res = collatz(i, i); XBT_VERB("collatz(%u, %u) returned %u", i, i, res); } while (i <= 0x80000000u); return 0; }
int main(){ uint64_t m = 0, n; uint16_t l; for(uint64_t i = 500001; i < 1000000; i += 2){ if((l = collatz(i)) > m){ m = l; n = i; } } printf("%uli\n", n); }
int main(void) { int zahl; printf("Für welche Zahl soll die Länge der Collatz-Folge berechnet werden?\n"); scanf("%d", &zahl); if (zahl<=0) { printf("Die Collatz-Folge ist für %d nicht definiert. \n", zahl); } else{ printf("Die Zahl der Schritte, um das erste Mal 1 zu errreichen sind %d\n", collatz(zahl)); } return 0;}
int main(int argc, char *argv[]) { int i; init_cache(); i = argc; while (i>1) printf("%d\n", collatz(atoi(argv[--i]))); free_cache(); return 0; }
static unsigned collatz(unsigned c0, unsigned n) { unsigned x; if (n == 0) { x = c0; } else { x = collatz(c0, n - 1); if (x % 2 == 0) x = x / 2; else x = 3 * x + 1; } return x; }
int main( void ) { dm.fill(0); uint16_t max = 0; uint32_t num = 0; for (uint32_t i = 1; i < 1000000; ++i ){ uint16_t v = collatz(i); dm.at(i-1) = v; if (v > max) { max = v; num = i; } } std::cout << num << std::endl; return 0; };
unsigned longest_sequence(unsigned limit) { unsigned max_len = 0; unsigned max_n = 0; unsigned i; for (i = 2; i <= limit; ++i) { unsigned long n; unsigned len = 1; for (n = i; n > 1; ++len) { n = collatz(n); } if (len > max_len) { max_len = len; max_n = i; } } return max_n; }
int main (int argc, char **argv) { if (argc < 3) { printf ("Error; exiting status -1\n"); return -1; } int start; int end = atoi(argv[2]); int c, temp, max = 0; for (start = atoi(argv[1]); start <= end; ++start) { temp = start; for (c = 1; temp > 1; ++c) { temp = collatz(temp); } if (max < c) { max = c; } } printf ("%d\n", max); }
uint p14::execute() { answerMap.resize(1000000,0); answerMap[0] = answerMap[1] = 1; uint answer = 1, maxStepsFound = 1; for ( uint i = 1; i < 1000000; ++i ) { uint col = collatz(i); if ( maxStepsFound < col ) { answer = i; maxStepsFound = col; } } return answer; }
/* Tests the scalability of OpenMP by performing the calculations on different number of threads */ void benchmark(int startNumber, int endNumber, int maxThreads, double* timings) { printf("Number of available threads: %d\n", maxThreads); /* Run the test */ int iThread; double timeStart, timeEnd; int nNumbers = endNumber - startNumber + 1; int* iter = malloc(nNumbers*sizeof(int)); for (iThread = 1; iThread <= maxThreads; iThread++) { omp_set_num_threads(iThread); printf("Running the calculation on %d threads ...\n", iThread); timeStart = omp_get_wtime(); collatz(startNumber, endNumber, iter, iThread); timeEnd = omp_get_wtime() - timeStart; printf(" Calculation finished in %lf seconds.\n", timeEnd); timings[iThread - 1] = timeEnd; } free(iter); }
int main() { time_t t1; time(&t1); int savedNum = 0; int savedIter = 0; for(int i = 2; i < 1000000; ++i) { int k = collatz(i); if (k > savedIter) { savedIter = k; savedNum = i; } } time_t t2; time(&t2); std::cout << "(" << savedNum <<", " << savedIter << ")" << std::endl; std::cout << "Runtime was " <<difftime(t2,t1) << std::endl; return 0; }
/** * Prints the hailstone sequence in a child process while the parent waits * for the child's termination. */ int main (int argc, char** argv) { int arg = 0; pid_t pid; if (argc != 2 || (arg = atoi(argv[1])) < 1) { printf("A single integer argument greater than 0 must be given\n"); exit(1); } // Fork off a child process pid = Fork(); // If this is the child process print the hailstone sequence if (pid == 0){ collatz(arg); } // If this is the parent wait for the childs termination and then exit. else { Wait(NULL); } exit(0); }
int main(void){ int i, j; for (i = 1; i < MAXJ; i++) collatz(i); while (scanf("%d %d", &i, &j) != EOF){ int k, m = 0; for (k = i; k <= j; k++) if (cLength[k] > m) m = cLength[k]; for (k = j; k <= i; k++) if (cLength[k] > m) m = cLength[k]; printf("%d %d %d\n", i, j, m); } return 0; }