Dies ist eine Code-Golf-Herausforderung, an die ich mit mathematischer Neigung dachte. Die Herausforderung besteht darin, den kürzestmöglichen Code so zu schreiben, dass offen ist, ob der Code terminiert oder nicht. Ein Beispiel für das, was ich meine, könnte der folgende Teil des Python-Codes sein, der von einer Antwort auf diese Frage von cs stackexchange angepasst wurde .

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

Mathematiker vermuten, dass es keine ungeraden perfekten Zahlen gibt, aber es wurde nie bewiesen, sodass niemand weiß, ob dieser Code jemals enden wird. Können Sie sich andere Codeteile ausdenken (die sich möglicherweise auf andere offene Probleme wie die Collatz-Vermutung oder die Doppelprimus-Vermutung stützen), die kürzer sind, für die jedoch nicht bekannt ist, ob sie enden oder nicht?

Bearbeiten: Einige Leute haben eine gute Zusatzregel vorgebracht - Die Lösungen für die Frage sollten deterministisch sein. Obwohl es noch interessanter sein könnte, wenn Sie kürzere Lösungen mit Nichtdeterminismus finden könnten. In diesem Fall lautet die Regel, ein Snippet zu finden, für das die Wahrscheinlichkeit der Beendigung unbekannt ist.

Gelee , 7 Bytes

!‘Ʋµ4#

Probieren Sie es online!

Hintergrund

Dies wird beendet, sobald eine vierte Lösung für das Brocard-Problem gefunden wurde , dh eine Lösung n! + 1 = m² mit (n, m) ≠ (4, 5), (5, 11), (7, 71) über den positiven ganzen Zahlen. Die Implementierung verwendet keine Gleitkomma-Arithmetik und wird daher nur beendet, wenn eine vierte Lösung gefunden wird oder wenn n! kann nicht mehr im Speicher dargestellt werden.

Das Problem von Brocard wurde zum ersten Mal in dieser Antwort von @xnor verwendet.

Wie es funktioniert

!‘Ʋµ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.

Jelly , 11 9 Bytes

ÆẸ⁺‘ÆPµ6#

Dies wird beendet, sobald die sechste Fermat-Primzahl gefunden wurde.

Probieren Sie es online!

Wie es funktioniert

ÆẸ⁺‘Æ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 Bytes

fP_h^2^2T5

Verwendet die Vermutung, dass alle Fermat-Zahlen zusammengesetzt 2^(2^n)+1 sind n>4.

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

Python, 36 Bytes

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

Verwendet Brocards Problem :

Ist n! +1 ein perfektes Quadrat für ein beliebiges n≥8?

Berechnet aufeinanderfolgende Fakultäten und überprüft, ob sie Quadrate sind und haben k>7. Danke an Dennis für 2 Bytes!

Dies setzt voraus, dass Python weiterhin eine genaue Arithmetik für beliebig große Zahlen besitzt. In der tatsächlichen Implementierung wird es beendet.

Perl, 50 38 36 34 33 Bytes

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

Erklärung: 196 ist eine mögliche Lychrel-Zahl - eine Zahl, die kein Palindrom bildet, indem sie wiederholt das Gegenteil zu sich selbst hinzufügt. Die Schleife wird fortgesetzt, bis $ n der Umkehrung entspricht, die für den Anfangswert 196 noch unbekannt ist.

25 + 52 = 77

das ist nicht gültig.

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

Daher ist keine der Zahlen in dieser Reihenfolge gültig.

Bearbeiten: Golfed es mit einer till-Schleife anstelle einer for-Schleife (irgendwie). Außerdem hatte ich weniger Bytes, als ich dachte (ich sollte mir mein Bytecount in Zukunft genauer ansehen).

Bearbeiten: Ersetzt $ndurch $_, um 2 Bytes für das implizite Argument in zu speichern reverse. Ich denke, das ist so gelungen, wie es diese Implementierung bringen wird.

Edit: Ich habe mich geirrt. Anstelle der Verwendung von until($%=reverse)==$_mir gehen kann , während die Differenz nicht Null ist (dh true): while($%=reverse)-$_.

MATL, 11 Bytes

`@QEtZq&+=z

Beendet, wenn die Goldbach-Vermutung falsch ist. Das heißt, das Programm stoppt, wenn es eine gerade Zahl findet, die größer 2ist als die Summe zweier Primzahlen.

`        % 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 Bytes

Wird beendet, wenn die 6. Fermat-Primzahl gefunden wurde.

5µNoo>p½

Erläuterung

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 Bytes

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

