Escriba un programa que arroje un error StackOverflow o el equivalente en el idioma utilizado. Por ejemplo, en Java , el programa debería lanzar java.lang.StackOverflowError.

No está permitido definir una función que se llame a sí misma o una nueva clase (excepto la que contiene mainen Java). Debe usar las clases del lenguaje de programación seleccionado.

Y no debe arrojar el error explícitamente.

Befunge, 1

No sé Befunge, pero ...

1

_{del código de desbordamiento de pila golf}

Python (2.7.3), 35 caracteres

import sys
sys.setrecursionlimit(1)

Esta operación en sí tiene éxito, pero tanto el script como el interactivo se lanzarán inmediatamente RuntimeError: 'maximum recursion depth exceeded'como consecuencia.

Inspirado por la respuesta de elssar.

Coq

Compute 70000.

70000es solo azúcar sintáctico para S (S ( ... (S O) ...))70000 S's. Creo que es el verificador de tipos lo que causa el desbordamiento de la pila.

Aquí hay una advertencia que se imprime antes de ejecutar el comando:

Warning: Stack overflow or segmentation fault happens when working with large
numbers in nat (observed threshold may vary from 5000 to 70000 depending on
your system limits and on the command executed).

Java - 35

class S{static{new S();}{new S();}}

Javascript 24 caracteres

Respuesta dependiente del navegador (debe tener acceso a apply):

eval.apply(0,Array(999999))

• eval fue el nombre de función global más corto que pude encontrar (¿alguien sabe de uno que sea más corto?)
• applynos permite convertir una matriz en parámetros de función, siendo el primer parámetro el contexto de la función ( this)
• Array(999999)creará una matriz con la longitud indicada. No estoy seguro de cuál es el número máximo de argumentos, pero es menor que esto y más de99999

IE9:

SCRIPT28: Out of stack space 
SCRIPT2343: Stack overflow at line: 20 

Chrome 24:

Uncaught RangeError: Maximum call stack size exceeded 

FireFox 18

RangeError: arguments array passed to Function.prototype.apply is too large

Nota : Debido a la naturaleza de un solo subproceso de javascript, los bucles infinitos terminan bloqueando la interfaz de usuario y nunca lanzan una excepción.

while(1);
for(;;);

Ninguno de estos califica.

Actualización : esto elimina tres caracteres:

eval.apply(0,Array(1e7))

Python 2.7 (12 caracteres)

exec('{'*99)

da como resultado un «s_push: desbordamiento de la pila del analizador»

Mathematica, 4 caracteres

x=2x

$ RecursionLimit :: reclim: se excedió la profundidad de recursión de 1024. >>

Clojure, 12 caracteres

