Vamos dar uma olhada em um loop típico, que geralmente realiza 8 iterações:

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

Você tem que torná-lo infinito!

É um concurso de popularidade para todos os idiomas que suportam essa forma de forloop. Portanto, a solução com a pontuação mais alta (upvotes menos downvotes) vence.

Se o seu idioma tiver outra forma de forloop, mas você tem certeza, pode fazer algo interessante com ele, sinta-se à vontade para postar a resposta e marcá-la como não-concorrente. Reservo-me o direito de ampliar o escopo das construções e idiomas disponíveis, mas isso nunca será reduzido, portanto, não tenha medo de descartar as soluções anteriormente corretas.

O que é solução?

A solução consiste em dois programas.

O primeiro programa é um programa limpo . É o programa típico em seu idioma, com o forloop fazendo 8 iterações. Deve ser o programa normal, qualquer desenvolvedor pode escrever. Não há hacks especiais para fins de preparação. Por exemplo:

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

O segundo programa é aumentado. Este programa deve conter todo o código do programa limpo e algum código adicional. Há um número limitado de pontos de extensão; consulte a seção de regras completas para obter detalhes. Um programa aumentado para o programa limpo acima pode ser

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

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

Esse é apenas um exemplo (não compilável em C ++) para mostrar uma ideia. O verdadeiro programa aumentado correto deve ser compilável, funcionando e possuindo loop infinito.

Regras completas

Ambos os programas:

• Qualquer idioma com suporte para esses forloops está ok.
• O corpo do loop deve estar vazio. Mais precisamente, você pode colocar alguma saída ou outro código no loop, mas o comportamento do loop deve ser o mesmo no caso de loop vazio.

Programa limpo:

• O loop usa contador inteiro ou numérico e executa 8 iterações:

  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++
  

• Tipos definidos pelo usuário não são permitidos.

• O uso da propriedade (exceto da variável global) em vez da variável de loop não é permitido.

• A declaração da variável pode estar dentro ou fora do loop. O código a seguir está ok:

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

• É possível usar o incremento de prefixo ou postfix.

• O limite do loop 8deve ser gravado como um literal constante sem salvar na constante ou variável nomeada. Foi criado para impedir soluções baseadas em declarar variável ou constante igual a 8 e, em seguida, reatribuir, substituir ou sombrear pelo outro valor:

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

Programa aumentado:

• Deve conter todo o código do código limpo.
• Deve estender o programa limpo em um número limitado de pontos de extensão.
• Deve executar o mesmo for loop que um loop infinito em si.
  Colocar o loop em outra construção infinita não é bom.
• O patch em tempo de execução ou em tempo de compilação do código é permitido desde que a representação textual dele seja inalterada.
• Colocar a construção em uma string e passar para evalnão é permitido.

Pontos de extensão:

• Em qualquer lugar fora do fragmento com código limpo, incluindo outros arquivos ou outros assemblies.
• forA declaração (como peça única - forconstrução e seu corpo) deve ser mantida inalterada.
• A declaração variável deve ser mantida igual.
• Qualquer lugar entre instruções simples pode ser usado como ponto de extensão.
• Se e somente se a variável foi declarada fora do loop e sem atribuição imediata do valor, essa atribuição pode ser adicionada.

