'루핑'없는 루프 [닫힘]


85

이와 비슷한 질문이 몇 년 전에 제기되었지만이 질문 은 훨씬 까다 롭습니다.

도전은 간단합니다. 반복적으로 같은 어떤 반복 구조를 사용하지 않고 코드를 실행 (선택의 여지가 귀하의 언어) 프로그램 쓰기 while, for, do while, foreach또는 goto( 모든 당신 nitpickers에 따라서를, 당신은 루프를 사용할 수 없습니다 ). 그러나 자체 호출 함수에서 재귀는 허용되지 않습니다 (아래 정의 참조) . 그렇게하면이 도전이 훨씬 쉬워집니다.

루프에서 실행해야 할 사항에 대한 제한은 없지만 다른 사람들이 구현중인 내용을 정확하게 이해할 수 있도록 답변과 함께 설명을 게시하십시오 .

정의에 매달린 사람들의 경우이 질문에 대한 루프 정의는 다음과 같습니다.

A programming language statement which allows code to be repeatedly executed.

이 질문에 대한 재귀 정의는 표준 재귀 함수 정의입니다.

A function that calls itself.

우승자는 7 월 16 일 오전 10시 (동부 표준시)에 가장 많이 찬성 한 답변이 될 것입니다. 행운을 빕니다!

최신 정보:

여전히 표현되고있는 혼란을 진정 시키려면 다음과 같은 도움이 될 수 있습니다.

위에서 언급 한 규칙 :

  • 루프 나 goto를 사용하지 마십시오
  • 함수는 스스로를 호출 할 수 없습니다
  • '루프'에서 원하는 것을하십시오

무언가를 구현하고 규칙에서 명시 적으로 허용하지 않는 경우 계속 진행하십시오. 많은 답변이 이미 규칙을 구부 렸습니다.


27
쉬운 트릭을 원하는 사람들을 위해 게시하지 않아도됩니다 : P 단지 함수 중 하나가 무언가를 수행하는 동안 2 개의 함수, function A호출 function Bfunction B호출 function A을하십시오. 함수 자체를 호출하지 않으므로 기준에 따라 유효해야합니다. ^. ^
Teun Pronk

2
"창의력에 초점을 맞추기 위해 인기 콘테스트로 변경됨"질문을 바꾸는 것은 속임수입니다!
CousinCocaine

4
"재귀"의 정의는 그다지 유용하지 않습니다. 직접 또는 간접적으로 자신을 참조하는 함수재귀 함수 를 허용하지 않는 것이 좋습니다 .
lrn

3
확실하지 않은 것은 루프 생성자와 재귀의 "정의"입니다. 둘 다 매우 정확하지 않습니다. 예 : rep(f){f();f();}-이것은 코드를 반복적으로 실행할 수있는 명령문입니다 (함수 선언은 일부 언어의 명령문 임). 허용되지 않습니까? 루프를 구현하기위한 코드를 요청합니다. 해당 코드가 구문 상 문장이라면 허용하지 않은 것입니다. 다른 예 : f(b) { b(); g(b); }; g(b) { f(b); }. 나는 f재귀 함수 라고 말합니다 (와 상호 재귀 적으로 g). 허용되지 않습니까?
lrn

3
내가 "하고있는 무슨 @CailinP, 끊었은 이 질문은하지 않는 명확하고 객관적인 사양을 갖는 것을 의미한다 :"사이트에 대한 질문이 사이트에 대한 주제에 있어야한다는 것입니다.
피터 테일러

답변:


258

루비

def method_missing(meth,*args)
  puts 'Banana'
  send(meth.next)
end

def also
  puts "Orange you glad I didn't say banana?"
end

ahem

데모

목구멍을 비우고 "바나나"를 3070 번 인쇄하며 "오렌지, 내가 바나나라고 말하지 않아 기뻐?"

루비의 어리석은 Just-In-Time 분석법 정의 기능을 사용하여 'ahem'과 'also'( "ahem", "ahen", "aheo", "ahep", "aheq", "aher", "ahes", "ahet", "aheu", "ahev"...)를 사용하여 바나나를 먼저 인쇄 한 다음 목록에서 다음을 호출하십시오.


4
결과적으로 정의 된 "또한"에 도달하므로 누락되지 않습니다.
histocrat

77
이것은 히스테리 적입니다.
Michael B

4
@barrycarter : Ruby에서 모든 영숫자 문자 (문자열의 유일한 문자 인 경우에는 숫자가 아닌 숫자)와 함께 작동한다는 점을 제외하고는 숫자에 1을 더하는 것과 같은 함수 String#next에서 호출됩니다 method_missing. ruby-doc.org/core-2.1.2/String.html#method-i-next
3Doubloons를

2
@NickT XML 생성기와 같은 클래스에서 사용할 수 있으며으로 만 만든 태그를 사용할 수 있습니다 b.my_tag. 또한 ActiveRecord 모델 또는에서 사용됩니다 OpenStruct. 'Wat talk'에서 그는 세계 method_missing는 나쁘지만 범위는 훌륭 하다고 말합니다 .
Hauleth

2
나는 또 다른 루비 프로그램에 대한 오래된 의견을 기억한다. "메타가 있기 때문에 좋아한다"
vidya sagar

82

파이썬-16

또는 평가가있는 다른 언어.

exec"print 1;"*9

프로그램의 기능을 설명 할 수 있습니까?
CailinP

10
문자열 ( "print 1;")을 가져 와서 9 번 복제 *9한 다음 결과 문자열 ( exec) 을 실행합니다 . 실제로 루핑하지 않고 코드 덩어리를 반복합니다.
scragar

12
문자열 곱셈에 대한 예!
Thane Brimhall

2
당신이를 변경하는 경우 또한 루비 작동 execeval 또는 (가) printecho.
Ajedi32

80

CSharp

나는 더 이상 코드 골프가 아니기 때문에 사람들이 실제로이 프로그램이 무언가를하고 있음을 알 수 있도록 코드를 더 읽기 쉬운 방식으로 확장했습니다.

class P{
    static int x=0;
    ~P(){
        System.Console.WriteLine(++x);
        new P();
    }
    static void Main(){
        new P();
    }
}

(이 작업을 수행하지 마십시오).

시작할 P때 클래스 의 새 인스턴스를 작성합니다 . 프로그램이 종료하려고하면 종료자를 호출하는 GC를 호출하여 P클래스 의 새 인스턴스를 작성하고 , 정리를 시도 할 때 종료자를 호출하는 새 인스턴스를 작성합니다 P. .

프로그램은 결국 죽습니다.

편집 : 분명히 이것은 죽기 전에 약 45k 번만 실행됩니다. GC가 내 까다로운 무한 루프를 어떻게 알아 냈는지 모르겠지만 그랬습니다. 짧은 것은 그것이 이해하지 못하고 스레드가 약 2 초의 실행 후 방금 죽었다는 것입니다 : https : //.com/questions/24662454/how-does-a-garbage-collector-avoid-an 무한 루프 여기

