Echemos un vistazo a un bucle típico, que generalmente realiza 8 iteraciones:

for (int x=0; x<8; ++x);

¡Tienes que hacerlo infinito!

Es un concurso de popularidad para todos los idiomas que admiten esa forma de forbucle. Entonces, la solución con la puntuación más alta (votos positivos menos votos negativos) gana.

Si su idioma tiene la otra forma de forbucle, pero está seguro, puede hacer algo genial con él, no dude en publicar la respuesta y marcarla como no competitiva. Me reservo el derecho de ampliar el alcance de las construcciones e idiomas disponibles, pero nunca se reducirá, así que no tenga miedo de descartar soluciones previamente correctas.

¿Qué es la solución?

La solución consta de dos programas.

El primer programa es un programa limpio . Es el programa típico en su idioma con el forciclo que hace 8 iteraciones. Debería ser el programa normal, cualquier desarrollador podría escribir. No hay hacks especiales para fines de preparación. Por ejemplo:

int main() 
{
  for (int x=0; x<8; ++x);
  return 0;
}

El segundo programa se aumenta. Este programa debe contener todo el código del programa limpio y algún código adicional. Hay un número limitado de puntos de extensión, vea la sección de reglas completas para más detalles. Un programa aumentado para el limpio de arriba puede ser

inline bool operator < (const int &a, const int &b)
{
  return true;
}

int main() 
{
  for (int x=0; x<8; ++x);
  return 0;
}

Eso es solo un ejemplo (no compatible en C ++) para mostrar una idea. El programa real correcto aumentado tiene que ser compilable, funcionar y tener bucle infinito.

Reglas completas

Ambos programas:

• Cualquier lenguaje con soporte de tales forbucles está bien.
• El cuerpo del bucle debe estar vacío. Más precisamente, puede colocar alguna salida u otro código en el bucle, pero el comportamiento del bucle debe ser el mismo en caso de bucle vacío.

Programa limpio:

• Loop usa un entero o un contador numérico y realiza 8 iteraciones:

  for (int          x=0; x<8; ++x);   // C, C++, C#
  for (var          x=0; x<8; ++x);   // C#, Javascript
  for (auto         x=0; x<8; ++x);   // C, C++
  for (auto signed  x=0; x<8; ++x);   // C, C++
  for (register int x=0; x<8; ++x);   // C, C++
  

• Los tipos definidos por el usuario no están permitidos.

• El uso de la propiedad (excepto la variable global) en lugar de la variable de bucle no está permitido.

• La declaración de variable puede estar dentro o fuera del bucle. El siguiente código está bien:

  int x;
  for(x=0; x<8; ++x);
  

• Se puede usar el incremento de prefijo o postfix.

• El límite de bucle 8debe escribirse como un literal constante sin guardarlo en una constante o variable nombrada. Está hecho para evitar soluciones basadas en declarar variable o constante igual a 8, y luego reasignarlo, anularlo o sombrearlo por el otro valor:

  const double n = 8;
  
  int main()
  {
    const double n = 9007199254740992;
    for (double x=0; x<n; ++x);
    return 0;
  }
  

Programa aumentado:

• Debe contener todo el código del limpio.
• Debe extender el programa limpio en un número limitado de puntos de extensión.
• Debe ejecutar el mismo for bucle que un bucle infinito.
  Colocar el bucle en otra construcción infinita no está bien.
• El parche en tiempo de ejecución o en tiempo de compilación del código está permitido siempre que la representación textual del mismo no se modifique.
• Colocar la construcción en una cuerda y pasar a evalno está permitido.

Puntos de extensión:

• En cualquier lugar fuera del fragmento con código limpio, incluidos otros archivos u otros ensamblados.
• fordeclaración (como pieza única - forconstrucción y su cuerpo) debe mantenerse sin cambios.
• La declaración variable debe mantenerse igual.
• Cualquier lugar entre declaraciones simples puede usarse como punto de extensión.
• Si y solo si la variable se declaró fuera del ciclo y sin una asignación inmediata del valor, dicha asignación se puede agregar.

/* extension point here */
int main()
/* extension point here */
{
  /* extension point here */
  int x /* extension point for assignment here */;
  /* extension point here */
  for (x=0; x<8; ++x);
  /* extension point here */
  return 0;
  /* extension point here */
}
/* extension point here */

int main() 
{
  /* BEGIN: No changes allowed */ int x = 0; /* END */
  /* extension point here */
  /* BEGIN: No changes allowed */ for (x=0; x<8; ++x); /* END */
  return 0;
}

