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;
}