편집 2 : 이것이 재귀와 같이 너무 많이 있다고 생각하면 다른 솔루션을 고려 하십시오 : https://codegolf.stackexchange.com/a/33268/23300

일반 메소드의 수정을 사용하여 런타임시 지속적으로 새 메소드를 생성하고 용어로 각 메소드가 새로 작성된 메소드를 호출합니다. 또한 reference일반적으로 런타임에서 해당 메소드의 코드를 공유 할 수 있으므로 유형 매개 변수를 사용하지 마십시오 . A의 value유형 매개 변수 런타임 새로운 방법을 만들어 강제로.


20
C #에 소멸자가 있다는 것도 몰랐습니다. 가르쳐 주셔서 +1
seequ

4
@TheRare는 그렇지 않지만 본질적으로 결정적이지 않으며 프로그램 실행 중에 절대 호출되지 않을 수 있습니다. 그것들은 가상 메소드의 오버라이드로 구현되어 Finalize때때로 호출 finalizer됩니다. 실제 C #에서는 IDisposable패턴을 사용해야합니다 .
Michael B

특정 시점에 시간 초과가 발생하는 것 같습니다. 사이클을 멈추는 것이 GC라고 생각하지 않지만 대신 운영 체제가 프로그램을 끝내는 데 너무 오래 걸리는 것으로 결정합니다.
LVBen

나는 이것이 실제로 OS를 필요로하지는 않지만 프로그램을 죽이기로 결정한 런타임이라고 생각합니다. 프로그램 끝에서 호출 된 가비지 수집기 스레드에는 종료되기 전에 ~ 2 초의 고정 시간 제한이 제공됩니다.
Michael B

약간의 수정 (프로그램이 종료되지 않도록하고, 첫 번째 P 개체를 GC에 공개하고 GC.Collect를 반복적으로 호출)하면 무한정으로 실행될 수 있습니다.
LVBen

53

펀지

.

좋은 오래된 Befunge는 빈 줄에서 0을 거의 영원히 출력합니다.


1
하아! 나는이 같은 속임수를 좋아한다
CailinP

47

JS

(f=function(){ console.log('hi!'); eval("("+f+")()") })()

기능 재미!

자체와 동일한 본문으로 다른 함수를 작성하여 실행하는 함수입니다.

스택 제한에 도달하고 전체 항목이 축소되면 끝에 hi가 표시됩니다.

면책 조항 : 스택 제한에 도달 할 때까지 브라우저에서 아무것도 할 수 없습니다.


그리고 또 하나의 더 악한 :

function f(){ var tab = window.open(); tab.f = f; tab.f()}()

창을 여는 함수를 만든 다음 해당 창 내에 함수의 복사 본인 함수를 만든 다음 실행합니다.

면책 조항 : 팝업 열기를 허용하는 경우이 작업을 완료하는 유일한 방법은 컴퓨터를 다시 시작하는 것입니다


5
이것은 확실히 악하다;)
CailinP

28
@CailinP 확실히 eval.
seequ

f두 번째 함수의 끝 에서을 놓친 것 같습니다. 마지막에 있어야합니다 }f().
Chirag Bhatia-chirag64

2
불행히도, 나는 그것을 시도했기 때문에 그것을 알았습니다. : P
Chirag Bhatia-chirag64

7
-1-이것은 단지 재귀입니다.
immibis

39

x86 어셈블리 / DOS

    org 100h

start:
    mov dx,data
    mov ah,9h
    int 21h
    push start
    ret

data:
    db "Hello World!",10,13,"$"

꼬리 재귀 가 반전 되지 않았다고 말했습니까 ? 내가 했어? 마담 마인 보라색 용

작동 원리

ret함수에서 복귀 명령 사용은 사실 (일반적으로 해당 거기 넣어 스택의 리턴 어드레스 튀어 call)로 이동하고있다. 여기에서 각 반복에서 우리 push는 스택의 시작점 주소를 반환하기 전에 무한 루프를 생성합니다.


이것이 조립이 가능한지 궁금했습니다.
Ian D. Scott

2
당신의 위험에 스택과 함께 혼란 . 여기에 용이 있습니다 ;-)
디지털 외상

1
나는 이것의 dup으로 codegolf.stackexchange.com/a/34295/11259 를 부를 것이지만, 그것이 실제로 이전의 대답 인 것을 본다
Digital Trauma

@DigitalTrauma : 예, 응모작을 게시 한 후 알아 차 렸지만 Madame Mim의 사진에 첨부되었습니다. :-) 다행히도 약간의 차이가 있습니다 (그는 조금 더 난독 화되어 32 비트 Linux에서 작동하며, DOS에서 직접 재생되며 다른 점프는 없습니다).
Matteo Italia

