Ich denke, die Collatz-Vermutung ist bereits bekannt. Aber was ist, wenn wir die Regeln umkehren?

Beginnen Sie mit einer ganzen Zahl n> = 1.

Wiederholen Sie die folgenden Schritte:

Wenn n selbst multiplizieren es mit 3 und 1 addieren.

Wenn n ungerade ist , subtrahiere 1 und dividiere es durch 2.

Stoppen Sie, wenn es 0 erreicht

Drucken Sie die iterierten Zahlen.

Testfälle:

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

Regeln:

• Diese Sequenz funktioniert nicht für viele Zahlen, da sie in eine Endlosschleife eingeht. Sie müssen diese Fälle nicht bearbeiten. Es reicht aus, nur die obigen Testfälle auszudrucken.

• Ich schlug vor, 1 zu subtrahieren und durch zwei zu dividieren, um eine gültige Ganzzahl zu erhalten, um fortzufahren, aber es ist nicht erforderlich, auf diese Weise berechnet zu werden. Sie können durch 2 teilen und in eine Ganzzahl oder eine andere Methode umwandeln, die die erwartete Ausgabe liefert.

• Sie müssen auch die erste Eingabe drucken.

• Die Ausgabe muss nicht als Testfall formatiert werden. Es war nur ein Vorschlag. Die iterierte Reihenfolge muss jedoch eingehalten werden.

• Der kleinste Code gewinnt.

Perl 6 , 30 Bytes

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

Probieren Sie es online!

Anonymer Codeblock, der eine Sequenz zurückgibt.

Erläuterung:

{$_,{$_%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)

Probieren Sie es online!

Jetzt ohne die letzte 0.

Sauber , 53 Bytes

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

Probieren Sie es online!

Gelee , 9 Bytes

:++‘ƊḂ?Ƭ2

Probieren Sie es online!

Python 2, 54 52 44 Bytes

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

-2 Bytes dank Mr. Xcoder

Es muss auf jeden Fall einen schnelleren Weg geben. Seltsamerweise, als ich ein Lambda probierte, war es das gleiche bytecount. Ich halluziniere wahrscheinlich.

Probieren Sie es online!

Haskell , 76 69 61 56 Bytes

Ich denke, das ist viel zu lang. Hier lwird eine unendliche Liste der Inverse-Collatz-Sequenz erstellt, und die anonyme Funktion in der ersten Zeile schneidet sie nur an der richtigen Stelle ab.

Vielen Dank für -5 Bytes @ ØrjanJohansen!

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

Probieren Sie es online!

Rust , 65 64 Bytes

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

Probieren Sie es online!

05AB1E , 15 14 Bytes

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

-1 Byte dank @MagicOctopusUrn .

Probieren Sie es online aus.

Erläuterung:

[             # 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>î?èÛ|õÀ

Probieren Sie es online!

JavaScript (ES6), 31 Byte

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

Probieren Sie es online!

Oder 30 Bytes in umgekehrter Reihenfolge.

Pyth , 12 Bytes

.u?%N2/N2h*3

Probieren Sie es hier als Testsuite aus!

Wolfram Language (Mathematica) , 35 Byte

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

Probieren Sie es online!

0<Echo@# && ...&ist eine Kurzschlussauswertung: Sie druckt den Eingang #, prüft, ob er positiv ist, und wertet ihn aus .... In diesem Fall ...ist #0[3#+1-(5#+3)/2#~Mod~2]; da #0(der nullte Schlitz) die Funktion selbst ist, ist dies ein rekursiver Aufruf 3#+1-(5#+3)/2#~Mod~2, der vereinfacht, 3#+1wann #gerade und (#-1)/2wann #ungerade ist.

Common Lisp , 79 Bytes

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

Probieren Sie es online!

PowerShell, 53 52 Bytes

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

Probieren Sie es online!

Edit:
-1 Byte dank @mazzy

Emojicode 0,5 , 141 Bytes

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

Probieren Sie es online!

🐖🎅🏿🍇
🍮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Ç╣;↑è

Führen Sie es aus, und debuggen Sie es

MathGolf , 12 Bytes

{o_¥¿½É3*)}∟

Probieren Sie es online!

Erläuterung

{             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

x86-Maschinencode, 39 Byte

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 

Assembly (NASM-Syntax):

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 '

Probieren Sie es online!

R , 66 61 Bytes

-5 Bytes dank Robert S. beim Konsolidieren von ifelse in ifund Entfernen von Klammern und x! = 0 bis x> 0

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

Anstatt von

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

Probieren Sie es online!

perl -Minteger -nlE, 39 Bytes

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

Add ++ , 38 35 33 Bytes

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

Probieren Sie es online!

Wie es funktioniert

Zunächst definieren wir eine Funktion $f(x)$Führt die invertierte Collatz-Operation mit nur einem Argument aus $x$gibt dann das Ergebnis aus. Das ist,

Im Funktionsmodus verwendet Add ++ ein Stapelspeichermodell, andernfalls werden Variablen verwendet. Bei der Berechnung$f(x)$sieht der Stack zunächst so aus $S = [x]$.

Wir duplizieren dann diesen Wert ( d), um zu ergeben$S = [x, x]$. Wir ergeben dann die erste mögliche Option,$3x + 1$( 3*1+), tauschen Sie die oberen beiden Werte aus und berechnen Sie dann$\lfloor\frac{x}{2}\rfloor$, Verlassen $S = [3x+1, \lfloor\frac{x}{2}\rfloor]$.

Als nächstes drängen wir $x$ zu $S$, und berechnen Sie das Bit von $x$ dh $x \: \% \: 2$, wo $a \: \% \: b$bezeichnet den Rest beim Teilen$a$ durch $b$. Das lässt uns mit$S = [3x+1, \lfloor\frac{x}{2}\rfloor, (x \: \% \: 2)]$. Zuletzt Dwählen wir das Element an dem von angegebenen Index aus$(x \: \% \: 2)$. Wenn das so ist$0$, wir geben das erste Element zurück dh $3x+1$, sonst geben wir das zweite Element zurück, $\lfloor\frac{x}{2}\rfloor$.

Damit ist die Definition von $f(x)$wir haben es jedoch noch nicht in die Praxis umgesetzt. Die nächsten drei Zeilen sind vom Funktionsmodus in den Vanillemodus gewechselt, in dem wir Variablen bearbeiten. Genauer gesagt bearbeiten wir in diesem Programm nur eine Variable, die aktive Variable , die durch den Buchstaben dargestellt wird x. Jedoch,x kann von Befehlen weggelassen , wo sie offensichtlich das andere Argument ist.

Beispielsweise +?ist identisch mit x+?und weist die Eingabe zu x, aber wie xdie aktive Variable kann sie weggelassen werden. Als nächstes geben wir die xgesamte while-Schleife aus, die so lange wiederholt wird$x \neq 0$. Die Schleife ist sehr einfach, bestehend aus einer einzigen Anweisung: $f>x. Alles was dies tut ist ausgeführt$f(x)$Weisen Sie das dann zu xund aktualisieren Sie es xbei jeder Iteration der Schleife.

Retina 0.8.2 , 46 Bytes

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

Probieren Sie es online! Erläuterung:

.+
$*

In Unary konvertieren.

{

Wiederholen, bis sich der Wert nicht mehr ändert.

*M`1

Den Wert dezimal ausgeben.

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

Wenn es gerade ist, multiplizieren Sie mit 6 und addieren Sie 3.

1(.*)\1
$1

Subtrahiere 1 und dividiere durch 2.

Der abschließende Zeilenumbruch kann durch Hinzufügen eines ;vor dem unterdrückt werden {.

Rot , 70 Bytes

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

Probieren Sie es online!

Schläger , 75 Bytes

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

Probieren Sie es online!

Entspricht der Common Lisp-Lösung von JRowan.

C # (.NET Core) , 62 Byte

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

Probieren Sie es online!

Ungolfed:

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

Probieren Sie es online!

Gambit-Schema (gsi) , 74 Bytes

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

Probieren Sie es online!