Escriba un programa que se ejecute para siempre y asigne más y más memoria en el montón cuanto más tiempo se ejecute, al menos hasta que alcance el límite del sistema operativo en la cantidad de memoria que se puede asignar.

Muchos núcleos en realidad no reservarán la memoria que asigne hasta que la use para algo, por lo que si su programa está en C o en algún otro lenguaje de bajo nivel, deberá asegurarse de escribir algo en cada página. Si está utilizando un lenguaje interpretado, probablemente no tendrá que preocuparse por esto.

El código más corto gana.

Funge-98 ( cfunge), 1 byte

9

Hubiera publicado esto antes, pero decidí probarlo y me llevó un tiempo volver a poner mi computadora en un estado utilizable. cfungealmacena la pila Funge en el montón del sistema operativo (que es fácilmente verificable ejecutando el programa con un pequeño límite de memoria, ¡algo que debería haber hecho antes!), por lo que una pila que crece infinitamente (como con este programa, que simplemente empuja 9repetidamente; Los programas de Funge (desde el final de una línea hasta el inicio de forma predeterminada) asignarán memoria para siempre. Es probable que este programa también funcione en algunas implementaciones de Befunge-93.

Más interesante:

"NULL #(4

Esta fue mi primera idea, y es una asignación infinita que no depende de la pila Funge (aunque también explota la pila Funge). Para comenzar, el "comando empuja una copia del resto del programa a la pila (es una cadena, y el programa se ajusta, por lo que la comilla cerrada también sirve como comilla abierta). Luego, el Nreflejo (no tiene significado por defecto), lo que hace que el programa se ejecute al revés. Se "ejecuta nuevamente y empuja el programa a la pila, al revés esta vez, con la Nparte superior de la pila, luego el programa se ajusta, cargando una biblioteca con un nombre de 4 letras ( 4(; la NULLbiblioteca es parte de cfungeLa biblioteca estándar). NULLdefine todas las letras mayúsculas para reflejar, por lo que Lrefleja, el#omite la carga de la biblioteca en el camino de regreso, 4empuja basura que no nos importa a la pila y todo el programa se repite desde el principio. Dado que cargar una biblioteca varias veces tiene un efecto y requiere que la lista de comandos de la biblioteca se almacene una vez para cada copia de la biblioteca (esto está implícito en la semántica de Funge-98), pierde memoria a través del almacenamiento no apilado (que es un método alternativo para definir "montón", relativo al lenguaje en lugar del sistema operativo).

Brainfuck, 5 bytes

+[>+]

Esto requiere un intérprete que no tenga límite en la longitud de la cinta.

Bash + coreutils, 5

o

Rubí, 5

`yes`

yesproduce salida sin fin. Poner yesen backticks le dice al shell que capture toda la salida y luego ejecute esa salida como un comando. Bash continuará asignando memoria para esta cadena interminable hasta que se agote el montón. Por supuesto, el resultado resultante terminaría siendo un comando no válido, pero deberíamos quedarnos sin memoria antes de que eso suceda.

Gracias a @GB por señalar que también es un políglota en rubí.

Python, 16 bytes

Sigue anidando ahasta que se alcanza un error:

a=0
while 1:a=a,

Las primeras iteraciones (como tuplas) se ven así:

0
(0,)
((0,),)
(((0,),),)

y así sucesivamente y así sucesivamente.

> <> (Pez), 1 byte

0

Pruébalo aquí!

0 en realidad se puede sustituir por cualquier número hexadecimal 1-f.

Explicación

0in> <> simplemente crea una caja de códigos 1x1 para que los peces naden. Constantemente agrega una 0a la pila, nada hacia la derecha, lo que hace un bucle hacia atrás y la 0agrega nuevamente a la pila. Esto continuará por siempre.

Java 101 bytes

class A{public void finalize(){new A();new A();}public static void main(String[]a){for(new A();;);}}

Capturando el programa principal en un bucle sin fin después de crear y tirar un objeto. La recolección de basura hace el trabajo de fugas al crear 2 objetos por cada uno eliminado

Perl, 12 bytes

{$"x=9;redo}

En perl, el xoperador, con una cadena a la izquierda y un número a la derecha, produce una cadena repetida. Entonces "abc" x 3evalúa a "abcabcabc".

El x=operador muta el argumento izquierdo, reemplazando el contenido de la variable a su izquierda con el resultado de repetir su contenido tantas veces como lo indique su lado derecho.

Perl tiene varias variables incorporadas con nombres extraños, una de las cuales es $", cuyo valor inicial es un espacio único.

El redooperador salta al comienzo del cerramiento {}.

La primera vez que el x=se realiza el operador, cambia el valor de $"partir " ""a " ", que es de 9 espacios.

La segunda vez que el x=operador termina, cambia el valor de $"a " ", que es 81 espacios.

La tercera vez, se $"convierte en una cadena de espacios de 729 bytes de longitud.

Creo que puedes ver por donde está yendo :).

sed, 5 bytes

Golfed

H;G;D

Uso (cualquier entrada servirá)

sed 'H;G;D' <<<""

Explicado

#Append a newline to the contents of the hold space, 
#and then append the contents of the pattern space to that of the hold space.
H

#Append a newline to the contents of the pattern space, 
#and then append the contents of the hold space to that of the pattern space. 
G

#Delete text in the pattern space up to the first newline, 
#and restart cycle with the resultant pattern space.
D

Captura de pantalla

¡Pruébelo en línea!

Haskell, 23 19 bytes

main=print$sum[0..]

Imprime la suma de una lista infinita

C ++ (usando el compilador g ++), 27 23 15 bytes

Gracias a Neop por ayudarme a eliminar 4 bytes.

Esta solución realmente no pierde ninguna memoria porque asigna todo en la pila y por lo tanto causa un desbordamiento de la pila. Es simplemente infinitamente recursivo. Cada recursión hace que se asigne algo de memoria hasta que la pila se desborde.

main(){main();}

Solución alternativa

Esta solución realmente pierde memoria.

main(){for(;;new int);}

Salida de Valgrind

Esta es la salida de Valgrind después de terminar el programa varios segundos después del tiempo de ejecución. Puedes ver que ciertamente está perdiendo memoria.

==2582== LEAK SUMMARY:
==2582==    definitely lost: 15,104,008 bytes in 3,776,002 blocks
==2582==    indirectly lost: 0 bytes in 0 blocks
==2582==      possibly lost: 16 bytes in 4 blocks
==2582==    still reachable: 4 bytes in 1 blocks
==2582==         suppressed: 0 bytes in 0 blocks

JAVA, 81 79 78 bytes

JAVA (HotSpot) 71 70 bytes

Más corto que otras respuestas de Java en el momento en que publiqué (81, más tarde 79 bytes):

class A{public static void main(String[]a){String x="1";for(;;)x+=x.intern();}}

Según lo sugerido por @Olivier Grégoire, se puede guardar un byte adicional:

class A{public static void main(String[]a){for(String x="1";;)x+=x.intern();}}

Colocar x+=x.intern()como el incremento de bucle for no ayudaría en nada, porque todavía se necesita un punto y coma para finalizar la instrucción for.

Según lo sugerido por @ETHproductions, solo usando x+=xtrabajos también:

class A{public static void main(String[]a){String x="1";for(;;)x+=x;}}

Lo que también puede beneficiarse del consejo de @Olivier Grégoire:

class A{public static void main(String[]a){for(String x="1";;)x+=x;}}

Mis únicas dudas sobre eso es que no se garantiza que se asignen datos en el montón , ya que una JVM eficiente puede darse cuenta fácilmente de que xnunca escapa a la función local. El uso intern()evita esta preocupación porque las cadenas internadas finalmente terminan almacenadas en un campo estático. Sin embargo, HotSpot genera un OutOfMemoryErrorcódigo para ese código, así que supongo que está bien.

Actualización: @Olivier Gregoire también señaló que el x+=xcódigo puede ejecutarse en StringIndexOutOfBoundsExceptionlugar de OOMcuando hay mucha memoria disponible. Esto se debe a que Java usa el tipo de 32 bits intpara indexar matrices (y las cadenas son solo matrices de char). Esto no afecta a la x+=x.intern()solución ya que la memoria requerida para este último es cuadrática en la longitud de la cadena, y por lo tanto debería escalar hasta el orden de 2 ^ 62 bytes asignados.

Perl 6 , 13 bytes

@= eager 0..*

Explicación:

@ = almacenar el resultado en una matriz sin nombre

eager haga la siguiente lista ansiosa

0 .. * rango infinito a partir de cero

///, 7 bytes

/a/aa/a

Reemplazar constantemente acon aanáuseas.

Python 3, 16 bytes

i=9
while 1:i*=i

Esto viene del hecho de que no hay límite para el tamaño entero en Python 3; en cambio, los enteros pueden ocupar tanta memoria como el sistema puede manejar (si algo sobre mi comprensión de esto está mal, corríjame).

Óxido, 46 ​​bytes

fn main(){loop{std::mem::forget(Box::new(1))}}

¿Notó algo interesante sobre este programa Rust, que pierde las asignaciones del montón hasta que se queda sin memoria?

Así es, no hay bloque inseguro. Rust garantiza la seguridad de la memoria en un código seguro (sin lectura de datos no inicializados, lectura libre, doble libre, etc.), pero las pérdidas de memoria se consideran perfectamente seguras. Incluso hay una función explícita para hacer que el compilador se olvide de la limpieza de RAII de variables fuera de alcance, que uso aquí.

Conjunto hexagonal TI-83, 7 bytes

PROGRAM:M
:AsmPrgm
:EF6A4E
:C3959D
:C9

Crea appvars indefinidamente hasta que ERR:MEMORYel sistema operativo arroja uno. Corre con Asm(prgmM). Cuento cada par de dígitos hexadecimales como un byte.

Python, 8 bytes

2**9**99

El OP ha permitido la tecnicidad de un programa que técnicamente no se ejecuta "para siempre", pero asigna más memoria de la que cualquier computadora podría manejar. Esto no es un googolplex (eso sería 10**10**100, 11 bytes), pero ingenuamente, la base de registro 2 del número es

>>> 9**99.
2.9512665430652752e+94

es decir, 10 ^ 94 bits para representarlo. WolframAlpha dice que es 10 ^ 76 más grande que la red profunda (tenga en cuenta que hay alrededor de 10 ^ 80 átomos en el universo ).

¿Por qué 2 en lugar de 9 preguntas? No hace mucha diferencia (usar 9 solo aumentaría el número de bits por un factor de log2(9) = 3.2, que ni siquiera cambia el exponente). Pero, por otro lado, el programa se ejecuta mucho más rápido con 2, ya que el cálculo es más simple. Esto significa que llena la memoria inmediatamente, a diferencia de la versión 9, que lleva un poco más de tiempo debido a los cálculos requeridos. No es necesario, pero bueno si quieres "probar" esto (lo que hice).

Jalea , 3 2 bytes

-1 byte gracias a Dennis ( Wwraps)

Wß

Un enlace (es decir, función o método), que también funciona como un programa completo, que envuelve recursivamente su entrada en una lista.

La entrada comienza como cero, por lo que la primera pasada crea la lista. [0]
La segunda pasada hace esto. [[0]]
La tercera pasada hace esto [[[0]]]
y así sucesivamente ...

3 byter anterior, que se filtra mucho más rápido:

;Ẇß

concatena recursivamente todas las sublistas contiguas no vacías de su entrada a su entrada.
[0]-> [0,[0]]-> [0,[0],[0],[[0]],[0,[0]]]y así sucesivamente ...

Java 7, 106 bytes

class A{public void finalize(){for(;;)Thread.yield();}public static void main(String[]a){for(;;)new A();}}

Menos golf

class A{
    @Override
    public void finalize(){
        for(;;) {
            Thread.yield();
        }
    }
    public static void main(String[]a){
        for(;;){
            new A();
        }
    }
}

El finalizerecolector de basura llama al método en un objeto cuando la recolección de basura determina que no hay más referencias al objeto. Simplemente he redefinido este método para hacer un bucle para siempre, por lo que el recolector de basura nunca libera la memoria. En el mainbucle, creo nuevos objetos que nunca se limpiarán, por lo que eventualmente se usará toda la memoria disponible.

Java 7 (alternativa divertida), 216 bytes

import sun.misc.*;class A{public static void main(String[]a)throws Exception{java.lang.reflect.Field f=Unsafe.class.getDeclaredField("theUnsafe");f.setAccessible(1>0);for(;;)((Unsafe)f.get(null)).allocateMemory(9);}}

Menos golf

import sun.misc.*;
class A{
    public static void main(String[]a)throws Exception{
        java.lang.reflect.Field f=Unsafe.class.getDeclaredField("theUnsafe");
        f.setAccessible(true);
        Unsafe u = (Unsafe)f.get(null);
        for(;;) {
            u.allocateMemory(9);
        }
    }
}

Esta es una diversión más que cualquier otra cosa. Esta respuesta hace uso de la Unsafebiblioteca Sun, que es una API interna no documentada. Es posible que deba cambiar la configuración del compilador para permitir API restringidas. Unsafe.allocateMemoryasigna una cantidad específica de bytes (sin ninguna verificación de límites) que no está en el montón y no está bajo la administración del recolector de basura de Java, por lo que esta memoria se mantendrá hasta que llame Unsafe.freeMemoryo hasta que jvm se quede sin memoria.

Haskell, 24 bytes

f x=f$x*x
main=pure$!f 9

El principal problema en Haskell es vencer a la pereza. mainnecesita tener algún IOtipo, por lo que simplemente llamar main=f 9no funcionaría. El uso main=pure(f 9)eleva el tipo de f 9a un IOtipo. Sin embargo, el uso de construcciones como main=pure 9no hace nada, 9se devuelve o se muestra en ninguna parte, sino que simplemente se descarta, por lo que no es necesario evaluar el argumento de pure, por main=pure(f 9)lo tanto , no causa que se asigne ninguna memoria como fno se llama. Para hacer cumplir la evaluación, el $!operador existe. Simplemente aplica una función a un argumento pero primero evalúa el argumento. Por lo tanto, el uso main=pure$!f 9evalúa fy, por lo tanto, asigna continuamente más memoria.

dc, 7 bytes

[ddx]dx

[ddx]empuja una cadena que contiene "ddx" a la pila. dxduplica y luego lo ejecuta como código (dejando una copia en la pila). Cuando se ejecuta, hace dos duplicados y luego ejecuta uno, dejando una copia más en la pila cada vez.

Haskell (usando ghc 8.0.1), 11 bytes

m@main=m>>m

Recursión sin cola. mainse llama a sí mismo y luego a sí mismo nuevamente.

C (Linux), 23 bytes

main(){while(sbrk(9));}

sbrk()incrementa la parte superior del segmento de datos en el número dado de bytes, lo que aumenta efectivamente la cantidad de memoria asignada al programa, al menos como se informa en el VIRTcampo de topsalida. Esto solo funciona en Linux: la implementación de macOS es aparentemente una emulación que solo permite la asignación de hasta 4 MB.

Entonces, una respuesta un poco más general:

C, 25 bytes

main(){while(malloc(9));}

Lo vi en el Monitor de actividad de macOS. Llegó hasta aproximadamente 48 GB, luego, finalmente, el proceso recibió una señal SIGKILL. FWIW mi macbook pro tiene 16 GB. La mayor parte de la memoria utilizada se informó como comprimida.

Tenga en cuenta que la pregunta efectivamente requiere que se escriba cada asignación, lo que no sucede explícitamente aquí. Sin embargo, es importante tener en cuenta que para cada malloc(9)llamada, no solo se asignan los 9 bytes solicitados por el usuario. Para cada bloque asignado, habrá un encabezado malloc que también se asigna desde algún lugar del montón, que necesariamente es escrito por los malloc()internos.

Perl, 4 bytes

do$0

Se ejecuta a sí mismo, en el intérprete actual. Cuando finaliza, la ejecución vuelve al script de llamada, que requiere una pila de llamadas.

Raqueta, 13 bytes

(let l()(l)1)

No estoy del todo seguro si mi respuesta corresponde a esta pregunta. Avíseme si debo eliminar esta respuesta.

JavaScript 22 21 17 16 15 Bytes

for(a=0;;)a=[a]

Ahorró 4 bytes envolviendo la lista en otra lista como en la respuesta de @Jonathan Allan's Jelly.

Guardado 1 byte gracias a @ETHProductions

Solución alternativa de 15 bytes (solo funciona con llamadas de cola adecuadas)

f=a=>f([a]);f()

Ruby, 11 bytes

loop{$*<<9}

Sigue empujando 9sobre $*, que es una matriz inicialmente que sostiene los argumentos de línea de comandos para el proceso de Ruby.

05AB1E , 2 bytes

[A

Pruébalo en línea! Seguirá empujando abcdefghijklmnopqrstuvwyxzen la pila por la eternidad.

Todas las posibles soluciones de 2 bytes:

[  # Infinite loop.
 A # Push alphabet.
 0 # Push 0.
 1 # Push 1.
 2 # Push 2.
 3 # Push 3.
 4 # Push 4.
 5 # Push 5.
 6 # Push 6.
 7 # Push 7.
 8 # Push 8.
 9 # Push 9.
 T # Push 10.
 X # Push 1.
 Y # Push 2.
 ® # Push -1.
 ¶ # Push \n.
 º # Push len(stack) > 0, so 0 once then 1 for eternity.
 ð # Push a space.
 õ # Push an empty string.
 ¾ # Push 0.
 ¯ # Push [].
 M # Push -inf.
 ) # Wrap current stack in an array.

Python, 35 bytes

def f(a=[]):a.append(a)
while 1:f()

a nunca se lanza y solo se hace más grande hasta que golpeas un MemoryError

Puede ver la ejecución en Python Tutor .

TI-BASIC, 8

:Lbl A
:While 1
:Goto A

(todos los tokens de 1 byte y dos líneas nuevas)

Esto continuamente pierde memoria porque el flujo de control estructurado, como el Whileanticipado por un cierre, Endy empuja algo en la pila (no la pila del sistema operativo, una pila separada en la memoria del montón) para realizar un seguimiento de eso. Pero aquí estamos usando Gotopara dejar el bucle (para que no Endse ejecute nada para eliminar la cosa de la pila), Whilese vuelve a ver, la cosa se empuja de nuevo, etc. Así que sigue empujándolos hasta que se obtieneERR:MEMORY