@MatteoItalia 난독 화되지 않고 단지 엉뚱한;) ( "eax 추가, 4"도 저를 혼란스럽게 만들었습니다. 내 작업 프로젝트가 컴파일되는 동안 온라인 컴파일러로 만들었으므로 끔찍하게 보입니다. "start :"를 사용하는 것이 좋습니다.
PTwr

37

자바

XKCD에서 직접

본딩

부모와 자식 사이의 끝없는 캐치 게임입니다!

의 목표는 CHILD로 설정 PARENT되고의 목표는 PARENT입니다 CHILD. 를 PARENT호출 AIM하면 BALL클래스 의 인스턴스를 throw 하고 catch 문에 의해 잡 힙니다. 그런 다음 catch 문 PARENT.TARGET.AIM은 대상이 어디에 있는지 호출 합니다 CHILD. CHILD인스턴스는 동일한을 수행하고 부모에게 "공을 다시 던졌습니다".


3
나는 그 만화를 좋아한다!
Derek 朕 會 功夫

1
공이 실제로 부모와 자식 사이에 던져지면 더 좋을 것입니다. 있는 그대로, 공은 항상 같은 "사람"에 의해 던져집니다.
Ajedi32

@ Ajedi32 실제로 앞뒤로 던지는 것처럼 보입니다. 부모 TARGET은 자녀이며, 자녀의 목표는 부모입니다. 목표는 부모를 부르고, 공을 찌르는 아이를 목표로하고 공을 던지는 큐 루프
Alex Coleman

12
@AlexColeman이 코드는 부모가 공을 공중에 던지고 그것을 잡은 다음 공을 부모에게 돌려주기 전에 같은 일을하는 아이에게 건네주는 것과 유사합니다.
Ajedi32

11
TARGET.AIM(B);메소드 의 명령 AIM은 재귀 호출입니다. 따라서 이것은 "함수를 호출 할 수없는"규칙을 위반합니다.
Theodore Norvell

31

배쉬, 3 자

yes

yes는 반복적으로 콘솔에 'y'를 반환합니다.

편집 : 모든 사람 이이 줄을 편집하는 것이 좋습니다 :

yes something | xargs someaction

(Olivier Dulac 덕분에)


1
왜 계속 작동합니까? 왜 그런지 알아 내려고 노력하는 것은 의심하지 않습니다.
Teun Pronk

2
@TeunPronk yes는 종료되거나 스트림이 닫힐 때까지 yes라는 ​​단어를 출력하는 bash 명령입니다. 화면에 쓰면 죽일 때까지 멈추지 않습니다. 그것은 기본적으로 루프 오버 printf로 구성된 명령이기 때문에 일종의 부정 행위입니다.
scragar

1
더 재미있는 것은 yes다른 루프를 계속 사용 하는 것입니다.
trlkly

3
@izkata : 그러나 당신은 할 수 있습니다 : yes something | xargs someaction: 재귀 없음 (xargs에 -n 1을 추가하여 한 줄에 1 개의 "뭔가"만 가질 수 있습니다). xargs를 사용하면 더 복잡한 행동 (예 출력과 전혀 관련이없는 행동조차도)을위한 길을 열 수 있습니다.
Olivier Dulac

4
@ scragar 당신은 대답했다 yes.
daviewales

28

C, 35 자

main(int a,char**v){execv(v[0],v);}

프로그램 자체가 실행됩니다. 이것이 재귀로 간주되는지 확실하지 않습니다.


4
@mniip Tail 재귀, 프로세스 수준에서 적용되는 경우
Izkata

3
@Izkata Tail 재귀는 여전히 재귀이지만 재귀는 아닙니다. 재귀는 함수 (또는이 경우 프로세스)가 다른 자체 반복이 종료되기를 '대기'함을 의미합니다. 이 경우 exec새 프로세스가 원래 프로세스를 대체하므로 결국 반환되거나 오버플로되는 호출 스택이 없습니다.
millinon

4
@millinon 최적화를 지원하는 언어에서 꼬리 재귀는 exec이전 프로세스를 대체하는 방법과 유사하게 호출 스택의 이전 호출을 대체합니다. 오버플로도 발생하지 않습니다.
이즈 카타

1
@millinon은 단지 초창기적이고 Scheme 프로그래밍 언어 에서이 토론을 더 오래 끌기 위해이 최적화 언어 기능입니다. 테일 재귀 호출을 수행하는 경우 인터프리터 / 컴파일러 마지막 스택 프레임을 재사용해야합니다. 계획이 있기 때문입니다 아니오 내장 된 유일한 방법은 계획에서 루프 꼬리 재귀를하는 것입니다을 구현하기 위해, 당신은 : 루프에 너무 많은 시간을 시도하는 오버 플로우 스택있어 경우는 가지 빨아 것이다, 그래서 구조를 반복
Ord

2
Pedantry를 원한다면 Scheme에는 "tail call optimisation"이없고 "protail tail call"이 있습니다. 최적화가 아니며 언어 표준의 기본 요구 사항이며이를 제공하지 못하면 허용되지 않으므로 "최적화"(또는 재귀와 관련이 있다는 제안)는 매우 권장되지 않는 용어입니다.
Leushenko

28

C (GCC 내장 기능-clang과 함께 작동하는 것 같습니다)

  • 명시 적 루프 없음
  • 명시 적 고 토스 없음
  • 재귀 없음
  • 스택을 엉망으로 만드는 좋은 구식입니다 (어린이, 감독없이 집에서 시도하지 마십시오).
#include <stdio.h>

void *frameloop (void *ret_addr) {
    void **fp;
    void *my_ra = __builtin_return_address(0);

    if (ret_addr) {
        fp = __builtin_frame_address(0);
        if (*fp == my_ra) return (*fp = ret_addr);
        else fp++;
        if (*fp == my_ra) return (*fp = ret_addr);
        else fp++;
        if (*fp == my_ra) return (*fp = ret_addr);
        else fp++;
        if (*fp == my_ra) return (*fp = ret_addr);
        return NULL;
    } else {
        return (my_ra);
    }
}

int main (int argc, char **argv) {
    void *ret_addr;
    int i = 0;

    ret_addr = frameloop(NULL);
    printf("Hello World %d\n", i++);
    if (i < 10) {
        frameloop(ret_addr);
    }
}

설명:

  • main()첫 통화 frameloop(NULL). 이 경우 __builtin_return_address()내장을 사용하여 반환 주소 (in main()) 를 가져 frameloop()옵니다. 이 주소를 반환합니다.
  • printf() 우리가 반복하고 있음을 보여주기 위해
  • 이제 frameloop()이전 통화의 반송 주소로 전화를 겁니다. 스택을 통해 현재 반송 주소를 찾고, 찾은 경우 이전 반송 주소를 대체합니다.
  • 그런 다음 두 번째 frameloop()전화 에서 돌아옵니다 . 그러나 반송 주소가 해킹 당했기 main()때문에 첫 번째 통화가 돌아 오는 지점으로 돌아갑니다. 따라서 우리는 루프로 끝납니다.

스택에서 반환 주소를 검색하는 것은 물론 루프로 더 깨끗하지만 루프가 발생하지 않도록 몇 가지 반복을 수행했습니다.

산출:

$ CFLAGS=-g make frameloop
cc -g    frameloop.c   -o frameloop
$ ./frameloop 
Hello World 0
Hello World 1
Hello World 2
Hello World 3
Hello World 4
Hello World 5
Hello World 6
Hello World 7
Hello World 8
Hello World 9
$ 

2
좋은! 왜 그 함수가 C 스펙의 일부가 아닌지 궁금합니다. ;-D
Brian Minton

4
실제로 비슷한 일이에 달성해야 @BrianMinton setjmp()/ longjmp(). 이것들은 c 표준이 아니지만 표준 라이브러리에 있습니다. 나는 오늘 수동으로 스택을 녹이는 것처럼 느꼈다. ;-)
Digital Trauma

@BrianMinton 내 추측은 CPU 사양에 있기 때문에 (하드웨어) 플랫폼에 의존하기 때문입니다. 그리고 스택 프레임이 자동 생성 될 때 사용하는 것이 다소 위험합니다 .AV가 그러한 코드에 대해 울지 않더라도 놀라지 않을 것입니다. 확인 또는 86 ASM 버전의.
PTwr

27

하스켈

다음 코드에는 재귀 함수 (간접적으로), 루핑 프리미티브가 없으며 내장 재귀 함수를 호출하지 않지만 ( IO출력 및 바인딩 만 사용 ) 지정된 동작을 동일하게 반복합니다.

data Strange a = C (Strange a -> a)

