Давайте рассмотрим типичный цикл, который обычно выполняет 8 итераций:

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

Вы должны сделать это бесконечным!

Это конкурс популярности для всех языков, которые поддерживают такую ​​форму forцикла. Таким образом, решение с наивысшим баллом (положительные отзывы минус отрицательные) побеждает.

Если у вашего языка есть другая форма forцикла, но вы уверены, что вы можете сделать что-то классное с ним, не стесняйтесь опубликовать ответ и пометить его как неконкурентный. Я оставляю за собой право увеличивать объем доступных конструкций и языков, но он никогда не будет сокращен, так что не бойтесь отбрасывать ранее правильные решения.

Что такое решение?

Решение состоит из двух программ.

Первая программа - это чистая программа. Это типичная программа на вашем языке с forциклом из 8 итераций. Это должна быть нормальная программа, написать любой разработчик. Никаких специальных взломов для целей подготовки. Например:

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

Вторая программа дополнена. Эта программа должна содержать весь код из чистой программы и некоторый дополнительный код. Количество точек расширения ограничено , подробности см. В полном разделе правил. Дополненная программа для чистой выше может быть

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

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

Это просто пример (не компилируемый в C ++), чтобы показать идею. Настоящая правильная дополненная программа должна быть компилируемой, работающей и имеющей бесконечный цикл.

Полные правила

Обе программы:

• Любой язык с поддержкой таких forциклов в порядке.
• Тело цикла должно быть пустым. Точнее, вы можете поместить некоторый вывод или другой код в цикл, но поведение цикла должно быть таким же в случае пустого цикла.

Чистая программа:

• Цикл использует целочисленный или числовой счетчик и выполняет 8 итераций:

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

• Пользовательские типы запрещены.

• Использование свойства (кроме глобальной переменной) вместо переменной цикла запрещено.

• Объявление переменной может быть внутри или снаружи цикла. Следующий код в порядке:

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

• Можно использовать префикс или постфиксный инкремент.

• Предел цикла 8должен быть записан как константный литерал без сохранения в именованную константу или переменную. Это сделано для предотвращения решений, основанных на объявлении переменной или константы равной 8, а затем переназначении, переопределении или дублировании ее другим значением:

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

Дополненная программа:

• Должен содержать весь код из чистого.
• Следует расширить чистую программу в ограниченном количестве точек расширения.
• Должен выполнять тот же for цикл, что и сам бесконечный цикл.
  Размещение цикла в другой бесконечной конструкции не нормально.
• Исправление кода во время выполнения или во время компиляции допускается, если его текстовое представление не изменяется.
• Размещение конструкции в виде строки и переход к ней evalзапрещен.

Точки расширения:

• Везде за пределами фрагмента с чистым кодом, включая другие файлы или другие сборки.
• forВыписка (как единое целое - forконструкция и ее тело) должны быть оставлены без изменений.
• Объявление переменной должно быть одинаковым.
• Любое место между простыми утверждениями может быть использовано в качестве точки расширения.
• Если и только если переменная была объявлена ​​вне цикла и без немедленного присвоения значения, такое присваивание может быть добавлено.

