Il tuo compito è creare la funzione di crescita più lenta che puoi in non più di 100 byte.

Il tuo programma prenderà come input un numero intero non negativo e produrrà un numero intero non negativo. Chiamiamo il tuo programma P.

Deve soddisfare questi due criteri:

• Il codice sorgente deve essere inferiore o uguale a 100 byte.
• Per ogni K, esiste una N, tale che per ogni n> = N, P (n)> K. In altre parole, lim _{(n-> ∞)} P (n) = ∞ . (Questo è ciò che significa "crescere").

Il tuo "punteggio" è il tasso di crescita della funzione sottostante del tuo programma.

Più specificamente, il programma P diventa più lento di Q se c'è una N tale che per tutti n> = N, P (n) <= Q (n), e c'è almeno un n> = N tale che P (n ) <Q (n). Se nessuno dei due programmi è migliore dell'altro, sono legati. (Essenzialmente, quale programma è più lento si basa sul valore di lim _{(n-> ∞)} P (n) -Q (n).)

La funzione di crescita più lenta è definita come quella che cresce più lentamente di qualsiasi altra funzione, secondo la definizione del paragrafo precedente.

Questo è il golf con tasso di crescita , quindi vince il programma a crescita più lenta!

Gli appunti:

• Per facilitare il calcolo del punteggio, prova a mettere la funzione calcolata dal tuo programma nella risposta.
• Inserisci anche alcuni input (teorici) e output, per aiutare le persone a capire quanto lentamente puoi andare.

Haskell, 98 byte, punteggio = f _{ε 0} ⁻¹ ( n )