-- Extract a value out of 'Strange'
extract :: Strange a -> a
extract (x@(C x')) = x' x

-- The Y combinator, which allows to express arbitrary recursion
yc :: (a -> a) -> a
yc f =  let fxx = C (\x -> f (extract x))
        in extract fxx

main = yc (putStrLn "Hello world" >>)

함수 extract는 아무것도 호출하지 않고 yc그냥 호출 하고 재귀하지 않는 and extract및을 main호출합니다 .ycputStrLn>>

설명 : 트릭은 재귀 데이터 유형 Strange입니다. 이 예제는 자체 반복적 인 데이터 유형으로, 예에 표시된 것처럼 임의의 반복을 허용합니다. 먼저, 우리는 형식화되지 않은 람다 미적분학에서 extract x자기 적용을 본질적으로 표현하는를 구성 할 수 있습니다 x x. 그리고 이것은로 정의 된 Y 결합기 를 구성 할 수있게합니다 λf.(λx.f(xx))(λx.f(xx)).


업데이트 : 제안 된 것처럼 , 형식화되지 않은 람다 미적분학에서 Y 의 정의에 더 가까운 변형을 게시하고 있습니다 .

data Strange a = C (Strange a -> a)

-- | Apply one term to another, removing the constructor.
(#) :: Strange a -> Strange a -> a
(C f) # x = f x
infixl 3 #

-- The Y combinator, which allows to express arbitrary recursion
yc :: (a -> a) -> a
yc f =  C (\x -> f (x # x)) # C (\x -> f (x # x))

main = yc (putStrLn "Hello world" >>)

3
재귀 함수 대신 재귀 데이터 구조 ... 좋습니다.
ApproachingDarknessFish

6
이것은 완전한 기능적 프로그래밍에 관심이있는 사람이 내 마음에 가깝습니다. 당신은 음의 반복적 인 데이터 타입으로 Y- 콤비 네이터를 만드는 방법을 보여주었습니다. 이것이 전체 언어가 화살표 오른쪽에 되풀이 유형이 필요한 이유와 장미 나무가 허용되지 않는 이유입니다. 좋은 것! 나는 이것을 공표하기 위해 여기에 계정을 만들었습니다!
Jake

let바인딩을 제거하고 재귀를 허용하는 언어 기능 (클래식 )을 정의 할 수 yc f = extract $ C $ f.extract있으므로 define을 정의 let할 수 있습니다 let x = x in x. 이것은 또한 일부 문자를 줄입니다 :)
Earth Engine

또는 심지어yc = extract . C . (.extract)
Earth Engine

@EarthEngine 사실, 나는 구조를 원래 정의에 더 가깝게 유지하고 싶었습니다 Y.
Petr Pudlák

26

C ++

다음은 카운트 다운을 10에서 "Blast off!"로 출력합니다. 템플릿 메타 프로그래밍 사용.

#include <iostream>

template<int N>
void countdown() {
    std::cout << "T minus " << N << std::endl;
    countdown<N-1>();
}

template<>
void countdown<0>() {
    std::cout << "Blast off!" << std::endl;
}

int main()
{
    countdown<10>();
    return 0;
}

재귀의 전형적인 예처럼 보이지만 실제로는 적어도 기술적으로는 정의에 따라 다릅니다. 컴파일러는 10 가지 기능 을 생성 합니다. countdown<10>"T minus 10"을 인쇄 한 다음을 호출 하고을 countdown<9>눌러 countdown<0>"Blast off!"를 인쇄합니다. 그런 다음 반환합니다. 재귀는 코드를 컴파일 할 때 발생하지만 실행 파일에는 루핑 구조가 없습니다.

C ++ 11에서는 constexpr이 계승 함수와 같은 키워드를 사용하여 유사한 효과를 얻을 수 있습니다 . ( constexpr함수에는 부작용이 없기 때문에 카운트 다운 예제를 구현할 수는 없지만 향후 C ++ 14에서 가능할 수 있다고 생각합니다.)

constexpr int factorial(int n)
{
    return n <= 1 ? 1 : (n * factorial(n-1));
}

다시이 정말 재귀처럼 보이지만 컴파일러는 밖으로 확장됩니다 factorial(10)10*9*8*7*6*5*4*3*2*1다음 아마의 상수 값으로 교체 3628800, 그래서 실행 파일이 어떤 루프 또는 재귀 코드가 포함되어 있지 않습니다.


4
이 중 두 번째는 메타 프로그래밍이 아니라 순수하고 간단한 재귀 입니다. 첫째, 컴파일러는 (일반적인 경우) 상수가 아닌 인수와 함께 사용할 수 있도록 일반 함수 본문을 생성하기 때문입니다. 두 번째로 컴파일 타임 작업을 수행 할 때 템플릿 스타일의 "확장"작업을 수행하지 않기 때문에 런타임과 동일한 표준 내부 평가를 실행 3628800하여 중간 형태.
Leushenko

@Leushenko 예, 알고 있습니다. 그러나 템플릿 예제 예제는 컴파일 타임에 Turing-complete 언어에서 재귀 함수를 사용합니다. 단 하나의 차이점은 constexpr이 C ++과 훨씬 유사한 언어를 사용한다는 것입니다. 모든 답변과 마찬가지로이 규칙을 구부리고 나는 정직합니다. constexpr는 템플릿 메타 프로그래밍을 쓸모 없게 만들도록 특별히 고안되었으므로 주제에 대한 게시물에서 언급 할 가치가있는 것 같습니다.
Nathaniel

1
+1 : &countdown<N-1> != &countdown<N>.
Thomas Eding

21

자바

Java 클래스 로더를 사용하여 자체 부모로 설정하십시오.

import java.lang.reflect.Field;

public class Loop {
    public static void main(String[] args) throws Exception {
        System.out.println("Let's loop");
        Field field = ClassLoader.class.getDeclaredField("parent");
        field.setAccessible(true);
        field.set(Loop.class.getClassLoader(), Loop.class.getClassLoader());

    }
}

이 루프는 실제로 너무 강력 kill -9하여 중지 하려면 a 를 사용해야 합니다 :-)

내 Mac CPU의 100,1 %를 사용합니다.

CPU의 100,1 %

System.out주 함수의 끝 에서을 움직여 다른 재미있는 동작을 실험 해 볼 수 있습니다.


lol. 자바 자체에
갇히고

JVM 재귀 로딩 해킹을 좋아합니다.
Isiah Meadows

20

CSharp

하나 더 동등하게 악 ::

public class P{

    class A<B>{
        public static int C<T>(){
            System.Console.WriteLine(typeof(T));
            return C<A<T>>();
        }
    }
    public static void Main(){
        A<P>.C<int>();
    }
}

이것은 재귀가 아닙니다 ... 이것은 코드 템플릿의 수정입니다. 동일한 메소드를 호출하는 동안 런타임은 지속적으로 새로운 메소드를 작성합니다. 우리는 int의 type 매개 변수를 사용합니다. 실제로 이것은 완전히 새로운 유형을 만들고 강제로 메소드의 각 인스턴스가 새로운 메소드를 생성해야하기 때문입니다. 코드 공유는 여기에서 할 수 없습니다. 결국, 우리는 약속했지만 결코 전달하지 않은 int의 반환을 무한정 기다릴 때 호출 스택을 죽입니다. 비슷한 방식으로, 우리는 흥미를 유지하기 위해 우리가 만든 유형을 계속 작성합니다. 기본적으로 우리가 호출하는 각 C는 동일한 몸체를 가진 완전히 새로운 방법입니다. 컴파일 타임에 템플릿을 만드는 C ++ 또는 D와 같은 언어에서는 실제로 불가능합니다. C # JIT는 매우 게으 르기 때문에 마지막 순간에만이 물건을 만듭니다. 그러므로,


14

레드 코드 94 (핵심 전쟁)

MOV 0, 1

주소 0의 명령을 주소 1에 복사합니다. Core War에서 모든 주소는 현재 PC 주소에 상대적이며 코어의 크기를 모듈로하기 때문에, 이것은 점프하지 않는 하나의 명령에서 무한 루프입니다.

이 프로그램 (전사)은 " Imp " 라고 하며 AK Dewdney에 의해 처음 출판되었습니다.


3
임프는 행진을하고, 성문을 준비하고, 준비 시키십시오.
seequ

SPL 0, 0; MOV 1, -2실제로 준비하십시오 .
wberry

니스, 아직 게시되지 않았 으면 좋겠다. +1
mbomb007

14

다트

이것이 실제 재귀 함수없이 재귀를 수행하는 고전적인 방법 일 것이라고 생각합니다. 아래의 기능은 직접 또는 간접적으로 이름 자체를 의미하지 않습니다.

( dartpad.dartlang.org 에서 시도하십시오 )

// Strict fixpoint operator.
fix(f) => ((x)=>f(x(x))) ((x)=>(v)=>f(x(x))(v));
// Repeat action while it returns true.
void repeat(action) { fix((rep1) => (b) { if (b()) rep1(b); })(action); }

main() {
  int x = 0;
  repeat(() {  
    print(++x);
    return x < 10;
  });
}

6
Y 조합기?
aditsu

5
엄밀히 말하면 Z 조합자인 것 같습니다. Y 조합기는 무한 전개를 피하기 위해 게으른 언어가 필요합니다. 유일한 차이점은 그것의 후자가 확장된다는 것입니다.
lrn

12

JS

독창적이지는 않지만 작습니다. 20 자

setInterval(alert,1)

실제로 제거 할 수 있으며 ,1여전히 작동합니다.
Derek 朕 會 功夫

@Derek 朕 會 功夫 그렇게하면 Firefox에 대해 경고가 하나만 나타납니다
xem

1
크롬에서는 마지막 매개 변수없이 작동합니다. 코드가 하나 이상의 환경에서 작동하는 경우 유효한 것으로 계산해야합니다.
Derek 朕 會 功夫

3
@Derek 朕 會 功夫setInterval는 진술이 아닙니다. 그것은 단지 기능 일뿐입니다. 표현식 문 안에서 사용되며 표현식 문을 사용할 수 없으면 더 이상 알지 못합니다.
Keen

1
@ 코리-글쎄, 그건 그때 유효하다고 생각합니다!
Derek 朕 會 功夫

12

C의 신호

#include <stdio.h>
#include <signal.h>

int main(void) {
    signal(SIGSEGV, main);
    *(int*)printf("Hello, world!\n") = 0;
    return 0;
}

이 프로그램의 동작은 분명히 정의되어 있지 않지만 오늘날 내 컴퓨터에서는 "Hello, world!"


11

이맥스 리스프

"코드는 데이터이고 데이터는 코드"인 Lisp의 강력한 디자인을 과시하기에 좋은시기입니다. 물론, 이러한 예제는 매우 비효율적이며 실제 상황에서 사용해서는 안됩니다.

매크로는 가정 된 루프의 롤링되지 않은 버전 인 코드를 생성하며 생성 된 코드는 런타임에 평가됩니다.

반복 : N 번 반복 할 수 있습니다

(defmacro repeat-it (n &rest body)
  "Evaluate BODY N number of times.
Returns the result of the last evaluation of the last expression in BODY."
  (declare (indent defun))
  (cons 'progn (make-list n (cons 'progn body))))

반복 테스트 :

;; repeat-it test
(progn
  (setq foobar 1)

  (repeat-it 10
    (setq foobar (1+ foobar)))

  ;; assert that we incremented foobar n times
  (assert (= foobar 11)))

반복되는 인덱스 :

이 매크로는 비슷 repeat-it하지만 실제로는 일반적인 루핑 매크로와 동일하게 작동 do-times하여 루프 인덱스에 바인딩 될 심볼을 지정할 수 있습니다. 확장 시간 기호를 사용하여 루프 본문 동안 값을 수정하는지 여부에 관계없이 각 루프의 시작 부분에 색인 변수가 올바르게 설정되도록합니다.

(defmacro repeat-it-with-index (var-and-n &rest body)
  "Evaluate BODY N number of times with VAR bound to successive integers from 0 inclusive to n exclusive..
VAR-AND-N should be in the form (VAR N).
Returns the result of the last evaluation of the last expression in BODY."
  (declare (indent defun))
  (let ((fallback-sym (make-symbol "fallback")))
    `(let ((,(first var-and-n) 0)
           (,fallback-sym 0))
       ,(cons 'progn
              (make-list (second var-and-n)
                         `(progn
                            (setq ,(first var-and-n) ,fallback-sym)
                            ,@body
                            (incf ,fallback-sym)))))))

