13

Penso che la congettura di Collatz sia già nota. Ma cosa succede se invertiamo le regole?

Inizia con un numero intero n> = 1.

Ripeti i seguenti passi:

Se n è pari , moltiplicalo per 3 e aggiungi 1.

Se n è dispari , sottrarre 1 e dividerlo per 2.

Stop quando raggiunge 0

Stampa i numeri ripetuti.

Casi test:

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

Regole:

Questa sequenza non funziona per molti numeri perché entra in un ciclo infinito. Non è necessario gestire tali casi. È sufficiente solo stampare i casi di test sopra riportati.
Ho suggerito di sottrarre 1 e dividere per due per dare un numero intero valido per continuare, ma non è necessario che sia calcolato in questo modo. È possibile dividere per 2 e trasmettere a numero intero o qualsiasi altro metodo che fornirà l'output previsto.
È necessario stampare anche l'input iniziale.
Non è necessario che l'output sia formattato come casi di test. Era solo un suggerimento. Tuttavia, l'ordine ripetuto deve essere rispettato.
Vince il codice più piccolo.

code-golf math integer

— Eduardo Hoefel
fonte

9

Poiché questa è la tua terza domanda in altrettante ore, ti consiglio di dare un'occhiata a Sandbox , il luogo in cui di solito pubblichiamo bozze di domande per il feedback e per assicurarti che non siano duplicati.

— caird coinheringaahing

Grazie @cairdcoinheringaahing. Non sapevo di questa pagina.

— Eduardo Hoefel,

Dobbiamo stampare il 0alla fine?

— Flawr

2

Potresti voler espandere gli ultimi due casi di test, poiché non sono così lunghi

— Jo King,

3

@JoKing L'ho compresso perché ripete l'output delle altre linee. Al punto in cui raggiungi 3 , ha lo stesso output di quando inizi da esso. Lo stesso vale per 10 o qualsiasi altro numero.

— Eduardo Hoefel,

5

Perl 6 , 30 byte

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

Provalo online!

Blocco di codice anonimo che restituisce una sequenza.

Spiegazione:

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

— Jo King
fonte

5

Haskell , 40 39 byte

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

Provalo online!

Ora senza lo 0 finale.

— Lynn
fonte

4

Pulito , 53 byte

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

Provalo online!

— Οurous
fonte

2

Gelatina , 9 byte

:++‘ƊḂ?Ƭ2

Provalo online!

— Erik l'Outgolfer
fonte

2

Python 2, 54 52 44 byte

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

-2 byte grazie a Mr. Xcoder

Deve esserci sicuramente un modo più veloce. Stranamente, quando ho provato un lambda è stato lo stesso conteggio. Probabilmente sto allucinando.

Provalo online!

— Quintec
fonte

-2 byte

— Mr. Xcoder il

@ Mr.Xcoder Ah, grazie.

— Quintec,

1

50 byte

— Jo King

Anche se 0ora è facoltativo, quindi è più breve sbarazzarsi del secondoprint

— Jo King,

Anzi, ora puoi farlo in 44

— Mr. Xcoder il

2

Haskell , 76 69 61 56 byte

Sento che questo è troppo lungo. Qui lproduce un elenco infinito della sequenza inverse-collatz e la funzione anonima nella prima riga la interrompe nel posto giusto.

Grazie per -5 byte @ ØrjanJohansen!

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

Provalo online!

— flawr
fonte

Non ci sono numeri negativi, quindi (>0)dovrebbe essere sufficiente. Inoltre c'è una oddfunzione.

— Ørjan Johansen,

@ ØrjanJohansen Grazie mille!

— flawr

2

Ruggine , 65 64 byte

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

Provalo online!

— Herman L
fonte

2

05AB1E , 15 14 byte

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

-1 byte grazie a @MagicOctopusUrn .

Provalo online.

Spiegazione:

[             # 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

— Kevin Cruijssen
fonte

[Ð=_#Èi3*>ë<2÷con =invece di D,.

— Magic Octopus Urn

@MagicOctopusUrn Ah, è stato abbastanza brutto da dimenticare .. Grazie! :)

— Kevin Cruijssen il

2

JAEL , 18 byte

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

Provalo online!

— Eduardo Hoefel
fonte

1

Il tuo permalink non sembra funzionare. Il programma stampa solo l'input e si ferma.

— Dennis,

Sì hai ragione. Chiederò a "loro" di estrarre l'ultima versione: P

— Eduardo Hoefel,

Ho aggiunto JAEL all'elenco delle lingue del golf . Per favore fatemi sapere se ho qualche informazione sbagliata :-)

— ETHproductions

@ETHproductions Grazie mille: DI, potrei dire che la specialità è il pacchetto di utilità che aiuta il programmatore a comprimere il codice, ma sono solo io che cerco di commercializzarlo.

— Eduardo Hoefel,

1

JavaScript (ES6), 31 byte

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

Provalo online!

O 30 byte in ordine inverso.

— Arnauld
fonte

1

Pyth , 12 byte

.u?%N2/N2h*3

Provalo qui come suite di test!

— Mr. Xcoder
fonte

1

Wolfram Language (Mathematica) , 35 byte

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

Provalo online!

0<Echo@# && ...&è una valutazione di corto circuito: stampa l'ingresso #, controlla se è positivo e, in tal caso, valuta .... In questo caso, ...è #0[3#+1-(5#+3)/2#~Mod~2]; poiché #0(lo slot zeroth) è la funzione stessa, si tratta di una chiamata ricorsiva 3#+1-(5#+3)/2#~Mod~2che semplifica 3#+1quando #è pari e (#-1)/2quando #è dispari.

— Misha Lavrov
fonte

1

Lisp comune , 79 byte

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

Provalo online!

— JRowan
fonte

1

PowerShell, 53 52 byte

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

Provalo online!

Modifica:
-1 byte grazie a @mazzy

— J. Bergmann
fonte

puoi for(;$i)invece provarewhile($i)

— mazzy

1

Emojicode 0,5 , 141 byte

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

Provalo 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
🍉🍉

— X1M4L
fonte

1

Stax , 11 byte

₧↑╔¶┘tÇ╣;↑è

Esegui ed esegui il debug

— Wastl
fonte

1

MathGolf , 12 byte

{o_¥¿½É3*)}∟

