Votre travail consiste à créer la fonction de croissance la plus lente possible en 100 octets maximum.

Votre programme prendra en entrée un entier non négatif et sortira un entier non négatif. Appelons votre programme P.

Il doit répondre à ces deux critères:

• Son code source doit être inférieur ou égal à 100 octets.
• Pour tout K, il y a un N, tel que pour tout n> = N, P (n)> K. En d'autres termes, lim _{(n-> ∞)} P (n) = ∞ . (C'est ce que cela signifie pour lui de "grandir".)

Votre «score» est le taux de croissance de la fonction sous-jacente de votre programme.

Plus précisément, le programme P est plus lent que Q s'il y a un N tel que pour tout n> = N, P (n) <= Q (n), et qu'il y ait au moins un n> = N tel que P (n ) <Q (n). Si aucun des deux programmes n'est meilleur que l'autre, ils sont à égalité. (Essentiellement, le programme le plus lent est basé sur la valeur de lim _{(n-> ∞)} P (n) -Q (n).)

La fonction de croissance la plus lente est définie comme celle qui croît plus lentement que toute autre fonction, selon la définition du paragraphe précédent.

C'est le golf à taux de croissance , donc le programme à croissance la plus lente gagne!

Remarques:

• Pour aider à la notation, essayez de mettre quelle fonction votre programme calcule dans la réponse.
• Mettez également quelques entrées et sorties (théoriques), pour aider à donner aux gens une idée de la lenteur de votre progression.