인덱스 반복 테스트 :

이 테스트는 다음을 보여줍니다.

  1. 몸은 N 번 평가합니다

  2. 인덱스 변수는 각 반복이 시작될 때 항상 올바르게 설정됩니다.

  3. "fallback"이라는 심볼의 값을 변경해도 인덱스가 엉망이되지 않습니다.

;; repeat-it-with-index test
(progn
  ;; first expected index is 0
  (setq expected-index 0)

  ;; start repeating
  (repeat-it-with-index (index 50)
    ;; change the value of a  'fallback' symbol
    (setq fallback (random 10000))
    ;; assert that index is set correctly, and that the changes to
    ;; fallback has no affect on its value
    (assert (= index expected-index))
    ;; change the value of index
    (setq index (+ 100 (random 1000)))
    ;; assert that it has changed
    (assert (not (= index expected-index)))
    ;; increment the expected value
    (incf expected-index))

  ;; assert that the final expected value is n
  (assert (= expected-index 50)))

11

형식화되지 않은 람다 미적분

λf.(λx.f (x x)) (λx.f (x x))

3
이것이 재귀로 계산되는지 아닌지 확실하지 않습니다. 어떻게 든 +1의 기본 이론적 근거가 무엇입니까?
푹신한

@fluffy 그것은 재귀 적이 지 않으며, 어떤 함수도 스스로 호출하지 않습니다 (특히 함수의 이름이 지정되지 않았기 때문에).
자랑스런 Haskeller