PD: Si es posible, proporcione un enlace a IDE en línea.

Python3

Programa limpio:

Esto es solo una cuenta regresiva estándar mientras que el ciclo.

n = 8
while n != 0:
  n -= 1
print("done")

Programa Aumentado:

import ctypes

ctypes.cast(id(8), ctypes.POINTER(ctypes.c_int))[6] = 9

n = 8
while n != 0:
  n -= 1
print("done")

Utiliza el caché int para redefinir 8, lo 9que efectivamente hace que el n -= 1no-op, ya 9-1 = 8que solo nvuelve a funcionar 9, causando el bucle infinito.

Puede ver el caché int en acción en línea aquí (aunque obviamente sin el ciclo infinito porque está en línea).

Python 3

Programa limpio:

La forma estándar de hacer algo 8 veces en python es:

for i in range(8): 
    # Do something
    pass

Programa Aumentado:

Sin embargo, si anulamos la función del generador de rango para producir infinitamente 1, se convierte en un bucle infinito ...

def range(x):
    while 1: yield 1

for i in range(8):
    # Infinite loop
    pass

Podemos llevar esto más lejos y crear una función generadora que, en lugar de producir infinitamente 1, cuente para siempre:

def range(x):
    i = 0
    while 1: yield i; i+=1

for i in range(8):
    # Counting from 0 to infinity
    pass

Prueba en repl.it

Perl

Limpiar

for($i=0; $i<8; $i++) { }

Aumentado

*i=*|;
for($i=0; $i<8; $i++) { }

Ideone .

ES5 + (Javascript)

EDITAR : Se eliminó la declaración de variable explícita, ya que de lo contrario se levantó y se creó una propiedad window.x no configurable (a menos que se ejecute línea por línea en la consola REPL).

Explicación:

Aprovecha el hecho de que cualquier variable de ámbito global también es una propiedad del objeto de ventana y redefine la propiedad "window.x" para tener un valor constante de 1.

Limpiar

for(x=0; x<8; x+=1) console.log(x);

Aumentado

Object.defineProperty(window,'x',{value:1});
for(x=0; x<8; x+=1) console.log(x);

NOTA : Para que esto funcione en Node.js, simplemente reemplace "ventana" con "global" (probado en Node.js 6.8.0)

C

Programa limpio

int main() 
{
  for (int x=0; x<8; ++x);
  return 0;
}

Programa aumentado

#define for(ever) while(1)

int main() 
{
  for (int x=0; x<8; ++x);
  return 0;
}

Java

Programa limpio:

public class Main {
    public static void main(String[] args) throws Exception {
        for (Integer i = 0; i < 8; i++);
    }
}

Programa aumentado:

import java.lang.reflect.Field;

public class Main {
    public static void main(String[] args) throws Exception {
        Class cache = Integer.class.getDeclaredClasses()[0];
        Field c = cache.getDeclaredField("cache");
        c.setAccessible(true);
        Integer[] intcache = (Integer[]) c.get(cache);
        intcache[129] = intcache[128];

        for (Integer i = 0; i < 8; i++);
    }
}

Establece el entero en la memoria caché de enteros que debe contener 1 a 0, haciendo efectivamente i++ no hace nada (se establece ien el número entero en caché que debe contener 1, pero dado que ese número entero realmente contiene 0, nada cambia).

C ++

int main() 
{
#define int bool
  for (int x=0; x<8; ++x);
  return 0;
}

boolsolo puede ser 0 o 1. Inspirado por la respuesta Perl de primo .

Python 3 (3.5.0)

Programa limpio:

for i in range(8):
    print(i)

Aumentado

import sys

from ctypes import *

code = sys._getframe().f_code.co_code

cast(sys._getframe().f_code.co_code, POINTER(c_char*len(code))).contents[len(code)-4] = 113
cast(sys._getframe().f_code.co_code, POINTER(c_char*len(code))).contents[len(code)-3] = 160

for i in range(8):
    print(i)

Esta solución es diferente a las otras escritas en Python en que realmente cambia el código fuente sobre la marcha. Todas las cosas en el bucle for se pueden cambiar a cualquier código que se desee.

El código cambia el penúltimo opcode para que sea 113o más legible - JUMP_ABSOLUTE. Cambia el operando a 160: la instrucción donde comienza el ciclo for, creando una declaración GOTO al final del programa.

El programa aumentado imprime los números 0..7infinitamente muchas veces sin desbordamiento de pila o similar.

PHP

Creo que esto sigue las reglas del punto de extensión; No estoy del todo claro en el punto 4. Es muy similar a la respuesta perl de @primo, así que creo que cuenta.

