Creo que la Conjetura de Collatz ya es conocida. Pero, ¿y si invertimos las reglas?

Comience con un número entero n> = 1.

Repita los siguientes pasos:

Si n es par , multiplíquelo por 3 y agregue 1.

Si n es impar , reste 1 y divídalo por 2.

Pare cuando llegue a 0

Imprime los números iterados.

Casos de prueba:

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

Reglas:

• Esta secuencia no funciona para muchos números porque entra en un bucle infinito. No necesita manejar esos casos. Solo imprimir los casos de prueba anteriores es suficiente.

• Sugerí restar 1 y dividir por dos para dar un número entero válido para continuar, pero no es necesario que se calcule de esa manera. Puede dividir por 2 y convertir a entero o cualquier otro método que dé el resultado esperado.

• También debe imprimir la entrada inicial.

• La salida no necesita formatearse como los casos de prueba. Era solo una sugerencia. Sin embargo, se debe respetar el orden iterado.

• El código más pequeño gana.

Perl 6 , 30 bytes

{$_,{$_%2??$_+>1!!$_*3+1}...0}

Pruébalo en línea!

Bloque de código anónimo que devuelve una secuencia.

Explicación:

{$_,{$_%2??$_+>1!!$_*3+1}...0}
{                            }   # Anonymous code block
   ,                     ...     # Define a sequence
 $_                              # That starts with the given value
    {                   }        # With each element being
     $_%2??     !!               # Is the previous element odd?
           $_+>1                 # Return the previous element bitshifted right by 1
                  $_*3+1         # Else the previous element multiplied by 3 plus 1
                            0    # Until the element is 0

Haskell , 40 39 bytes

f 0=[]
f n=n:f(cycle[3*n+1,div n 2]!!n)

Pruébalo en línea!

Ahora sin el 0 final.

Limpio , 53 bytes

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

Pruébalo en línea!

Jalea , 9 bytes

:++‘ƊḂ?Ƭ2

Pruébalo en línea!

Python 2, 54 52 44 bytes

n=input()
while n:print n;n=(n*3+1,n/2)[n%2]

-2 bytes gracias al Sr. Xcoder

Ciertamente debe haber una forma más rápida. Curiosamente, cuando probé una lambda fue el mismo bytecount. Probablemente estoy alucinando.

Pruébalo en línea!

Haskell , 76 69 61 56 bytes

Siento que esto es demasiado tiempo. Aquí lproduce una lista infinita de la secuencia inversa-collatz, y la función anónima en la primera línea simplemente la corta en el lugar correcto.

Gracias por -5 bytes @ ØrjanJohansen!

fst.span(>0).l
l r=r:[last$3*k+1:[div k 2|odd k]|k<-l r]

Pruébalo en línea!

Óxido , 65 64 bytes

|mut n|{while n>0{print!("{} ",n);n=if n&1>0{n>>1}else{n*3+1};}}

Pruébalo en línea!

05AB1E , 15 14 bytes