Provalo online!

Spiegazione

{             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

— maxb
fonte

Ho aggiunto MathGolf all'elenco dei lang del golf: sentiti libero di correggermi se ho sbagliato qualcosa :-)

— ETHproductions

Grazie per averlo aggiunto! Tutto mi sembra giusto.

— max

1

codice macchina x86, 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 (sintassi 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 '

Provalo online!

— Logern
fonte

1

R , 66 61 byte

-5 byte grazie a Robert S. nel consolidare ifelse in ife rimuovere parentesi, e x! = Da 0 a x> 0

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

invece di

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

Provalo online!

— Sumner18
fonte

1

61 byte

— Robert S.

0

perl -Minteger -nlE, 39 byte

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

0

Aggiungi ++ , 38 35 33 byte

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

Provalo online!

Come funziona

Innanzitutto, iniziamo definendo una funzione $f(x)$ , che accetta un singolo argomento, esegue l'operazione di Collatz invertita su $x$ quindi genera il risultato. Questo è,

f (X) = {\begin{cases} X è anche, & 3 X + 1 \\ X è strano, & ⌊ \frac{X}{2} ⌋ \end{cases}

$f(x) = \begin{cases} x \: \text{is even}, & 3x+1 \\ x \: \text{is odd}, & \lfloor\frac{x}{2}\rfloor \end{cases}$

In modalità funzione, Aggiungi ++ utilizza un modello di memoria dello stack, altrimenti vengono utilizzate le variabili. Nel calcolo $f(x)$ , inizialmente sembra che lo stack $S = [x]$ .

Quindi dupliciamo questo valore ( d), per produrre $S = [x, x]$ . Diamo quindi la prima opzione possibile, $3x + 1$ ( 3*1+), scambia i primi due valori, quindi calcola $\lfloor\frac{x}{2}\rfloor$ , leaving $S = [3x+1, \lfloor\frac{x}{2}\rfloor]$ .

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, \lfloor\frac{x}{2}\rfloor, (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, $\lfloor\frac{x}{2}\rfloor$ .

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.

— caird coinheringaahing
fonte

Just to understand: Is the break line part of the code? Or is it just for better explanation? I don't really know this language.

— Eduardo Hoefel

@EduardoHoefel Break line?

— caird coinheringaahing

@cairdcoinheringaahing The newline characters, presumably.

— Lynn

0

Retina 0.8.2, 46 bytes

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

Try it online! Explanation:

.+
$*

Convert to unary.

Repeat until the value stops changing.

*M`1

Print the value in decimal.

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

If it is even, multiply by 6 and add 3.

1(.*)\1
$1

Subtract 1 and divide by 2.

The trailing newline can be suppressed by adding a ; before the {.

— Neil
fonte

0

Red, 70 bytes

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

Try it online!

— Galen Ivanov
fonte

0

Racket, 75 bytes

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

Try it online!

Equivalent to JRowan's Common Lisp solution.

— Galen Ivanov
fonte

0

C# (.NET Core), 62 bytes

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

Try it 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)
}

— Meerkat
fonte

0

Dart, 49 bytes

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

Try it online!

— Elcan
fonte

0

Gambit Scheme (gsi), 74 bytes

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

Try it online!

— Comrade SparklePony
fonte

La congettura inversa di Collatz

Casi test:

Regole:

Perl 6 , 30 byte

Spiegazione:

Haskell , 40 39 byte

Pulito , 53 byte

Gelatina , 9 byte

Python 2, 54 52 44 byte

Haskell , 76 69 61 56 byte

Ruggine , 65 64 byte

05AB1E , 15 14 byte

JAEL , 18 byte

JavaScript (ES6), 31 byte

Pyth , 12 byte

Wolfram Language (Mathematica) , 35 byte

Lisp comune , 79 byte

PowerShell, 53 52 byte

Emojicode 0,5 , 141 byte

Stax , 11 byte

MathGolf , 12 byte

Spiegazione

codice macchina x86, 39 byte

R , 66 61 byte

perl -Minteger -nlE, 39 byte

Aggiungi ++ , 38 35 33 byte

Come funziona

Retina 0.8.2, 46 bytes

Red, 70 bytes

Racket, 75 bytes

C# (.NET Core), 62 bytes

Dart, 49 bytes

Gambit Scheme (gsi), 74 bytes