도전

다음 문자를 인쇄하십시오.

abcdefghijklmnopqrstuvwxyzABCDEFGHIJKLMNOPQRSTUVWXYZ1234567890

중요한 것은 코드에서 그중 하나를 사용할 수 없다는 것입니다.

선행 또는 후행 줄 바꿈의 유무에 관계없이 임의의 순서로 인쇄 할 수 있지만 다른 문자는 인쇄 할 수 없습니다.

규칙

• 위에서 언급 한 세트의 문자를 사용할 수 없습니다
• 다른 문자를 사용할 수 있습니다
• 컨닝 하지마
• 금지 된 표준 허점
• 이것은 code-golf , 최단 답변이 이깁니다.

설명

• 언어에서 다른 문자 집합을 사용하는 경우 해당 문자 집합에서 영숫자 문자에 해당하는 코드 포인트를 사용할 수 없습니다.
• 함수에서 문자열을 반환하는 것은 유효한 형식의 출력으로 간주됩니다.
• char 배열을 반환 할 수 있습니다.

V , 8 7 바이트

@DJMcMayhem 덕분에 하나의 정규 표현식 문에 1 바이트가 절약되었습니다.

¬/{Ó×ü_

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

출력 :

0123456789ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz

: 주 ×입니다 하지 x 또는 X그것이,0xd7

16 진 덤프 :

00000000: ac2f 7bd3 d7fc 5f                        ./{..._

설명

¬/{            " inserts every character in the range / to {

이제 출력은 다음과 같습니다

/0123456789:;<=>?@ABCDEFGHIJKLMNOPQRSTUVWXYZ[\]^_`abcdefghijklmnopqrstuvwxyz{

영숫자가 아닌 문자와 _(포함되지 않기 때문에) 문자를 모두 제거해야 \W하므로 정규 표현식을 사용하여 수행하십시오.

Ó×ü_           " removes every character that is non-alphanumeric or an underscore _ 
               " vim equivalent of :s/\W\|_//g

옥타브 , 52 46 40 바이트

['['-('"':'+'),'{'-(_='!':':'),_+'@','']

이것은 평가

9876543210ZYXWVUTSRQPONMLKJIHGFEDCBAabcdefghijklmnopqrstuvwxyz

설명

여기서 우리는 산술 연산 +-이나 range 함수 :가 적용될 때 문자가 암시 적으로 정수로 변환된다는 사실을 사용합니다 . 빈 문자열 ( [...,''])로 연결 하면 숫자가 다시 문자로 변환됩니다.

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

brainfuck , 77 76 75 72 바이트

++++++++[>+>++++++>++++>-<<<<-]>++[>.+<-]>>[>+>++>+++<<<-]>++[>+.>+.<<-]

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

작동 원리

인터프리터는 0 개 셀 의 테이프로 시작 합니다.

++++++++

그러면 첫 번째 셀이 8로 설정되어 테이프가 다음 상태로 유지됩니다.

   8
   ^

[>+>++++++>++++>-<<<<-]

이렇게하면 두 번째 셀이 한 번 증가하고 세 번째 셀이 6 번, 네 번째 셀이 4 번 증가하고 다섯 번째 셀이 한 번 감소한 다음 테이프의 시작 부분으로 돌아가 첫 번째 셀이 감소합니다. 8 번 반복 한 후 테이프는 다음과 같습니다.

  0   8  48  32  -8
  ^

>++

우리는 두 번째 셀로 진행하여 두 번 증가시켜 숫자 인쇄를 준비합니다.

  0  10  48  32  -8
      ^

[>.+<-]

이렇게하면 세 번째 셀이 인쇄되고 증가한 다음 두 번째 셀로 돌아가서 감소합니다. 10 회 반복 한 후 인쇄 0123456789되었으며 테이프는 다음과 같습니다.

  0   0  58  32  -8
      ^

>>

편지를 위해 테이프를 준비 할 시간입니다! 우리는 두 개의 세포를 발전시키는 것으로 시작합니다.

  0   0  58  32  -8   0   0
              ^

[>+>++>+++<<<-]

이렇게하면 다섯 번째 셀이 한 번 증가하고 여섯 번째 셀이 두 번 증가하고 일곱 번째 셀이 세 번 증가한 다음 네 번째 셀로 돌아가서 감소합니다. 32 회 반복 한 후 테이프는 다음과 같습니다.

  0   0  58   0  24  64  96
              ^

>++

문자를 인쇄하기 전 마지막 단계로 다섯 번째 셀로 이동하여 두 번 증가시킵니다.

  0   0  58   0  26  64  96
                  ^

[>+.>+.<<-]

마지막으로 6 번째 셀로 이동하여 증가시키고 인쇄하고 7 번째 셀에 대해 동일한 작업을 수행 한 다음 5 번째 셀로 돌아가서 감소시킵니다. 이후 26 반복, 우리는 인쇄했습니다 Aa...Zz.

루비, 42 바이트

->{[*?/...?:,*?@...?[,*?`...?{]-[?/,?@,?`]}

문자 배열을 반환하는 함수입니다. 문자 만 출력하는 프로그램은 49 바이트입니다.

$><<([*?/...?:,*?@...?[,*?`...?{]-[?/,?@,?`])*''

이것은 단순히 범위를 정의하기 위해 관련 범위의 양쪽에 아스키 문자를 사용합니다. 예를 들어, ?/...?:끝을 제외한 슬래시와 콜론 사이의 문자를 의미합니다. 시작 부분을 없애기 위해 시작 문자가 3 개인 배열을 뺍니다.

6502 기계 언어, 74 70 68 바이트

16 진 덤프 (6502 프로그램은 일반적으로 재배치 할 수 없으며 여기의 코드는 $ 0603 위치에서 저장됩니다) :

0600:          a9 24 0a 8d 20 06 8d 21 06 8d 23 06 8d 
0610: 25 06 09 20 8d 1a 06 8d 1c 06 ea aa ea a8 a9 00 
0620: ea ea 98 ea 8a ea a2 ff a9 7b a0 60 20 3a 06 a9 
0630: 5b a0 40 20 3a 06 a9 3a a0 2f 85 80 c8 e8 98 95 
0640: 00 c8 c4 80 d0 f7 60

이것은 $ 41-$ 5a, $ 61-$ 7a 또는 $ 30-$ 39의 금지 된 바이트를 사용하지 않음을 알 수 있습니다.

이것은 호출 될 때 표준 6502 호출 규칙에 따라 스택 맨 위에 문자 배열 "abcdefghijklmnopqrstuvwxyzABCDEFGHIJKLMNOPQRSTUVWXYZ0123456789"에 대한 포인터를 리턴하는 인수가없는 함수입니다.

설명을 위해 분해는 다음과 같습니다.

Hexdump 분해 주소
-------------------------------
$ 0603 a9 24 LDA # $ 24
$ 0605 0a ASL A
$ 0606 8d 20 06 STA $ 0620
$ 0609 8d 21 06 STA $ 0621
$ 060c 8 일 23 06 STA $ 0623
$ 060f 8d 25 06 STA $ 0625
$ 0612 09 20 ORA # $ 20
$ 0614 8d 1a 06 STA $ 061a
$ 0617 8d 1c 06 STA $ 061c
NOP $ 061a 
$ 061b aa 세금 
NOP $ 061c 
$ 061d a8 TAY 
$ 061e a9 00 LDA # $ 00
NOP $ 0620 
NOP $ 0621 
$ 0622 98 TYA 
NOP $ 0623 
$ 0624 8a TXA 
NOP $ 0625 
$ 0626 a2 ff LDX # $ ff
$ 0628 a9 7b LDA # $ 7b
$ 062a a0 60 LDY # $ 60
$ 062c 20 3a 06 JSR $ 063a
$ 062f a9 5b LDA # $ 5b
$ 0631 a0 40 LDY # $ 40
$ 0633 20 3a 06 JSR $ 063a
$ 0636 a9 3a LDA # $ 3a
$ 0638 a0 2f LDY # $ 2f
$ 063a 85 80 STA $ 80
$ 063c c8 INY 
$ 063d e8 INX 
$ 063e 98 TYA 
$ 063f 95 00 STA $ 00, X
$ 0641 C8 INY 
$ 0642 c4 80 CPY $ 80
$ 0644 d0 f7 BNE $ 063d
$ 0646 60 RTS

기계 언어 코드는 자체 수정됩니다. 스택 조작을 위해서는 PHA와 PLA를 사용하여 누산기를 밀고 팝해야했지만이 명령에는 $ 48와 $ 68의 오피 코드가 있으며 금지되어 있습니다 (문자 'H'와 'h'의 ASCII 코드 임). 따라서 PHA의 경우 $ 24의 숫자를 취하고 산술 시프트 왼쪽 (ASL)을 수행하고 결과 $ 48를 코드의 4 개 지점에 저장해야합니다. 그런 다음 PLA의 경우 누산기의 $ 48에 비트 단위 OR을 사용하여 $ 68을 계산하고 필요한 코드의 두 지점에 저장합니다.

PHA 및 PLA 외에 opcode가 ASCII 문자 또는 숫자와 같기 때문에 사용할 수없는 몇 가지 지침이 있었지만 다른 사람들을위한 직접적인 해결 방법을 찾았습니다.

원하는 문자 배열은 위치 0에서 시작하여 계산되고 저장됩니다 (저장소의 포인터가 스택의 맨 위에 반환되는지 확인해야하기 때문에 저장 위치는 중요하지 않습니다).

Nick Morgan의 6502 어셈블러 및 에뮬레이터 에서 시도해 볼 수 있습니다 . 스크린 샷이 있습니다. 하단의 모니터 박스는 프로그램이 실행 된 후 출력 문자열을 보여줍니다 ($ 00에서 $ 3D 위치).

하스켈 , 75 72 63 58 56 바이트

__=[__|[_',ä]<-["/:","@[","`{"],__<-[_'..],_'<__,__<ä]

온라인으로 사용해보십시오! 로 전화하십시오 __. 산출:

0123456789ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz

9 바이트를 절약하는 대신 2 바이트 변수 이름 을 제안 __하고 비슷한 xnor 덕분에 . 특히 구문 강조 표시를 중단하는 방법 이 마음에 듭니다. 범위를 일반화하여 다른 4 바이트를 절약 한 xnor에게 다시 감사드립니다. 편집 : 그래서 예를 들어, 유니 코드 문자가 하스켈에서 식별자로 사용할 수 있습니다 것을 발견 , ... 또한 2 바이트 식별자로 사용할 수 있습니다. 프로그램에 하나의 3 바이트 식별자가 남아 있기 때문에 다른 2 바이트를 저장 하여로 대체했습니다 ._'(!)_'
äöä

설명:

__및 _'유효한 변수 이름입니다. 로부터 언어 사양 :

식별자는 문자와 0 개 이상의 문자, 숫자, 밑줄 및 작은 따옴표로 구성됩니다. [...] 밑줄 _은 소문자로 취급되며 소문자가 가능한 모든 곳에서 발생할 수 있습니다. 그러나 _그 자체는 예약 된 식별자이며 패턴에서 와일드 카드로 사용됩니다.

따라서 코드는

s = [x|[a,b]<-["/:", "@[", "`{"], x<-[a..], a<x, x<b]

목록에서 이해가 a결합 도착 '/'과 b에 ':'( "/:"에 해당 ['/',':']하므로 패턴 매칭이 성공). 그런 다음 범위 [a..]는 모든 문자의 문자열을 더 크게 만듭니다 '/'.

"/0123456789:;<=>?@ABCDE ... \1114110\1114111"

각 문자의 경우 x이 문자열에서 그 다음 여부를 확인할 것 '/'<x및 x<':'문자의 결과 0123456789. 다음 a과은 b에 바인딩 @ 하고 [문자 산출 ABCDEFGHIJKLMNOPQRSTUVWXYZ등등하고있다.

Perl (5.10 또는 5.12), 30 29 바이트

이 프로그램은 대부분 인쇄 할 수없는 문자로 구성되어 있으므로 다음은 16 진 덤프입니다.

00000000: 5f 3d 7e 7e 22 d7 c0 84 8c 9e 86 df 9e d1 d1 85 _=~~"...........
00000010: d3 be d1 d1 a5 d3 cf d1 d1 c6 82 d6 22          ............"

이 프로그램은 매우 간단합니다. 정규 표현식에 대해 =~밑줄을 긋습니다 ( _; @Dennis 덕분에). 정규식은 문자 그대로가 아니라 표현식으로 지정됩니다. 특히, 우리는 ~문자열 의 비트 단위 보수 ( )를 취 합니다. 기본 문자열을 얻기 위해 비트 단위 보수를 뒤집 으면 다음과 같은 정규식이 실행됩니다.

(?{say a..z,A..Z,0..9})

Perl 버전 5.10 및 5.12에서이 (?{…})구문은 정규식이 런타임에 임의의 코드를 실행할 수 있도록하는 실험적인 구문입니다. 이 경우,이를 사용하여 간단한 Perl 프로그램을 실행하여 원하는 출력을 인쇄합니다. (5.10 이전의 버전은이 없기 때문에 사용할 수 없습니다 say.)

최신 버전의 Perl은 (?{…})보안상의 이유로 기본적으로 비활성화 되어 있지만 이러한 버전의 Perl이 -Mre=eval있는 경우 명령 행 인수 ( -M5.010버전을 지정하는 표준과 함께 )를 통해 검사를 비활성화 (및이 프로그램을 실행할 수 있음) 할 수 있습니다. 구현 할 언어 및 바이트 수에 포함되지 않습니다).

실제로 8 5 4 바이트

'>┘▀

작동 방식 :

 '>    Pushes > onto the stack as a string
           STACK: [>]
    ┘  Converts the top item of the stack to it's ordinal
           STACK: [62]
     ▀ Push all digits from base n(top item of the stack)
           STACK: [012...xyz]

프로그램 끝 부분에 인쇄가 내재되어 있습니다.

편집 1 : 알파벳을 소문자 / 대문자로 바꾸고 숫자 범위 (10)를 기본 62의 인쇄 가능한 문자를 얻는 것으로 대체했습니다.

편집 2 : Mego 덕분에 ">"를 '>로 변경 :) 1 바이트를 저장했습니다.

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

PHP, 69 바이트

<?=~"ÏÎÍÌËÊÉÈÇƾ½¼»º¹¸·¶µ´³²±°¯®­¬«ª©¨§¦¥žœ›š™˜—–•”“’‘ŽŒ‹Š‰ˆ‡†…";

코드는 Windows-1252를 사용하여 양식화됩니다. 아래는 뒤집을 수있는 xxd 16 진수 덤프입니다.

00000000: 3c 3f 3d 7e 22 cf ce cd cc cb ca c9 c8 c7 c6 be  <?=~"...........
00000010: bd bc bb ba b9 b8 b7 b6 b5 b4 b3 b2 b1 b0 af ae  ................
00000020: ad ac ab aa a9 a8 a7 a6 a5 9e 9d 9c 9b 9a 99 98  ................
00000030: 97 96 95 94 93 92 91 90 8f 8e 8d 8c 8b 8a 89 88  ................
00000040: 87 86 85 22 3b                                   ...";

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

자바 (OpenJDK 9) , 277 바이트

예, Java, 잘 읽어보세요!

$->""+($='='+'=')+--$+--$+--$+--$+--$+--$+--$+--$+--$+--$+--$+--$+--$+--$+--$+--$+--$+--$+--$+--$+--$+--$+--$+--$+--$+($='-'+'-')+--$+--$+--$+--$+--$+--$+--$+--$+--$+--$+--$+--$+--$+--$+--$+--$+--$+--$+--$+--$+--$+--$+--$+--$+--$+($='_'-'&')+--$+--$+--$+--$+--$+--$+--$+--$+--$

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

순서가 중요하지 않기 때문에 범위가 인쇄되지만 반전됩니다.

zyxwvutsrqponmlkjihgfedcbaZYXWVUTSRQPONMLKJIHGFEDCBA9876543210

나는 "입력 없음"규칙이없는 상태 char에서 모든 것을 작동시키는 데 필요한 것을 암시 적으로 정의했습니다 . 그것이 부정 행위라면 말하십시오.

언 골프 및 테스트

public class PCG105781 {
  interface X { String apply(char x); }

  public static void main(String[] args) {
    X x = $
        -> "" // Force the result as a String.
        // The line below appends "zyxwvutsrqponmlkjihgfedcba"
        // '=' + '=' is 122 as int. $=122 casts 122 as a char, 'z'
        + ($ = '=' + '=') + --$ + --$ + --$ + --$ + --$ + --$ + --$ + --$ + --$ + --$ + --$ + --$ + --$ + --$ + --$ + --$ + --$ + --$ + --$ + --$ + --$ + --$ + --$ + --$ + --$
        // The line below appends "ZYXWVUTSRQPONMLKJIHGFEDCBA"
        // '-' + '-' is 90 as int. $=90 casts 90 as a char, 'Z'
        + ($ = '-' + '-') + --$ + --$ + --$ + --$ + --$ + --$ + --$ + --$ + --$ + --$ + --$ + --$ + --$ + --$ + --$ + --$ + --$ + --$ + --$ + --$ + --$ + --$ + --$ + --$ + --$
        // The line below appends "9876543210"
        // '_' - '&' is 57 as int. $=57 casts 57 as a char, '9'
        + ($ = '_' - '&') + --$ + --$ + --$ + --$ + --$ + --$ + --$ + --$ + --$
      ;

    System.out.println(x.apply('_'));
  }
}

Brainfuck, 89 85 바이트

brainfuck은 어쨌든 영숫자를 무시하기 때문에, 이것은 일정한 출력 문제입니다 ... (편집 : 10 바이트보다 짧은 버전 은 Dennis 's Solution 참조 )

+[-[--<]>>--]++++++++++[<+.>-]<++++++++>+[-[---<]>>-]<-<<+++++[>+++++<-]>+[>.+<<<.+>>-]

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

이 코드는 brainfuck의 기본 카운트 루프의 좋은 예입니다.

+[-[--<]>>--]   Create value 47: char just before '0'
++++++++++      Set adjacent cell to 10: to be used as a counter

[               While the counter is not 0:
 <+.              Increment and print the char
    >-            Decrement the counter
       ]        (End loop: Exits when all digits have been printed)


<++++++++>           The char is now at '9' so add 8 to make it 'A'
+[-[---<]>>-]<-      In another cell create lowercase 'a'
<<+++++[>+++++<-]>+  Create 26: the number of times to loop

[                While the counter is not 0:
 >.+               Print and increment the lowercase char
    <<<.+          Print and increment the uppercase char
         >>-       Decrement the counter
            ]    (End loop: Exits when all letters have been printed)

이것은 랩핑 단축키를 사용하여 숫자를 생성합니다. 즉, 인터프리터에는 8 비트 랩핑 셀 (예 : 링크 된 셀)이 있어야합니다.

자바 스크립트 (ES6), 983 바이트

ES6에는 JavaScript 변수 이름에 사용할 수있는 문자 가 많이 있습니다 ! $and로 6 개의 1-2 바이트 변수 이름을 소진 한 후에 효과적 _입니다.

_=~[]
$={}
Á=++_
À=![]+""
Â=À[_]
Ã=++_
Ä=À[_]
Å=++_
Æ=($+"")[_]
Ç=(_[_]+"")[_]
È=++_
É=(!""+"")[_]
Ë=++_
Ì=++_
Ê=($+"")[_]
Í=++_
µ=++_
Î=++_
Ï=++_
_="\\"
Ð=$.$
È_=(!""+"")[Ã]
Å_=$+""
Ñ=Å_[Ã]
Ò=(Ð+"")[Ã]
__=Å_[Í]
Ó=(!""+"")[Å]
$_=Å_[Ì]+Ñ+Ò+(!$+"")[È]+__+È_+Ó+Å_[Ì]+__+Ñ+È_
$$=È_+(!""+"")[È]+__+Ó+È_+Ò
$=Á[$_][$_]
$($($$+"\""+Ê+Ñ+_+Ã+Ì+Í+_+Ã+Í+È+Ñ+À[Å]+É+"."+À[Å]+Ñ+_+Ã+Ë+µ+"('"+Ä+Æ+Ê+Ç+É+Â+_+Ã+Ë+µ+_+Ã+Ì+Á+_+Ã+Ì+Ã+_+Ã+Ì+Å+_+Ã+Ì+È+À[Å]+_+Ã+Ì+Ì+_+Ã+Ì+Í+Ñ+_+Ã+Í+Á+_+Ã+Í+Ã+_+Ã+Í+Å+_+Ã+Í+È+__+Ó+_+Ã+Í+Í+_+Ã+Í+µ+_+Ã+µ+Á+_+Ã+µ+Ã+_+Ã+µ+Å+_+Ã+Á+Ã+_+Ã+Á+Å+_+Ã+Á+È+_+Ã+Á+Ë+_+Ã+Á+Ì+_+Ã+Á+Í+_+Ã+Á+µ+_+Ã+Ã+Á+_+Ã+Ã+Ã+_+Ã+Ã+Å+_+Ã+Ã+È+_+Ã+Ã+Ë+_+Ã+Ã+Ì+_+Ã+Ã+Í+_+Ã+Ã+µ+_+Ã+Å+Á+_+Ã+Å+Ã+_+Ã+Å+Å+_+Ã+Å+È+_+Ã+Å+Ë+_+Ã+Å+Ì+_+Ã+Å+Í+_+Ã+Å+µ+_+Ã+È+Á+_+Ã+È+Ã+_+Ã+È+Å+Ã+Å+È+Ë+Ì+Í+µ+Î+Ï+Á+"')\"")())()

자바 스크립트, 1223 바이트

위의 내용을 배우기 전에 이것이 내 대답이었습니다.

_=~[]
$={}
___=++_
____=![]+""
$$$$=____[_]
__$=++_
$_$_=____[_]
_$_=++_
$_$$=($+"")[_]
$$_$=(_[_]+"")[_]
_$$=++_
$$$_=(!""+"")[_]
$__=++_
$_$=++_
$$__=($+"")[_]
$$_=++_
$$$=++_
$___=++_
$__$=++_
_="\\"
_$_$=$.$
_$$_=(!""+"")[__$]
_$__=$+""
_$=_$__[__$]
__$_=(_$_$+"")[__$]
__=_$__[$$_]
___$=(!""+"")[_$_]
$_=_$__[$_$]+_$+__$_+(!$+"")[_$$]+__+_$$_+___$+_$__[$_$]+__+_$+_$$_
$$=_$$_+(!""+"")[_$$]+__+___$+_$$_+__$_
$=___[$_][$_]
$($($$+"\""+$$__+_$+_+__$+$_$+$$_+_+__$+$$_+_$$+_$+____[_$_]+$$$_+"."+____[_$_]+_$+_+__$+$__+$$$+"('"+$_$_+$_$$+$$__+$$_$+$$$_+$$$$+_+__$+$__+$$$+_+__$+$_$+___+_+__$+$_$+__$+_+__$+$_$+_$_+_+__$+$_$+_$$+____[_$_]+_+__$+$_$+$_$+_+__$+$_$+$$_+_$+_+__$+$$_+___+_+__$+$$_+__$+_+__$+$$_+_$_+_+__$+$$_+_$$+__+___$+_+__$+$$_+$$_+_+__$+$$_+$$$+_+__$+$$$+___+_+__$+$$$+__$+_+__$+$$$+_$_+_+__$+___+__$+_+__$+___+_$_+_+__$+___+_$$+_+__$+___+$__+_+__$+___+$_$+_+__$+___+$$_+_+__$+___+$$$+_+__$+__$+___+_+__$+__$+__$+_+__$+__$+_$_+_+__$+__$+_$$+_+__$+__$+$__+_+__$+__$+$_$+_+__$+__$+$$_+_+__$+__$+$$$+_+__$+_$_+___+_+__$+_$_+__$+_+__$+_$_+_$_+_+__$+_$_+_$$+_+__$+_$_+$__+_+__$+_$_+$_$+_+__$+_$_+$$_+_+__$+_$_+$$$+_+__$+_$$+___+_+__$+_$$+__$+_+__$+_$$+_$_+__$+_$_+_$$+$__+$_$+$$_+$$$+$___+$__$+___+"')\"")())()

나는 실행 console.log('abcdefghijklmnopqrstuvwxyzABCDEFGHIJKLMNOPQRSTUVWXYZ1234567890')을 통해 jjencode 수동으로 결과를 golfed. 수행 할 수있는 더 많은 최적화가 있습니다.

베 펀지, 73 72 59 57 55 53 바이트

"{"< ^+`"`"\+*`\":"\`"/":\*`\"["\`"@":::::-!!
#@_^,_!

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

이것은 하나의 루프 카운트 다운에서 시작합니다 {(즉, 뒤에 한 문자 z). 첫 번째 반복에서 "{"<시퀀스는 두 개의 사본을 {스택으로 푸시합니다. 하나는 초기 루프 카운터이고 다른 하나는 시퀀스를 사용하여 해당 카운터를 감소시키는 데 사용됩니다 !!-(두 개의 NOT이 만들어지고 1빼기). 후속 반복에서 루프 카운터는 이미 스택에 있으므로 {감소 시퀀스를 설정하는 데 하나만 필요합니다.

코드의 나머지 부분은 문자가 범위 내에 있는지 계산하는 긴 부울 식입니다. 이 경우 두 번째 줄의 분기가 왼쪽으로 분할되어 값을 씁니다. 그렇지 않은 경우 오른쪽 지점은 우리가 0에 도달하고 종료 해야하는지 테스트하기 위해 랩을 감습니다. 두 개의 가지가 가운데로 합쳐져서 루프를 반복합니다. 를 사용할 수 없기 때문에 모든 수직 방향 명령이 위쪽으로 이동 v하지만 명령 포인터가 자동으로 플레이 필드의 맨 위에 래핑되기 때문에 좋습니다.

루프 증분을위한 더 나은 기술을 처음 도입 한 Mistah Figgins 에게 감사드립니다 .

그러나 보다 컴팩트 한 브랜치 레이아웃뿐만 아니라 카운트 다운보다 더 나은 접근 방식 을 제공 한 Jo King 에게 특별한 감사를드립니다 .

젤리 , 17 16 바이트

“:[{“/@`‘Ḷḟ"/ỌḊ€

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

작동 원리

“:[{“/@`‘Ḷḟ"/ỌḊ€  Main link. No arguments.

“:[{“/@`‘         Yield [[58, 91, 123], [47, 64, 96]].
         Ḷ        Unlength; map each n to [0, ..., n-1].
          ḟ"/     Reduce by vectorizing filter-false.
                  This yields [[47, ..., 57], [64, ..., 90], [96, ..., 122]].
             Ọ    Unordinal; replace each n with the corr. Unicode character.
              Ḋ€  Deqeue each; remove the first character of each of the three
                  generated strings ('/', '@', and '`').

자체 수정 Brainfuck , 32 바이트

<[-<+.>]<<[-<+.>]<<[-<+.>]`@/

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

xxd -r뒤집을 수있는 16 진 덤프 (인쇄 할 수없는 파일 포함) :

00000000: 3c5b 2d3c 2b2e 3e5d 3c3c 5b2d 3c2b 2e3e  <[-<+.>]<<[-<+.>
00000010: 5d3c 3c5b 2d3c 2b2e 3e5d 601a 401a 2f0a  ]<<[-<+.>]`.@./.

C, 128 바이트

그렇습니다. C. 심지어 난해한 것보다 짧습니다.

__($$,_,$,_$,$_){$>_$?_$=_$?!$:$,$=*(""-_+$_++)&*"{":_;_$?*(""-_+$$++)=$++:_;$&&__($$,_,$,_$,$_);}_(_){__(_,"",_,!!_,"½´ÞÅþå");}

_충분히 큰 빈 char *버퍼를 호출하십시오 .

_{teeny wee bit 컴파일러에 따라 다를 수 있습니다. GCC를 사용하여 테스트; 파일이 코드 페이지 1252에 저장되었습니다.}

자바 스크립트 (ES6) 812 745 657 650 536 520 416 바이트

(À=(Á=!($={})+(Ø=""))[Â=_=+[]],Ã=(Ä=!_+Ø)[Å=++_],Æ=(Ç=$+Ø)[_],È=(É=$.$+Ø)[_],Ê=Ä[Ë=++_],Ì=Ä[Í=++_],Î=++_,Ï=Ç[Ð=++_],Ñ=Ç[Ò=++_],Ó=++_,$=$[Ô=Ï+Æ+È+Á[Í]+Ñ+Ã+Ê+Ï+Ñ+Æ+Ã][Ô],$($((Õ=Ã+Ä[Í]+Ñ+Ê+Ã+È)+`"${Ù=($=À)+Æ+(Ö=Ô[Ð])}($ ${[Æ+$+"[["+Î+ ++_,Ø+Ð+_+"],["+Ò+Ð,Ø+ ++_+Å+"],["+_+Ó,Ú=Ø+Å+Ë+Í]}]])${Ù}(_=$[Â];_<$[Å];)Ø+=${(_="\\")+Ú+Ñ+Ö+(Û=(_=_+Å)+Ð)+Å+Ô[Ë]+_+Î+Ó}.${$+Ö+Æ+Û+Ð+_+Â+Í+Û+Â+Á[Å]+Ö+_+Â+Í+Æ+É[Ë]+Ì}(_++);${Õ} Ø"`)()))

편집 : ISO8859-1 인코딩을 사용하면이 솔루션은 520 바이트가 아닌 416 바이트입니다. 전체 프로그램은 추가 16 바이트를 고려하여 432 바이트입니다.

f=\r\n
416 byte submission here\r\n
alert(f())

이것은 전체 프로그램이 아닌 기능 제출입니다. 나는 JJEncode를 골프하는 데 꽤 오랜 시간 을 보냈지 만 골프 대신 대신

console.log('abcdefghijklmnopqrstuvwxyzABCDEFGHIJKLMNOPQRSTUVWXYZ1234567890')

나는 골프를 쳤다

for($ of[[48,58],[65,91],[97,123]])for(_=$[0];_<$[1];)Ø+=String.fromCharCode(_++);return Ø

여기서, Ø초기화되는 ""오버 헤드이다.

쉼표 연산자를 개행 문자로 변환하여 다시 작성 :

À=(Á=!($={})+(Ø=""))[Â=_=+[]]
Ã=(Ä=!_+Ø)[Å=++_]
Æ=(Ç=$+Ø)[_]
È=(É=$.$+Ø)[_]
Ê=Ä[Ë=++_]
Ì=Ä[Í=++_]
Î=++_
Ï=Ç[Ð=++_]
Ñ=Ç[Ò=++_]
Ó=++_
$=$[Ô=Ï+Æ+È+Á[Í]+Ñ+Ã+Ê+Ï+Ñ+Æ+Ã][Ô]
// function that returns string
$($((Õ=Ã+Ä[Í]+Ñ+Ê+Ã+È)+`"${Ù=($=À)+Æ+(Ö=Ô[Ð])}($ ${[Æ+$+"[["+Î+ ++_,Ø+Ð+_+"],["+Ò+Ð,Ø+ ++_+Å+"],["+_+Ó,Ú=Ø+Å+Ë+Í]}]])${Ù}(_=$[Â];_<$[Å];)Ø+=${(_="\\")+Ú+Ñ+Ö+(Û=(_=_+Å)+Ð)+Å+Ô[Ë]+_+Î+Ó}.${$+Ö+Æ+Û+Ð+_+Â+Í+Û+Â+Á[Å]+Ö+_+Â+Í+Æ+É[Ë]+Ì}(_++);${Õ} Ø"`)())

설명

이 스크립트는 몇 가지 내장 유형을 초기화하고 문자열로 강제 변환하는 것으로 시작합니다. 영숫자를 사용하지 않고 얻을 수있는 문자열은 다음과 같습니다.

{}+""     -> "[object Object]"
!{}+""    -> "false"
!+[]+""   -> "true"
{}[{}]+"" -> "undefined"

이러한 문자열과 개별 문자를 참조하는 데 필요한 숫자에서 문자열 return과를 얻을 constructor수 있으며 다음과 같이 사용할 수 있습니다.

$={}[Ô="constructor"][Ô]
$(("return"+`"encoded script"`)())

객체의 생성자는입니다 Object(). 생성자는 입니다. Function()본질적으로 like를 사용할 수 있습니다 eval().

이 경우, 실행되는 인코딩 된 스크립트는 for코드 포인트를 사용하여 모든 영숫자 문자를 문자열로 연결하고 반환 하는 중첩 루프입니다.

인코딩 된 스크립트에서 내장을 사용하여 액세스 할 수없는 알파벳 문자의 경우 JJEncode는 8 진 이스케이프를 사용하여이를 표시 한 다음 내부 함수에서 전체 문자열을 리턴하여 디코딩합니다. 그런 다음 외부 함수를 호출하여 소스를 실행할 수 있습니다.

데모

f=
(À=(Á=!($={})+(Ø=""))[Â=_=+[]],Ã=(Ä=!_+Ø)[Å=++_],Æ=(Ç=$+Ø)[_],È=(É=$.$+Ø)[_],Ê=Ä[Ë=++_],Ì=Ä[Í=++_],Î=++_,Ï=Ç[Ð=++_],Ñ=Ç[Ò=++_],Ó=++_,$=$[Ô=Ï+Æ+È+Á[Í]+Ñ+Ã+Ê+Ï+Ñ+Æ+Ã][Ô],$($((Õ=Ã+Ä[Í]+Ñ+Ê+Ã+È)+`"${Ù=($=À)+Æ+(Ö=Ô[Ð])}($ ${[Æ+$+"[["+Î+ ++_,Ø+Ð+_+"],["+Ò+Ð,Ø+ ++_+Å+"],["+_+Ó,Ú=Ø+Å+Ë+Í]}]])${Ù}(_=$[Â];_<$[Å];)Ø+=${(_="\\")+Ú+Ñ+Ö+(Û=(_=_+Å)+Ð)+Å+Ô[Ë]+_+Î+Ó}.${$+Ö+Æ+Û+Ð+_+Â+Í+Û+Â+Á[Å]+Ö+_+Â+Í+Æ+É[Ë]+Ì}(_++);${Õ} Ø"`)()))
console.log(f())

Brain-Flak , 171 바이트

에 +3 포함 -A

(((((()()()){}){}){}){})(((()()())){}{}){({}[()]<(({})())>)}{}(({})(()()()()){})(((((()()()){}){}){}())<{({}[()]<(({})())>)}{}(({})(()()()){}())>){({}[()]<(({})())>)}{}

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

(((((()()()){}){}){}){}) # push 48
(((()()())){}{})         # push 9
{({}[()]<                # for 9..0
(({})())                 # pop a, push a, push a+1
>)}{}                    # end for
(({})(()()()()){})       # pop a, push a, push a + 8
(((((()()()){}){}){}())< # push 26 and save a 26 for later
{({}[()]<                # for 26..0
(({})())                 # pop a, push a, push a+1
>)}{}                    # end for
(({})(()()()){}())       # pop a, push a, push a + 7
>)                       # push that 26 that we held
{({}[()]<                # for 26..0
(({})())                 # pop a, push a, push a+1
>)}{}                    # end for

add 1 "function"을 반복하지 않고도이 작업을 수행 할 수 있습니다.

줄리아 0.4 , 46 바이트

_()=['¥':'®';'¶':'Ï';'Ö':'ï'].-['~'-'	']

문자 배열을 반환하는 일반 함수입니다.

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

대체 버전, 47 바이트, ASCII 전용

_(_=_==_)=['/'+_:':'-_;'@'+_:'['-_;'`'+_:'{'-_]

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

J, 171 바이트

(+:>.+:^^*_){.".(':',~(+:+:>.^*_){(*:>.^*_)!:(+:<.^+:*_)''),',',(":(>:*:+:+:+:*_),(<.^<:^<:^*_),<:*:<.^+:*_),'+/',('.',~(+:<.+:^*_){(*:>.^*_)!:(+:<.^+:*_)''),":+:<.*:>:^*_

아 ... 내 뇌가 아프다 ... 온라인으로 해봐!

여기에 한 줄을 모두 볼 수 있습니다 (줄 바꿈으로 실행되지는 않습니다).

(+:>.+:^^*_){.".(':',~(+:+:>.^*_){(*:>.^*_)!:(+:<.^+:*_)''),',',(":(>:*:+:+:+:*_),(<.^<:^<:^*
_),<:*:<.^+:*_),'+/',('.',~(+:<.+:^*_){(*:>.^*_)!:(+:<.^+:*_)''),":+:<.*:>:^*_

j805/j64/linux/release/commercial/www.jsoftware.com/2016-12-11T08:02:52그 순서대로 J 버전에서만 작동하도록 보장됩니다 . (처음 12 자만 중요합니다.)

설명

프로그램의 대부분은 지속적인 생성에 전념합니다. 해당 상수가 해당 값으로 바뀌면 프로그램은 다음과 같습니다.

(62){.".(':',~(12){(9)!:(14)''),',',(":(65),(97),48),'+/',('.',~(10){(9)!:(14)''),":26

일부 괄호가 제거되고 일부 숫자가 더 좋아졌습니다.

62{.".(':',~12{9!:14''),',',(":65 97 48),'+/',('.',~10{9!:14''),":26

이것은의 무리로 구성되어 ,및 ,~추가하고 앞에 추가 인수의. 별도의 값은 다음과 같습니다.

1. ":26
2. ('.',~10{9!:14'')
3. '+/'
4. (":65 97 48)
5. ','
6. (':',~12{9!:14'')

1이다 26문자열로.

9!:14'' TIO에서 다음 문자열을 생성합니다.

j805/j64/linux/release/commercial/www.jsoftware.com/2016-12-11T08:02:52

로 2, 우리는 10( i에서 linux) th 문자를 얻고, .그것의 끝에 a 를 추가하여 를 산출 i.합니다.

3그리고 5자명하다.

465 97 48문자열 로 숫자 목록입니다 .

6비슷 2가있어 제외 12번째 문자 ( u로부터 linux) 및 추가 :수득 끝에 u:.

이것은 모두 함께 산출 u:,65 97 48+/i.26합니다. ".이것을 평가하여 다음을 제공합니다.

ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz0123456789:;<=>?@ABCDEFGHI

(참고 : +/표로 추가되었습니다.)

그런 다음을 사용 62{.하여 첫 62문자를 가져 와서을 제공합니다 ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz0123456789.

05AB1E , 18 15 11 바이트

입력 크기가 1이면 05AB1E는 첫 번째 명령에서 b를 0으로 사용하기 때문에 Adnan 덕분에 -4입니다.

•£•Ýç©á®þ«˜

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

•£•Ÿ            # Push [0..122] using implicit 0 and the base-214 of `£`.
    ç           # Convert to ASCII chars.
     ©          # Store full array in register.
      á         # Push the same array with ONLY letters.
       ®        # Push contents of register (char)[0..122].
        þ       # Push only the digits.
         «˜     # Concat to list, flatten it. 

나는 많은 다른 접근법을 시도했지만 여기서 중요한 점은 그것을 어렵게 만들었다.

- Basic commands will not work, only extended and a select few of the basics.
- Extended commands are pretty complex.
- Eval (.V) will not work.
- To push numbers you can do a base 214 compression.
- ALL sequence pushes (E.G. žK) won't work.
- ALL number pushes won't work, except for compression and the -1 an empty register pushes.

Brainfuck, 55 바이트

+++[[<+>->++<]>]<<[-<->]<<<<++[->>+.>+.<<<]<--[->>.+<<]

산출:

aAbBcCdDeEfFgGhHiIjJkKlLmMnNoOpPqQrRsStTuUvVwWxXyYzZ0123456789

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

테이프를 3 · 2 ^n으로 초기화하고 거기서부터 작동합니다.

+++[[<+>->++<]>]    initialize the tape
                    |   0 |   3 |   6 |  12 |  24 |  48 |  96 | 192 | 128 |   0 |   0 |
                                                                                    ^
<<[-<->]            subract 128 from 192
                    |   0 |   3 |   6 |  12 |  24 |  48 |  96 |  64 |   0 |   0 |   0 |
                                                                        ^
<<<<++              increment 24 twice
                    |   0 |   3 |   6 |  12 |  26 |  48 |  96 |  64 |   0 |   0 |   0 |
                                                ^
[->>+.>+.<<<]       output aAbBcC ~ zZ
                    |   0 |   3 |   6 |  12 |   0 |  48 | 122 |  90 |   0 |   0 |   0 |
                                                ^
<--[->>.+<<]        decrement 12 twice; output 0 ~ 9
                    |   0 |   3 |   6 |   0 |   0 |  58 | 122 |  90 |   0 |   0 |   0 |
                                          ^

Perl 6 , 43 바이트-비경쟁

{|('`'^..^'{'),|('@'^..^'['),|('/'^..^':')}

문자 목록을 반환하는 람다.
설명:

   '`'                                       # The character before "a" (in Unicode order)
          '{'                                # The character after "z"
      ^..^                                   # Endpoint-exclusive range between them
 |(          )                               # Slip the range into the outer list
               |('@'^..^'[')                 # Same thing for "A" to "Z"
                             |('/'^..^':')}  # Same thing for "0" to "9"

오늘날 git repo에 전념하고 Rakudo 공식 릴리스의 일부가 아닌 Rakudo Perl 6 인터프리터의 버그 수정에 따라 다릅니다. 사실, 나는이 도전에 대답하는 동안 버그가 발생하여 Perl 6 핵심 개발자 중 하나의 도움으로 고칠 수있었습니다. 이 사이트의 규칙은 내가 이해하는 것처럼 그러한 상황에서 답변을 경쟁하는 것을 허용하지 않으므로 경쟁이 아닌 것으로 표시했습니다.

PHP 7.0 이상, 110 바이트

신은 비트 현을 축복합니다!

<?=($__='`@`@'^'*/).')(($_='->.<:'^'__@[_')('>'^_,'%'^_)),$__($_('|'^'=','|'^'&')),$__($_(':'^"\n",';'^']'^_));

를 교체 \n겠다는 * NIX 스타일의 줄 바꿈으로.
줄 바꿈 문제를 피하기 위해 코드에 있지만 점수에는 포함되지 않습니다.

이로 인해 많은 경고가 발생하지만 @모든 길 잃은 앞에를 추가하면 이러한 경고를 억제 할 수 있습니다 _.

경고 없음 , 113 바이트

<?=($__='`@`@'^'*/).')(($_='->.<:'^'__@[_')('>'^@_,'%'^@_)),$__($_('|'^'=','|'^'&')),$__($_(':'^"\n",';'^']'^@_));

65c02 기계 언어 + Apple] [ROM, 25 바이트

A9 E0 20 0F 80 A9 C0 20 0F 80 A2 0A A9 AF 2C A2 1A 1A 20 ED FD CA D0 F9 60

인쇄 abcdefghijklmnopqrstuvwxyzABCDEFGHIJKLMNOPQRSTUVWXYZ0123456789합니다.

에서 시작해야합니다 $8000.

분해

8000-   A9 E1       LDA   #$E0
8002-   20 0F 80    JSR   $800F
8005-   A9 C1       LDA   #$C0
8007-   20 0F 80    JSR   $800F
800A-   A2 0A       LDX   #$0A
800C-   A9 B0       LDA   #$AF
800E-   2C          HEX   2C     ; SKIPS NEXT 2 BYTES
800F-   A2 1A       LDX   #$1A
8011    1A          INC   
8012-   20 ED FD    JSR   $FDED
8015-   CA          DEX   
8016-   D0 F9       BNE   $8011
8018-   60          RTS   

(리눅스) 떠들썩한 파티, 507 493 490 485 바이트

전역 변수에 문자 배열을 저장합니다. __

: {_}>_ {_}>_ {_}>_ {_}>_ {_}>_ {_}>_ {_}>_ {_}>_ {_}>_ {_}>_
__=(/????/????/??/??)
___=${__%??}
__=(${__[@]#$___?})
____=${___#/*/?}
____=${____%?/*/}
_____=${____%?}
____=${____#?}
___=${___%??/}
______=($___*_??)
______=${______#$___???????}
______=${______%??_*}
_______=($___$_____???*)
_______=${_______#$___??}
_______=${_______%????}
___=$#
___=$((++___))$((___+++++___+___--))$___
$_____$_______$______$____{,} ___="\({$______..$'\\$___'}\)"
__=(${__[@]} ${___[@]} ${___[@]^})

/proc, 또는 pid 네임 스페이스와 같이 새로 부팅 된 Linux 시스템에서 실행해야 합니다.

설명:

# {var}>file opens a file descriptor >= 10 to that file
: {_}>_ {_}>_ {_}>_ {_}>_ {_}>_ {_}>_ {_}>_ {_}>_ {_}>_ {_}>_
# at startup no pid is > 999 so there's no other /proc/pid/fd/??
__=(/????/????/??/??)                                 # /proc/self/fd/1[0-9]
___=${__%??}                                          # /proc/self/fd/
__=(${__[@]#$___?})                                   # {0..9}
____=${___#/*/?}                                      # elf/fd/
____=${____%?/*/}                                     # el
_____=${____%?}                                       # e
____=${____#?}                                        # l
___=${___%??/}                                        # /proc/self/
______=($___*_??)                                     # /proc/self/timerslack_ns
______=${______#$___???????}                          # ack_ns
______=${______%??_*}                                 # a
_______=($___$_____???*)                              # /proc/self/environ
_______=${_______#$___??}                             # viron
_______=${_______%????}                               # v

___=$#                                                # 0
___=$((++___))$((___+++++___+___--))$___              # 172 (z in octal)

# eval eval                   ___="\({a..$'\172'}\)"
$_____$_______$______$____{,} ___="\({$______..$'\\$___'}\)"
#   {0..9}   {a..z}    {A..Z}
__=(${__[@]} ${___[@]} ${___[@]^})

그것을 시도하기 위해 우리는 declare -p __결과를 표시하기 위해 끝에 추가 할 수 있습니다

$ sudo unshare --fork --pid --mount-proc bash golf
declare -a __=([0]="0" [1]="1" [2]="2" [3]="3" [4]="4" [5]="5" [6]="6" [7]="7" [8]="8" [9]="9" [10]="a" [11]="b" [12]="c" [13]="d" [14]="e" [15]="f" [16]="g" [17]="h" [18]="i" [19]="j" [20]="k" [21]="l" [22]="m" [23]="n" [24]="o" [25]="p" [26]="q" [27]="r" [28]="s" [29]="t" [30]="u" [31]="v" [32]="w" [33]="x" [34]="y" [35]="z" [36]="A" [37]="B" [38]="C" [39]="D" [40]="E" [41]="F" [42]="G" [43]="H" [44]="I" [45]="J" [46]="K" [47]="L" [48]="M" [49]="N" [50]="O" [51]="P" [52]="Q" [53]="R" [54]="S" [55]="T" [56]="U" [57]="V" [58]="W" [59]="X" [60]="Y" [61]="Z")

자바 스크립트, 1273 1351 1610 바이트

이 솔루션은이 스레드에서 다른 두 답변으로 기본적으로 동일한 방식으로 작동 여기 와 여기 가에서 문자를 사용하여, true, false, undefined,과 [object Object]는 다른 문자를 생성하는 데 필요한 기능을 구축하는 문자열.

많은 수의 문자가 이미 객체에 삽입되었으므로 나머지 모든 빼기 문자와 숫자를 객체에 추가 한 다음 객체의 toUpperCase모든 값에 적용 하여 누락 된 대추 문자를 생성했습니다.

최신 정보:

8 진수 값을 설정하는 방식을 향상시킬 수 있었지만 여전히 13 x 30 바이트를 차지하고 있습니다 (또는 숫자를 다른 키로 변경 한 후 각각 30 바이트가됩니다). 패턴 : $.ž=\'\\'+$.一+$.七+$.二+'\';.

숫자 키를 2 바이트 문자로 전환하여 추가로 49 바이트를 쉽게 꺼낼 수 있습니다.

현재 제출물 :

$=~[];_={ť:!""+"",ň:![]+"",û:$._+'',ô:{}+"",ø:''};$={零:++$,ƒ:_.ň[$],ť:_.ť[$],一:++$,â:_.ň[$],ř:_.ť[$],ô:_.ô[$],ň:_.û[$],二:++$,ľ:_.ň[$],û:_.ť[$],ƅ:_.ô[$],ď:_.û[$],三:++$,ŝ:_.ň[$],ĵ:_.ô[$],四:++$,ě:_.ň[$],五:++$,ĉ:_.ô[$],î:_.û[$],六:++$,七:++$,八:++$,Ô:_.ô[$],九:++$};_.ĉ=$.ĉ+$.ô+$.ň+$.ŝ+$.ť+$.ř+$.û+$.ĉ+$.ť+$.ô+$.ř;_.ř=$.ř+$.ě+$.ť+$.û+$.ř+$.ň;_.ƒ=(0)[_.ĉ][_.ĉ];_.ƒ(_.ƒ(_.ř+' "$.Û=\'\\'+$.一+$.二+$.五+'\';$.Ĉ=\'\\'+$.一+$.零+$.三+'\';$.Ě=\'\\'+$.一+$.零+$.五+'\';$.ĝ=\'\\'+$.一+$.四+$.七+'\';$.ĥ=\'\\'+$.一+$.五+$.零+'\';$.ǩ=\'\\'+$.一+$.五+$.三+'\';$.ӎ=\'\\'+$.一+$.五+$.五+'\';$.ƥ=\'\\'+$.一+$.六+$.零+'\';$.ǫ=\'\\'+$.一+$.六+$.一+'\';$.ư=\'\\'+$.一+$.六+$.六+'\';$.ŵ=\'\\'+$.一+$.六+$.七+'\';$.ӽ=\'\\'+$.一+$.七+$.零+'\';$.ŷ=\'\\'+$.一+$.七+$.一+'\';$.ž=\'\\'+$.一+$.七+$.二+'\';"')())();_.ƒ(_.ƒ(_.ř+' "_.â=\''+$.Ô+$.ƅ+$.ĵ+$.ě+$.ĉ+$.ť+'.'+$.ǩ+$.ě+$.ŷ+$.ŝ+'($).'+$.ƒ+$.ô+$.ř+$.Ě+$.â+$.ĉ+$.ĥ+'\';_.ƅ=\''+$.ť+$.ô+$.Û+$.ƥ+$.ƥ+$.ě+$.ř+$.Ĉ+$.â+$.ŝ+$.ě+'\';"')())();_.ƒ(_.ƒ(_.ř+' "'+_.â+'((ǩ)=>{$[ǩ.'+_.ƅ+"()]=($[ǩ]+'')."+_.ƅ+"()});"+_.â+"((ǩ)=>{_.ø+=$[ǩ];});"+$.â+$.ľ+$.ě+$.ř+$.ť+'(_.ø);"')())()

C (클랑) 164 바이트

é,ú,í,ó;_(*$){ú-=ú;ú++;í=ú+ú;ó=í<<í*í<<ú;!é?é++,é<<=í*í+ú,é+=í<<í+ú:é;*$++=é++;é+=é==ó-(í*í+í)?(í<<í)-ú:ú-ú;é+=é==ó+(í<<í<<í)-í*í-ú?í*í+í:ú-ú;é<í*ó-(í*í)-ú?_($):ú;}

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

이것은 1의 값으로 시작하여 (자기에서 빼기 및 증가) 문자를 가져오고 그로부터 다른 모든 숫자를 만드는 재귀 함수입니다.

언 골프 / 설명 :

é,ú,í,ó;
_(*$){ //function "_" taking a pointer "$"
	ú-=ú;ú++; //constant ú=1
	í=ú+ú; //constant í=2
	ó=í<<í*í<<ú; //constant ó=64
	!é?é++,é<<=í*í+ú,é+=í<<í+ú:é; //if é isn't initialized, seek to character '0'
	*$++=é++; //write to string and increase string index
	é+=é==ó-(í*í+í)?(í<<í)-ú:ú-ú; //skip to 'A'
	é+=é==ó+(í<<í<<í)-í*í-ú?í*í+í:ú-ú; //skip to 'a'
	é<í*ó-(í*í)-ú?_($):ú; //keep recursing until end of alphabet
}

CJam , 15 바이트

"{`[@:/"_:,:^\-

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

설명

"{`[@:/" e# Push this string. Note that these are the characters just above and
         e# below the a-z, A-Z and 0-9 ranges, respectively.
_        e# Get a copy of the string.
:,       e# Turn each character into a range, i.e. all characters from the null byte
         e# to the the character below the given one. E.g. { is turned into "...xyz".
:^       e# Fold symmetric set difference over the list. Gives us the characters that
         e# appear in an odd number of the strings. Those are the letters, the digits
         e# as well as `, @ and /.
\        e# Pull the other copy of the string on top.
-        e# Remove these characters from the string. That leaves only the alphanumerics.

𝔼𝕊𝕄𝕚𝕟, 8 문자 / 19 바이트

ᶐ+ᶛ+⩥Ⅹă⬯

여기 사용해보십시오!

ᶐ대문자 알파벳이다 ᶛ소문자 알파벳이고, ⩥Ⅹă⬯범위이다 ( ⩥행) 0을 10( Ⅹ유니 코드 로마 숫자) 마이너스 1(의해 합류 ă) 아무것도 ( ⬯).