_#[]=0
k#(0:a)=k#a
k#(a:b)=1+(k#(([1..k]>>fst(span(>=a)b)++[a-1])++b))
f n=[k|k<-[0..],k#[k]>n]!!0

Come funziona

Questo calcola l'inverso di una funzione in rapida crescita correlata al gioco worm di Beklemishev . Il suo tasso di crescita è paragonabile a f _{ε 0} , dove f _α è la gerarchia in rapida crescita e ε ₀ è il primo numero epsilon .

Per un confronto con altre risposte, si noti che

• esponenziazione è paragonabile a f ₂ ;
• esponenziazione iterata ( tetrazione o ↑↑ ) è paragonabile a f ₃ ;
• ↑↑ ⋯ ↑↑ con le frecce m è paragonabile a f _{m + 1} ;
• La funzione di Ackermann è paragonabile a f _ω ;
• ripetute iterazioni della funzione di Ackermann (costruzioni come il numero di Graham ) sono ancora dominate da f _{ω + 1} ;
• e ε ₀ è il limite di tutte le torri ω ^{ω ω ⋰ ω} .

Brachylog , 100 byte

llllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllll

Provalo online!

Questo probabilmente non è affatto vicino alla lentezza di alcune altre risposte fantasiose, ma non potevo credere che nessuno avesse provato questo approccio semplice e bello.

Semplicemente, calcoliamo la lunghezza del numero di input, quindi la lunghezza di questo risultato, quindi la lunghezza di questo altro risultato ... 100 volte in totale.

Questo cresce velocemente come log (log (log ... log (x), con 100 log di base-10.

Se inserisci il tuo numero come stringa , questo verrà eseguito molto velocemente su qualsiasi input che potresti provare, ma non aspettarti di vedere mai un risultato superiore a 1: D

JavaScript (ES6), Inverse Ackermann Function *, 97 byte

* se l'ho fatto bene

A=(m,n)=>m?A(m-1,n?A(m,n-1):1):n+1
a=(m,n=m,i=1)=>{while(A(i,m/n|0)<=Math.log2(n))i++;return i-1}

La funzione Aè la funzione Ackermann . La funzione adovrebbe essere la funzione inversa di Ackermann . Se l'ho implementato correttamente, Wikipedia dice che non colpirà 5fino a quando non sarà muguale 2^2^2^2^16. Vado in StackOverflowgiro 1000.

Uso:

console.log(a(1000))

spiegazioni:

Funzione di Ackermann

A=(m,n)=>                           Function A with parameters m and n
         m?                   :n+1  If m == 0, return n + 1; else,
           A(m-1,n?        :1)       If n == 0, return A(m-1,1); else,
                   A(m,n-1)          return A(m-1,A(m,n-1))

Funzione inversa di Ackermann

a=(m,n=m,i=1)=>{                                                Function a with parameter m, with n preinitialized to m and i preinitialized to 1
                while(A(i,m/n|0)<=Math.log2(n))                 While the result of A(i, floor(m/n)) is less than log₂ n,
                                               i++;             Increment i
                                                   return i-1}  Return i-1

Pure Evil: Eval

a=lambda x,y:(y<0)*x or eval("a("*9**9**9+"x**.1"+",y-1)"*9**9**9)
print a(input(),9**9**9**9**9)//1

L'affermazione all'interno di eval crea una stringa di lunghezza 7 * 10 ^{10 10 10 10 10 8.57} che consiste in nient'altro che più chiamate alla funzione lambda ciascuna delle quali costruirà una stringa di lunghezza simile , avanti e yindietro fino a diventare 0. Apparentemente questo ha la stessa complessità del metodo Eschew di seguito, ma piuttosto che basarsi sulla logica if-and-o control, rompe semplicemente stringhe giganti (e il risultato netto sta ottenendo più stack ... probabilmente?).

Il yvalore più grande che posso fornire e calcolare senza che Python generi un errore è 2, che è già sufficiente per ridurre un input di max-float nel ritorno 1.

Una stringa di lunghezza 7.625.597.484.987 è semplicemente troppo grande: OverflowError: cannot fit 'long' into an index-sized integer.

Dovrei smettere.

Eschew Math.log: andando alla (decima) radice (del problema), Punteggio: funzione effettivamente indistinguibile da y = 1.

L'importazione della libreria matematica sta limitando il conteggio dei byte. Eliminiamo ciò e sostituiamo la log(x)funzione con qualcosa di approssimativamente equivalente: x**.1e che costa approssimativamente lo stesso numero di caratteri, ma non richiede l'importazione. Entrambe le funzioni hanno un output sublineare rispetto all'input, ma x ^0,1 cresce ancora più lentamente . Tuttavia, non ci interessa molto, ci importa solo che abbia lo stesso modello di crescita di base rispetto ai grandi numeri mentre consuma un numero comparabile di caratteri (ad es. x**.9È lo stesso numero di caratteri, ma cresce più rapidamente, quindi lì è un valore che mostrerebbe la stessa identica crescita).

Ora, cosa fare con 16 personaggi. Che ne dici di ... estendere la nostra funzione lambda per avere le proprietà della sequenza di Ackermann? Questa risposta per grandi numeri ha ispirato questa soluzione.

a=lambda x,y,z:(z<0)*x or y and a(x**.1,z**z,z-1)or a(x**.1,y-1,z)
print a(input(),9,9**9**9**99)//1

La z**zparte qui mi impedisce di eseguire questa funzione con qualsiasi input vicino agli input sani per ye z, i valori più grandi che posso usare sono 9 e 3 per i quali ottengo il valore di 1.0, anche per il float più grande supportato da Python (nota: mentre 1.0 è numericamente maggiore di 6.77538853089e-05, un aumento dei livelli di ricorsione sposta l'output di questa funzione più vicino a 1, rimanendo maggiore di 1, mentre la funzione precedente ha spostato i valori più vicino a 0 rimanendo maggiore di 0, quindi anche una moderata ricorsione su questa funzione provoca così tante operazioni che il numero in virgola mobile perde tutti i bit significativi).

Riconfigurazione della chiamata lambda originale per avere valori di ricorsione di 0 e 2 ...

>>>1.7976931348623157e+308
1.0000000071

Se il confronto viene effettuato su "offset da 0" anziché su "offset da 1" questa funzione ritorna 7.1e-9, che è decisamente inferiore a 6.7e-05.

La ricorsione di base del programma effettivo (valore z) è di 10 ^{10 10 10 1,97} livelli in profondità, non appena si esaurisce, viene ripristinata con 10 ^{10 10 10 10 1,97} (motivo per cui è sufficiente un valore iniziale di 9), quindi io don so anche come calcolare correttamente il numero totale di ricorsioni che si verificano: ho raggiunto la fine delle mie conoscenze matematiche. Allo stesso modo non so se spostare una delle **nesponenziazioni dall'input iniziale al secondario z**zmigliorerebbe o meno il numero di ricorsioni (idem inverso).

Andiamo ancora più lentamente con ancora più ricorsione

import math
a=lambda x,y:(y<0)*x or a(a(a(math.log(x+1),y-1),y-1),y-1)
print a(input(),9**9**9e9)//1

• n//1 - salva 2 byte oltre int(n)
• import math, math.salva 1 byte sufrom math import*
• a(...) salva 8 byte in totale m(m,...)
• (y>0)*x salva un byte sopray>0and x
• 9**9**99aumenta il conteggio dei byte di 4 e aumenta la profondità di ricorsione di circa 2.8 * 10^xdove si xtrova la vecchia profondità (o una profondità vicina a un googolplex in dimensioni: 10 ^{10 94} ).
• 9**9**9e9aumenta il numero di byte di 5 e aumenta la profondità di ricorsione di ... una quantità folle. La profondità di ricorsione è ora 10 ^{10 10 9,93} , per riferimento, un googolplex è 10 ^{10 10 2} .
• dichiarazione lambda aumenta ricorsione da un ulteriore passaggio: m(m(...))a a(a(a(...)))costi 7 byte

Nuovo valore di output (a 9 profondità di ricorsione):

>>>1.7976931348623157e+308
6.77538853089e-05

La profondità di ricorsione è esplosa al punto in cui questo risultato è letteralmente insignificante tranne che in confronto ai risultati precedenti utilizzando gli stessi valori di input:

• L'originale ha chiamato log25 volte
• Il primo miglioramento lo chiama 81 volte
  • Il programma attuale lo chiamerebbe 1e99 ² o circa 10 ^{10 2.3} volte
• Questa versione lo chiama 729 volte
  • Il programma attuale lo chiamerebbe (9 ^{9 99} ) ³ o leggermente meno di 10 ^{10 95} volte).

Lambda Inception, punteggio: ???

Ti ho sentito come i lambda, quindi ...

from math import*
a=lambda m,x,y:y<0and x or m(m,m(m,log(x+1),y-1),y-1)
print int(a(a,input(),1e99))

Non riesco nemmeno a eseguire questo, impilo il troppo pieno anche con soli 99 strati di ricorsione.

Il vecchio metodo (sotto) restituisce (saltando la conversione in un numero intero):

>>>1.7976931348623157e+308
0.0909072713593

Il nuovo metodo ritorna, usando solo 9 strati di incursione (anziché il googol completo di essi):

>>>1.7976931348623157e+308
0.00196323936205

Penso che questo abbia una complessità simile alla sequenza di Ackerman, solo piccola invece che grande.

Anche grazie a ETHproductions per un risparmio di 3 byte in spazi che non avevo realizzato potevano essere rimossi.

Vecchia risposta:

Il troncamento intero del registro delle funzioni (i + 1) ha ripetuto 20 volte 25 (Python) usando lambda lambda.

La risposta di PyRulez può essere compressa introducendo una seconda lambda e impilandola:

from math import *
x=lambda i:log(i+1)
y=lambda i:x(x(x(x(x(i)))))
print int(y(y(y(y(y(input()))))))

99 100 caratteri usati.

Questo produce un'iterazione di 20 25, rispetto al 12. originale Inoltre salva 2 caratteri utilizzando int()invece di quello floor()consentito per uno x()stack aggiuntivo . Se gli spazi dopo il lambda possono essere rimossi (al momento non riesco a controllare), è y()possibile aggiungere un quinto . Possibile!

Se c'è un modo per saltare l' from mathimportazione usando un nome completo (es. x=lambda i: math.log(i+1))), Ciò salverebbe ancora più caratteri e consentirebbe un altro stack di x()ma non so se Python supporta tali cose (sospetto di no). Fatto!

Questo è essenzialmente lo stesso trucco usato nel post del blog di XCKD su grandi numeri , tuttavia l'overhead nel dichiarare lambdas preclude un terzo stack:

from math import *
x=lambda i:log(i+1)
y=lambda i:x(x(x(i)))
z=lambda i:y(y(y(i)))
print int(z(z(z(input()))))

Questa è la ricorsione più piccola possibile con 3 lambda che superano l'altezza dello stack calcolata di 2 lambda (riducendo qualsiasi lambda a due chiamate si riduce l'altezza dello stack a 18, inferiore a quella della versione 2-lambda), ma purtroppo richiede 110 caratteri.

Haskell , 100 byte

f 0 a b=a^b
f c a b=foldr(f$c-1)a$[0..b]>>[a]
i=length.show
0#x=i x
y#x=i$(y-1)#x
g=(f(f 9 9 9)9 9#)

Provalo online!

Questa soluzione non prende l'inverso di una funzione in rapida crescita, ma prende una funzione in crescita piuttosto lenta, in questo caso length.show, e la applica un sacco di volte.

Per prima cosa definiamo una funzione f. fè una versione bastarda della notazione uptle di Knuth che cresce leggermente più velocemente (leggermente è un eufemismo, ma i numeri con cui abbiamo a che fare sono così grandi che nel grande schema delle cose ...). Definiamo il caso base di f 0 a bessere a^bo aal potere di b. Definiamo quindi il caso generale da (f$c-1)applicare alle b+2istanze di a. Se stessimo definendo una notazione Knuth uparrow come un costrutto, la applicheremmo a bcasi di a, ma in b+2realtà è più golfista e ha il vantaggio di essere in più rapida crescita.

Definiamo quindi l'operatore #. a#bè definito per essere length.showapplicato ai b atempi. Ogni applicazione di length.showè approssimativamente uguale a log ₁₀ , che non è una funzione in rapida crescita.

Quindi andiamo a definire la nostra funzione gche accetta e integra e si applica length.showall'intero un mucchio di volte. Per essere specifici, si applica length.showall'input f(f 9 9 9)9 9. Prima di capire quanto sia grande, vediamo f 9 9 9. f 9 9 9è maggiore di 9↑↑↑↑↑↑↑↑↑9 (nove frecce), con un margine enorme. Credo che sia da qualche parte tra 9↑↑↑↑↑↑↑↑↑9(nove frecce) e 9↑↑↑↑↑↑↑↑↑↑9(dieci frecce). Ora questo è un numero inimmaginabilmente grande, troppo grande per essere memorizzato su qualsiasi computer esistente (in notazione binaria). Quindi prendiamo quello e lo mettiamo come primo argomento del nostro fche significa che il nostro valore è più grande che 9↑↑↑↑↑↑...↑↑↑↑↑↑9conf 9 9 9frecce in mezzo. Non descriverò questo numero perché è così grande che non credo che sarei in grado di rendergli giustizia.

Ognuno length.showè approssimativamente uguale a prendere la base log 10 dell'intero. Ciò significa che la maggior parte dei numeri restituirà 1 quando fviene applicato a loro. Il numero più piccolo per restituire qualcosa di diverso da 1 è 10↑↑(f(f 9 9 9)9 9), che restituisce 2. Vediamolo per un momento. Per quanto abominevolmente grande come quel numero che abbiamo definito in precedenza è, il numero più piccolo che restituisce 2 è 10 alla propria potenza che molte volte. Quello è 1 seguito da 10↑(f(f 9 9 9)9 9)zeri.

Per il caso generale ndell'input più piccolo, l'output di ogni dato n deve essere (10↑(n-1))↑↑(f(f 9 9 9)9 9).

Nota che questo programma richiede enormi quantità di tempo e memoria anche per piccole n (più di quante ce ne siano molte volte nell'universo), se vuoi testarlo ti suggerisco di sostituirlo f(f 9 9 9)9 9con un numero molto più piccolo, prova 1 o 2 se vuoi mai ottenere qualsiasi output diverso da 1.

APL, Applica log(n + 1), e^9^9...^9tempi in cui la lunghezza della catena è e^9^9...^9della lunghezza della catena meno 1 volte e così via.

⌊((⍟1+⊢)⍣((*⍣(*⍣(*⍣(*⍣(*⍣(*⍣(*⍣(*⍣(*⍣(*⍣(*⍣(*⍣(*⍣(*⍣(*⍣(*⍣(*⍣(*⍣(*⍣(*⍣(*⍣⊢)))))))))))))))))))))9))⊢

MATL , 42 byte

iXI:`2*.]X{oXH1H/16L+XKxI:`Yl.]K+XKXdXzXGx

Provalo online!

Questo programma si basa sulle serie armoniche con l'uso della costante di Eulero-Mascheroni. Mentre stavo leggendo la documentazione di @LuisMendo sul suo linguaggio MATL (con lettere maiuscole, quindi sembra importante) ho notato questa costante. L'espressione della funzione di crescita lenta è la seguente:

dove εk ~ 1 / 2k

Ho testato fino a 10000 iterazioni (in Matlab, poiché è troppo grande per TIO) e ha un punteggio inferiore a 10, quindi è molto lento.

spiegazioni:

 iXI      % ask user input (number of iterations)

:`2*.]    % do...while loop, multiply by 2

X{        % convert numeric array into cell array

o         % convert to double precision array 

XH1H/     % copy to clipboard H and divide by 1: now we have an array of 1/2k

16L       % Euler–Mascheroni constant 

+         % addition (element-wise, singleton expansion)

XKxI:`    % save, clear the stack, do...while loop again

  Yl      % logarithm 

  .]      % break, ends the loop

K+XK      % paste from clipboard K, sum all

Xd        % trim: keep the diagonal of the matrix 

Xz        % remove all zeros

XG        % plot (yes it plots on-line too!)

x         % clear the stack
          % (implicit) display

Prova empirica: (ln k ) + 1 in rosso sempre sopra ln k + γ + εk in blu.

È stato creato il programma per (ln k ) + 1

Matlab, 47 18 14 byte

n=input('')
A=(1:n)
for k=1:n
A(k)=log(k)+1
end

Interessante notare che il tempo trascorso per n = 100 è 0,208693s sul mio laptop, ma solo 0,121945s con d=rand(1,n);A=d*0;e ancora meno, 0,112147s con A=zeros(1,n). Se gli zeri sono uno spreco di spazio, risparmiano velocità! Ma sto divergendo dall'argomento (probabilmente molto lentamente).

Modifica: grazie a Stewie per aver contribuito a ridurre questa espressione di Matlab, semplicemente:

 @(n)log(1:n)+1

Python 3 , 100 byte

Il piano del registro delle funzioni (i + 1) ha ripetuto 999999999999999999999999999999999999999 volte.

Si possono usare esponenti per aumentare ulteriormente il numero sopra ...

from math import *
s=input()
exec("s=log(s+1);"*99999999999999999999999999999999999)
print(floor(s))

Provalo online!

Il piano del registro delle funzioni (i + 1) è stato ripetuto 14 volte (Python)

import math
x=lambda i: math.log(i+1)
print int(x(x(x(x(x(x(x(x(x(x(x(x(x(x(input())))))))))))))))

Non mi aspetto che funzioni molto bene, ma ho pensato che fosse un buon inizio.

Esempi:

• e ^ n ^ n ^ n ^ n ^ n ^ n ^ n ^ n ^ n ^ n ^ n ^ n ^ n ^ n -> ~ n (circa n)

Rubino, 100 byte, punteggio ^-1 = f _{ω ^{ω + 1}} (n ² )

Praticamente preso in prestito dal mio numero più grande stampabile , ecco il mio programma:

->k{n=0;n+=1 until(H=->z,a=[0]*z{b,*c=a;z.times{z+=b ?H[z,b==1?c:[b>1?b-1:z]*z+c]:z};z};H[n*n]>k);n}

Provalo online

Calcola sostanzialmente l'inverso di f _{ω ^{ω + 1}} (n ² ) nella gerarchia in rapida crescita. I primi valori sono

x[0] = 1
x[1] = 1
x[2] = 1
x[3] = 1
x[4] = 2

E poi continua a produrre 2per molto tempo. Anche x[G] = 2, dov'è Gil numero di Graham.

Mathematica, 99 byte

(supponendo che ± richieda 1 byte)

0±x_=1±(x-1);y_±0=y+1;x_±y_:=(y-1)±x±(x-1);(i=0;NestWhile[(++i;#±#±#±#±#±#±#±#)&,1,#<k&/.k->#];i)&

I primi 3 comandi definiscono x±yper valutareAckermann(y, x) .

Il risultato della funzione è il numero di volte in cui è f(#)=#±#±#±#±#±#±#±#necessario applicare 1 prima che il valore raggiunga il valore del parametro. Poiché f(#)=#±#±#±#±#±#±#±#(cioè f(#)=Ackermann[Ackermann[Ackermann[Ackermann[Ackermann[Ackermann[Ackermann[#, #], #], #], #], #], #], #]) cresce molto velocemente, la funzione cresce molto lentamente.

Clojure, 91 byte

(defn f (apply +(for[n(range %)](/(loop[r 1 v n](if(< v 1)r(recur(* r v)(Math/log v))))))))

Tipo di calcola il sum 1/(n * log(n) * log(log(n)) * ...), che ho trovato da qui . Ma la funzione è arrivata a 101 byte, quindi ho dovuto eliminare il numero esplicito di iterazioni e invece eseguire l'iterazione purché il numero sia maggiore di uno. Esempi di output per input di 10^i:

0 1
1 3.3851305685279143
2 3.9960532565317575
3 4.232195089969394
4 4.370995106860574
5 4.466762285601703
6 4.53872567524327
7 4.595525574477128
8 4.640390570825608

Presumo che questa serie modificata diverga ancora, ma ora so come dimostrarlo.

La terza serie richiede in realtà un numero di termini googolplex prima che i termini parziali superino 10.

Javascript (ES6), 94 byte

(p=j=>i=>h=>g=>f=>x=>x<2?0:1+p(p(j))(j(i))(i(h))(h(g))(g(f))(f(x)))(_=x=>x)(_)(_)(_)(Math.log)

Spiegazione :

Idsi riferisce a x => xquanto segue.

Diamo prima un'occhiata a:

p = f => x => x < 2 ? 0 : 1 + p(p(f))(f(x))

p(Math.log) è approssimativamente uguale a log*(x).

p(p(Math.log))è approssimativamente uguale a log**(x)(numero di volte che puoi prendere log*fino a quando il valore è al massimo 1).

p(p(p(Math.log)))è approssimativamente uguale a log***(x).

La funzione inversa di Ackermann alpha(x)è approssimativamente uguale al numero minimo di volte che è necessario comporre pfino a quando il valore è al massimo 1.

Se poi utilizziamo:

p = g => f => x => x < 2 ? 0 : 1 + p(p(g))(g(f))(f(x))

allora possiamo scrivere alpha = p(Id)(Math.log).

È piuttosto noioso, tuttavia, quindi aumentiamo il numero di livelli:

p = h => g => f => x => x < 2 ? 0 : 1 + p(p(h))(h(g))(g(f))(f(x))

Questo è come abbiamo costruito alpha(x), tranne che invece di farlo log**...**(x), ora lo facciamo alpha**...**(x).

Perché fermarsi qui però?

p = i => h => g => f => x => x < 2 ? 0 : 1 + p(p(i))(i(h))(h(g))(g(f))(f(x))

Se la funzione precedente è f(x)~alpha**...**(x), questa è adesso ~ f**...**(x). Facciamo un altro livello per ottenere la nostra soluzione finale.