일반적으로 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에 대한 링크를 제공하십시오.

파이썬 3

클린 프로그램 :

이것은 표준 카운트 다운 while 루프입니다.

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무한 루프가 발생, 다시합니다.

당신은 온라인 액션에서 INT 캐시를 볼 수 있습니다 여기에 (비록 분명하지 않고 온라인 사촌 무한 루프).

파이썬 3

클린 프로그램 :

파이썬에서 8 번 무언가를하는 표준 방법은 다음과 같습니다.

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에서 테스트

펄

깨끗한

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

증강

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

Ideone .

ES5 + (자바 스크립트)

EDIT : 명시 적 변수 선언을 제거했습니다. 그렇지 않으면 게양되어 구성 할 수없는 window.x 속성이 만들어졌습니다 (REPL 콘솔에서 한 줄씩 실행하지 않는 한).

설명:

전역 적으로 범위가 지정된 변수도 window 개체 의 속성이며 "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++);
    }
}

1에서 0을 포함해야하는 Integer 캐시에 Integer를 설정하여 효과적으로 i++아무것도 수행하지 않습니다 ( i1을 포함해야하는 캐시 된 Integer로 설정 하지만 Integer는 실제로 0을 포함하므로 변경되지 않음).

C ++

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

boolprimo의 Perl answer 에서 영감을 얻었습니다 .

파이썬 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 루프의 모든 내용은 원하는 코드로 변경할 수 있습니다.

코드는 두 번째를 마지막 opcode로 변경합니다. 113 보다 읽기JUMP_ABSOLUTE . 피연산자를 다음과 같이 변경합니다.160for 루프가 시작되는 명령으로 . 실제로 프로그램 끝에서 GOTO 문을 작성합니다.

기능 보강 된 프로그램은 0..7스택 오버플로 또는 이와 유사한 방식으로 숫자를 무한정 인쇄합니다 .

PHP

이것이 확장 점 규칙을 따르는 것 같습니다. 나는 포인트 4에서 완전히 명확하지 않습니다. @primo의 펄 답변과 매우 유사하므로 중요합니다.

깨끗한

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

증강

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

PHP를 사용하면 다음과 같이 특정 문자열을 증가시킬 수 있습니다.

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

이 모든 문자열은 0으로 평가되므로 실제로는 영원히 반복됩니다 (어쨌든 메모리 부족이 발생하지 않음).

펄

깨끗한 코드

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

기능 보강 된 코드

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

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

대부분의 Perl 변수는 변수 일뿐입니다. 그러나이 언어에는 tie변수 게터와 세터를 효과적으로 제공 할 수 있는 기능 도 있습니다 . 이 프로그램에서는 기본 패키지 (이름이 null 문자열 임)를 객체 지향 언어의 클래스와 동일하게 만드는 한편 프로그램이기도합니다. 이를 통해 for루프 카운터를 프로그램 자체에 연결할 수 있습니다. 구현이 TIESCALAR수 에는 영향을 미치지 않으며, 시도는 항상 반환 읽을 작은 수치의 8 이상이다.tie 성공할 수 있습니다. 의 반환 값은 TIESCALAR변수와 관련하여 유지해야하는 내부 상태에 대한 참조를 의미하지만 필요하지 않으므로 빈 배열 참조를 자리 표시 자로 반환합니다. 그런 다음 getter 및 setter의 가장 간단한 구현을 제공합니다. 그들 중 누구도 아무것도하지 않으므로 할당하려고합니다.$xundef

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에서 0이 아닌 모든 값은 사실이므로 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:dotimes, 일명 매크로 :dotimes( 11.1.2.3 키워드 패키지 참조 )가 정의됩니다. 이 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)

https://ideone.com/sR3AiU 에서 Ideone에서 테스트를 실행할 수 있습니다 .

루비

깨끗한

이런 종류의 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

하스켈

클린 버전 :

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.

자바 스크립트 ES6

여기, ES6 for ... of 루프 구성을 사용하여 작동하는 버전이 있습니다. 나는 재미있는 사업이 없다는 것을 확신하기 위해 깨끗한 배열을 줄 것입니다.

깨끗한

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

물론, 누군가가 어레이 프로토 타입을 망칠 수는 없습니다.

증강

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

온라인으로 사용해보십시오

기능 보강 버전은 8 비트 셀을 사용한 일반적인 Brainfuck 구현에 의존합니다. 이러한 구현에서 "증가"는 실제로 "증가 (mod 256)"입니다. 따라서 클린 버전과 확장 버전에서 끝없이 정확히 8 번 반복되는 루프를 찾으려면 다음과 같은 불평등 시스템에 대한 해결책을 찾을 수 있습니다.

• a + b * 8 (mod 256) == 0 (클린 버전의 경우)
• 모든 n에 대해 c + a + b * n (mod 256)> 0 (증강 버전)
• 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)
]                                            }

온라인으로 사용해보십시오

이 항목이 경쟁 중인지 확인하기 위해 OP에 맡깁니다. Brainfuck에는 명시적인 for 루프가 없지만 내가 사용한 루프 형식은 최대한 가깝습니다. ++++++++또한 가능한 한 리터럴에 가깝습니다 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반드시 하스켈 그 루프를 작성하는 "깨끗한"방법이 아니다; 많은 Haskellers는 루프 바디를 얻을 수 forM_ [0..8] print있고, $오버라이드 할 필요가 없습니다 . 내 방어에서 나는 그 속성이 필요없는 Cactus의 답변 에서 깨끗한 코드를 복사 했으므로 적어도 하나의 Haskell 프로그래머는 실제로 불필요하게 $!

C ++

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

하자 x가 assignement 및 증가에서 좌변을 필요로하기 때문에 C에서 작동하지 않습니다 7로 평가합니다.

님

다음을 사용하는 관용적 버전 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

간단하고 재정의하는 파이썬 답변range 과 매우 유사합니다 . 우리는 재정의한다countup 하나의 int (포함)에서 다른 int (포함)로 반복하는 관용적 Nim 방식을 8s를 무한대로 제공합니다.

range 연산자를 사용하는 더 흥미로운 버전 .. :

깨끗한

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

이전 솔루션과 매우 유사하지만 ..일반적으로 배열을 제공하는 range 연산자 [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

어셈블리 프로그래머가 사용할 루프의 종류와 종료 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

자바 스크립트

깨끗한:

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++)는 i1에 도달 한 후에는 아무 것도 수행하지 않습니다 . 출력은 다음과 같습니다.

0
1
1
1
1
1
...