Questa è una sfida di golf del codice che ho pensato con una piega matematica. La sfida è scrivere il codice più breve possibile in modo che sia una domanda aperta se il codice termina o meno. Un esempio di ciò che intendo potrebbe essere il seguente pezzo di codice Python, adattato da una risposta a questa domanda cs stackexchange.

def is_perfect(n):
    return sum(i for i in range(1, n) if n % i == 0) == n

n = 3
while not is_perfect(n):
    n = n + 2

I matematici ipotizzano che non ci siano numeri perfetti dispari, ma non è mai stato provato, quindi nessuno sa se questo pezzo di codice finirà mai. Puoi trovare altri pezzi di codice (forse basandoti su altri problemi aperti come la congettura di Collatz o la congettura dei primi gemelli) che sono più brevi, ma per i quali non si sa se terminano o no?

Modifica: alcune persone hanno introdotto una buona regola aggiuntiva: le soluzioni alla domanda dovrebbero essere deterministiche. Anche se potrebbe essere ancora più interessante se tu potessi trovare soluzioni più brevi usando il non determinismo. In questo caso, la regola sarebbe quella di trovare uno snippet per il quale non è nota la probabilità di terminazione.

Gelatina , 7 byte

!‘Ʋµ4#

Provalo online!

sfondo

Questo terminerà quando troverà una quarta soluzione al problema di Brocard , ovvero una soluzione n! + 1 = m² con (n, m) ≠ (4, 5), (5, 11), (7, 71) sugli interi positivi. L'implementazione non usa l'aritmetica in virgola mobile, quindi termina solo se trova una quarta soluzione o se n! non può più essere rappresentato in memoria.

Il problema di Brocard è stato usato per la prima volta in questa risposta da @xnor.

Come funziona

!‘Ʋµ4#  Main link. No arguments. Implicit argument: 0

    µ4#  Convert the links to the left into a monadic chain and call it with
         arguments k = 0, 1, 2, ... until 4 of them return 1.
!        Factorial; yield k!.
 ‘       Increment; yield k! + 1.
  Ʋ     Squareness; return 1 if k! + 1 is a perfect square, 0 if not.

Gelatina , 11 9 byte

ÆẸ⁺‘ÆPµ6#

Questo terminerà una volta trovato il sesto numero primo di Fermat .

Provalo online!

Come funziona

ÆẸ⁺‘ÆPµ6#  Main link. No arguments. Implicit argument: 0

      µ6#  Convert the links to the left into a monadic chain and call it with
           arguments k = 0, 1, 2, ... until 6 of them return 1.
ÆẸ         Convert [k] to the integer with that prime exponent factorization, i.e.,
           into 2 ** k.
  ⁺        Repeat.
   ‘       Increment.
           We've now calculated 2 ** 2 ** k + 1.
    ÆP     Test the result for primality.

Pyth, 10 byte

fP_h^2^2T5

Utilizza la congettura per cui tutti i numeri di Fermat 2^(2^n)+1 sono composti n>4.

f        5   Find the first number T>=5 for which
   h^2^2T    2^(2^T)+1
 P_          is prime                   

Python, 36 byte

k=n=1
while(n+1)**.5%1+7/k:k+=1;n*=k

Usa il problema di Brocard :

N! +1 è un quadrato perfetto per qualsiasi n≥8?

Calcola fattoriali successivi e verifica se sono quadrati e hanno k>7. Grazie a Dennis per 2 byte!

Ciò presuppone che Python continui ad avere un'aritmetica accurata per numeri arbitrariamente grandi. Nell'attuazione effettiva, termina.

Perl, 50 38 36 34 33 byte

$_=196;$_+=$%while($%=reverse)-$_

Spiegazione: 196 è un possibile numero di Lychrel - un numero che non forma un palindromo aggiungendo ripetutamente il suo rovescio a se stesso. Il ciclo continua fino a $ n è uguale al suo contrario, che è ancora sconosciuto per il valore iniziale 196.

25 + 52 = 77

che non è valido.

96 + 69 = 165
165 + 561 = 726
726 + 627 = 1353
1353 + 3531 = 4884

quindi nessuno dei numeri in questa sequenza è valido.

Modifica: golfato utilizzando un ciclo until anziché un ciclo for (in qualche modo). Inoltre, avevo meno byte di quanto pensassi (probabilmente dovrei guardare il mio byte più attentamente in futuro).