Dieses Programm wird genau dann angehalten, wenn eine ganze Zahl n größer als 1 ist, sodass 2 ^ (n-1) -1 durch n ^ 3 teilbar ist. Meines Wissens ist nicht bekannt, ob eine Zahl mit dieser Eigenschaft existiert (wenn eine Zahl, die diese Eigenschaft erfüllt, eine Primzahl ist, wird sie Wieferich-Primzahl der Ordnung 3 zur Basis 2 genannt, und es ist offen, ob eine solche Primzahl existiert).

Haskell, 47 Bytes

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

Durchsuchen der ersten Quasiperfekt-Zahl , bei der es sich um eine Zahl handelt, nderen Summe aus Teilern besteht 2*n+1. Anstatt 1 hinzuzufügen, schließe ich 1 aus der Liste der Teiler aus.

Brain-Flak, 212 208 204 Bytes

Dieses Programm verwendet einen von MegaTom geschriebenen Multiplikationsalgorithmus und einen von 1000000000 geschriebenen Nicht-Quadrat-Checker

Probieren Sie es online

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

Dieses Programm startet bei 8 und testet jede Zahl, um festzustellen, ob n! +1 eine quadratische Zahl ist. Es wird beendet, wenn es eines findet. Dies ist als Brocard-Problem bekannt und in der Mathematik ein offenes Problem.

Brachylog (v2), 3 Bytes in der Brachylog-Codierung

⟦cṗ

Probieren Sie es online! (Aus offensichtlichen Gründen wird die Zeit abgelaufen, ohne dass etwas sichtbar ist.)

Volles Programm; Wenn es ohne Eingabe ausgeführt wird, wird nach der ersten Smarandache-Primzahl gesucht und ausgegeben, true.ob und wann eine gefunden wird. Es ist eine offene Frage, ob Smarandache-Primzahlen existieren. (Beachten Sie, dass der Brachylog-Algorithmus zum Testen von Primzahlen, obwohl er theoretisch mit beliebig großen Zahlen arbeitet, in der Regel langsam ausgeführt wird. Wenn Sie also selbst nach Smarandache-Primzahlen suchen möchten, empfehle ich, eine andere Sprache zu verwenden.)

Erläuterung

⟦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 verarbeitet die Dezimalstellen einer Zahl, wenn Sie versuchen, sie wie eine Liste zu behandeln. Daher ist "range" gefolgt von "concatenate" eine sehr knappe Methode, um die Folge von Smarandache-Zahlen zu generieren (und dann filtern wir diese nach der Primalität; Brachylogs) Das Standardverhalten des vollständigen Programms erzwingt dann das erste Element des resultierenden Generators. Der Bereich hat eine führende Null, aber zum Glück entfernt Brachylog mit diesem Flussmuster die Null, anstatt zu scheitern.

Hier ist ein Beispiel, in dem die erste Smarandache-Nummer gefunden wird, die gleich 6 ist (Mod 11), als Demonstration eines ähnlichen Programms, das innerhalb von 60 Sekunden beendet wird, anstatt einen unbekannten Stoppstatus zu haben:

⟦c{-₆~×₁₁&}

Probieren Sie es online!

Dies würde true.als vollständiges Programm ausgegeben, aber ich habe das ZKommandozeilenargument eingegeben, um die fragliche Zahl tatsächlich auszudrucken, was besser demonstriert, dass dieser allgemeine Ansatz funktioniert.

Python 2, 88 Bytes

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)

Dieser Code endet, wenn 10223 eine Sierpiński-Nummer ist. 10223 ist derzeit der kleinste Kandidat, der ab Dezember 2013 eine Sierpiński-Zahl sein kann oder nicht.

Eine Sierpiński-Zahl ist eine Zahl, kbei der alle Zahlen der Form zusammengesetzt (k * 2^n) + 1sind.

Pyth, 16 Bytes

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

Gibt den ersten Wert zurück, für den die Collatz-Vermutung nicht gilt. Da nicht bekannt ist, ob die Vermutung für alle Zahlen gilt, ist nicht bekannt, ob dieser Code enden wird.

Eigentlich 16 Bytes

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

Probieren Sie es online!

Dieser Code endet, wenn es eine zusammengesetzte Zahl gibt n, die sich totient(n)teilt n-1( Lehmers totientes Problem ).

Erläuterung:

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

Gelee , 9 8 Bytes

-1 Byte dank @Dennis! (Verwenden Sie Exponentiation anstelle von Multiplikation, um zu vermeiden Æṣ(0))

*ḂÆṣ=µ2#

Gibt eine Liste mit Null und der kleinsten ungeraden perfekten Zahl zurück , falls vorhanden.

Wie?

*ḂÆṣ=µ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 Bytes

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

