Quel est le code le plus court pour provoquer un débordement de pile? [fermé]

Pour commémorer le lancement public de Stack Overflow, quel est le code le plus court pour provoquer un débordement de pile? Toute langue est la bienvenue.

ETA: Juste pour être clair sur cette question, vu que je suis un utilisateur occasionnel de Scheme: la "récursion" de l'appel final est en fait une itération, et toute solution qui peut être convertie en une solution itérative de manière relativement triviale par un compilateur décent ne le sera pas Être compté. :-P

ETA2: J'ai maintenant sélectionné une «meilleure réponse»; voir ce post pour la justification. Merci à tous ceux qui ont contribué! :-)

Toutes ces réponses et pas de Befunge? Je parierais pas mal que c'est la solution la plus courte de toutes:

1

Sans blague. Essayez-le vous-même: http://www.quirkster.com/iano/js/befunge.html

EDIT: Je suppose que je dois expliquer celui-ci. L'opérande 1 pousse un 1 sur la pile interne de Befunge et le manque de quoi que ce soit d'autre le met en boucle selon les règles du langage.

En utilisant l'interpréteur fourni, vous finirez par - et je veux dire par la suite - atteindre un point où le tableau Javascript qui représente la pile Befunge devient trop grand pour que le navigateur puisse se réallouer. Si vous aviez un interpréteur Befunge simple avec une pile plus petite et limitée - comme c'est le cas avec la plupart des langages ci-dessous - ce programme provoquerait un débordement plus visible plus rapidement.

Lisez cette ligne et faites ce qu'elle dit deux fois .

Vous pouvez également essayer ceci en C # .net

throw new StackOverflowException();

Nemerle :

Cela plante le compilateur avec une exception StackOverflowException:

def o(){[o()]}

Mon meilleur actuel (en assemblage x86) est:

push eax
jmp short $-1

ce qui donne 3 octets de code objet ( 50 EB FD). Pour le code 16 bits, cela est également possible:

call $

ce qui donne également 3 octets ( E8 FD FF).

PIC18

La réponse PIC18 donnée par TK entraîne les instructions suivantes (binaire):

overflow
   PUSH
   0000 0000 0000 0101
   CALL overflow
   1110 1100 0000 0000
   0000 0000 0000 0000

Cependant, CALL seul effectuera un débordement de pile:

CALL $
1110 1100 0000 0000
0000 0000 0000 0000

PIC18 plus petit, plus rapide

Mais RCALL (appel relatif) est encore plus petit (pas de mémoire globale, donc pas besoin des 2 octets supplémentaires):

RCALL $
1101 1000 0000 0000

Ainsi, le plus petit sur le PIC18 est une seule instruction, 16 bits (deux octets). Cela prendrait 2 cycles d'instructions par boucle. À 4 cycles d'horloge par cycle d'instruction, vous avez 8 cycles d'horloge. Le PIC18 a une pile de 31 niveaux, donc après la 32ème boucle, il débordera de la pile, en 256 cycles d'horloge. À 64 MHz, vous déborderiez la pile en 4 microsecondes et 2 octets .

PIC16F5x (encore plus petit et plus rapide)

Cependant, la série PIC16F5x utilise des instructions 12 bits:

CALL $
1001 0000 0000

Encore une fois, deux cycles d'instruction par boucle, 4 horloges par instruction donc 8 cycles d'horloge par boucle.

Cependant, le PIC16F5x a une pile à deux niveaux, donc sur la troisième boucle il déborderait, en 24 instructions. À 20 MHz, il déborderait en 1,2 micro seconde et 1,5 octets .

Intel 4004

L' Intel 4004 a une instruction de sous-programme d'appel 8 bits:

CALL $
0101 0000

Pour les curieux qui correspond à un ascii 'P'. Avec une pile à 3 niveaux qui prend 24 cycles d'horloge pour un total de 32,4 micro secondes et un octet . (Sauf si vous overclockez votre 4004 - allez, vous savez que vous voulez.)

Ce qui est aussi petit que la réponse befunge, mais beaucoup, beaucoup plus rapide que le code befunge exécuté dans les interpréteurs actuels.

C #:

public int Foo { get { return Foo; } }

Hoot trop-plein!

//              v___v
let rec f o = f(o);(o)
//             ['---']
//             -"---"-

Chaque tâche a besoin du bon outil. Découvrez le langage SO Overflow , optimisé pour produire des débordements de pile:

so

Texas:

\def~{~.}~

Résulte en:

! Capacité TeX dépassée, désolé [taille de la pile d'entrée = 5000].
~ -> ~
    .
~ -> ~
    .
~ -> ~
    .
~ -> ~
    .
~ -> ~
    .
~ -> ~
    .
...
<*> \ def ~ {~.} ~

Latex:

\end\end

Résulte en:

! Capacité TeX dépassée, désolé [taille de la pile d'entrée = 5000].
\ end # 1 -> \ csname end # 1
                      \ endcsname \ @checkend {# 1} \ expandafter \ endgroup \ if @ e ...
<*> \ end \ end

Assembleur Z-80 - à l'emplacement de mémoire 0x0000:

rst 00

un octet - 0xC7 - boucle sans fin de poussée du PC actuel vers la pile et de saut à l'adresse 0x0000.

En anglais:

recursion = n. See recursion.

Un autre exemple PHP:

<?
require(__FILE__);

Que diriez-vous de ce qui suit en BASIC:

10 GOSUB 10

(Je n'ai pas d'interprète BASIC, je crains donc c'est une supposition).

J'ai adoré les tas de réponses de Cody, alors voici ma contribution similaire, en C ++:

template <int i>
class Overflow {
    typedef typename Overflow<i + 1>::type type;
};

typedef Overflow<0>::type Kaboom;

Pas une entrée de code de golf en aucun cas, mais quand même, quoi que ce soit pour un débordement de méta-pile! :-P

Voici ma contribution C, pesant 18 caractères:

void o(){o();o();}

C'est beaucoup plus difficile à optimiser! :-P

À l'aide du fichier de commandes d'une fenêtre nommé "s.bat":

call s

Javascript

Pour couper quelques caractères de plus et nous faire expulser de plus de boutiques de logiciels, allons-y avec:

eval(i='eval(i)');

Sensationnel:

main()

$ groovy stack.groovy:

Caught: java.lang.StackOverflowError
    at stack.main(stack.groovy)
    at stack.run(stack.groovy:1)
 ...

Veuillez me dire ce que signifie l'acronyme « GNU ».

Person JeffAtwood;
Person JoelSpolsky;
JeffAtwood.TalkTo(JoelSpolsky);

En espérant aucune récursion de queue!

C - Ce n'est pas le plus court, mais il est sans récursivité. Ce n'est pas non plus portable: il plante sous Solaris, mais certaines implémentations d'alloca () peuvent renvoyer une erreur ici (ou appeler malloc ()). L'appel à printf () est nécessaire.

#include <stdio.h>
#include <alloca.h>
#include <sys/resource.h>
int main(int argc, char *argv[]) {
    struct rlimit rl = {0};
    getrlimit(RLIMIT_STACK, &rl);
    (void) alloca(rl.rlim_cur);
    printf("Goodbye, world\n");
    return 0;
}

perl en 12 caractères:

$_=sub{&$_};&$_

bash en 10 caractères (l'espace dans la fonction est important):

i(){ i;};i

essayez de mettre plus de 4 galettes sur un seul hamburger. débordement de pile.

Python :

so=lambda:so();so()

Alternativement:

def so():so()
so()

Et si Python optimisé tail appelle ...:

o=lambda:map(o,o());o()

Je sélectionne la «meilleure réponse» après cet article. Mais tout d'abord, je tiens à remercier quelques contributions très originales:

1. ceux d'aku. Chacun explore une manière nouvelle et originale de provoquer un débordement de pile. L'idée de faire f (x) ⇒ f (f (x)) est celle que j'explorerai dans ma prochaine entrée, ci-dessous. :-)
2. Celui de Cody qui a donné au compilateur Nemerle un débordement de pile.
3. Et (un peu à contrecœur), celle de GateKiller sur le fait de lancer une exception de débordement de pile. :-P

Tout comme j'aime ce qui précède, le défi consiste à faire du golf codé, et pour être juste envers les répondants, je dois attribuer la «meilleure réponse» au code le plus court, qui est l'entrée Befunge; Je ne pense pas que quiconque puisse battre ça (bien que Konrad ait certainement essayé), alors félicitations Patrick!

Voyant le grand nombre de solutions de débordement de pile par récursivité, je suis surpris que personne n'ait (à l'heure actuelle) évoqué le combinateur Y (voir l'essai de Dick Gabriel, The Why of Y , pour une introduction). J'ai une solution récursive qui utilise le combinateur Y, ainsi que l'approche f (f (x)) d'aku. :-)

((Y (lambda (f) (lambda (x) (f (f x))))) #f)

En voici un autre intéressant de Scheme:

((lambda (x) (xx)) (lambda (x) (xx)))

Java

Version légèrement plus courte de la solution Java.

class X{public static void main(String[]a){main(a);}}

xor esp, esp
ret

3 octets:

label:
  pusha
  jmp label

Mettre à jour

D'après la (ancienne?) Documentation Intel (?) , C'est aussi 3 octets:

label:
  call label