Modifica: sostituito $ncon $_per salvare 2 byte per l'argomento implicito in reverse. Penso che sia tanto golf quanto questa implementazione avrà.

Modifica: ho sbagliato. Invece di usare until($%=reverse)==$_posso andare, mentre la differenza è diverso da zero (cioè vero): while($%=reverse)-$_.

MATL, 11 byte

`@QEtZq&+=z

Termina se la congettura di Goldbach è falsa. Cioè, il programma si interrompe se trova un numero pari maggiore di quello 2che non può essere espresso come la somma di due numeri primi.

`        % Do...while
  @      %   Push iteration index k. Gives 1, 2, 3, ...
  QE     %   Add 1 and multiply by 2. Gives 4, 6, 8, ...
  tZq    %   Duplicate. Push all primes up to current k
  &+     %   Matrix with all pairwise additions of those primes
  =z     %   Number of entries of that matrix that equal k. This is used as loop
         %   condition. That is, the loop continues if this number is nonzero
         % Implicit end

05AB1E , 8 byte

Termina quando viene trovato il 6o primo Fermat .

5µNoo>p½

Spiegazione

5µ          # loop over increasing N (starting at 1) until counter reaches 5
  Noo       # 2^2^N
     >      # + 1
      p½    # if prime, increase counter

Python, 30 28 byte

n=2
while 2**~-n%n**3-1:n+=1

Questo programma si arresterà se e solo se esiste un numero intero n maggiore di 1 in modo tale che 2 ^ (n-1) -1 sia divisibile per n ^ 3. Per quanto ne sappia, non è noto se esiste un numero con questa proprietà (se un numero che soddisfa questa proprietà è primo, viene chiamato un primo di Wieferich dall'ordine 3 alla base 2, ed è aperto se esiste uno di questi primi).

Haskell, 47 byte

[n|n<-[1..],2*n==sum[d|d<-[2..n],n`mod`d<1]]!!0

Cercando il primo numero quasiperfect , che è un numero la ncui somma di divisori è 2*n+1. Invece di aggiungere 1, escludo 1 dall'elenco dei divisori.

Brain-Flak, 212 208 204 byte

Questo programma utilizza un algoritmo di moltiplicazione scritto da MegaTom e un controllo non quadrato scritto da 1000000000

Provalo online

(((()()()()){})){{}((({}()))<{(({})[()])}{}>[()]){({}<({}<>)({<({}[()])><>({})<>}{}<><{}>)>[()])}{}(({}())){(({}[()]<>)<>)(({({})({}[()])}{}[({})]<>)){{}{}({}<>)(<([()])>)}{}({}()){(((<{}{}<>{}>)))}{}}{}}

Questo programma inizia alle 8 e verifica ogni numero per vedere se n! +1 è un numero quadrato. Esce quando ne trova uno. Questo è noto come Problema di Brocard ed è un problema aperto in matematica.

Brachylog (v2), 3 byte nella codifica di Brachylog

⟦cṗ

Provalo online! (andrà in timeout senza fare nulla di visibile, per ovvi motivi)

Programma completo; se eseguito senza input, cerca il primo primo di Smarandache ed emettetrue. se e quando ne trova uno. È una domanda aperta sull'esistenza di numeri primi di Smarandache. (Si noti che l'algoritmo di primo test di Brachylog, sebbene funzioni in teoria su numeri arbitrariamente grandi, tende a correre lentamente su di essi; quindi, se sei interessato a trovare i numeri primi di Smarandache, ti consiglio di usare una lingua diversa.)

Spiegazione

⟦cṗ
⟦     Form an increasing range from 0 to {the smallest number with no assertion failure} 
 c    Concatenate all the numbers that make up that range, in decimal
  ṗ   Assert that the result is prime

