Давайте розглянемо типовий цикл, який зазвичай виконує 8 ітерацій:

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

Ви повинні зробити це нескінченним!

Це конкурс на популярність для всіх мов, які підтримують таку форму forциклу. Тож рішення з найвищим балом (upvotes мінус downvotes) виграє.

Якщо ваша мова має іншу форму 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знову, викликаючи нескінченний цикл.

Ви можете побачити кеш ІНТ в дії онлайн тут (хоча , очевидно , не нескінченні цикл ТОМУ його онлайн).

Пітон 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++) { }

Ідеон .

ES5 + (Javascript)

EDIT : Видалено явну декларацію змінної, оскільки в іншому випадку вона була піднята і було створено неконфігуруване властивість 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, просто замініть "вікно" на "глобальне" (перевірено в 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;
}

Java

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

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. Натхненний Primo в Perl відповідь .

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
}

Цей підхід створює псевдонім для <як |, тому при <зустрічі в коді псевдонім розширюється на |і порозрядне - або робиться замість менше-менш. У WinDbg всі ненульові значення є істинними, тому anything | 8це завжди так.

Примітка. Фактично .blockне потрібно, якщо aSі .forфактично введені у вигляді двох різних рядків, як показано тут, це потрібно лише тоді, коли aSі .forзнаходяться в одному рядку.

Математика

Чисто

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 .

Рубін

Чисто

Цей різновид для циклу не дуже використовується в 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

Хаскелл

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

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екземпляр є нескінченною послідовністю, а потім використовуємо типовий тип за замовчуванням, щоб значення, анотовані un-type, 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;
}

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

Брейнфук

Я друкую "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 (mod 256) == 0 (для чистої версії)
• c + a + b * n (mod 256)> 0 для всіх n (для доповненої версії)
• a> 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)
]                                            }

Спробуйте в Інтернеті

Я залишаю це в ОП, щоб визначити, чи змагається ця запис. У Brainfuck немає явного циклу, але форма циклу, яку я використав, наближається до того, наскільки ви, ймовірно, отримаєте. ++++++++також наближається до буквального, 8скільки ви можете отримати; Я включив досить багато таких.

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

Хаскелл

Чисто

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; багато хаскелерів би ета-зменшити тіло циклу, щоб отримати, 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, оскільки для цього потрібне значення у призначенні та збільшення.

Нім

Ідіоматична версія, використовуючи 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 , ідіоматичний нім спосіб переходу від однієї інти (включно) до іншої, щоб нескінченно дати 8с.

Більш цікава версія, використовуючи оператор діапазону .. :

Чисто

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

ткл

Звичайний:

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

Різновид циклу, який використовував би будь-який програміст Асамблеї з подальшим вихідним syscall, щоб не ввімкнути додавання 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
...