IMHO, 람다 미적분학은 계산 모델이며 프로그래밍 언어가 아닙니다 (즉, 구체적인 기계 모델이 없으면 람다 미적분을 PL로 간주 할 수 없습니다).
Ta Thanh Dinh

람다 미적분을 해석하는 기계를 절대적으로 만들 수 있습니다. 그리고 구문은 프로그래밍 언어로 사용될 수 있습니다. 예를 들어 github.com/MaiaVictor/caramel
Arthur B

10

하스켈, 24 자

sequence_ (repeat (print "abc"))

또는 24 자로 압축 된 형태로

sequence_$repeat$print"" 

(텍스트가 변경되었지만 여전히 반복됩니다-두 개의 따옴표와 줄 바꿈이 무한대로 인쇄됩니다)

설명 : print "abc"는 기본적으로 "abc"를 인쇄하는 입출력 조치입니다.
repeat는 x 값을 가져 와서 x로만 이루어진 무한리스트를 리턴하는 함수입니다.
sequence_는 i / o 조치 목록을 가져오고 모든 조치를 순차적으로 수행하는 i / o 조치를 리턴하는 함수입니다.

따라서 기본적으로이 프로그램은 무한한 인쇄 "abc"명령 목록을 작성하고 반복적으로 실행합니다. 루프 나 재귀가 없습니다.


4
나는 기본적으로 Clojure의에 같은 대답을 게시하려고했지만, 나는 생각 repeat될 것이다 a programming language statement which allows code to be repeatedly executed.
seequ

3
fix(print"">>)또한 명시 적으로 명명 된 반복 함수는 포함하지 않습니다.
mniip

1
@TheRare 나는 어떻게 닫혀 있는지 알지 못하지만 Haskell에서 repeat은 "코드를 반복적으로 실행할 수있는 프로그래밍 언어 문"이 아닙니다-무한 목록을 생성하는 함수입니다. "int [] arr = {x, x, x};"와 같은 루프입니다. 루프입니다.
자랑스런 Haskeller

1
네,하지만 뭔가가없이 기본적으로 불가능하기 때문에, 재귀를 사용하여 구현되어야합니다
자랑 haskeller을

3
실제로이 코드에있는 모든 함수는 재귀-심지어 인쇄
자랑스런 Haskeller

10

ASM (Linux의 경우 x86 + I / O)

당신의 퓨니 고급 언어가 얼마나 많은 어려움을 겪는지는 중요하지 않지만 여전히 숨겨진 지시 포인터 조작 일 것입니다. 결국 런타임에 루프를 풀기에 충분히 지루하지 않는 한 일종의 "goto"(jmp)가됩니다.

Ideone에서 코드를 테스트 할 수 있습니다

Matteo Italia DOS 코드 에서이 아이디어의보다 세련된 버전을 확인할 수도 있습니다 .

문자열은 0..9로 시작하여 A..J로 바뀝니다. 직접 점프를 사용하지 않으며 ( "goto"가 발생하지 않았다고 말함) 반복도 없습니다.

주소 계산을 잘못 사용하면 코드가 더 작을 수 있지만 온라인 컴파일러 작업은 번거롭기 때문에 그대로 두겠습니다.

핵심 부분 :

mov dl, 'A' ; I refuse to explain this line!
mov ebx, msg ; output array (string)

call rawr   ; lets put address of "rawr" line on stack
rawr: pop eax ; and to variable with it! In same time we are breaking "ret"

add eax, 4 ; pop eax takes 4 bytes of memory, so for sake of stack lets skip it
mov [ebx], dl ; write letter
inc dl ; and proceed to next 
inc ebx
cmp dl, 'J' ; if we are done, simulate return/break by leaving this dangerous area
jg print

push eax ; and now lets abuse "ret" by making "call" by hand
ret

전체 코드

section     .text
global      _start                              

_start:

;<core>
mov dl, 'A'
mov ebx, msg

call rawr
rawr: pop eax

add eax, 4
mov [ebx], dl
inc dl
inc ebx
cmp dl, 'J'
jg print

push eax
ret
;</core>

; just some Console.Write()
print:
    mov     edx,len
    mov     ecx,msg
    mov     ebx,1
    mov     eax,4
    int     0x80

    mov     eax,1
    xor     ebx, ebx
    int     0x80

section     .data

msg     db  '0123456789',0xa
len     equ $ - msg

나는 이것을 codegolf.stackexchange.com/a/34298/11259 의 dup이라고 부를 것이지만 이것이 이것이 이전의 대답임을 알 수 있습니다. +1
디지털 외상

