이것은 강도의 실입니다. 경찰의 실 이 여기로갑니다 .

경찰 포스트와 동일한 바이트 수를 가지며 공개 된 문자가 동일한 코드를 작성하십시오. 코드는 1초기 상태로 생성해야하며 2, 3 ..단일 변경시 숫자를 생성해야합니다 .

우승자는 가장 많은 게시물을 해독 한 강도가됩니다.

게시물 예 :

MyLang, 9 바이트, 8 자리 숫자 (응답 링크 포함), 경찰 사용자 이름.

원본 코드 :

abc1efghi

1-8을 생성하는 코드

1: abc1efghi
2: abc2efghi
3: abc2efghij
4: kbc2efghij
5: kbc23fghij
6: kbc23fghi
7: kbc63fghi
8: kbc63fhi

설명이 권장됩니다. 강도 게시물의 정확한 형식은 선택 사항입니다.

망막, 2에 의해, 10 개 번호를 바이트 마틴 청산 .

원본 코드 :

1

이것은 빈 입력을 숫자 1로 대체합니다.

1-10을 생성하는 코드 ( \n편리 성과 관련하여 줄 바꿈 표시 ) :

1 : \n1
2 : \n1\n
3 : \n11\n
4 : \n111\n
5 : \n1111\n
6 : \n11111\n
7 : \n111111\n
8 : \n1111111\n
9 : \n11111111\n
10: \n111111111\n

2 이상에서는 이전 단계에서 빈 문자열의 수를 계산합니다. 2의 경우 1 앞뒤에 빈 문자열이 있습니다. 3의 경우 앞과 뒤에 빈 문자열이 있습니다. 이것은 최대 10까지 작동합니다.

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

Peris , 12 바이트, 10 자리, ais523

원본 코드 :

____;say__-9

1-10을 생성하는 코드 :

wait;say$!-9
wait;say$!-8
wait;say$!-7
wait;say$!-6
wait;say$!-5
wait;say$!-4
wait;say$!-3
wait;say$!-2
wait;say$!-1
wait;say$!-0

설명:

wait;         # waits for a child process to end (there is no child so it just returns)
     say      # put the following on the screen:
        $!    # current value of the C errno. In this case, ECHILD (No child processes)
              # which has a value of 10
          -9  # minus 9

자바 스크립트 (30)에 의해, 10 개 번호를 바이트 ETHproductions .

원본 코드 :

1: alert(Array(2).join(3).length)

다른 번호

 2: alert(Array(2).join(31).length)
 3: alert(Array(2).join(314).length)
 4: alert(Array(2).join(3141).length)
 5: alert(Array(2).join(31415).length)
 6: alert(Array(2).join(314159).length)
 7: alert(Array(2).join(3141592).length)
 8: alert(Array(2).join(31415926).length)
 9: alert(Array(2).join(314159265).length)
10: alert(Array(2).join(3141592653).length)

설명

Array(2)두 개의 빈 셀이있는 배열을 만듭니다. 이 .join메서드는 구분자를 사용하여 Array의 모든 요소를 ​​조인하여 String으로 변환합니다. 원본 코드에서 구분 기호는 3입니다. 이것은 배열에있는 두 개의 빈 셀 3이 분리 문자로 사용 되어 결합되었음을 의미합니다 . 이 배열은 비어 있기 때문에의 "3"양쪽에 아무것도없이 평가 3됩니다. 그리고 이후 length의가 "3"있다 1,이 값은 콘솔에 출력된다.

다른 숫자의 경우 배열의 요소를 결합하는 구분 기호에 1 자리를 더 추가합니다. 따라서 길이 alert가 길어지고 값 이 커집니다 . 구분 기호의 숫자 값은 중요하지 않으며 길이 만 중요합니다.

스낵 스 니펫!

참고 : 명백한 이유로 스낵 스 니펫 console.log대신에 사용 했습니다 alert. 또한 콘솔의 출력이 스 니펫에 표시됩니다.