/* 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;
}

PS: Se possível, forneça um link para o IDE online.

Python3

Programa Limpo:

Esta é apenas uma contagem regressiva padrão enquanto loop.

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

Ele usa o cache int para redefinir 8o 9que efetivamente torna o n -= 1no-op, uma vez 9-1 = 8que apenas nvolta ao 9normal, causando o loop infinito.

Você pode ver o cache int em ação online aqui (embora obviamente sem o loop infinito porque esteja online).

Python 3

Programa Limpo:

A maneira padrão de fazer algo 8 vezes em python é:

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

Programa aumentado:

No entanto, se substituirmos a função do gerador de alcance para gerar infinitamente 1, ela se tornará um loop infinito ...

def range(x):
    while 1: yield 1

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

Podemos levar isso adiante e criar uma função geradora que, em vez de produzir infinitamente 1, conta para sempre:

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

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

Teste em repl.it

Perl

Limpar \ limpo

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

Aumentada

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

Ideone .

ES5 + (Javascript)

EDIT : Removida a declaração de variável explícita, caso contrário ela foi içada e uma propriedade window.x não configurável foi criada (a menos que seja executada linha por linha no console REPL).

Explicação:

Aproveita o fato de que qualquer variável com escopo global também é uma propriedade do objeto window e redefine a propriedade "window.x" para ter um valor constante de 1.

Limpar \ limpo

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

Aumentada

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

NOTA : Para fazer isso funcionar no Node.js., substitua "window" por "global" (testado no Node.js. 6.8.0)

C

Programa limpo

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 limpo:

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++);
    }
}

Define o número inteiro no cache de número inteiro que deve conter 1 a 0, efetivamente fazendo i++nada (ele define io número inteiro em cache que deve conter 1, mas desde que esse número inteiro realmente contém 0, nada muda).

C ++

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

boolsó pode ser 0 ou 1. Inspirado pela resposta Perl do primo .

Python 3 (3.5.0)

Programa Limpo:

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

Aumentada

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 solução é diferente das outras escritas em Python, pois na verdade altera o código-fonte em tempo real. Todas as coisas no loop for podem ser alteradas para qualquer código desejado.

O código altera o penúltimo opcode para ser 113ou mais legível - JUMP_ABSOLUTE. Ele altera o operando para 160- a instrução em que o loop for começa, criando uma instrução GOTO no final do programa.

O programa aumentado imprime os números 0..7infinitamente várias vezes sem sobrecarregar a pilha ou similar.

PHP

Eu acho que isso está seguindo as regras do ponto de extensão; Não sou totalmente claro no ponto 4. É muito semelhante à resposta perl do @ primo, então acho que conta.

Limpar \ limpo

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

Aumentada

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

O PHP permite incrementar certas strings, da seguinte forma:

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

Todas essas seqüências são avaliadas como 0, então isso ocorrerá praticamente para sempre (exceto, de alguma forma, a falta de memória).

Perl

Código limpo

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

Código aumentado

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

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

A maioria das variáveis ​​Perl são apenas variáveis. No entanto, o idioma também possui um tierecurso, que permite fornecer efetivamente getters e setters de variáveis. Neste programa, eu faço o pacote principal (cujo nome é a cadeia nula) no equivalente a uma classe de uma linguagem orientada a objetos, além de ser um programa. Isso me permite amarrar o forcontador de loop ao próprio programa. Implementar TIESCALARpermite tieter sucesso; o valor de retorno de TIESCALARdeve ser uma referência a qualquer estado interno que precisamos manter associado à variável, mas como não precisamos disso, retornamos uma referência de matriz vazia como espaço reservado. Em seguida, fornecemos as implementações mais simples possíveis do getter e setter; nenhum deles faz nada, então tenta atribuir a$xnão têm efeito e as tentativas de lê-lo sempre retornam undef, que é numericamente menor que 8.

WinDbg

Limpar \ limpo

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

Aumentada

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
}

Essa abordagem cria um alias para <as |, portanto, quando <é encontrado no código, o alias é expandido |e bit a bit - ou é feito em vez de menor que. No WinDbg, todos os valores diferentes de zero são anything | 8verdadeiros, portanto sempre é verdade.

Nota: Na .blockverdade, não é necessário se o aSe .forfor inserido como duas linhas diferentes, como mostrado aqui, é necessário apenas quando o aSe .forestiver na mesma linha.

Mathematica

Limpar \ limpo

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

Aumentada

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

Lisp comum

Código limpo

(dotimes(i 8))

Aumentada

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

Uma macro chamada keyword:dotimesaka :dotimes(consulte 11.1.2.3 O pacote KEYWORD ) é definida e se expande como um loop infinito. A defmacromacro retorna o nome da macro que está sendo definida, e pode ser alimentada shadowing-import. Portanto, esse novo dotimessímbolo sombreia o padrão (que não deve ser redefinido ou vinculado lexicamente a outra macro em programas portáteis).

Aumentado (2)

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

Quando lemos o caractere 8, substituímos por (loop). Isso significa que o texto acima mostra como (dotimes (i (loop)))e, portanto, o código nunca termina o cálculo do limite superior. Isso afeta todas as ocorrências de 8, não apenas a do loop. Em outras palavras, 8 realmente significa infinito. Se você estiver curioso, quando a tabela de leitura for modificada como acima, o caractere 8 se tornará "terminador" e se desconectará de outros números / símbolos atualmente sendo lidos:

(list 6789)

... lê como:

(list 67 (loop) 9)

Você pode executar testes no Ideone: https://ideone.com/sR3AiU .

Rubi

Limpar \ limpo

Esse tipo de loop for não é muito usado no Ruby, mas um tutorial típico informa que esse é o caminho a seguir:

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

Aumentada

O loop for apenas chama (1..8).eachcom o bloco de código fornecido, então alteramos esse 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

Versão limpa:

import Control.Monad (forM_)

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

Versão 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

É bastante básico, realmente: nós apenas definir o nosso próprio tipo Tde tal forma que o seu enumFromTocaso é uma sequência infinita, em seguida, usar o tipo de falta para que os valores un-anotada do tipo 0e 8são tomados como tipo T.

///

Não há forloops explícitos em ///, mas podem ser simulados (afinal, ele está completo).

Limpar \ limpo:

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

Aumentada:

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

O que está acontecendo?

Enquanto o primeiro programa faz a contagem regressiva 8-0, o último de uma /0/0/regra irá substituir 0por 0até a eternidade.

Javascript ES6

OK, aqui está uma versão que funciona usando o ES6 para ... da construção de loop. Vou até lhe dar uma matriz limpa, para ter certeza de que não há nenhum negócio engraçado:

Limpar \ limpo

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

Claro, isso não impede que alguém mexa com o protótipo Array ...

Aumentada

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

Isso funciona substituindo o iterador padrão para que ele nunca termine, bloqueando tudo em um loop infinito. O código nem sequer tem a chance de executar as coisas dentro do loop.

C ++

Usa 2 pontos de extensão:

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;
}

Programa limpo é o mesmo que na descrição.

Brainfuck

Imprimo um '0' cada iteração, apenas para facilitar a contagem de iterações. Mas qualquer código pode ser inserido lá sem alterar o funcionamento do loop.

Limpar \ limpo

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

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

Experimente online

A versão aumentada depende da implementação comum do Brainfuck com células de 8 bits. Nessas implementações, "incremento" é na verdade "incremento (mod 256)". Assim, para encontrar um loop que iterará exatamente 8 vezes na versão limpa e infinitamente na versão aumentada, podemos simplesmente encontrar uma solução para o seguinte sistema de desigualdades.

• a + b * 8 (mod 256) == 0 (para versão limpa)
• c + a + b * n (mod 256)> 0 para todos n (para versão aumentada)
• a> 0

Nesse caso, deixamos a = 128, b = 16 e ec = 1. Obviamente 128 + 16 * 8 = 256 (e 256 (mod 256) = 0) e 128> 0, e como b é par, c + a + b * n é ímpar para qualquer ímpar a + c e, portanto, nunca será um múltiplo par de 256 nesses casos. Selecionamos c = 1 por uma questão de simplicidade. Portanto, a única mudança que precisamos é de uma única +no início do programa.

Aumentada

+                                            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)
]                                            }

Experimente online

Deixo ao OP para determinar se esta entrada está competindo. Brainfuck não tem um loop for explícito, mas o formulário que usei é o mais próximo possível. ++++++++também é o mais próximo possível de um literal 8; Eu incluí alguns deles.

A versão limpa quase certamente constitui um programa típico escrito nessa linguagem, pois mesmo o Brainfuck Hello World mais curto conhecido depende de uma relação de recorrência modular ao trabalho.

Haskell

Limpar \ limpo

import Control.Monad (forM_)

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

Aumentada

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

Substitui o operador de aplicativo de função usual $por um que repete o loop novamente toda vez que termina. A execução da versão limpa imprime 0 a 8 e depois pára; a versão aumentada imprime 0 a 8 e depois 0 a 8 novamente, e assim por diante.

Eu trapaceio um pouco, pois essa forM_ [0..8] $ \i -> print inão é necessariamente a maneira "mais limpa" de escrever esse loop em Haskell; muitos Haskellers reduziriam o corpo do loop para obter forM_ [0..8] printe, então, não há $como substituir. Em minha defesa, copiei o código limpo da resposta do Cactus , que não precisava dessa propriedade, então pelo menos um programador de Haskell realmente escreveu esse código sem motivação para adicionar desnecessariamente o $!

C ++

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

Vamos xavaliar para 7. Não funciona em C porque requer um valor l na atribuição e no incremento.

Nim

A versão idiomática, usando countup:

Limpar \ limpo

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

Aumentada

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

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

Simples e muito semelhante à resposta do Python, que redefinerange . Redefinimos countup, a maneira idiomática do Nim de iterar de um int (inclusive) para outro, para dar 8s infinitamente.

A versão mais interessante, usando o operador range ..:

Limpar \ limpo

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

Aumentada

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

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

Muito semelhante à solução anterior, exceto que redefinimos o operador range .., que normalmente daria uma matriz [1, 2, 3, 4, 5, 6, 7, 8], para o iterador de antes.

GolfScript

Limpar \ limpo

0{.8<}{)}while;

Aumentada

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

Atribui a função retornando n + 1 à variável 8

tcl

Normal:

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

Aumentada:

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

A idéia é redefinir o incrcomando que é usado para incrementar a variável i, para realmente não incrementar!

Pode ser testado em: http://rextester.com/live/QSKZPQ49822

Montagem x86_64

Programa limpo:

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

O tipo de loop que qualquer programador do Assembly usaria, seguido por um syscall de saída para não permitir adicionar uma jmp loop_startinstrução posteriormente.

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

Além disso, desculpe se é ruim que o programa limpo não tenha um ponto de entrada ou um section .text

Javascript

Limpar \ limpo:

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

Aumentada:

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

C ++

Programa Limpo

Um loop normal e agradável, repetindo os números de 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

O pré-processador de C ++ é um recurso bastante perigoso ...

#include <iostream>
#define short bool

int main() {

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

}

A única linha que tivemos que adicionar foi #define short bool. Isso torna ium booleano em vez de um número inteiro curto e, portanto, o operador de incremento ( i++) não faz nada depois de iatingir 1. A saída fica assim:

0 0
1 1
1 1
1 1
1 1
1 1
...