/* 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: Если возможно, предоставьте ссылку на онлайн IDE.

python3

Чистая программа:

Это просто стандартный цикл обратного отсчета.

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

Дополненная программа:

import ctypes

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

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

Он использует кэш INT для переназначения 8в 9которых эффективно не делает n -= 1пустую операцию, так как, 9-1 = 8который просто устанавливает nобратно 9снова, вызывая бесконечный цикл.

Вы можете увидеть кэш ИНТ в действии онлайн здесь (хотя , очевидно , не бесконечный цикл ПОТОМУ его онлайн).

Python 3

Чистая программа:

Стандартный способ сделать что-то 8 раз в Python:

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

Дополненная программа:

Однако, если мы переопределим функцию генератора диапазона, чтобы бесконечно выдавать 1, она станет бесконечным циклом ...

def range(x):
    while 1: yield 1

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

Мы можем пойти дальше и создать генераторную функцию, которая, вместо бесконечного результата 1, будет иметь значение вечно:

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

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

Тест на repl.it

Perl

чистый

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

Дополненная

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

Ideone .

ES5 + (Javascript)

РЕДАКТИРОВАТЬ : Удалено явное объявление переменной, так как в противном случае она была поднята, и было создано неконфигурируемое свойство window.x (если не запускается построчно в консоли REPL).

Объяснение:

Использует тот факт, что любая переменная в глобальном масштабе также является свойством объекта окна и переопределяет свойство «window.x», чтобы иметь постоянное значение 1.

чистый

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

Дополненная

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

ПРИМЕЧАНИЕ . Чтобы это работало в Node.js, просто замените «window» на «global» (протестировано в Node.js 6.8.0).

С

Чистая программа

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

Дополненная программа

#define for(ever) while(1)

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

Джава

Чистая программа:

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

Дополненная программа:

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

Устанавливает Integer в кеше Integer, который должен содержать от 1 до 0, фактически заставляя i++ничего не делать (он устанавливает iкешированное Integer, которое должно содержать 1, но поскольку это Integer фактически содержит 0, ничего не меняется).

C ++

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

boolможет быть только 0 или 1. Вдохновлен Perl-ответом primo .

Python 3 (3.5.0)

Чистая программа:

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

Дополненная

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)

Это решение отличается от других написанных на Python тем, что фактически изменяет исходный код на лету. Все содержимое цикла for можно изменить на любой нужный код.

Код меняет второй или последний код операции, чтобы быть 113или более читабельным - JUMP_ABSOLUTE. Он изменяет операнд на 160- инструкцию, с которой начинается цикл for, фактически создавая оператор GOTO в конце программы.

Расширенная программа печатает числа 0..7бесконечно много раз без переполнения стека или чего-либо подобного.

PHP

Я думаю, что это следует правилам точки расширения; Я не совсем ясен в пункте 4. Это очень похоже на perl-ответ @ primo, поэтому я думаю, что он имеет значение.

чистый

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

Дополненная

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

PHP позволяет увеличивать определенные строки, например, так:

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

Все эти строки оцениваются в 0, так что это будет зацикливаться практически вечно (за исключением того, что не хватает памяти).

Perl

Чистый код

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

Дополненный код

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

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

Большинство переменных Perl являются просто переменными. Тем не менее, язык также имеет tieфункцию, которая позволяет эффективно задавать переменные геттеры и сеттеры. В этой программе я превращаю основной пакет (имя которого является пустой строкой) в эквивалент класса из объектно-ориентированного языка, в то же время имея программу. Это позволяет мне привязать forсчетчик цикла к самой программе. Реализация TIESCALARпозволяет tieдобиться успеха; Возвращаемое значение TIESCALARпредназначено для ссылки на любое внутреннее состояние, которое нам нужно хранить, связанное с переменной, но, поскольку оно нам не нужно, мы возвращаем пустую ссылку на массив в качестве заполнителя. Затем мы даем простейшие возможные реализации методов получения и установки; ни один из них ничего не делает, поэтому пытается назначить$xне имеют никакого эффекта, и попытки прочитать его всегда возвращаются undef, что численно меньше 8.

WinDbg

чистый

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

Дополненная

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
}

Этот подход создает псевдоним для <as |, поэтому, когда <он встречается в коде, псевдоним расширяется до |и побитового или делается вместо меньше чем. В WinDbg все ненулевые значения верны, поэтому anything | 8всегда верны.

Примечание. .blockФактически не нужно, если aSи .forфактически введены в виде двух разных строк, как показано здесь, это требуется только тогда, когда aSи .forнаходятся в одной строке.

Mathematica

чистый

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

Дополненная

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

Обыкновенный Лисп

Чистый код

(dotimes(i 8))

Дополненная

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

Макрос с именем keyword:dotimesaka :dotimes(см. 11.1.2.3 Пакет KEYWORD ), который расширяется как бесконечный цикл. В defmacroмакрокоманда возвращает имя макроса определяется, который может быть подан shadowing-import. Таким образом, эти новые dotimesсимволы затеняют стандартный (который не должен быть переопределен или лексически связан с другим макросом в переносимых программах).

Дополненная (2)

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

Когда мы читаем символ 8, мы заменяем его на (loop). Это означает, что вышеизложенное читается как(dotimes (i (loop))) и поэтому код никогда не завершает вычисление верхней границы. Это влияет на все 8 случаев, а не только на один в цикле. Другими словами, 8 действительно означает бесконечность. Если вам интересно, когда читаемая таблица изменяется, как описано выше, то символ 8 становится «завершающим» и отсоединяется от других читаемых в данный момент чисел / символов:

(list 6789)

... читается как:

(list 67 (loop) 9)

Вы можете запустить тесты на Ideone: https://ideone.com/sR3AiU .

Рубин

чистый

Такого рода цикл for не очень часто используется в Ruby, но типичное руководство покажет вам, как это сделать:

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

Дополненная

Цикл for просто вызывает (1..8).eachданный блок кода, поэтому мы изменим этот метод:

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

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

Haskell

Чистая версия:

import Control.Monad (forM_)

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

Дополненная версия:

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

Это довольно простой, на самом деле: мы просто определить наш собственный тип Tтакой , что его enumFromToэкземпляр является бесконечная последовательность, то использовать тип по умолчанию это так , что значения ип-типа аннотированный 0и 8принимаются в качестве типа T.

///

В for/// нет явных циклов, но их можно смоделировать (в конце концов, они завершаются).

Чистота:

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

Дополненная:

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

В чем дело?

В то время как первая программа ведет отсчет от 8 до 0, /0/0/правило последней будет заменено 0на 0вечность.

Javascript ES6

Хорошо, вот версия, которая работает с использованием ES6 для ... конструкции цикла. Я даже дам вам чистый массив, чтобы мы были уверены, что нет ничего смешного:

чистый

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

Конечно, это не мешает кому-то возиться с прототипом Array ...

Дополненная

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

Это работает путем перезаписи итератора по умолчанию, чтобы он никогда не завершался, поэтому все блокируется в бесконечный цикл. Код даже не имеет возможности запустить материал внутри цикла.

C ++

Использует 2 точки расширения:

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

Чистая программа такая же, как в описании.

Brainfuck

Я печатаю «0» на каждой итерации, чтобы было проще считать итерации. Но любой код может быть вставлен туда без изменения работы цикла.

чистый

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

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

Попробуйте онлайн

Дополненная версия опирается на общую реализацию Brainfuck с 8-битными ячейками. В этих реализациях «приращение» фактически является «приращением (мод 256)». Таким образом, чтобы найти цикл, который будет повторяться ровно 8 раз в чистой версии и бесконечно в расширенной версии, мы можем просто найти решение для следующей системы неравенств.

• a + b * 8 (мод 256) == 0 (для чистой версии)
• c + a + b * n (мод 256)> 0 для всех n (для дополненной версии)
• а> 0

В этом случае мы допустим a = 128, b = 16 и c = 1. Очевидно, что 128 + 16 * 8 = 256 (и 256 (mod 256) = 0) и 128> 0, а поскольку b четно, c + a + b * n нечетно для любого нечетного a + c, и, таким образом, никогда не будет четным кратным 256 в таких случаях. Мы выбираем c = 1 для простоты. Таким образом, единственное изменение, которое нам нужно, это одиночное +начало программы.

Дополненная

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

Попробуйте онлайн

Я оставляю это на OP, чтобы определить, конкурирует ли эта запись. У Brainfuck нет явного цикла for, но форма цикла, которую я использовал, настолько близка, насколько это возможно. ++++++++также максимально приближен к литералу 8; Я включил довольно много из них.

Чистая версия почти наверняка представляет собой типичную программу, написанную на этом языке, так как даже самый короткий известный Brainfuck Hello World зависит от модульного рекуррентного отношения к работе.

Haskell

чистый

import Control.Monad (forM_)

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

Дополненная

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

Заменяет обычный оператор приложения функции оператором, $который повторяет цикл снова каждый раз, когда завершается. Запуск чистой версии печатает от 0 до 8, а затем останавливается; расширенная версия печатает от 0 до 8, затем снова от 0 до 8 и так далее.

Я немного обманываю, так как forM_ [0..8] $ \i -> print iэто не обязательно самый «чистый» способ написать этот цикл в Haskell; многие Haskellers будут сокращать тело цикла, чтобы получить, forM_ [0..8] printи тогда нет $необходимости переопределять. В свою защиту я скопировал чистый код из ответа Кактуса , который не нуждался в этом свойстве, поэтому, по крайней мере, один программист на Haskell написал этот код без какой-либо мотивации без необходимости добавлять $!

C ++

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

Давайте xоценим до 7. Не работает в C, потому что требует lvalue при присваивании и приращении.

Nim

Идиоматическая версия, использующая countup:

чистый

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

Дополненная

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

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

Простой и очень похож на ответ Python, который переопределяетrange . Мы переопределяем countup, идиоматический способ Nim итерации от одного int (включительно) к другому, чтобы дать 8s бесконечно.

Более интересная версия, используя оператор диапазона ..:

чистый

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

Дополненная

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

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

Очень похоже на предыдущее решение, за исключением того, что мы переопределяем оператор диапазона .., который обычно дает массив [1, 2, 3, 4, 5, 6, 7, 8], для итератора ранее.

GolfScript

чистый

0{.8<}{)}while;

Дополненная

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

Назначает функцию, возвращающую n + 1 переменной 8

TCL

Обычный:

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

Дополненная:

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

Идея состоит в том, чтобы переопределить incrкоманду, которая используется для увеличения переменнойi , чтобы фактически не увеличивать!

Можно проверить на: http://rextester.com/live/QSKZPQ49822

Сборка x86_64

Чистая программа:

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

Тип цикла, который будет использовать любой программист на ассемблере, с последующим системным вызовом exit, чтобы не допустить последующего добавления jmp loop_startинструкции.

Дополненная программа:

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

Кроме того, извините, если это плохо, что чистая программа не имеет точки входа или section .text

JavaScript

Чистота:

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

Дополненная:

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

C ++

Чистая программа

Хороший, нормальный цикл, повторяющийся от чисел от 0 до 7.

#include <iostream>

int main() {

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

}

Дополненная программа

Препроцессор C ++ - довольно опасная особенность ...

#include <iostream>
#define short bool

int main() {

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

}

Единственная строка, которую мы должны были добавить, была #define short bool. Это делает iлогическое значение вместо короткого целого числа, и поэтому оператор приращения ( i++) ничего не делает после того, как iдостигнет 1. Выходные данные выглядят так:

0
1
1
1
1
1
...