console.log(Array(2).join(3).length)
console.log(Array(2).join(31).length)
console.log(Array(2).join(314).length)
console.log(Array(2).join(3141).length)
console.log(Array(2).join(31415).length)
console.log(Array(2).join(314159).length)
console.log(Array(2).join(3141592).length)
console.log(Array(2).join(31415926).length)
console.log(Array(2).join(314159265).length)
console.log(Array(2).join(3141592653).length)

Stewie Griffin의 옥타브, 17 바이트, 10 자리

original:
_i_(__i__(2_5_))

solution:
fix( 'i'-(2*52))
fix( 'j'-(2*52))
fix( 'k'-(2*52))
fix( 'l'-(2*52))
fix( 'm'-(2*52))
fix( 'n'-(2*52))
fix( 'o'-(2*52))
fix( 'p'-(2*52))
fix( 'q'-(2*52))
fix( 'r'-(2*52))

xnor 에 의한 Python 2, 17 바이트, 10 숫자

print len(['  '])
print len(*['  '])
print len(*['   '])
print len(*['    '])
print len(*['     '])
print len(*['      '])
print len(*['       '])
print len(*['        '])
print len(*['         '])
print len(*['          '])

반복

파이썬 2, 9 바이트, 10 숫자, xnor

print 8/8
print 18/8
print 28/8
print 38/8
print 38/7
print 38&7
print 31&7
print 31&72
print 31&73
print 31&74

Dada의 Perl, 14 바이트, 10 자리

원본 코드 :

say_!"___"%""_

1-10을 생성하는 코드 :

1. say"!"+1#"%""r
2. say"!"+2#"%""r
3. say"!"+3#"%""r
4. say"!"+4#"%""r
5. say"!"+5#"%""r
6. say"!"+6#"%""r
7. say"!"+7#"%""r
8. say"!"+8#"%""r
9. say"!"+9#"%""r
10. say"1"+9#"%""r

나는 이것이 당신이 원하는 것이 아니라고 생각합니다.

Arnauld의 JavaScript, 22 바이트, 10 자리

오리지널 프로그램 :

alert(0_6_4_>_0_2_0_7)

깨진:

1. alert(0+6^42>101210^7)
2. alert(0+5^42>101210^7)
3. alert(0+4^42>101210^7)
4. alert(0+3^42>101210^7)
5. alert(0+2^42>101210^7)
6. alert(0+1^42>101210^7)
7. alert(0+0^42>101210^7)
8. alert(0+0^42>101210^8)
9. alert(0+0^42>101210^9)
10. alert(0+3^42>101210^9)

어려운 부분은 >우선 순위가 매우 낮은 을 처리하는 것 입니다. 나는 그것을로 변경하려고 시도했지만 >>, 42>101210숫자 0 인 부울 거짓 ( 섹션)을 쓸데없이 계산하여 흡수하는 것이 가장 쉽고 우선 순위가 더 낮은 연산자로 1에서 10까지의 숫자를 생성합니다 >. 내가 사용 ^은 비교적 쉽게 1에서 10까지의 숫자를 생성 할 수 있기 때문에, 비트 XOR을 (편리, 원래의 입력에서 6과 7은 저 아래에 표현 간단하게 6^71 인을).

자바 스크립트, 9 바이트, Hedi

원본 코드 :

alert(+1)

수정 :

alert(1+1)   // 2
alert(2+1)   // 3
alert(3+1)   // 4
alert(4+1)   // 5
alert(5+1)   // 6
alert(6+1)   // 7
alert(7+1)   // 8
alert(8+1)   // 9
alert(9+1)   // 10

옥타브, 55 바이트, 10 자리, flawr

(o=@(O,o)(@(O,o)o{2-O} ) (0<O,{ (yo=O-1)+1,@()1}))(1,o)

마지막은 19까지 순환 한 후 변경 될 수 있습니다 +1로 +2.

Sp3000 에 의한 Python 3, 16 바이트, 10 자리

재미있었습니다.

print(?%??f?r?t)

print(1%0xfor t)
print(2%0xfor t)
...
print(8%0xfor t)
print(84%0xfor t)
print(85%0xfor t)