@DigitalTrauma 오, 누군가가 내 아이디어의 세련된 버전을 만들었습니다-오래된 트릭이지만 관리 코드 시대에는 사람들이 실제로 작동하는 방식을 잊어 버렸습니다. (나는 골프를 싫어한다, 너무 자주 너무 자주 "엄마를 본다! 나는 하나의 키를 눌러 물건을 만들 수있다!"로
줄어든다

9

C 전 처리기

난독 화 챌린지에서 내가 생각 해낸 작은 "기술". 함수 재귀는 없지만 파일 재귀가 있습니까?

noloop.c :

#if __INCLUDE_LEVEL__ == 0
int main() 
{
    puts("There is no loop...");
#endif
#if __INCLUDE_LEVEL__ <= 16
    puts(".. but Im in ur loop!");
    #include "noloop.c"
#else
    return 0;
}
#endif

gcc를 사용하여 이것을 작성 / 테스트했습니다. 분명히 컴파일러는 이것을 컴파일하기 위해 __INCLUDE_LEVEL__매크로 (또는 __COUNTER__약간의 조정이 있는 매크로) 를 지원해야합니다 . 이것이 어떻게 작동하는지는 분명해야하지만 재미를 위해 코드를 컴파일하지 않고 전처리기를 실행하십시오 ( -Egcc와 함께 플래그 사용 ).


8

PHP

다음은 PHP와 관련된 것입니다. 카운터가 $ max에 도달 할 때까지 동일한 파일을 포함하여 반복합니다.

<?php
if (!isset($i))
    $i = 0;        // Initialize $i with 0
$max = 10;         // Target value

// Loop body here
echo "Iteration $i <br>\n";

$i++;               // Increase $i by one on every iteration

if ($i == $max)
    die('done');    // When $i reaches $max, end the script
include(__FILE__);  // Proceed with the loop
?>

for- 루프와 동일

<?php
for ($i = 0; $i < 10; $i++) {
    echo "Iteration $i <br>\n";
}
die('done');
?>

Darn, 이것도 재귀로 간주되지 않습니까?
Pichan

@Nathaniel의 예에서 유사성이 떠오를 것이라고 생각하지 마십시오. 전처리기에는 이러한 파일이 포함되어 동시에 평가됩니다.
eithed

@Pichan 메모리에 코드 사본이 있으면 루프가 더 전개된다고 말할 수 있습니다.
PTwr

나는 오늘 질문을 보았고 거의 동일한 코드를 생각해 냈습니다. 너무 늦었 어!
TecBrat

되어 header("Location: .?x=".$_GET['x']+1);재귀로 계산?
찰리

8

파이썬

다음 코드에는 재귀 함수 (직접 또는 간접), 루핑 프리미티브가 없으며 내장 함수를 호출하지 않습니다 (제외 print).

def z(f):
    g = lambda x: lambda w: f(lambda v: (x(x))(v), w)
    return g(g)

if __name__ == "__main__":
    def msg(rec, n):
        if (n > 0):
            print "Hello world!"
            rec(n - 1)
    z(msg)(7)

"Hello world!"를 인쇄합니다. 주어진 횟수.

설명 : 함수 z엄격한 Z 고정 소수점 결합기를 구현하며 , 이는 재귀 알고리즘을 표현할 수 있습니다 (재귀 적으로 정의되지는 않음).


g간접적으로 매우 재귀 적이 라고 부릅니다 .
seequ

@TheRare 왜? 당신의 주장은 무엇입니까? 다시 g전화하는 것은 무엇입니까 g? 물론 트릭은 자체 응용 프로그램 g(g)이지만 재귀는 포함되지 않습니다. g보이지 않으면 간접적으로 재귀 적 으로 전화 하시겠습니까 g(g)? 이것은 람다 미적분학과 같이 재귀 적 정의를 허용하지 않는 언어로 수행하는 표준 방법입니다.
Petr Pudlák

당신은 g인수로 제공 x하고 다음을 호출 x(x)합니다.
seequ

2
@TheRare 함수 (또는 함수 세트)는 사용 방식에 따라 재귀 적이거나 비재 귀적이지 않습니다. 정의에 따라 결정됩니다.
Petr Pudlák

1
모든 대답은 어떤 방식 으로든 속임수입니다. 답변 이 아닌 경우 항상 어딘가에 재귀 또는 루프가 있으며 코드에서 응답이 호출됩니다. 나는 이것이 속임수를 좋아한다.
Wayne Conrad

8

z80 기계 코드

모든 주소에서 실행하고 어디에서나 ROM을 매핑 할 수있는 환경에서는 0으로 채워진 64kb의 ROM을 전체 주소 공간에 매핑하십시오.

그것이하는 일 : 아무것도 없습니다. 자꾸.

작동 방식 : 프로세서가 실행을 시작하고 바이트 00nop명령이므로 계속 진행하고 주소에 도달하고 $ffff랩핑하고 재설정 할 때까지 s를 $0000계속 실행 nop합니다.

약간 더 흥미롭게하려면 메모리를 다른 값으로 채우십시오 (제어 흐름 명령을 피하도록주의하십시오).


메모리를 0으로 채우고 어딘가에 실제 프로그램을 배치 할 수 있습니다.
seequ

따라서 분기가없는 64k 프로그램을 넣을 수 있으며 반복적으로 실행됩니까?
Bill Woodger

@BillWoodger, 특히 플랫폼에 인터럽트가없는 경우 (또는 활성화되지 않은 경우)
해롤드

재미의 종류 :-)
Bill Woodger

8

펄 정규식

(q x x x 10) =~ /(?{ print "hello\n" })(?!)/;

데모

또는 다음과 같이 시도하십시오.

perl -e '(q x x x 10) =~ /(?{ print "hello\n" })(?!)/;'

(?!)일치하지 않습니다. 따라서 정규식 엔진 은 일치하는 문자열의 각 0 너비 위치 를 일치시킵니다.

(q x x x 10)동일하다 (" " x 10)반복 - space열 번.

편집 : 이해하기 쉽도록 "문자"를 0 너비 위치 로 변경했습니다 . 이 stackoverflow 질문에 대한 답변을 참조하십시오 .


6

T-SQL -12

print 1
GO 9

실제로 Sql Server Management Studio의 단점입니다. GO는 스크립트 구분 기호이며 T-SQL 언어의 일부가 아닙니다. GO 다음에 숫자를 지정하면 블록이 여러 번 실행됩니다.


1
나는 거의 매일 T-SQL을 사용하며 GO 로이 작업을 수행 할 수 있다는 것을 몰랐습니다. +1
CailinP

기술적으로는 T-SQL이 아닙니다. GO실제로 SSMS 지시문이므로 저장 프로 시저와 같이 T-SQL 스크립트 개체에 넣을 수 없습니다.
RBarryYoung

네, 스포일러 의견에 추가했습니다. sqlcmd를 사용하면 너무 많은 부정 행위가 될 것이라고 생각합니다.
Michael B

6

씨#

