Créez la fonction de croissance la plus lente possible en moins de 100 octets


23

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 , 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.


3
Une stratégie efficace consiste à écrire une fonction à croissance rapide et à prendre son inverse, c'est-à-dire à trouver la plus petite entrée qui produit au moins la valeur requise. C'est peut-être dupe?
2017

Un tiers du paragraphe "Plus précisément" était manquant car Markdown pense qu'un <suivi d'une lettre est le début d'une balise HTML. Prévisualisez vos questions avant de les poster: P
ETHproductions

1
Quels grands axiomes cardinaux pouvons-nous supposer?
Peter Taylor

1
La machine à remonter le temps pour tester nos réponses est-elle fournie?
Magic Octopus Urn

Réponses:


13

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 ε 0 est le premier nombre epsilon .

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

  • l'exponentiation est comparable à f 2 ;
  • l'exponentiation itérée ( tétration ou ↑↑ ) est comparable à f 3 ;
  • ↑↑ ⋯ ↑↑ 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 ε 0 est la limite de toutes les tours ω ω ω ω .

J'aime mieux la description ici .
PyRulez

Vous pouvez mettre un lien vers l'introduction de Googology Wiki à la hiérarchie en croissance rapide
MilkyWay90

18

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


8
+1 juste pour la folie pure: o Fait amusant: Fonctionne également dans Jelly si vous faites tout en majuscules. : P
HyperNeutrino

5
Le premier nombre qui produit 2 est 10 ↑↑ 99.
Wheat Wizard

11

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

2
Mais Stack Overflow n'est-il pas bon ?
NoOneIsHere

Votre affirmation selon laquelle il n'atteindra pas 5 jusqu'à ce que m = 2 ^^ 7 soit fausse. Il n'atteindra 5 que m = 2 ^^ 7-3, mais à 2 ^^ 7-1, il est 5. Je sais que -3 est très petit par rapport à 2 ^^ 7, mais 5A5 = 2 ^^ 7-3 <2 ^^ 7. (^^ représente la tétration)
user75200

8

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 2 ou environ 10 10 2,3 fois
  • Cette version l'appelle 729 fois
    • Le programme réel l'appellerait (9 9 99 ) 3 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.


Pour info, je compte 103 octets dans le programme supérieur
ETHproductions

@ETHproductions oh oups. J'ai probablement fait un dénombrement sans la intconversion et j'ai pensé que j'avais quelques pièces de rechange.
Draco18s

Je pense que vous pouvez supprimer l'espace après importet l'espace après y<0. Je ne connais pas beaucoup Python, donc je ne suis pas certain
ETHproductions

Aussi, peut-être y<0and x or m(m,m(m,log(x+1),y-1),y-1)pour enregistrer un autre octet (en supposant que ce xn'est jamais 0quand y<0)
ETHproductions

2
Eh bien ... log(x)croît plus lentement que n'importe quelle puissance positive de x(pour les grandes valeurs de x), et ce n'est pas difficile à montrer en utilisant la règle de L'Hopital. Je suis presque sûr que votre version actuelle fait (...(((x**.1)**.1)**.1)** ...)tout un tas de fois. Mais ces pouvoirs se multiplient, c'est donc effectivement x**(.1** (whole bunch)), ce qui est un (très petit) pouvoir positif de x. Cela signifie qu'elle se développe en fait plus rapidement qu'une seule itération de la fonction de journal (bien que, d'accord, vous devriez regarder de TRÈS grandes valeurs xavant de le remarquer ... mais c'est ce que nous entendons par "aller à l'infini" ).
mathmandan

4

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 10 , 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.


Meh, je ne pense pas que quiconque se soucie du temps qu'il faut ou de la quantité de mémoire requise pour que le programme s'exécute sur ce genre de questions.
Simply Beautiful Art

3

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

Existe-t-il un moyen de gérer cela?
Draco18s

7
@ Draco18s obtient un ordinateur quantique avec une mémoire pratiquement infinie, installe une distribution APL décente et passe le temps que tu attends pour créer un sérum anti-vieillissement, car tu devras rester assis pendant quelques siècles.
Uriel

Haha. Alors ok. : p
Draco18s

Êtes-vous sûr que cela approche de l'infini?
PyRulez

@PyRulez c'est la même chose que les autres solutions, mais avec beaucoup plus d'itérations sur le journal. mais plus d'itération est toujours la même fermeture - défiée par l'exposant autant. Je n'étais pas sûr de la e^n^n...^npièce alors je l'ai transformée en constante, mais cela pourrait être vrai
Uriel

3

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: entrez la description de l'image ici

ε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.

entrez la description de l'image ici

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.

entrez la description de l'image ici

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

+1 pour ne pas être simplement l'inverse d'une fonction rapide
PyRulez

1
Un SO-post intéressant sur votre note intéressante. :)
Stewie Griffin