헥스 리터럴 끝으로 빨리되지 않는 문자 것을 (나는 지금까지 몰랐) 사실을 악용 0-9a-fA-F하여 - 발생이 0xfor쓰기에 아주 비열한 방법입니다 15 or. 그 후, 10 모듈로 15에 적합한 올바른 값을 찾는 것이 문제였습니다.

Arnauld의 JavaScript, 22 바이트, 10 자리 숫자

원본 코드 :

alert(__14_337__xc_de)

수정 :

alert(00140337-0xc0de) // 1
alert(00140337-0xc0dd) // 2
alert(00140337-0xc0dc) // 3
alert(00140337-0xc0db) // 4
alert(00140337-0xc0da) // 5
alert(00140337-0xc0d9) // 6
alert(00140337-0xc0d8) // 7
alert(00140337-0xc0d7) // 8
alert(00140337-0xc0d6) // 9
alert(00140337-0xc0d5) // 10

나는 이것이 의도 된 해결책이 아니라고 생각하지만 너무 멀지 않기를 바라고 있습니다 ...

Luis Mendo의 옥타브, 32 바이트, 10 자리

원본 코드 :

nnz(isprime(floor(s=3):i*-2i))+1

수정 된 코드 :

2:  nnz(isprime(floor(s=3):i*-3i))+1
3:  nnz(isprime(floor(s=3):i*-5i))+1
4:  nnz(isprime(floor(s=3):i*-9i))+1
5:  nnz(isprime(floor(s=3):i*-9i))+2
6:  nnz(isprime(floor(s=3):i*-9i))+3
7:  nnz(isprime(floor(s=3):i*-9i))+4
8:  nnz(isprime(floor(s=3):i*-9i))+5
9:  nnz(isprime(floor(s=3):i*-9i))+6
10: nnz(isprime(floor(s=3):i*-9i))+7

(예를 들어 여기에 수정하게하는 방법에는 여러 가지가 있습니다 s=2그리고 +0처음에이).

편집 : 더 가능한 대안 :

nnz(isprime(floor(s=2):i*-2i))+0
nnz(isprime(floor(s=2):i*-2i))+1
nnz(isprime(floor(s=2):i*-2i))+2
nnz(isprime(floor(s=2):i*-2i))+3
nnz(isprime(floor(s=2):i*-2i))+4
nnz(isprime(floor(s=2):i*-2i))+5
nnz(isprime(floor(s=2):i*-2i))+6
nnz(isprime(floor(s=2):i*-2i))+7
nnz(isprime(floor(s=2):i*-2i))+8
nnz(isprime(floor(s=2):i*-2i))+9

05AB1E , 11 바이트, 10 개 숫자에 의해 올리버

원본 코드 :

 1: 3628801zï0>

다른 번호

 2: 3628801zï0>>
 3: 3628801zï0>>>
 4: 3628801zï0>>>>
 5: 3628801zï0>>>>>
 6: 3628801zï0>>>>>>
 7: 3628801zï0>>>>>>>
 8: 3628801zï0>>>>>>>>
 9: 3628801zï0>>>>>>>>>
10: 3628801zï0>>>>>>>>>>

설명

3628801                        # push this number
       z                       # find its reciprocal
        ï                      # round it to the nearest integer (becomes 0)
         0                     # push 0
          >>>>                 # increment by 1 for each `>` present (this is for 4)
                               # implicit output

이를 요약하려면을 3628801누르고 역수를 취하고 가장 가까운 정수로 반올림합니다 (평가 0). 그런 다음 스택을 늘리십시오. 타다!

온라인으로 사용해보십시오! 출력 = 1의 경우 출력 >하려는 숫자에 따라 원하는만큼을 추가하십시오 .

자바 스크립트, 12 바이트, 10 자리, Hedi

원본 코드 :

alert(+[+1])

2 ~ 10 :