Haskell, 98 octets, score = f _{ε 0} ^-1 ( 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

Comment ça marche

Cela calcule l'inverse d'une fonction à croissance très rapide liée au jeu de vers de Beklemishev . Son taux de croissance est comparable à f _{ε 0} , où f _α est la hiérarchie à croissance rapide et ε ₀ est le premier nombre epsilon .

Pour comparaison avec d'autres réponses, notez que

• l'exponentiation est comparable à f ₂ ;
• l'exponentiation itérée ( tétration ou ↑↑ ) est comparable à f ₃ ;
• ↑↑ ⋯ ↑↑ avec m flèches est comparable à f _{m + 1} ;
• La fonction Ackermann est comparable à f _ω ;
• les itérations répétées de la fonction d'Ackermann (constructions comme le nombre de Graham ) sont toujours dominées par f _{ω + 1} ;
• et ε ₀ est la limite de toutes les tours ω ^{ω ω ⋰ ω} .

Brachylog , 100 octets

llllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllll

Essayez-le en ligne!

C'est probablement loin de la lenteur de certaines autres réponses fantaisistes, mais je ne pouvais pas croire que personne n'avait essayé cette approche simple et belle.

Simplement, nous calculons la longueur du numéro d'entrée, puis la longueur de ce résultat, puis la longueur de cet autre résultat ... 100 fois au total.

Cela augmente aussi rapidement que log (log (log ... log (x), avec 100 journaux base-10).

Si vous entrez votre numéro sous forme de chaîne , cela fonctionnera extrêmement rapidement sur toute entrée que vous pourriez essayer, mais ne vous attendez jamais à voir un résultat supérieur à 1: D

JavaScript (ES6), fonction Ackermann inverse *, 97 octets

* si je l'ai bien fait

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 fonction Aest la fonction Ackermann . La fonction aest censée être la fonction Ackermann inverse . Si je mis en œuvre correctement, Wikipedia dit qu'il ne sera pas touché 5jusqu'à mégaux 2^2^2^2^16. Je fais le StackOverflowtour 1000.

Usage:

console.log(a(1000))

Explications:

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

Fonction Ackermann inverse

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'instruction à l'intérieur de l'éval crée une chaîne de longueur 7 * 10 ^{10 10 10 10 10 8.57} qui se compose de rien mais plus d'appels à la fonction lambda dont chacun construira une chaîne de longueur similaire , yindéfiniment jusqu'à ce qu'elle devienne finalement 0. Ostensiblement cela a la même complexité que la méthode Eschew ci-dessous, mais plutôt que de s'appuyer sur une logique de contrôle si et / ou, il écrase simplement des chaînes géantes (et le résultat net obtient plus de piles ... probablement?).

La plus grande yvaleur que je puisse fournir et calculer sans que Python ne génère d'erreur est 2, ce qui est déjà suffisant pour réduire une entrée de max-float en renvoyant 1.

Une chaîne de longueur 7.625.597.484.987 est trop grand: OverflowError: cannot fit 'long' into an index-sized integer.

Je devrais m'arrêter.

Eschew Math.log: Aller à la racine (10e) (du problème), Score: fonction effectivement indiscernable de y = 1.

L'importation de la bibliothèque mathématique limite le nombre d'octets. Supprimons cela et remplaçons la log(x)fonction par quelque chose à peu près équivalent: x**.1et qui coûte environ le même nombre de caractères, mais ne nécessite pas l'importation. Les deux fonctions ont une sortie sublinéaire par rapport à l'entrée, mais x ^0,1 croît encore plus lentement . Cependant, nous ne nous soucions pas beaucoup, nous nous soucions seulement du fait qu'il a le même schéma de croissance de base en ce qui concerne les grands nombres tout en consommant un nombre comparable de caractères (par exemple, x**.9est le même nombre de caractères, mais croît plus rapidement, donc il est une valeur qui présenterait exactement la même croissance).

Maintenant, que faire avec 16 caractères. Que diriez-vous ... d'étendre notre fonction lambda pour avoir des propriétés de séquence Ackermann? Cette réponse pour un grand nombre a inspiré cette solution.

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**zpartie ici m'empêche d'exécuter cette fonction avec n'importe où près d'entrées saines pour yet z, les plus grandes valeurs que je peux utiliser sont 9 et 3 pour lesquelles je récupère la valeur de 1,0, même pour les plus grands supports flottants Python (note: tandis que 1.0 est numériquement supérieur à 6,77538853089e-05, l'augmentation des niveaux de récursivité rapproche la sortie de cette fonction de 1, tout en restant supérieure à 1, tandis que la fonction précédente rapprochait les valeurs de 0 tout en restant supérieure à 0, donc même une récursion modérée sur cette fonction entraîne tellement d'opérations que le nombre à virgule flottante perd tous les bits significatifs).

Reconfiguration de l'appel lambda d'origine pour avoir des valeurs de récursivité de 0 et 2 ...

>>>1.7976931348623157e+308
1.0000000071

Si la comparaison est faite à "décalage de 0" au lieu de "décalage de 1", cette fonction retourne 7.1e-9, ce qui est nettement inférieur à 6.7e-05.

La récursion de base du programme réel (valeur z) est profonde de 10 ^{10 10 10 1,97} , dès que y s'épuise, il est réinitialisé avec 10 ^{10 10 10 10 1,97} (ce qui explique pourquoi une valeur initiale de 9 est suffisante), donc je ne ne sais même pas comment calculer correctement le nombre total de récursions qui se produisent: j'ai atteint la fin de mes connaissances mathématiques. De même je ne sais pas si déplacer une des **nexponentiations de l'entrée initiale vers le secondaire z**zaméliorerait ou non le nombre de récursions (idem inverse).

Permet d'aller encore plus lentement avec encore plus de récursivité

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 - enregistre 2 octets de plus int(n)
• import math, math.enregistre 1 octet de plusfrom math import*
• a(...) enregistre 8 octets au total sur m(m,...)
• (y>0)*x enregistre un octet sury>0and x
• 9**9**99augmente le nombre d'octets de 4 et augmente la profondeur de récursivité approximativement 2.8 * 10^xoù se xtrouve l'ancienne profondeur (ou une profondeur proche d'un googolplex de taille: 10 ^{10 94} ).
• 9**9**9e9augmente le nombre d'octets de 5 et augmente la profondeur de récursivité de ... une quantité folle. La profondeur de récursivité est maintenant de 10 ^{10 10 9,93} , pour référence, un googolplex est de 10 ^{10 10 2} .
• déclaration lambda augmente récursion par une étape supplémentaire: m(m(...))pour les a(a(a(...)))coûts 7 octets

Nouvelle valeur de sortie (à 9 profondeurs de récursivité):

>>>1.7976931348623157e+308
6.77538853089e-05

La profondeur de récursivité a explosé au point où ce résultat est littéralement dénué de sens, sauf en comparaison avec les résultats précédents utilisant les mêmes valeurs d'entrée:

• L'original appelé log25 fois
• La première amélioration l'appelle 81 fois
  • Le programme actuel l'appellerait 1e99 ² ou environ 10 ^{10 2,3} fois
• Cette version l'appelle 729 fois
  • Le programme réel l'appellerait (9 ^{9 99} ) ³ ou un peu moins de 10 ^{10 95} fois).

Lambda Inception, score: ???

Je t'ai entendu comme des lambdas, alors ...

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

Je ne peux même pas exécuter cela, j'empile le débordement même avec seulement 99 couches de récursivité.

L'ancienne méthode (ci-dessous) renvoie (en ignorant la conversion en un entier):

>>>1.7976931348623157e+308
0.0909072713593

La nouvelle méthode revient, en utilisant seulement 9 couches d'incursion (plutôt que le googol complet ):

>>>1.7976931348623157e+308
0.00196323936205

Je pense que cela a une complexité similaire à la séquence Ackerman, seulement petite au lieu de grande.

Merci aussi à ETHproductions pour une économie de 3 octets dans des espaces que je ne pensais pas pouvoir supprimer.

Ancienne réponse:

La troncature entière du journal de fonction (i + 1) a été répétée 20 à 25 fois (Python) en utilisant des lambdas lambda.

La réponse de PyRulez peut être compressée en introduisant un deuxième lambda et en l'empilant:

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 caractères utilisés.

Cela produit une itération de 20 25, au-dessus de l'original 12. En outre, il enregistre 2 caractères en utilisant int()au lieu de floor()ce qui permettait une x()pile supplémentaire . Si les espaces après le lambda peuvent être supprimés (je ne peux pas vérifier pour le moment), un 5ème y()peut être ajouté. Possible!

S'il existe un moyen d'ignorer l' from mathimportation en utilisant un nom complet (par exemple x=lambda i: math.log(i+1))), cela économiserait encore plus de caractères et permettrait une autre pile de x()mais je ne sais pas si Python prend en charge de telles choses (je ne le pense pas). Terminé!

C'est essentiellement la même astuce que celle utilisée dans le blog de XCKD sur les grands nombres , mais la surcharge de déclaration des lambdas empêche une troisième pile:

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

Il s'agit de la plus petite récursivité possible avec 3 lambdas qui dépasse la hauteur de pile calculée de 2 lambdas (la réduction de tout lambda à deux appels fait chuter la hauteur de pile à 18, en dessous de celle de la version 2-lambda), mais nécessite malheureusement 110 caractères.

Haskell , 100 octets

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

Essayez-le en ligne!

Cette solution ne prend pas l'inverse d'une fonction à croissance rapide au lieu de cela, elle prend une fonction à croissance plutôt lente, dans ce cas length.show, et l'applique plusieurs fois.

Nous définissons d'abord une fonction f. fest une version bâtarde de la notation ascendante de Knuth qui croît légèrement plus vite (c'est un peu un euphémisme, mais les chiffres auxquels nous avons affaire sont si grands que dans le grand schéma des choses ...). Nous définissons le cas de base de f 0 a bêtre a^bou aà la puissance de b. Nous définissons ensuite le cas général à (f$c-1)appliquer aux b+2instances de a. Si nous définissions une notation de type ascendant Knuth comme construction, nous l'appliquerions aux binstances de a, mais b+2est en fait plus golfeur et a l'avantage d'être plus rapide.

Nous définissons ensuite l'opérateur #. a#best défini pour être length.showappliqué aux b atemps. Chaque application de length.showest approximativement égale à log ₁₀ , ce qui n'est pas une fonction à croissance très rapide.

Nous allons ensuite définir notre fonction gqui prend et entier et applique length.showà l'entier un tas de fois. Pour être précis, il s'applique length.showà l'entrée f(f 9 9 9)9 9. Avant d'entrer dans sa taille, regardons f 9 9 9. f 9 9 9est supérieur à 9↑↑↑↑↑↑↑↑↑9 (neuf flèches), par une marge massive. Je pense que c'est quelque part entre 9↑↑↑↑↑↑↑↑↑9(neuf flèches) et 9↑↑↑↑↑↑↑↑↑↑9(dix flèches). Maintenant, c'est un nombre incroyablement grand, bien trop grand pour être stocké sur n'importe quel ordinateur existant (en notation binaire). Nous prenons ensuite cela et le mettons comme premier argument de notre fqui signifie que notre valeur est plus grande 9↑↑↑↑↑↑...↑↑↑↑↑↑9qu'avecf 9 9 9flèches entre les deux. Je ne vais pas décrire ce nombre parce qu'il est si grand que je ne pense pas pouvoir lui rendre justice.

Chacun length.showest approximativement égal à prendre la base de log 10 de l'entier. Cela signifie que la plupart des nombres renverront 1 lorsqu'ils leur seront fappliqués. Le plus petit nombre pour renvoyer autre chose que 1 est 10↑↑(f(f 9 9 9)9 9), ce qui renvoie 2. Pensons-y un instant. Aussi abominablement grand que ce nombre que nous avons défini plus haut, le plus petit nombre qui renvoie 2 est 10 à sa propre puissance autant de fois. C'est 1 suivi de 10↑(f(f 9 9 9)9 9)zéros.

Pour le cas général de nla plus petite entrée en sortie, tout n donné doit être (10↑(n-1))↑↑(f(f 9 9 9)9 9).

Notez que ce programme nécessite énormément de temps et de mémoire même pour les petits n (plus qu'il n'y en a plusieurs fois dans l'univers), si vous voulez tester cela, je suggère de le remplacer f(f 9 9 9)9 9par un nombre beaucoup plus petit, essayez 1 ou 2 si vous le souhaitez jamais obtenir une sortie autre que 1.

APL, Appliquer log(n + 1), e^9^9...^9fois, où la longueur de la chaîne est e^9^9...^9de la longueur de la chaîne moins 1 fois, et ainsi de suite.

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

MATL , 42 octets

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

Essayez-le en ligne!

Ce programme est basé sur la série harmonique avec l'utilisation de la constante d'Euler – Mascheroni. Alors que je lisais la documentation de @LuisMendo sur son langage MATL (avec des majuscules, donc ça a l'air important) j'ai remarqué cette constante. L'expression de la fonction de croissance lente est la suivante:

où εk ~ 1 / 2k

J'ai testé jusqu'à 10000 itérations (dans Matlab, car il est trop grand pour TIO) et son score est inférieur à 10, donc c'est très lent.

Explications:

 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

Preuve empirique: (ln k ) + 1 en rouge toujours au-dessus de ln k + γ + εk en bleu.

Le programme pour (ln k ) + 1 a été réalisé en

Matlab, 47 18 14 octets

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

Il est intéressant de noter que le temps écoulé pour n = 100 est 0,208693s sur mon ordinateur portable, mais seulement 0,121945s avec d=rand(1,n);A=d*0;et encore moins, 0,112147s avecA=zeros(1,n) . Si les zéros sont une perte d'espace, cela fait gagner de la vitesse! Mais je m'éloigne du sujet (probablement très lentement).

Edit: merci à Stewie pour avoir aidé à réduire cette expression Matlab à, simplement:

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

Python 3 , 100 octets

Le plancher du journal des fonctions (i + 1) a été répété 99999999999999999999999999999999999 fois.

On peut utiliser des exposants pour rendre le nombre ci-dessus encore plus grand ...

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

Essayez-le en ligne!

Le plancher du journal des fonctions (i + 1) a été répété 14 fois (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())))))))))))))))