Limpiar

for(;$i<8;$i++);

Aumentado

$i='a';
for(;$i<8;$i++);

PHP te permite incrementar ciertas cadenas, así:

'a' -> 'b'
'b' -> 'c'
'z' -> 'aa'
'aa' -> 'ab'
'aab' -> 'aac'
etc

Todas estas cadenas se evalúan a 0, por lo que esto se repetirá prácticamente para siempre (salvo que de alguna manera se quede sin memoria).

Perl

Código limpio

for ($x = 0; $x < 8; $x++) {}

Código aumentado

sub TIESCALAR {bless []}
sub FETCH {}
sub STORE {}
tie $x, "";

for ($x = 0; $x < 8; $x++) {}

La mayoría de las variables de Perl son solo variables. Sin embargo, el lenguaje también tiene una tiecaracterística que le permite dar variables de forma eficaz a los captadores y definidores. En este programa, convierto el paquete principal (cuyo nombre es la cadena nula) en el equivalente de una clase de un lenguaje orientado a objetos, a la vez que hago que sea un programa. Eso me permite vincular el forcontador de bucle al programa en sí. La implementación no TIESCALARpermite ningún efecto, y los intentos de leerlo siempre regresan , que es numéricamente menor que 8.tie tener éxito; El valor de retorno de TIESCALARdebe ser una referencia a cualquier estado interno que necesitemos mantener asociado con la variable, pero debido a que no necesitamos ninguno, devolvemos una referencia de matriz vacía como marcador de posición. Luego damos las implementaciones más simples posibles de getter y setter; ninguno de ellos hace nada, así que intenta asignar a$xundef

WinDbg

Limpiar

.for (r$t0 = 0; @$t0 < 8; r$t0 = @$t0 + 1) { }

Aumentado

aS < |;                                            * Create alias of < as |
.block {                                           * Explicit block so aliases are expanded
    .for (r$t0 = 0; @$t0 < 8; r$t0 = @$t0 + 1) { } * Condition is now @$t0 | 8, always true
}

Este enfoque crea un alias para <as |, por lo que cuando <se encuentra en el código, el alias se expande |y se hace a nivel de bits, o se hace en lugar de menos que. En WinDbg, todos los valores distintos de cero son verdaderos, por anything | 8lo que siempre es cierto.

Nota: El .blockno es realmente necesario si el aSy .forse ingresan como dos líneas diferentes como se muestra aquí, solo se requiere cuando aSy .forestán en la misma línea.

Mathematica

Limpiar

For[x = 0, x < 8, ++x,]

Aumentado

x /: (x = 0) := x = -Infinity;
For[x = 0, x < 8, ++x,]

Lisp común

Código limpio

(dotimes(i 8))

Aumentado