alert(+[1+1])
alert(+[2+1])
alert(+[3+1])
alert(+[4+1])
alert(+[5+1])
alert(+[6+1])
alert(+[7+1])
alert(+[8+1])
alert(+[9+1])

이 많은 코드로 할 수있는 일이 너무 많습니다 ...

젤리, 7 바이트, 10 자리, Jonathan Allan

원본 코드 :

“1‘ỌȮḊ‘

그때:

“1‘‘ỌȮḊ‘
“1‘‘‘ỌȮḊ‘
“1‘‘‘‘ỌȮḊ‘
“1‘‘‘‘‘ỌȮḊ‘
“1‘‘‘‘‘‘ỌȮḊ‘
“1‘‘‘‘‘‘‘ỌȮḊ‘
“1‘‘‘‘‘‘‘‘ỌȮḊ‘
“1‘‘‘‘‘‘‘‘‘ỌȮḊ‘
“1‘‘‘‘‘‘‘‘‘ỌvḊ‘

TryItOnline 에서 마지막을 확인할 수 있습니다 !

“2‘ỌȮḊ‘
“3‘ỌȮḊ‘
...
“9‘ỌȮḊ‘
“9‘ỌvḊ‘

Stewie Griffin의 옥타브, 21 바이트, 10 자리

는 fpr= 멋진 그릇된했다)하지만 난 사랑 (1') -> 2(1') -> 2+(1')순서를!

original:
disp(fpr___f__e_(_'_)     % original
disp(fprintf= e=(1'))     % my solution
disp(fprintf= e=2(1'))
disp(fprintf= e=2+(1'))
disp(fprintf= e=3+(1'))
disp(fprintf= e=4+(1'))
disp(fprintf= e=5+(1'))
disp(fprintf= e=6+(1'))
disp(fprintf= e=7+(1'))
disp(fprintf= e=8+(1'))
disp(fprintf= e=9+(1'))

Martin Ender의 Hexagony, 7 바이트, 10 자리

기발한:

1<@|!__

1-10을 생성하는 코드 :

1<@|!).
2<@|!).
3<@|!).
4<@|!).
5<@|!).
6<@|!).
7<@|!).
8<@|!).
9<@|!).
9<@|!).!

1 : 온라인으로 사용해보십시오!
9 : 온라인으로 사용해보십시오!
10 : 온라인으로 사용해보십시오!

처음 9 개 프로그램의 16 진수는 다음과 같습니다 (여기서 #은 인쇄하려는 숫자입니다).

 # <
@ | !
 ) .

메모리 가장자리는 인쇄하려는 값으로 설정되어 SE로 편향되어 인쇄됩니다.

그리고 16 진수 :

  9 < @
 | ! ) .
! . . . .
 . . . .
  . . . 

여기에 문자를 추가하여 16 진수 크기를 늘 렸습니다. 먼저 메모리 에지가 9로 설정되고 포인터가 SE로 편향되고 메모리가 증가하고 줄 바꿈되며 포인터가 SW로 편향되고 값이 인쇄되고 프로그램이 종료됩니다.

두 번째 해결책은 다음과 같습니다.

1<@|!$)
2<@|!$)
3<@|!$)
...
8<@|!$)
9<@|!$)
9#@|!$)

1 : 온라인으로 사용해보십시오!
9 : 온라인으로 사용해보십시오!
10 : 온라인으로 사용해보십시오!

1-9의 16 진수 (이번 *은 인쇄 할 숫자입니다) :

 * <
@ | !
 $ )

이것은 위의 1-9와 동일하게 작동합니다.

10 진수 :

 9 #
@ | !
 $ )

이 명령을 누르면 명령 포인터가 오른쪽 아래 9로 #전환되고 메모리가 10으로 증가 $하고을 뛰어 넘고 !포인터가 동쪽으로 되돌아 가서 건너 뛰고 )끝납니다.

C #, 90 바이트, 10 자리, Scepheo

기발한:

using ______________________________________________;class C{static void Main(){_______;}}

먼저:

using System;class D{public D(){Console.Write(+1);}};class C{static void Main(){new D();}}

그때:

using System;class D{public D(){Console.Write(1+1);}};class C{static void Main(){new D();}}
using System;class D{public D(){Console.Write(2+1);}};class C{static void Main(){new D();}}
using System;class D{public D(){Console.Write(3+1);}};class C{static void Main(){new D();}}
using System;class D{public D(){Console.Write(4+1);}};class C{static void Main(){new D();}}
using System;class D{public D(){Console.Write(5+1);}};class C{static void Main(){new D();}}
using System;class D{public D(){Console.Write(6+1);}};class C{static void Main(){new D();}}
using System;class D{public D(){Console.Write(7+1);}};class C{static void Main(){new D();}}
using System;class D{public D(){Console.Write(8+1);}};class C{static void Main(){new D();}}
using System;class D{public D(){Console.Write(9+1);}};class C{static void Main(){new D();}}

루비, 81 바이트, 10 자리, histocrat

원본 코드 :

x=##/=#%#
)
###x

깨진:

x=/$/=~%q
)

p x

이것은 까다로운 일이었습니다. 밝혀진 많은 인물들이 붉은 청어로 밝혀졌습니다! /분할이 아니라 정규 표현식 리터럴의 일부입니다. %모드가 아니지만 드문 문자열 리터럴 구문의 일부입니다. 이 프로그램은 단순히 줄 바꿈으로 구분 된 문자열의 길이를 인쇄합니다. 후속 프로그램은 두 번째 줄에 추가 문자를 삽입하여 얻을 수 있습니다.

Luis Mendo의 옥타브, 25 바이트, 10 자리

mean(repmat(1,ones(1,1)))
mean(repmat(2,ones(1,1)))
mean(repmat(3,ones(1,1)))
mean(repmat(4,ones(1,1)))
mean(repmat(5,ones(1,1)))
mean(repmat(6,ones(1,1)))
mean(repmat(7,ones(1,1)))
mean(repmat(8,ones(1,1)))
mean(repmat(9,ones(1,1)))

아희 (Aheui), 19 바이트, 10 자리, JHM

원본 코드 :

봃法희
반자뭉

수정 :

2
봃法희
반반뭉
3
봃法희
반밬뭉
4
봃法희
반밭뭉
5
봃法희
반발뭉
6
봃法희
반타뭉
7
봃法희
반밝뭉
8
봃法희
반밣뭉
9
봃法희
반밢뭉
10
봃法희
반다뭉

flawr 에 의한 옥타브, 24 바이트, 9 자리

max(repmat(1,ones(),1))%
max(repmat(2,ones(),1))%
max(repmat(3,ones(),1))%
max(repmat(4,ones(),1))%
max(repmat(5,ones(),1))%
max(repmat(6,ones(),1))%
max(repmat(7,ones(),1))%
max(repmat(8,ones(),1))%
max(repmat(9,ones(),1))%

옥타브, 24 바이트 9 10 자리

참고 :이 균열은 공개 된 코드가 다음과 같은 경찰 게시물의 첫 번째 버전 (잘못된 스 니펫 게시)에 대한 것 ___a__repmat(__one__),__)입니다. 올바른 버전이 위에 있습니다.

원본 코드 :

+mean(repmat(1,ones(),1))

2-10을 인쇄하는 수정 된 버전

1+mean(repmat(1,ones(),1))
2+mean(repmat(1,ones(),1))
3+mean(repmat(1,ones(),1))
4+mean(repmat(1,ones(),1))
5+mean(repmat(1,ones(),1))
6+mean(repmat(1,ones(),1))
7+mean(repmat(1,ones(),1))
8+mean(repmat(1,ones(),1))
9+mean(repmat(1,ones(),1))

자바 스크립트, 15 바이트, 10 자리, ETHProductions

원본 코드 :

alert( +"+1"+0)  // Prints 1

프로그램 :

alert( +"+1"+1)  // Prints 2
alert( +"+1"+2)  // Prints 3
alert( +"+1"+3)  // Prints 4
alert( +"+1"+4)  // Prints 5
alert( +"+1"+5)  // Prints 6
alert( +"+1"+6)  // Prints 7
alert( +"+1"+7)  // Prints 8
alert( +"+1"+8)  // Prints 9
alert( +"+1"+9)  // Prints 10

flawr 에 의한 옥타브, 21 바이트, 9 자리

나는 이것을 정말로 즐겼다 ​​... 영리한 :)

a='repmat(1one'(1,8)
a='repmat(2one'(1,8)
a='repmat(3one'(1,8)
a='repmat(4one'(1,8)
a='repmat(5one'(1,8)
a='repmat(6one'(1,8)
a='repmat(7one'(1,8)
a='repmat(8one'(1,8)
a='repmat(9one'(1,8)

Acc !! DLosc 에 의한, 10 바이트, 9 자리

원본 코드 :

Write 49+_

1에서 9까지의 숫자를 생성하려면

Write 49+_
Write 49+1
Write 49+2
Write 49+3
Write 49+4
Write 49+5
Write 49+6
Write 49+7
Write 49+8

49는의 ASCII 코드입니다 1. _기본적으로 0을 포함합니다 (so 49+_ = 1). 그리고 Write인수의 ASCII 코드에 해당하는 문자를 인쇄합니다. 꽤 직설적 인.

Python 2, 49 바이트, 10 자리, AlexRacer

어쩌면 (아마도) 의도 한 솔루션 일 것입니다. 그렇다면 많은 바이트가 골퍼되었습니다.

y=10-6;s='0901100000';print int(s[8-8+y-2+0+0:y])
y=10-6;s='0902100000';print int(s[8-8+y-2+0+0:y])
y=10-6;s='0903100000';print int(s[8-8+y-2+0+0:y])
y=10-6;s='0904100000';print int(s[8-8+y-2+0+0:y])
y=10-6;s='0905100000';print int(s[8-8+y-2+0+0:y])
y=10-6;s='0906100000';print int(s[8-8+y-2+0+0:y])
y=10-6;s='0907100000';print int(s[8-8+y-2+0+0:y])
y=10-6;s='0908100000';print int(s[8-8+y-2+0+0:y])
y=10-6;s='0909100000';print int(s[8-8+y-2+0+0:y])
y=10-4;s='0909100000';print int(s[8-8+y-2+0+0:y])

Befunge-93 , 11 바이트, 10 자리, James Holderness

905:**-8-.@
905:**-7-.@
905:**-6-.@
905:**-5-.@
905:**-4-.@
905:**-3-.@
905:**-2-.@
905:**-1-.@
905:**-0-.@
905:**-~-.@

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

아마도 의도 된 해결책이 아닙니다.

내가 한 것은 성가신 25 5:*를 곱하여 제거 했다 0. 우리가 다음9 시작 부분 출력이 단일 명령에서 9 - N생성 되어야하는 위치에있게됩니다 N. 유일한 문제는 -1get 10이지만 입력이 없으면 정수를 읽으려고하면 a가 편리합니다 -1.

05AB1E, 5 바이트, 10 자리 아드 난 .

원본 코드 :

…[==1

1-10 :

…[==1
…[==2
…[==3
…[==4
…[==5
…[==6
…[==7
…[==8
…[==9
…[==T

설명:

…[==   3 char string
    1  Push number

05AB1E, 6 바이트, 10 자리, Adnan

원본 코드 :

¼ [==q

¼를 10 개까지 출력 하려면를 계속 추가하십시오 .

¼¼ [==q
¼¼¼ [==q
¼¼¼¼ [==q
¼¼¼¼¼ [==q
¼¼¼¼¼¼ [==q
¼¼¼¼¼¼¼ [==q
¼¼¼¼¼¼¼¼ [==q
¼¼¼¼¼¼¼¼¼ [==q
¼¼¼¼¼¼¼¼¼¼ [==q

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

작동 방식 :

¼        # Increment counter_variable to count_of(¼), it's printed at some point...
  [      # Infinite loop start
   ==    # Print nothing because stack is empty
     q   # Quit