8 debería convertirse en Infinito [cerrado]

19

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

Qwertiy
fuente
2
@Oliver, como sé, "el puntaje más alto (votos a favor menos votos a favor)" es exactamente el valor predeterminado para el concurso de popularidad , al menos está escrito en la descripción de la etiqueta: "Un concurso de popularidad es una competencia donde la respuesta con el mayor puntaje de votos (votos positivos menos votos negativos) gana ". Pero puedo agregarlo a la pregunta explícitamente.
Qwertiy
1
@Maltysen, hay muchas soluciones interesantes en idiomas con esta construcción. Hay C y C ++ (con soluciones absolutamente diferentes), C #, Java, Javascript, php, Perl, Groovy. Estoy seguro de que hay mucho más. De todos modos, estoy abierto a agrandar la pregunta y eso se especifica en las reglas. Si puede hacer algo interesante en otro idioma, publíquelo. Si tendrá una relación positiva, las reglas pueden ampliarse.
Qwertiy
44
Hacer esto como un concurso de popularidad es un poco incómodo porque no hay una descripción de qué criterios deben elegir los votantes al votar (haciendo que la condición de victoria sea subjetiva). Estaba trabajando en una solución de código de golf sobre la base de que muchas personas aquí encuentran interesantes las soluciones de golf y, por lo tanto, podrían ser populares; parece que podría ser una condición de victoria viable para el desafío.
2
1. " entero o contador numérico " es un poco vago. Por ejemplo, ¿incluye java.lang.Integer? 2. Esto sería mejor con un criterio ganador adecuado.
Peter Taylor
1
1. Sí, lo hace. 2. ¿Qué cretería ganadora exactamente? PD: podemos continuar en meta .
Qwertiy

Respuestas:

33

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

Maltysen
fuente
¿Podría proporcionar un enlace a onlinde IDE, por favor? ideone.com/aI3ZrI : parece que no funciona allí.
Qwertiy
@Qwertiy, intenté ejecutarlo en repl.it, pero simplemente se congela, lo cual es de esperar ya que será un bucle infinito. Sé que las cosas int caché trabaja allí, porque ahí es donde he experimentado con la forma de conjunto 8a9
Maltysen
Realmente funciona allí. Es extraño que no tengan límite de tiempo como ideone (5 segundos). MuestranPython 3.5.2 (default, Dec 2015, 13:05:11) [GCC 4.8.2] on linux
Qwertiy
@Qwertiy enlace sin bucle: repl.it/E4fx/0
Maltysen
Eso es interesante ...
Qwertiy
22

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

FlipTack
fuente
2
Esconda eso en el medio de un gran módulo ...
Benjamin
21

Perl

Limpiar

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

Aumentado

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

Ideone .

primo
fuente
16
Oh, eso es realmente inteligente. Para cualquiera que no conozca a Perl: esto es $iun alias para convertirse en un alias para una variable especial que solo es capaz de contener booleanos, por lo que una vez que llega a 1 se vuelve inmune al incremento.
10

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)

zepelín
fuente
1
Por cierto, es ES5, ¿no?
Qwertiy
Tampoco funciona varen Crome. Pero puede eliminar varde ambos programas, estará bien.
Qwertiy
@Qwertiy esto funciona con "var" en Chrome para mí (Linux / Versión 52.0.2743.82 (64 bits))
zeppelin
> Por cierto, es ES5, ¿no? Es cierto, corregirá el título ahora
zeppelin
1
El problema son los varpolipastos, por lo que al momento de usarlo definePropertyya sale. Pero si coloca estas 2 líneas en diferentes scripts (por cierto, está permitido), funcionaría, ya que la propiedad se creará primero y varluego se ignorará. Prueba: i.stack.imgur.com/lSwbE.png
Qwertiy
10

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;
}
Omar
fuente
Must execute same for loop as an infinite loop itself. Placing of the loop into another infinite construction is not ok.
Karl Napf
3
@KarlNapf El ciclo "for" no está dentro de otra construcción infinita.
coredump
3
@KarlNapf Pensé que esta respuesta estaba explícitamente permitida por la regla: • Se
Omar
Es la frase "Debe ejecutarse igual para el bucle", pero sí, esto entra en conflicto con la representación textual.
Karl Napf
7

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

insert_name_here
fuente
Vénceme, esta solución es idéntica a la mía.
Hypino
66
Esto no es realmente un Java for loop idiomático, que probablemente usaría el unboxed en intlugar del relativamente pesado Integer.
7

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 .

Karl Napf
fuente
6

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.

Azul
fuente
6

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

ToXik-yogurt
fuente
Eso está en el espíritu de la competencia y es muy interesante. En realidad, no se dijo nada acerca de omitir la asignación inicial, por lo que es un caso marginal. En realidad, se esperaba que no haya un punto de extensión entre la asignación de 0 y las iteraciones. Pero no voy a rechazarlo ahora, ya que veo algunas formas interesantes de casos extremos basadas en eso y no es fácil usarlo en exceso.
Qwertiy
2
@Qwertiy "así que ese es un caso marginal". PHP en pocas palabras :)
ToXik-yogHurt
6

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


fuente
5

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.

Leche
fuente
5

Mathematica

Limpiar

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

Aumentado

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

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 .

volcado de memoria
fuente
4

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
daniero
fuente
4

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.

Cactus
fuente
1
Buena idea cambiar el tipo predeterminado para los literales numéricos sobrecargados de Haskell.
nimi
3

///

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.

Cedric Reichenbach
fuente
Y pensé que en realidad harías algo como /0/1//1/2/.../7/8//8/8/8contar en su lugar.
Erik the Outgolfer
3

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.

Marcus Dirr
fuente
"El comportamiento del bucle debe ser el mismo en caso de bucle vacío"
Qwertiy
Maldición, lo perdí, tendré que resolver algo.
Marcus Dirr
Por lo que puedo decir, no es posible hacer cuál es el desafío con un bucle de estilo C en Javascript a menos que rompa una regla, ya sea teniendo algo dentro (como mi solución) o masajeando previamente el bucle declaración en su código limpio (como con Cedric Reichenbach's).
Marcus Dirr
En realidad hay algunas formas. El camino con la variable global ya está publicado, pero hay algunos más, lo que permite varel bucle.
Qwertiy
Como dije, hasta donde puedo decir. Vi la forma variable global después de hacer ese comentario y me pateé.
Marcus Dirr
2

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.

Karl Napf
fuente
Agradable, pero puede ser "optimizado" :) Hay algunas incorporaciones interesantes en C ++ para hacer otra respuesta.
Qwertiy
2

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.

Rayo
fuente
2

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 $!

Ben
fuente
1

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.

Karl Napf
fuente
1

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.

Cobre
fuente
1

GolfScript

Limpiar

0{.8<}{)}while;

Aumentado

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

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

jimmy23013
fuente
1

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

sergiol
fuente
1

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

ganso121
fuente
¿No se detendrá después del desbordamiento de enteros?
Qwertiy
1
Oh, eh ... tal vez. ¿Pero llevará mucho tiempo? Yo como que se olvidó de que eso podría suceder, siendo sobre todo un programador de alto nivel de lenguaje
goose121
0

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++);
Cedric Reichenbach
fuente
No parece ser un bucle típico ...
Qwertiy
Sí, alargué un poco el término típico ...: /
Cedric Reichenbach el
0

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
...
FlipTack
fuente