Brachylog opera sulle cifre decimali di un numero ogni volta che provi a trattarlo come un elenco, quindi "intervallo" seguito da "concatenare" è un modo molto conciso per generare la sequenza di numeri Smarandache (e quindi filtriamo per primalità; Brachylog's il comportamento predefinito del programma completo forzerà quindi il primo elemento del generatore risultante). L'intervallo ha uno zero iniziale, ma per fortuna, con questo schema di flusso, Brachylog rimuove lo zero anziché fallire.

Ecco un esempio che trova il primo numero di Smarandache che è uguale a 6 (mod 11), come dimostrazione di un programma simile che termina entro 60 secondi anziché avere uno stato di arresto sconosciuto:

⟦c{-₆~×₁₁&}

Provalo online!

Questo verrebbe stampato true.come un programma completo, ma ho gettato l' Zargomento della riga di comando per stampare effettivamente il numero in questione, dando una migliore dimostrazione che questo approccio generale funziona.

Python 2, 88 byte

p=lambda n:all(n%x for x in range(2,n))
s=lambda n:0if p((10223*2**n)+1)else s(n+1)
s(0)

Questo codice terminerà se 10223 è un numero Sierpiński. 10223 è attualmente il più piccolo candidato che può o meno essere un numero Sierpiński, a partire da dicembre 2013.

Un numero Sierpiński è un numero kin cui tutti i numeri del modulo (k * 2^n) + 1sono composti.

Pyth, 16 byte

f!}1.u@,/G2h*3GG

Restituisce il primo valore per il quale la congettura di Collatz non regge. Poiché non è noto se la congettura valga per tutti i numeri, non è noto se questo codice verrà chiuso.

In realtà , 16 byte

1`;;pY)▒@D÷íu*`╓

Provalo online!

Questo codice termina se esiste un numero composto ntale da totient(n)dividere n-1( il problema totale di Lehmer ).

Spiegazione:

1`;;pY)▒@D÷íu*`╓
1`            `╓  first integer, starting with 0, where the following function leaves a truthy value on top of the stack:
    pY       *      composite (not prime) and
   ;  )▒            totient(n)
  ;     @D֒u       is in the list of divisors of n-1

Gelatina , 9 8 byte

