I think the Collatz Conjecture is already well-known. But what if we invert the rules?

Start with an integer n >= 1.

Repeat the following steps:

If n is even, multiply it by 3 and add 1.

If n is odd, subtract 1 and divide it by 2.

Stop when it reaches 0

Print the iterated numbers.

Test cases:

 1 => 1, 0
 2 => 2, 7, 3, 1, 0
 3 => 3, 1, 0
10 => 10, 31, 15, 7, 3...
14 => 14, 43, 21, 10, ...

Rules:

• This sequence does not work for a lot of numbers because it enters in an infinite loop. You do not need to handle those cases. Only printing the test cases above is enough.




• I suggested to subtract 1 and divide by two to give a valid integer to continue, but it is not required to be computed that way. You may divide by 2 and cast to integer or whatever other methods that will give the expected output.




• You need to print the initial input as well.




• The output does not need to be formatted as the test cases. It was just a suggestion. However, the iterated order must be respected.




• The smallest code wins.

Jelly, 9 bytes

:++‘ƊḂ?Ƭ2

Try it online!

JavaScript (ES6), 31 bytes

f=n=>n&&n+' '+f(n&1?n>>1:n*3+1)

Try it online!

Or 30 bytes in reverse order.

Rust, 65 bytes

fn f(n:u8)print!(" ",n);if n>0f(if n&1>0n>>1elsen*3+1);

Try it online!

Pyth, 12 bytes

.u?%N2/N2h*3

Try it here as a test suite!

JAEL, 12 chars, 24 bytes

![⍩î?ûḄ|õÀ⸵ẘ

I would post the TIO link but it's not working as expected there.

Right now, the input must be prepended to the code, like:

14![⍩î?ûḄ|õÀ⸵ẘ

perl -Minteger -nlE, 39 bytes

say;$_=$_%2?$_/2:3*$_+1 and redosay 0

Clean, 53 bytes

import StdEnv
$0=[0]
$n=[n: $if(isOdd n)(n/2)(n*3+1)]

Try it online!

Add++, 38 35 33 bytes

D,f,@:,d3*1+$2/iA2%D
+?
O
Wx,$f>x

Try it online!

How it works

First, we begin by defining a function $f(x)$, that takes a single argument, performs the inverted Collatz operation on $x$ then outputs the result. That is,

$$f(x) = begincases
x : textis even, & 3x+1 \
x : textis odd, & lfloorfracx2rfloor
endcases$$

When in function mode, Add++ uses a stack memory model, otherwise variables are used. When calculating $f(x)$, the stack initially looks like $S = [x]$.

We then duplicate this value (d), to yield $S = [x, x]$. We then yield the first possible option, $3x + 1$ (3*1+), swap the top two values, then calculate $lfloorfracx2rfloor$, leaving $S = [3x+1, lfloorfracx2rfloor]$.

Next, we push $x$ to $S$, and calculate the bit of $x$ i.e. $x : % : 2$, where $a : % : b$ denotes the remainder when dividing $a$ by $b$. This leaves us with $S = [3x+1, lfloorfracx2rfloor, (x : % : 2)]$. Finally, we use D to select the element at the index specified by $(x : % : 2)$. If that's $0$, we return the first element i.e. $3x+1$, otherwise we return the second element, $lfloorfracx2rfloor$.

That completes the definition of $f(x)$, however, we haven't yet put it into practice. The next three lines have switched from function mode into vanilla mode, where we operate on variables. To be more precise, in this program, we only operate on one variable, the active variable, represented by the letter x. However, x can be omitted from commands where it is obviously the other argument.

For example, +? is identical to x+?, and assigns the input to x, but as x is the active variable, it can be omitted. Next, we output x, then entire the while loop, which loops for as long as $x neq 0$. The loop is very simple, consisting of a single statement: $f>x. All this does is run $f(x)$, then assign that to x, updating x on each iteration of the loop.