(#(%%)#(%%))

Ejecutando en la réplica:

user=> (#(%%)#(%%))
StackOverflowError   user/eval404/fn--407 (NO_SOURCE_FILE:1)

Java - 113 caracteres

Creo que esto se mantiene dentro del espíritu de la regla "sin métodos de auto-llamada". No lo hace explícitamente, e incluso pasa por una construcción de lenguaje Java.

public class S {
    public String toString() {
        return ""+this;
    }
    public static void main(String[] a) {
        new S().toString();
    }
}

Versión condensada:

public class S{public String toString(){return ""+this;}public static void main(String[] a){new S().toString();}}

C, 19 bytes

main(){int i[~0u];}

GolfScript (8 caracteres)

{]}333*`

Resultado:

$ golfscript.rb overflow.gs 
golfscript.rb:246:in `initialize': stack level too deep (SystemStackError)
from /home/pjt33/bin/golfscript.rb:130:in `new'
from /home/pjt33/bin/golfscript.rb:130:in `ginspect'
from /home/pjt33/bin/golfscript.rb:130:in `ginspect'
from /home/pjt33/bin/golfscript.rb:130:in `map'
from /home/pjt33/bin/golfscript.rb:130:in `ginspect'
from /home/pjt33/bin/golfscript.rb:130:in `ginspect'
from /home/pjt33/bin/golfscript.rb:130:in `map'
from /home/pjt33/bin/golfscript.rb:130:in `ginspect'
 ... 993 levels...
from (eval):4
from /home/pjt33/bin/golfscript.rb:293:in `call'
from /home/pjt33/bin/golfscript.rb:293:in `go'
from /home/pjt33/bin/golfscript.rb:485

Básicamente, esto crea una estructura de datos muy anidada y luego desborda la pila al intentar convertirla en una cadena.

Ensamblaje x86, sintaxis NASM, 7 bytes

db"Pëý"

"Pëý" es 50 EB FD en hexadecimal, y

_loop:
push eax
jmp _loop

en montaje x86.

Rubí, 12

eval"[]"*9e3

Da

SystemStackError: stack level too deep

Presumiblemente depende del sistema, pero puede agregar órdenes de magnitud subiendo el último dígito (no recomendado).

Editar para explicación: de manera similar a algunos otros ejemplos, esto crea una cadena de [][][]... repetida 9000 veces, luego la evalúa: el extremo derecho []se analiza como una llamada de función al resto, y así sucesivamente. Si realmente llegara al principio, arrojaría un ArgumentError porque []es un objeto con un []método que requiere un argumento, pero mi máquina arroja un error un poco antes de que la pila supere los nueve mil.

Rebol (11 caracteres)

do s:[do s]

Rendimientos:

>> do(s:[do s])    
** Internal error: stack overflow
** Where: do do do do do do do do do do do do do do do do 
do do do do do do do do do do do do do do do do do do do
do do do do do do do do do do do do do do do do do do do 
do do do do do do do do do do do do do do do do do do do
do do do do do do do do do do do do do do do do do do do
do do do do do do do do do do do do do do do do do do do
do do do do do do do do do do do do do do do do do do do
do do do do do do do do do do do do do do do do do do do
do do do do do do do do do do do do do do do do do do do
do do do do do do do do do do do do do do do do do do do
do do do do do do do do do do do do...

Aunque Rebol tiene funciones, cierres y objetos ... esto no define ninguno de esos. Define una estructura de datos, que en el paradigma de código como datos puede tratarse como código usando DO.

Podemos investigar la cuestión de "qué es S" con el REPL:

>> s: [do s]
== [do s]

>> type? s
== block!

>> length? s
== 2

>> type? first s
== word!

>> type? second s
== word!

DO nunca convierte esto en una función, invoca al evaluador en el entorno actual de la estructura.

C, 35 caracteres

main(){for(;;)*(int*)alloca(1)=0;}

Lisp común, 7 caracteres

#1='#1#

Python - 11 caracteres

exec'('*999

>>> exec'('*999
s_push: parser stack overflow
Traceback (most recent call last):
  File "<stdin>", line 1, in <module>
MemoryError

Calculadora Casio, 11 pulsaciones de teclas

Es bastante difícil contar bytes / tokens en este "idioma": he dado la cantidad de pulsaciones de teclas requeridas, excluyendo Shift, Alpha (la segunda tecla de mayúsculas) y =al final, esto ciertamente cabe en 1 byte por pulsación de tecla.

Probado en el modelo fx-85GT PLUS , que es una calculadora científica estándar, no gráfica, "no programable". Otros modelos funcionarán.

Solo apila 11 raíces cúbicas:

3√ 3√ 3√ 3√
3√ 3√ 3√ 3√
3√ 3√ 3√

Ni siquiera da un error de sintaxis sobre el número que falta debajo de la raíz cuadrada.

Esto no parece funcionar con raíces cuadradas.

Alternativamente, repita cos(31 veces.

Salida

Stack ERROR

[AC]  :Cancel
[<][>]:Goto

Creo que esto califica como un desbordamiento de pila. La pila parece ser pequeña ...

FORTH, 13 bytes

BEGIN 1 AGAIN

desborda la pila de valores

Postdata, 7

{1}loop

P.ej.

$ gsnd
GPL Ghostscript 9.06 (2012-08-08)
Copyright (C) 2012 Artifex Software, Inc.  All rights reserved.
This software comes with NO WARRANTY: see the file PUBLIC for details.
GS>{1}loop
Error: /stackoverflow in 1
Operand stack:
   --nostringval--
Execution stack:
   %interp_exit   .runexec2   --nostringval--   --nostringval--   --nostringval--   2   %stopped_push   --nostringval--   --nostringval--   %loop_continue   --nostringval--   --nostringval--   false   1   %stopped_push   .runexec2   --nostringval--   --nostringval--   --nostringval--   2   %stopped_push   --nostringval--   --nostringval--   %loop_continue
Dictionary stack:
   --dict:1168/1684(ro)(G)--   --dict:0/20(G)--   --dict:77/200(L)--
Current allocation mode is local
Last OS error: No such file or directory
Current file position is 8
GS<1>

Haskell (GHC, sin optimización), 25

main=print$sum[1..999999]

sum es vago en el total. Esto acumula un montón de thunks, luego intenta evaluarlos todos al final, lo que resulta en un desbordamiento de la pila.

LaTeX: 8 caracteres

\end\end

Este es el mismo código utilizado en esta respuesta . Esencialmente, la \endmacro se expande repetidamente, lo que resulta en un desbordamiento de pila: TeX capacity exceeded, sorry [input stack size=5000]. Una explicación más detallada se puede encontrar aquí .

PHP 5.4, 33 caracteres

for($n=1e5;$n--;)$a=(object)[$a];

Esto provoca un desbordamiento de la pila cuando los objetos stdClass anidados se destruyen automáticamente:

$ gdb -q php
Reading symbols from /usr/bin/php...(no debugging symbols found)...done.
(gdb) set pagination 0
(gdb) r -nr 'for($n=1e5;$n--;)$a=(object)[$a];'
Starting program: /usr/bin/php -nr 'for($n=1e5;$n--;)$a=(object)[$a];'
[Thread debugging using libthread_db enabled]
Using host libthread_db library "/lib/x86_64-linux-gnu/libthread_db.so.1".

Program received signal SIGSEGV, Segmentation fault.
0x00000000006debce in zend_objects_store_del_ref_by_handle_ex ()
(gdb) bt
#0  0x00000000006debce in zend_objects_store_del_ref_by_handle_ex ()
#1  0x00000000006dee73 in zend_objects_store_del_ref ()
#2  0x00000000006a91ca in _zval_ptr_dtor ()
#3  0x00000000006c5f78 in zend_hash_destroy ()
#4  0x00000000006d909c in zend_object_std_dtor ()
#5  0x00000000006d9129 in zend_objects_free_object_storage ()
#6  0x00000000006dee53 in zend_objects_store_del_ref_by_handle_ex ()
#7  0x00000000006dee73 in zend_objects_store_del_ref ()
#8  0x00000000006a91ca in _zval_ptr_dtor ()
#9  0x00000000006c5f78 in zend_hash_destroy ()
#10 0x00000000006d909c in zend_object_std_dtor ()
#11 0x00000000006d9129 in zend_objects_free_object_storage ()
[...]
#125694 0x00000000006dee53 in zend_objects_store_del_ref_by_handle_ex ()
#125695 0x00000000006dee73 in zend_objects_store_del_ref ()
#125696 0x00000000006a91ca in _zval_ptr_dtor ()
#125697 0x00000000006c5f78 in zend_hash_destroy ()
#125698 0x00000000006d909c in zend_object_std_dtor ()
#125699 0x00000000006d9129 in zend_objects_free_object_storage ()
#125700 0x00000000006dee53 in zend_objects_store_del_ref_by_handle_ex ()
#125701 0x00000000006dee73 in zend_objects_store_del_ref ()
#125702 0x00000000006a91ca in _zval_ptr_dtor ()
#125703 0x00000000006c4945 in ?? ()
#125704 0x00000000006c6481 in zend_hash_reverse_apply ()
#125705 0x00000000006a94e1 in ?? ()
#125706 0x00000000006b80e7 in ?? ()
#125707 0x0000000000657ae5 in php_request_shutdown ()
#125708 0x0000000000761a18 in ?? ()
#125709 0x000000000042c420 in ?? ()
#125710 0x00007ffff5b6976d in __libc_start_main (main=0x42bf50, argc=3, ubp_av=0x7fffffffe738, init=<optimized out>, fini=<optimized out>, rtld_fini=<optimized out>, stack_end=0x7fffffffe728) at libc-start.c:226
#125711 0x000000000042c4b5 in _start ()

Q / k (16 caracteres)

No estoy seguro si esto está en el espíritu del desafío, pero no creo que rompa las reglas:

s:{f`};f:{s`};f`

Un grupo del mismo estilo:

Python, 30

(lambda x:x(x))(lambda y:y(y))

Javascript, 38

(function(x){x(x)})(function(y){y(y)})

Lua, 44

(function(x) x(x) end)(function(y) y(y) end)

C #: 106 86 58 46 32 28

32 : Getters puede SO su máquina fácil en C #:

public int a{get{return a;}}

INTERCAL, 12 bytes

(1)DO(1)NEXT

Explicación:

NEXTes la versión de INTERCAL de una llamada de subrutina (o, al menos, la más cercana que puede obtener). Empuja la posición actual en la NEXTpila y salta a la etiqueta dada.

Sin embargo, si la NEXTlongitud de la pila excede 80, obtienes lo que es más o menos la versión INTERCAL de un desbordamiento de pila:

ICL123I PROGRAM HAS DISAPPEARED INTO THE BLACK LAGOON
    ON THE WAY TO 1
        CORRECT SOURCE AND RESUBNIT

Pruébalo en Ideone. .

Mornington Crescent, 139 133

Take Northern Line to Bank
Take Circle Line to Temple
Take Circle Line to Temple
Take Circle Line to Bank
Take Northern Line to Angel

Conjunto X86 (AT&T), 33 caracteres

Tenga en cuenta que aunque estoy usando la etiqueta maincomo un objetivo de salto, esta no es una función recursiva.

.globl main
main:push $0;jmp main

Python (17):

c='exec c';exec c