(shadowing-import(defmacro :dotimes(&rest args)'(loop)))
(dotimes(i 8))

Se define una macro llamada keyword:dotimesaka :dotimes(ver 11.1.2.3 El paquete KEYWORD ) que se expande como un bucle infinito. losdefmacro macro devuelve el nombre de la macro que se está definiendo, que se puede alimentar shadowing-import. Por lo tanto, estos nuevos dotimessímbolos sombrean el estándar (que no debe ser redefinido o ligado léxicamente a otra macro en programas portátiles).

Aumentado (2)

(set-macro-character #\8 (lambda (&rest args) '(loop)))
(dotimes(i 8))

Cuando leemos el carácter 8, lo reemplazamos por (loop). Eso significa que lo anterior se lee como (dotimes (i (loop)))y, por lo tanto, el código nunca termina de calcular el límite superior. Esto afecta a todas las ocurrencias de 8, no solo la del bucle. En otras palabras, 8 realmente significa infinito. Si tiene curiosidad, cuando la tabla de lectura se modifica como anteriormente, el carácter 8 se "termina" y se separa de otros números / símbolos que se leen actualmente:

(list 6789)

... se lee como:

(list 67 (loop) 9)

Puede ejecutar pruebas en Ideone: https://ideone.com/sR3AiU .

Rubí

Limpiar

Este tipo de bucle for no se usa mucho en Ruby, pero un tutorial típico le dirá que esta es la manera de hacerlo:

for x in 1..8
  # Some code here
end

Aumentado

El bucle for solo llama (1..8).eachcon el bloque de código dado, por lo que cambiamos ese método:

class Range
  def each
    i = first
    loop { yield i; i+= 1 }
  end
end

for x in 1..8
  # Some code here
end

Haskell

Versión limpia:

import Control.Monad (forM_)

main = forM_ [0..8] $ \i -> print i

Versión aumentada:

import Control.Monad (forM_)

data T = C

instance Num T where
    fromInteger _ = C

instance Enum T where
    enumFromTo _ _ = repeat C

instance Show T where
    show _ = "0"

default (T)

main = forM_ [0..8] $ \i -> print i

Es bastante básico, en realidad: lo único que definimos nuestro propio tipo Ttal que su enumFromTocaso es una secuencia infinita, a continuación, utilizar el tipo de morosos para que la ONU-tipo-anotada valores 0y 8se toman como tipo T.

///

No hay forbucles explícitos en ///, pero se pueden simular (se está completando después de todo).

Limpiar:

/1/0/
/2/1/
/3/2/
/4/3/
/5/4/
/6/5/
/7/6/
/8/7/
8

Aumentado:

/0/0/
/1/0/
/2/1/
/3/2/
/4/3/
/5/4/
/6/5/
/7/6/
/8/7/
8

¿Que esta pasando?

Mientras que el primero programa cuenta frente al 8 a 0, de esta última /0/0/norma reemplazará 0por 0hasta la eternidad.

Javascript ES6

OK, aquí hay una versión que funciona usando el ES6 para ... de construcción de bucle. Incluso te daré una matriz limpia para que estemos seguros de que no hay asuntos divertidos:

Limpiar

for(a of [0,1,2,3,4,5,6,7]);

Por supuesto, eso no impide que alguien se meta con el prototipo Array ...

Aumentado

Array.prototype[Symbol.iterator]=function(){return {next: function(){return {done: false}}}}
for(a of [0,1,2,3,4,5,6,7]);

Esto funciona sobrescribiendo el iterador predeterminado para que nunca termine, por lo tanto, bloquea todo en un bucle infinito. El código ni siquiera tiene la oportunidad de ejecutar las cosas dentro del bucle.

C ++

Utiliza 2 puntos de extensión:

struct True {
  True(int x){}
  bool operator<(const int&){
    return true;
  }
  void operator++(){}
};


int main() 
{
#define int True
  for (int x=0; x<8; ++x);
  return 0;
}

El programa limpio es el mismo que en la descripción.

Brainfuck

Imprimo un '0' en cada iteración, solo para que sea fácil contar las iteraciones. Pero cualquier código podría insertarse allí sin cambiar el funcionamiento del bucle.

Limpiar

>> ++++++ [-<++++++++>] <<                   b = '0' (value to be printed each iteration)

>> ++++++++ [-<< ++++++++ ++++++++ >>] <<    for (a = a plus 128;
[                                              a;
++++++++ ++++++++                              a = a plus 16 (mod 256)) {
>.<                                              loop body (print b)
]                                            }

Pruébalo en línea

La versión aumentada se basa en la implementación común de Brainfuck con celdas de 8 bits. En estas implementaciones, "incremento" es en realidad "incremento (mod 256)". Por lo tanto, para encontrar un bucle que iterará exactamente 8 veces en la versión limpia y sin fin en la versión aumentada, simplemente podemos encontrar una solución para el siguiente sistema de desigualdades.

• a + b * 8 (mod 256) == 0 (para versión limpia)
• c + a + b * n (mod 256)> 0 para todos los n (para la versión aumentada)
• a> 0

En este caso, dejamos a = 128, b = 16 y c = 1. Obviamente 128 + 16 * 8 = 256 (y 256 (mod 256) = 0) y 128> 0, y dado que b es par, c + a + b * n es impar para cualquier a + c impar y, por lo tanto, nunca será un múltiplo par de 256 en tales casos. Seleccionamos c = 1 por simplicidad. Por lo tanto, el único cambio que necesitamos es un solo+ al comienzo del programa.

Aumentado

+                                            increment a (only change)
>> ++++++ [-<++++++++>] <<                   b = '0' (value to be printed each iteration)

>> ++++++++ [-<< ++++++++ ++++++++ >>] <<    for (a = a plus 128;
[                                              a;
++++++++ ++++++++                              a = a plus 16 (mod 256)) {
>.<                                              loop body (print b)
]                                            }

Pruébalo en línea

Lo dejo al OP para determinar si esta entrada está compitiendo. Brainfuck no tiene un bucle for explícito, pero la forma de bucle que utilicé es lo más cercana posible. ++++++++también es lo más parecido a un literal 8que puedas obtener; He incluido bastantes de esos.

La versión limpia casi seguramente constituye un programa típico escrito en este lenguaje, ya que incluso el Brainfuck Hello World más corto conocido depende de una relación de recurrencia modular con el trabajo.

Haskell

Limpiar

import Control.Monad (forM_)

main = forM_ [0..8] $ \i -> print i

Aumentado

import Control.Monad (forM_)

import Prelude hiding (($))
import Control.Monad (when)

f $ x = f (\i -> x i >> when (i == 8) (f $ x))

main = forM_ [0..8] $ \i -> print i

Reemplaza el operador de aplicación de función habitual $por uno que repite el ciclo nuevamente cada vez que finaliza. La ejecución de la versión limpia imprime de 0 a 8 y luego se detiene; la versión aumentada imprime de 0 a 8 y luego de 0 a 8 nuevamente, y así sucesivamente.

Hago un poco de trampa, porque esa forM_ [0..8] $ \i -> print ino es necesariamente la forma "más limpia" de escribir ese bucle en Haskell; muchos Haskellers reducirían el cuerpo del bucle para obtener forM_ [0..8] printy luego no hay $que anular. En mi defensa, copié el código limpio de la respuesta de Cactus , que no necesitaba esa propiedad, por lo que al menos un programador de Haskell escribió ese código sin motivación para agregar innecesariamente el $!

C ++

int main() 
{
  int y;
#define int
#define x (y=7)
  for (int x=0; x<8; ++x);
  return 0;
}

Vamos a xevaluar a 7. No funciona en C porque requiere un valor l en la asignación e incremento.

Nim

La versión idiomática, usando countup :

Limpiar

for i in countup(1, 8):
  # counting from 1 to 8, inclusive
  discard

Aumentado

iterator countup(a: int, b: int): int =
  while true:
    yield 8

for i in countup(1, 8):
  # counting 8s forever
  discard

Simple y muy similar a la respuesta de Python que redefinerange . Redefinimoscountup , la forma idiomática de Nim de iterar de un int (inclusive) a otro, para dar 8s infinitamente.

La versión más interesante, usando el operador de rango .. :

Limpiar

for i in 1..8:
  # counting from 1 to 8, inclusive
  discard

Aumentado

iterator `..`(a: int, b: int): int =
  while true:
    yield 8

for i in 1..8:
  # counting 8s forever
  discard

Muy similar a la solución anterior, excepto que redefinimos el operador de rango .., que normalmente daría una matriz [1, 2, 3, 4, 5, 6, 7, 8], al iterador de antes.

GolfScript

Limpiar

0{.8<}{)}while;

Aumentado

{.)}:8;
0{.8<}{)}while;