-1 byte grazie a @Dennis! (usa l'espiazione invece della moltiplicazione per evitare Æṣ(0))

*ḂÆṣ=µ2#

Restituirà un elenco di zero e il numero perfetto dispari più piccolo , se presente.

Come?

*ḂÆṣ=µ2# - Main link: no arguments
     µ   - monadic chain separation
      2# - count up from implicit `n=0` and return the first 2 truthy results of
 Ḃ       -     mod 2        -> n%2
*        -     exponentiate -> n**(n%2)  (1 when n is even, n when n is odd)
  Æṣ     -     sum of proper divisors of n**(n%2)
    =    -     equals n?    -> 1 if n is zero or both perfect and odd, else 0

Haskell, 46 byte

[n|m<-[1..],n<-[1..m],product[1..n]+1==m^2]!!3

Termina se trova la 4a soluzione al problema di brocard .

Python, 92 byte

Questo non sta vincendo alcuna competizione di codice golf, e richiede memoria infinita e profondità di ricorsione, ma questa è un'opportunità quasi perfetta per collegare un problema interessante che ho chiesto a StackExchange matematico due anni fa, che nessun numero di Fibonacci maggiore di 8 è la somma di due cubi positivi . Stranamente, è iniziato come un'idea di sfida per il golf del codice, quindi credo di essere tornato al punto di partenza.

def f(i,j):
 r=range(i)
 for a in r:
  for b in r:
   if a**3+b**3==i:1/0
 f(j,i+j)
f(13,21)

Python 2, 123 98 92 byte

p=lambda n,k=2:n<=k or n%k*p(n,k+1)
g=lambda n:[p(b)*p(n-b)for b in range(n)]and g(n+2)
g(4)

Questo codice terminerà se la congettura di Goldbach non vale per tutti i numeri pari (cioè se tutti i numeri pari possono essere espressi come la somma di due numeri primi). Attualmente è stato testato per numeri fino a 4 * 10 ^ 18.

Grazie mille a @ Pietu1998 per aver abbreviato molto il mio codice!

EDIT: Grazie a @JonathanAllan per aver rasato 6 byte dal mio codice!

JavaScript (ES6), 104 101 byte

for(n=[6,9,p=1];!p;n=n.map((x,i)=>(q=n[n.length+~i],p|=x^q,c=q+x+c/10|0)%10).concat(c/10|0||[]))c=p=0

Utilizza lo stesso metodo della risposta Perl: imposta n su 196, quindi aggiunge ripetutamente n al suo contrario di base 10 fino a quando non è un palindromo in base 10. Questo sarebbe più breve se JS supportasse numeri di precisione arbitraria, ma vabbè.

Python, 80 byte

Termina se la congettura di Collatz si dimostra falsa. Vedere questa domanda .

n=2
while 1:
 L=[];x=n
 while~-n:1/(n not in L);L+=[n];n=(n/2,n*3+1)[n%2]
 n=x+1

Python 2, 64 byte

Un numero di Lychrel è un numero naturale che non può formare un palindromo attraverso il processo iterativo di invertire ripetutamente le sue cifre e aggiungere i numeri risultanti.

Nessun numero di Lychrel ha dimostrato di esistere nella base dieci. 196 è il numero dieci più piccolo candidato Lychrel di base. È stato dimostrato che se un palindromo esiste (rendendo 196 non un numero di Lychrel), avrebbe almeno un miliardo (10 ^ 9) cifre, perché le persone hanno eseguito l'algoritmo così a lungo.

n=196
while 1:
    x=str(n);r=x[::-1]
    if x!=r:n=n+int(r)
    else:1/0

Gelatina , 7 byte

*+3Ẓµ4#

Provalo online! (stampa due elementi, non 4, in modo da poterlo effettivamente vedere arrestare)

$n$$n^n+3$

Spiegazione

*+3Ẓµ4#
     4#  Find the first four numbers with the following property:
    µ      (bracketing/grouping: place everything to the left inside the loop)
*          {The number} to the power of {itself}
 +3        plus 3
   Ẓ       is prime

R, 30 byte, discutibile se sia deterministico

while(any(sample(2,654,T)>1))1

Il generatore di numeri casuali predefinito di R ha equidistribuzione in 653 dimensioni consecutive ma non è noto in 654 dimensioni. Quindi potrebbe esserci o meno una sequenza di numeri pseudocasuali che campionano l'elemento più basso da un dato vettore 654 volte di seguito (qui il vettore1:2 ).

Dal momento che RNG di R è periodico (anche se con un periodo molto lungo), sostengo che questo è deterministico poiché alla fine si arrotolerà all'inizio. Le tue opinioni possono essere diverse, ovviamente.

Python 3, 101 byte

So che è più lungo di molti altri, ma ho trascorso molto tempo a vedere quanto potevo giocare a golf.

Questo tenta di confutare la congettura della somma dei poteri di Eulero per k=6(non esiste una soluzione intera positiva all'equazione diofantea A^6+B^6+C^6+D^6+E^6==F^6), per la quale non è stato trovato alcun controesempio.

R=[1]
while 1:R+=[R[-1]+1];eval(("[1/("+"+%s**6"*5+"!=%%s**6)%s]"%("for %s in R "*6))%(*"ABCDEF"*2,))

In Python 2 (104 byte):

R=[1]
while 1:R+=[R[-1]+1];eval(("[1/("+"+%s**6"*5+"!=%%s**6)%s]"%("for %s in R "*6))%tuple("ABCDEF"*2))

Meno golf:

x=2
while 1:
    R=range(1,x)
    [1/(A**6+B**6+C**6+D**6+E**6!=F**6)for F in R for E in R for D in R for C in R for B in R for A in R]
    x+=1

Versione Mathy senza valutazione:

R=range
x=2
while 1:
    for i in R(x**6):1/(sum(map(lambda x:x**6,[1+(i%x**-~j/x**j)for j in R(6)]))-i%x-1)
    x+=1

Riferimento alternativo: Congettura della somma dei poteri di Eulero - MathWorld

Python, 68 byte

n=2
while"".join(str((i+2)**n)[0]for i in range(8))!="23456789":n+=1

Provalo online

Cerca di rispondere a una delle domande di Gelfand .

2. La riga "23456789" verrà mai visualizzata per n> 1? Nessuno fa per n <= 10 ^ 5. ...

Clojure, 154 byte

(loop[x 82001](if(= 0(reduce +(map{true 1 false 0}(for[y(range 3 6)](true?(for[z(str(range 2 y))](.indexOf z(Integer/toString x y))))))))x(recur(inc x))))

Verifica se esiste un numero superiore a 82.000 che contiene solo 0 e 1 per la base 2 fino alla base 5. In altre parole, controlla se c'è un altro numero in questa sequenza .

In questo gruppo speciale, ci sono solo 3 numeri: 0, 1e 82,000. Non ci sono più numeri che seguono quella regola che sono meno di approssimativamente 3*10^19723.

Pyt , 14 byte

27*²0`ŕĐ₫+Đ₽¬ł

La risposta di Port of mbomb007 .