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

도전은 간단합니다. 반복적으로 같은 어떤 반복 구조를 사용하지 않고 코드를 실행 (선택의 여지가 귀하의 언어) 프로그램 쓰기 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를 사용하지 마십시오
• 함수는 스스로를 호출 할 수 없습니다
• '루프'에서 원하는 것을하십시오

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

루비

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"...)를 사용하여 바나나를 먼저 인쇄 한 다음 목록에서 다음을 호출하십시오.

파이썬-16

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

exec"print 1;"*9

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유형 매개 변수 런타임 새로운 방법을 만들어 강제로.

펀지

.

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

JS

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

기능 재미!

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

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

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

그리고 또 하나의 더 악한 :

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

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

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

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는 스택의 시작점 주소를 반환하기 전에 무한 루프를 생성합니다.

자바

XKCD에서 직접

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

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

배쉬, 3 자

yes

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

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

yes something | xargs someaction

(Olivier Dulac 덕분에)

C, 35 자

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

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

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
$ 

하스켈

다음 코드에는 재귀 함수 (간접적으로), 루핑 프리미티브가 없으며 내장 재귀 함수를 호출하지 않지만 ( 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" >>)

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, 그래서 실행 파일이 어떤 루프 또는 재귀 코드가 포함되어 있지 않습니다.

자바

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 %를 사용합니다.

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

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는 매우 게으 르기 때문에 마지막 순간에만이 물건을 만듭니다. 그러므로,

레드 코드 94 (핵심 전쟁)

MOV 0, 1

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

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

다트

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

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

JS

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

setInterval(alert,1)

C의 신호

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

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

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

이맥스 리스프

"코드는 데이터이고 데이터는 코드"인 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)))

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

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

하스켈, 24 자

sequence_ (repeat (print "abc"))

또는 24 자로 압축 된 형태로

sequence_$repeat$print"" 

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

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

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

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

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와 함께 플래그 사용 ).

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');
?>

파이썬

다음 코드에는 재귀 함수 (직접 또는 간접), 루핑 프리미티브가 없으며 내장 함수를 호출하지 않습니다 (제외 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 고정 소수점 결합기를 구현하며 , 이는 재귀 알고리즘을 표현할 수 있습니다 (재귀 적으로 정의되지는 않음).

z80 기계 코드

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

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

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

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

펄 정규식

(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 질문에 대한 답변을 참조하십시오 .

T-SQL -12

print 1
GO 9

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

씨#

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

JS (브라우저에서)

이것은 어떤가요?

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

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