Soit dit en passant, le golf le script dans le fond (depuis que vous avez inclus le nombre d'octets): Le dernier script Matlab est simplement: n=input('');A=log(1:n)+1, ou comme une fonction anonyme sans nom (14 octets): @(n)log(1:n)+1. Je ne suis pas sûr de MATLAB, mais A=log(1:input(''))+1travaille dans Octave ...
Stewie Griffin

merci @Stewie n=input('');A=log(1:n)+1fonctionne, @(n)log(1:n)+1pas (en effet une fonction valide avec poignée dans Matlab, mais l'entrée n'est pas demandée), A=log(1:input(''))+1fonctionne et peut être raccourcielog(1:input(''))+1
J Doe

Ce que je voulais dire avec la fonction anonyme était ce . C'est la façon "normale" d'économiser des octets (sur ce site au moins) en exigeant que l'entrée soit donnée comme arguments de fonction (meta-post) au lieu de ligne de commande. De plus, il f=n'est pas nécessaire de compter, car il est possible de simplement: @(n)log(1:n)+1suivi par ans(10)pour obtenir les 10 premiers chiffres.
Stewie Griffin

2

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!


2
Les solutions doivent-elles réellement fonctionner? Cela déclenche une OverflowError.
ETHproductions

2
@ETHproductions dans des problèmes comme celui-ci, il est communément admis que les solutions n'ont besoin que d'être théoriquement viables, sur une machine avec une mémoire infinie et un processeur. Si vous voulez essayer cela, réduisez le 99999 ... 999 à seulement 999 environ
Sparr

3
Alors pourquoi ne pas utiliser 9**9**9**...**9**9e9?
CalculatorFeline

2

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)

Si vous utilisez intau lieu de floor, vous pouvez en intégrer un autrex(
Beta Decay

@BetaDecay D'accord, je l'ai mis à jour.
PyRulez

1
L'expression ne devrait-elle pas être e^e^e^e...^n? Aussi, pourquoi y a-t-il un espace après le :?
CalculatorFeline

@CalculatorFeline, car ce n'est pas du golf de code, il doit simplement être inférieur à 100 octets.
Cyoce

Alors? Qu'y a-t-il de si mal à sauvegarder un octet pour pouvoir ajouter un autre x()appel?
CalculatorFeline

2

Ruby, 100 octets, score -1 = f ω ω + 1 (n 2 )

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


Mais qu'en est-il de g (f <sub> ω9001CK </sub> 3) où f est FGH?
user75200

@ user75200 le fgh n'est pas bien défini pour les ordinaux non calculables.
Simply Beautiful Art

FGH est bien défini pour les ordinaux non calculables, car ils ont des séquences fondamentales. C'est juste non calculable.
user75200

@ user75200 Non. Les séquences fondamentales sont très arbitraires. Je pourrais définir ω9001CK [x] = x pour avoir une séquence fondamentale de longueur ω9001CK, qui est calculable pour x fini, mais très probablement pas ce que vous vouliez. Par «bien défini», je voulais dire qu'il n'y a pas de séquence fondamentale standard pour les ordinaux non calculables sur laquelle tout le monde peut s'entendre.
Simply Beautiful Art

S'il est vrai que les séquences fondamentales ne sont pas uniques, une séquence fondamentale pour un ordinal dénombrable est censée être de longueur ω.
Anders Kaseorg

0

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.


0

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.


0

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.


msgstr " p(p(x => x - 2)) est approximativement égal à log**(x)(nombre de fois que vous pouvez prendre log*jusqu'à ce que la valeur soit au plus 1)". Je ne comprends pas cette affirmation. Il me semble que cela p(x => x - 2)devrait être "le nombre de fois que vous pouvez soustraire 2jusqu'à ce que la valeur soit au plus 1". Autrement dit, p (x => x - 2) `devrait être la fonction" diviser par 2 ". Par conséquent, cela p(p(x => x - 2))devrait être "le nombre de fois que vous pouvez diviser par 2 jusqu'à ce que la valeur soit au plus 1" ... c'est-à-dire que ce devrait être la logfonction, pas log*ou log**. Peut-être que cela pourrait être clarifié?
mathmandan

@mathmandan ressemble à ce que j'ai fait une faute de frappe sur cette ligne, ce devrait être p = f => x => x < 2 ? 0 : 1 + p(p(f))(f(x)), où pest passé p(f)comme dans les autres lignes, non f.
es1024
En utilisant notre site, vous reconnaissez avoir lu et compris notre politique liée aux cookies et notre politique de confidentialité.
Licensed under cc by-sa 3.0 with attribution required.