uint.MaxValue의 모든 정수를 0으로 인쇄합니다.

   class Program
   {
      public static void Main()
      {
          uint max = uint.MaxValue;
          SuperWriteLine(ref max);
          Console.WriteLine(0);
      }

      static void SuperWriteLine(ref uint num)
      {
          if ((num & (1 << 31)) > 0) { WriteLine32(ref num); }
          if ((num & (1 << 30)) > 0) { WriteLine31(ref num); }
          if ((num & (1 << 29)) > 0) { WriteLine30(ref num); }
          if ((num & (1 << 28)) > 0) { WriteLine29(ref num); }
          if ((num & (1 << 27)) > 0) { WriteLine28(ref num); }
          if ((num & (1 << 26)) > 0) { WriteLine27(ref num); }
          if ((num & (1 << 25)) > 0) { WriteLine26(ref num); }
          if ((num & (1 << 24)) > 0) { WriteLine25(ref num); }
          if ((num & (1 << 23)) > 0) { WriteLine24(ref num); }
          if ((num & (1 << 22)) > 0) { WriteLine23(ref num); }
          if ((num & (1 << 21)) > 0) { WriteLine22(ref num); }
          if ((num & (1 << 20)) > 0) { WriteLine21(ref num); }
          if ((num & (1 << 19)) > 0) { WriteLine20(ref num); }
          if ((num & (1 << 18)) > 0) { WriteLine19(ref num); }
          if ((num & (1 << 17)) > 0) { WriteLine18(ref num); }
          if ((num & (1 << 16)) > 0) { WriteLine17(ref num); }
          if ((num & (1 << 15)) > 0) { WriteLine16(ref num); }
          if ((num & (1 << 14)) > 0) { WriteLine15(ref num); }
          if ((num & (1 << 13)) > 0) { WriteLine14(ref num); }
          if ((num & (1 << 12)) > 0) { WriteLine13(ref num); }
          if ((num & (1 << 11)) > 0) { WriteLine12(ref num); }
          if ((num & (1 << 10)) > 0) { WriteLine11(ref num); }
          if ((num & (1 << 9)) > 0) { WriteLine10(ref num); }
          if ((num & (1 << 8)) > 0) { WriteLine09(ref num); }
          if ((num & (1 << 7)) > 0) { WriteLine08(ref num); }
          if ((num & (1 << 6)) > 0) { WriteLine07(ref num); }
          if ((num & (1 << 5)) > 0) { WriteLine06(ref num); }
          if ((num & (1 << 4)) > 0) { WriteLine05(ref num); }
          if ((num & (1 << 3)) > 0) { WriteLine04(ref num); }
          if ((num & (1 << 2)) > 0) { WriteLine03(ref num); }
          if ((num & (1 <<  1)) > 0) { WriteLine02(ref num); }
          if ((num & (1 <<  0)) > 0) { WriteLine01(ref num); }
      }

      private static void WriteLine32(ref uint num) { WriteLine31(ref num); WriteLine31(ref num); }
      private static void WriteLine31(ref uint num) { WriteLine30(ref num); WriteLine30(ref num); }
      private static void WriteLine30(ref uint num) { WriteLine29(ref num); WriteLine29(ref num); }
      private static void WriteLine29(ref uint num) { WriteLine28(ref num); WriteLine28(ref num); }
      private static void WriteLine28(ref uint num) { WriteLine27(ref num); WriteLine27(ref num); }
      private static void WriteLine27(ref uint num) { WriteLine26(ref num); WriteLine26(ref num); }
      private static void WriteLine26(ref uint num) { WriteLine25(ref num); WriteLine25(ref num); }
      private static void WriteLine25(ref uint num) { WriteLine24(ref num); WriteLine24(ref num); }
      private static void WriteLine24(ref uint num) { WriteLine23(ref num); WriteLine23(ref num); }
      private static void WriteLine23(ref uint num) { WriteLine22(ref num); WriteLine22(ref num); }
      private static void WriteLine22(ref uint num) { WriteLine21(ref num); WriteLine21(ref num); }
      private static void WriteLine21(ref uint num) { WriteLine20(ref num); WriteLine20(ref num); }
      private static void WriteLine20(ref uint num) { WriteLine19(ref num); WriteLine19(ref num); }
      private static void WriteLine19(ref uint num) { WriteLine18(ref num); WriteLine18(ref num); }
      private static void WriteLine18(ref uint num) { WriteLine17(ref num); WriteLine17(ref num); }
      private static void WriteLine17(ref uint num) { WriteLine16(ref num); WriteLine16(ref num); }
      private static void WriteLine16(ref uint num) { WriteLine15(ref num); WriteLine15(ref num); }
      private static void WriteLine15(ref uint num) { WriteLine14(ref num); WriteLine14(ref num); }
      private static void WriteLine14(ref uint num) { WriteLine13(ref num); WriteLine13(ref num); }
      private static void WriteLine13(ref uint num) { WriteLine12(ref num); WriteLine12(ref num); }
      private static void WriteLine12(ref uint num) { WriteLine11(ref num); WriteLine11(ref num); }
      private static void WriteLine11(ref uint num) { WriteLine10(ref num); WriteLine10(ref num); }
      private static void WriteLine10(ref uint num) { WriteLine09(ref num); WriteLine09(ref num); }
      private static void WriteLine09(ref uint num) { WriteLine08(ref num); WriteLine08(ref num); }
      private static void WriteLine08(ref uint num) { WriteLine07(ref num); WriteLine07(ref num); }
      private static void WriteLine07(ref uint num) { WriteLine06(ref num); WriteLine06(ref num); }
      private static void WriteLine06(ref uint num) { WriteLine05(ref num); WriteLine05(ref num); }
      private static void WriteLine05(ref uint num) { WriteLine04(ref num); WriteLine04(ref num); }
      private static void WriteLine04(ref uint num) { WriteLine03(ref num); WriteLine03(ref num); }
      private static void WriteLine03(ref uint num) { WriteLine02(ref num); WriteLine02(ref num); }
      private static void WriteLine02(ref uint num) { WriteLine01(ref num); WriteLine01(ref num); }
      private static void WriteLine01(ref uint num) { Console.WriteLine(num--); }
   }

1
이것이 중요한지 정말 모르겠습니다. WriteLine01 Int.MaxValue 시간을 명시 적으로 호출하고 있습니다. 방대한 양의 콜 스택 뒤에서 폭발했습니다.
Michael B

어떻게 계산하지 않습니까? 루프와 재귀가 없습니다.
LVBen

1
또한 32 개의 통화를 대규모로 간주하지 않는 한 통화 스택은 대규모 근처에 있지 않습니다.
LVBen

1
4294967296 번 대신 32 번만하는 이유는 무엇입니까?
LVBen

4
@ ja72 루프 나 재귀를 사용할 수없는 오픈 소스 프로젝트를 진행하고 있다면, 이와 같은 코드를 제공 할 것입니다!
LVBen

6

JS (브라우저에서)

이것은 어떤가요?

document.write(new Date());
location = location;

현재 시간을 인쇄하고 페이지를 다시로드합니다.


오 쏴 방금 동일한 기본 개념으로 답변을 게시했습니다. 페이지에서 "JavaScript"또는 HTML 태그를 표시하는 항목을 스캔하고있었습니다. 위치에 "#"이 포함 된 코너 케이스를 처리하기 때문에 대답을 그대로 둘 수 있다고 가정합니다. 어쨌든 +1.
Keen

Firefox 30에서 :[Exception... "The operation is insecure." code: "18" nsresult: "0x80530012 (SecurityError)" location: "<unknown>"]
Alex Reynolds

@AlexReynolds 허, 이상하다. 광산은 FF (30)에 잘 작동합니다
Pichan

코드가 쓰여질 때만 복사하여 붙여 넣었습니다. 작동하지 않습니다. 이 작업을 수행하기 위해 특별한 보안 환경 설정이 활성화되어 있습니까?
Alex Reynolds

@AlexReynolds Nope, 보안 설정을 변경하지 않았습니다. 그리고 Chrome에서도 작동합니다.
Pichan
당사 사이트를 사용함과 동시에 당사의 쿠키 정책개인정보 보호정책을 읽고 이해하였음을 인정하는 것으로 간주합니다.
Licensed under cc by-sa 3.0 with attribution required.