Je ne m'attends pas à ce que cela se passe très bien, mais j'ai pensé que c'était un bon début.

Exemples:

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

Ruby, 100 octets, score ^-1 = f _{ω ^{ω + 1}} (n ² )

Fondamentalement emprunté à mon plus grand nombre imprimable , voici mon programme:

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

Essayez-le en ligne

Calcule fondamentalement l'inverse de f _{ω ^{ω + 1}} (n ² ) dans la hiérarchie à croissance rapide. Les premières valeurs sont

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

Et puis il continue de produire 2pendant très longtemps. Même x[G] = 2, où Gest le numéro de Graham.

Mathematica, 99 octets

(en supposant que ± prend 1 octet)

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

Les 3 premières commandes définissent x±yà évaluer Ackermann(y, x).

Le résultat de la fonction est le nombre de fois f(#)=#±#±#±#±#±#±#±#qu'il faut appliquer à 1 avant que la valeur atteigne la valeur du paramètre. Au fur et à mesure f(#)=#±#±#±#±#±#±#±#que (c'est-à-dire f(#)=Ackermann[Ackermann[Ackermann[Ackermann[Ackermann[Ackermann[Ackermann[#, #], #], #], #], #], #], #]) croît très rapidement, la fonction se développe très lentement.

Clojure, 91 octets

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

Type de calcule le sum 1/(n * log(n) * log(log(n)) * ...) , que j'ai trouvé à partir d' ici . Mais la fonction a fini par 101 octets, j'ai donc dû abandonner le nombre explicite d'itérations, et à la place répéter tant que le nombre est supérieur à un. Exemples de sorties pour les entrées de 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

Je suppose que cette série modifiée diverge toujours, mais je sais maintenant comment le prouver.

La troisième série nécessite en fait un nombre de termes googolplex avant que les termes partiels dépassent 10.

Javascript (ES6), 94 octets

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

Explication :

Id fait référence à x => x dans ce qui suit.

Jetons d'abord un coup d'œil à:

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

p(Math.log) est approximativement égal à log*(x) .

p(p(Math.log))est approximativement égal à log**(x)(nombre de fois que vous pouvez prendre log*jusqu'à ce que la valeur soit au plus 1).

p(p(p(Math.log))) est approximativement égal à log***(x) .

La fonction Ackermann inverse alpha(x)est approximativement égale au nombre minimum de fois que vous devez composerp jusqu'à ce que la valeur soit au plus 1.

Si nous utilisons alors:

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

alors nous pouvons écrire alpha = p(Id)(Math.log).

C'est assez ennuyeux, cependant, augmentons donc le nombre de niveaux:

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

C'est comme la façon dont nous avons construit alpha(x), sauf qu'au lieu de le faire log**...**(x), nous le faisons maintenant alpha**...**(x).

Mais pourquoi s'arrêter ici?

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

Si la fonction précédente est f(x)~alpha**...**(x), celle-ci l'est maintenant ~ f**...**(x). Nous faisons un niveau de plus pour obtenir notre solution finale.