[Ð=_#Èi3*>ë<2÷

-1 byte gracias a @MagicOctopusUrn .

Pruébalo en línea.

Explicación:

[             # Start an infinite loop
 Ð            #  Duplicate the top value on the stack three times
              #  (Which will be the (implicit) input in the first iteration)
  =           #  Output it with trailing newline (without popping the value)
   _#         #  If it's exactly 0: stop the infinite loop
     Èi       #  If it's even:
       3*     #   Multiply by 3
         >    #   And add 1
      ë       #  Else:
       <      #   Subtract 1
        2÷    #   And integer-divide by 2

JAEL , 18 bytes

![ؼw>î?èÛ|õÀ

Pruébalo en línea!

JavaScript (ES6), 31 bytes

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

Pruébalo en línea!

O 30 bytes en orden inverso.

Pyth , 12 bytes

.u?%N2/N2h*3

Pruébalo aquí como un conjunto de pruebas!

Wolfram Language (Mathematica) , 35 bytes

0<Echo@#&&#0[3#+1-(5#+3)/2#~Mod~2]&

Pruébalo en línea!

0<Echo@# && ...&es una evaluación de cortocircuito: imprime la entrada #, comprueba si es positiva y, de ser así, la evalúa .... En este caso, ...es #0[3#+1-(5#+3)/2#~Mod~2]; dado que #0(la ranura cero) es la función en sí, esta es una llamada recursiva 3#+1-(5#+3)/2#~Mod~2, que se simplifica a 3#+1cuándo #es par y (#-1)/2cuándo #es impar.

Lisp común , 79 bytes

(defun x(n)(cons n(if(= n 0)nil(if(=(mod n 2)0)(x(+(* n 3)1))(x(/(- n 1)2))))))

Pruébalo en línea!

PowerShell, 53 52 bytes

param($i)for(;$i){$i;$i=(($i*3+1),($i-shr1))[$i%2]}0

Pruébalo en línea!

Editar:
-1 byte gracias a @mazzy

Emojicode 0.5 , 141 bytes

🐖🎅🏿🍇🍮a🐕😀🔡a 10🔁▶️a 0🍇🍊😛🚮a 2 1🍇🍮a➗a 2🍉🍓🍇🍮a➕✖️a 3 1🍉😀🔡a 10🍉🍉

Pruébalo en línea!

🐖🎅🏿🍇
🍮a🐕      👴 input integer variable 'a'
😀🔡a 10      👴 print input int
🔁▶️a 0🍇      👴 loop while number isn’t 0
🍊😛🚮a 2 1🍇     👴 if number is odd
🍮a➗a 2       👴 divide number by 2
🍉
🍓🍇      👴 else
🍮a➕✖️a 3 1   👴 multiply by 3 and add 1
🍉
😀🔡a 10     👴 print iteration
🍉🍉

Stax , 11 bytes

₧↑╔¶┘tÇ╣;↑è

Ejecutar y depurarlo

MathGolf , 12 bytes

{o_¥¿½É3*)}∟

Pruébalo en línea!

Explicación

{             Start block of arbitrary length
 o            Output the number
  _           Duplicate
   ¥          Modulo 2
    ¿         If-else with the next two blocks. Implicit blocks consist of 1 operator
     ½        Halve the number to integer (effectively subtracting 1 before)
      É       Start block of 3 bytes
       3*)    Multiply by 3 and add 1
          }∟  End block and make it do-while-true

código de máquina x86, 39 bytes

00000000: 9150 6800 0000 00e8 fcff ffff 5958 a901  .Ph.........YX..
00000010: 0000 0074 04d1 e8eb 066a 035a f7e2 4009  ...t.....j.Z..@.
00000020: c075 dec3 2564 20                        .u..%d 

Ensamblado (sintaxis NASM):

section .text
	global func
	extern printf
func:					;the function uses fastcall conventions
	xchg eax, ecx			;load function arg into eax
	loop:
		push eax
		push fmt
		call printf	;print eax
		pop ecx
		pop eax
		test eax, 1	;if even zf=1
		jz even		;if eax is even jmp to even
		odd:		;eax=eax/2
			shr eax, 1
			jmp skip
		even:		;eax=eax*3+1
			push 3
			pop edx
			mul edx
			inc eax
		skip:
		or eax, eax
		jne loop	;if eax!=0, keep looping
	ret			;return eax
section .data
	fmt db '%d '

Pruébalo en línea!

R , 66 61 bytes

-5 bytes gracias a Robert S. en la consolidación de ifelse ify en la eliminación de corchetes, y x! = 0 a x> 0

print(x<-scan());while(x>0)print(x<-`if`(x%%2,(x-1)/2,x*3+1))

en lugar de

print(x<-scan());while(x!=0){print(x<-ifelse(x%%2,(x-1)/2,x*3+1))}

Pruébalo en línea!

perl -Minteger -nlE, 39 bytes

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

Agregar ++ , 38 35 33 bytes

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

Pruébalo en línea!

Cómo funciona

Primero, comenzamos definiendo una función $f(x)$, que toma un solo argumento, realiza la operación invertida de Collatz en $x$luego da salida al resultado. Es decir,

Cuando está en modo de función, Add ++ usa un modelo de memoria de pila, de lo contrario se usan variables. Al calcular$f(x)$, la pila se ve inicialmente como $S = [x]$.

Luego duplicamos este valor ( d), para obtener$S = [x, x]$. Luego damos la primera opción posible,$3x + 1$( 3*1+), intercambie los dos valores superiores, luego calcule$\lfloor\frac{x}{2}\rfloor$, dejando $S = [3x+1, \lfloor\frac{x}{2}\rfloor]$.

A continuación, empujamos $x$ a $S$y calcular el bit de $x$ es decir $x \: \% \: 2$, dónde $a \: \% \: b$denota el resto al dividir$a$ por $b$. Esto nos deja con$S = [3x+1, \lfloor\frac{x}{2}\rfloor, (x \: \% \: 2)]$. Finalmente, usamos Dpara seleccionar el elemento en el índice especificado por$(x \: \% \: 2)$. Si eso es$0$, devolvemos el primer elemento, es decir $3x+1$de lo contrario, devolvemos el segundo elemento, $\lfloor\frac{x}{2}\rfloor$.

Eso completa la definición de $f(x)$Sin embargo, todavía no lo hemos puesto en práctica. Las siguientes tres líneas han cambiado del modo función al modo vainilla, donde operamos con variables. Para ser más precisos, en este programa, solo operamos en una variable, la variable activa , representada por la letra x. Sin embargo,x puede omitirse de los comandos donde obviamente es el otro argumento.

Por ejemplo, +?es idéntico a x+?, y asigna la entrada a x, pero como xes la variable activa , se puede omitir. Luego, sacamos x, luego todo el ciclo while, que se repite durante tanto tiempo como$x \neq 0$. El bucle es muy simple, que consiste en una sola instrucción: $f>x. Todo lo que hace es correr$f(x)$, luego asigne eso a x, actualizando xen cada iteración del bucle.

Retina 0.8.2 , 46 bytes

.+
$*
{*M`1
^(..)+$
$&$&$&$&$&$&111
1(.*)\1
$1

Pruébalo en línea! Explicación:

.+
$*

Convierte a unario.

{

Repita hasta que el valor deje de cambiar.

*M`1

Imprime el valor en decimal.

^(..)+$
$&$&$&$&$&$&111

Si es par, multiplique por 6 y agregue 3.

1(.*)\1
$1

Resta 1 y divide entre 2.

La nueva línea final se puede suprimir agregando un ;antes de {.

Rojo , 70 bytes

func[n][print n if n = 0[exit]either odd? n[f n - 1 / 2][f n * 3 + 1]]

Pruébalo en línea!

Raqueta , 75 bytes

(define(f n)(cons n(if(= n 0)'()(if(odd? n)(f(/(- n 1)2))(f(+(* 3 n)1))))))

Pruébalo en línea!

Equivalente a la solución Common Lisp de JRowan.

C # (.NET Core) , 62 bytes

a=>{for(;a>0;a=a%2<1?a*3+1:a/2)Console.Write(a+" ");return a;}

Pruébalo en línea!

Sin golf:

a => {
    for(; a > 0;                // until a equals 0
        a = a % 2 < 1 ?             // set a depending on if a is odd or even
                a * 3 + 1 :             // even
                a / 2                   // odd (minus one unnecessary because of int casting)
    )
        Console.Write(a + " "); // writes the current a to the console
    return a;                   // writes a to the console (always 0)
}

Dart , 49 bytes

f(n){for(;n>0;n=n%2>0?(n-1)>>1:(n*3)+1)print(n);}

Pruébalo en línea!

Esquema de Gambito (gsi) , 74 bytes

(define(f n)(if(= 0 n)'()(cons n(f(if(even? n)(+ (* 3 n)1)(/(- n 1)2))))))

Pruébalo en línea!