Asigna la función que devuelve n + 1 a la variable 8

tcl

Normal:

for {set i 0} {$i<8} {incr i} {}

Aumentado:

proc incr x {}
for {set i 0} {$i<8} {incr i} {}

La idea es redefinir el incrcomando que se usa para incrementar la variable i, ¡para que no se incremente!

Se puede probar en: http://rextester.com/live/QSKZPQ49822

Asamblea x86_64

Programa limpio:

mov rcx, 8
loop_start:
sub rcx, 1
cmp rcx,0
jne loop_start
mov rax, 0x01
mov rdi, 0
syscall

El tipo de bucle que usaría cualquier programador de ensamblaje, seguido de una llamada al sistema de salida para no permitir agregar una jmp loop_startinstrucción después.

Programa aumentado:

global start
section .text
start:
mov rcx, -1
jmp loop_start
mov rcx, 8
loop_start:
sub rcx, 1
cmp rcx,0
jne loop_start
mov rax, 0x01
mov rdi, 0
syscall

Además, lo siento si es malo que el programa limpio no tenga un punto de entrada o un section .text

JavaScript

Limpiar:

for (var i = 0; !(i > Math.PI * 2.5); i++);

Aumentado:

window.Math = {PI: NaN};
for (var i = 0; !(i > Math.PI * 2.5); i++);

C ++

Programa limpio

Un buen bucle normal, iterando de los números 0 a 7.

#include <iostream>

int main() {

  for (short i = 0; i < 8; i++) {
    // Print `i` with a newline.
    std::cout << i << std::endl;
  }    

}

Programa Aumentado

El preprocesador de C ++ es una característica bastante peligrosa ...

#include <iostream>
#define short bool

int main() {

  for (short i = 0; i < 8; i++) {
    // Print `i` with a newline.
    std::cout << i << std::endl;
  }    

}

La única línea que tuvimos que agregar fue #define short bool. Esto hace iun booleano en lugar de un entero corto, por lo que el operador de incremento ( i++) no hace nada después de illegar a 1. La salida se ve así:

0 0
1
1
1
1
1
...