Beendet sich, wenn die vierte Lösung für das Brocard-Problem gefunden wird .

Python, 92 Bytes

Dies ist kein Gewinn bei Code-Golf-Wettbewerben, und es erfordert unendlich viel Speicher und Rekursionstiefe, aber dies ist eine fast perfekte Gelegenheit, ein interessantes Problem zu lösen, das ich vor zwei Jahren beim Mathematikstapel-Austausch gefragt habe, dass keine Fibonacci-Zahl größer als 8 die Summe ist von zwei positiven Würfeln . Witzigerweise begann es als Code-Golf-Challenge-Idee, also habe ich wohl den Kreis geschlossen.

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 Bytes

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)

Dieser Code endet, wenn die Goldbach-Vermutung nicht für alle geraden Zahlen gilt (dh wenn alle geraden Zahlen als Summe von zwei Primzahlen ausgedrückt werden können). Es wurde derzeit auf Nummern bis zu 4 * 10 ^ 18 getestet.

Ein großes Dankeschön an @ Pietu1998 für die enorme Verkürzung meines Codes!

BEARBEITEN: Danke an @ JonathanAllan für das Rasieren von 6 Bytes meines Codes!

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

Verwendet die gleiche Methode wie die Perl-Antwort: Setzt n auf 196 und addiert dann wiederholt n zu seiner Basis 10-Umkehrung, bis es ein Palindrom in Basis 10 ist.

Python, 80 Bytes

Beendet, wenn die Collatz-Vermutung als falsch erwiesen ist. Siehe diese Frage .

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 Bytes

Eine Lychrel-Zahl ist eine natürliche Zahl, die kein Palindrom bilden kann, wenn die Ziffern wiederholt umgedreht und die resultierenden Zahlen addiert werden.

Es wurde nachgewiesen, dass keine Lychrel-Zahlen in der Basis 10 existieren. 196 ist der Kandidat für die kleinste Lychrel-Zahl zur Basis zehn. Es hat sich gezeigt, dass ein Palindrom, wenn es existiert (196 ist keine Lychrel-Zahl), mindestens eine Milliarde (10 ^ 9) Stellen hat, weil die Leute den Algorithmus so lange ausgeführt haben.

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

Gelee , 7 Bytes

*+3Ẓµ4#

Probieren Sie es online! (druckt zwei Elemente, nicht 4, damit du es halt tatsächlich sehen kannst)

$n$$n^n+3$

Erläuterung

*+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 Bytes, fraglich, ob es deterministisch ist

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

Der Standard-Zufallszahlengenerator von R hat in 653 aufeinanderfolgenden Dimensionen die gleiche Verteilung, in 654 Dimensionen ist dies jedoch nicht bekannt. Somit kann es eine Folge von Pseudozufallszahlen geben oder nicht, die das niedrigste Element von einem gegebenen Vektor 654-mal in einer Reihe (hier dem Vektor 1:2) abtasten .

Da Rs RNG periodisch ist (wenn auch mit sehr langer Periode), behaupte ich, dass dies deterministisch ist , da es schließlich eine Schleife zum Start gibt. Ihre Meinung kann natürlich abweichen.

Python 3, 101 Bytes

Ich weiß, es ist länger als viele andere, aber ich habe viel Zeit damit verbracht zu sehen, wie kurz ich das Golf spielen kann.

Dies versucht, Eulers Sum of Powers Conjecture für k=6(es gibt keine positive ganzzahlige Lösung der diophantinischen Gleichung A^6+B^6+C^6+D^6+E^6==F^6), für die kein Gegenbeispiel gefunden wurde, zu widerlegen .

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

Weniger golfen:

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

Mathy-Version ohne Auswertung:

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

Alternativer Verweis: Eulers Sum of Powers-Vermutung - MathWorld

Python, 68 Bytes

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

Probieren Sie es online aus

Versucht, eine von Gelfands Fragen zu beantworten .

2. Wird die Zeile "23456789" jemals für n> 1 angezeigt? Keine gilt für n <= 10 ^ 5. ...

Clojure, 154 Bytes

(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))))

Prüft, ob es eine Zahl über 82.000 gibt, die nur Nullen und Einsen für die Basis 2 bis zur Basis 5 enthält. Mit anderen Worten, es wird geprüft, ob es eine andere Zahl in dieser Sequenz gibt .

In dieser speziellen Gruppe gibt es nur drei Zahlen: 0, 1und 82,000. Nach dieser Regel gibt es keine weiteren Zahlen, die weniger als ungefähr sind 3*10^19723.

Pyt , 14 Bytes

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

Port von mbomb007's Antwort .