첫 번째 문자와 이후의 모든 N 번째 문자를 새 프로그램으로 결합 할 때 출력이 N이되도록 가능한 가장 짧은 프로그램을 작성하십시오. 이것은 N = 1, 2, ..., 16에 대해 작동해야합니다.

또 다른 방법은 프로그램 에서 첫 번째 문자를 제외한 모든 문자 를 제거한 후 나머지 N 번째 문자를 모두 제거 하면 나머지 코드의 출력은 N이어야합니다.

예

코드가

ABCDEFGHIJKLMNOP

N = 1은 결과입니다 ABCDEFGHIJKLMNOP. 이것을 실행하면 1을 출력해야합니다.
N = 2가됩니다 ACEGIKMO. 이것을 실행하면 2가 출력됩니다.
N = 3이됩니다 ADGJMP. 이것을 실행하면 3이 출력
됩니다 AEIM. N = 4가됩니다 . 이것을 실행하면 4가 출력됩니다.
N = 5가됩니다 AFKP. 이것을 실행하면 5가 출력됩니다.
N = 6이됩니다 AGM. 이것을 실행하면 6이 출력됩니다.
N = 7이됩니다 AHO. 이것을 실행하면 7이 출력됩니다.
N = 8이됩니다 AI. 이것을 실행하면 8이 출력
됩니다 AJ. N = 9가됩니다 . 이것을 실행하면 9가 출력
됩니다 AK. N = 10이됩니다 . 이것을 실행하면 10이 출력됩니다.
N = 11이됩니다 AL. 이것을 실행하면 11이 출력됩니다.
N = 12AM. 이것을 실행하면 12가 출력됩니다.
N = 13 결과 AN. 이것을 실행하면 13이 출력
됩니다 AO. N = 14가됩니다 . 이것을 실행하면 14가 출력됩니다.
N = 15가됩니다 AP. 이것을 실행하면 15가 출력됩니다.
N = 16이됩니다 A. 이것을 실행하면 16이 출력됩니다.

세부

• ASCII 및 ASCII가 아닌 모든 문자가 허용됩니다. 줄 바꿈 및 인쇄 할 수없는 ASCII도 허용됩니다. 캐리지 리턴 및 줄 바꿈은 고유 문자로 계산됩니다.
• 점수는 변경되지 않은 프로그램의 문자 길이 입니다 (예 : 15). 가장 낮은 점수가 이깁니다.
• 16 개 미만의 점수는 명백히 불가능하며, 변경된 프로그램 중 2 개 이상이 동일하기 때문입니다.
• 출력은 파일 또는 표준 출력 또는 기타 합리적인 결과 일 수 있습니다. 그러나 16 개의 서로 다른 프로그램의 출력은 모두 같은 위치로 이동해야합니다 (예 : AOstdout으로 이동하지만 A파일로 이동하면 괜찮습니다 ). 입력이 없습니다.
• 출력은 16 진수가 아닌 10 진수 여야합니다. 실제 출력에는 1에서 16까지의 숫자를 구성하는 1 자 또는 2 자만 포함해야합니다. (Matlab과 같은 ans =것은 괜찮습니다.)
• 프로그램은 N = 17 이상에서 작동하지 않아도됩니다.

APL, 49

⌊⊃⍟○7⍟⍟1|/2111118 9⍝×-1 ×○3×4_5_×   1_   _⍝_⍝ __2

변경된 프로그램

1  ⌊⊃⍟○7⍟⍟1|/2111118 9⍝×-1 ×○3×4_5_×   1_   _⍝_⍝ __2
2  ⌊⍟7⍟|21189×1×345× 1  ⍝⍝_2
3  ⌊○⍟/119-××5 1 ⍝ 2
4  ⌊7|18××4×1 ⍝2
5  ⌊⍟21×○5   
6  ⌊⍟19×51⍝2
7  ⌊11-4 ⍝
8  ⌊|8×× 2
9  ⌊/9×1 
10 ⌊2×5 
11 ⌊11 ⍝
12 ⌊1×12
13 ⌊13 
14 ⌊14⍝
15 ⌊15 
16 ⌊8×2

설명

설명을 쉽게하기 위해 아래부터 시작하겠습니다.

명심해야 할 APL의 두 가지 언어 기능이 있습니다. 하나, APL은 연산자 우선 순위가 없으며 명령문은 항상 오른쪽에서 왼쪽으로 평가됩니다. 둘째, 많은 APL 함수는 오른쪽에 하나의 인수 (모노 딕) 또는 왼쪽 과 오른쪽 에 두 개의 인수 (이차)가 제공되는지에 따라 상당히 다르게 작동합니다 .

Monadic ⌊은 반올림 (바닥 함수), Dyadic ×은 분명히 곱셈입니다. ⍝나머지 줄은 주석 처리합니다
.

16 ⌊8×2
15 ⌊15 
14 ⌊14⍝
13 ⌊13 
12 ⌊1×12
11 ⌊11 ⍝
10 ⌊2×5 

9 :⌊/9×1
/ 감소입니다. 기본적으로 왼쪽과 오른쪽의 배열 기능을 수행하고 배열의 모든 요소 쌍 사이에 함수를 삽입하고 평가하십시오. (이것은 일부 언어에서는 "fold"라고합니다.)
여기서 올바른 인수는 스칼라이므로 /아무 것도하지 않습니다.

8 :⌊|8×× 2
단항이 ×는 IS 시그넘 함수 와 모나드는 |때문에 절대 값 함수 × 2로 평가 1하고 |8×1물론이다8

7 :⌊11-4 ⍝ 분명해야한다

6 :⌊⍟19×51⍝2
Monadic ⍟은 자연 로그
이므로로 ⍟19×51평가 ln(19×51) = 6.87626...하고 ⌊반올림합니다.6

5 :⌊⍟21×○5
단항 ○π 의해 인수가 곱
⍟21×○5이며ln(21×5π) = 5.79869...

4 :⌊7|18××4×1 ⍝2
이항은 |유행의 함수이다
×4×1평가 1하고 7|18×1있다18 mod 7 = 4

3 :⌊○⍟/119-××5 1 ⍝ 2
공백으로 구분 된 값은 배열입니다. APL에서 대부분의 스칼라 함수가 배열 인수를 제공하면 내재 된 맵입니다.
이항은 ⍟로그입니다
그래서를 ××5 1준다 5 일에 부호 요소의 부호 요소이다 1 1, 119-1 1있다가 ¯118 ¯118( ¯APL은 음수과 뺄셈을 구별 할 수있다. 다만 마이너스 기호입니다), 그리고 ⍟/¯118 ¯118인 로그 _-118 (-118) = 1

2 :⌊⍟7⍟|21189×1×345× 1 ⍝⍝_2
스스로 해결할 수 있습니다

1 :⌊⊃⍟○7⍟⍟1|/2111118 9⍝×-1 ×○3×4_5_× 1_ _⍝_⍝ __2
이것은보다 복잡한 사용으로 구성됩니다 /. 경우 n다수가, F함수이며, A그리고, 배열 nF/A의 각각의 그룹 얻어 n연속 항목 A및 적용 F/. 예를 들어, 2×/1 2 3각 연속 항목 쌍 ( 1 2및 2 3)을 가져 와서 각 ×/그룹에 적용 하여 2 6
So 를 제공 하면 스칼라에 적용 되는대로 1|/2111118 9반환 2111118 9됩니다 |/. 그런 다음 ⍟○7⍟⍟ln을 적용한 다음 이 숫자에 ₇ 을 로그 한 다음 π와 ln을 다시 곱합니다. 반대쪽에 나오는 숫자는 1.46424... 0.23972...
여기, ⊃배열의 첫 번째 요소를 선택하는 데 사용됩니다.

Python- 1201 1137 (제너레이터 : 241 218)-해시가 오래 지속됩니다!

전략:

원하는 출력만큼 ​​많은 해시로 모든 줄을 시작하려고했습니다 n. 그런 다음 다른 모든 버전은이 줄을 완전히 건너 뜁니다.

그러나 가장 어려운 점은 올바른 수의 해시를 추가하여 다음 실행이 다음 행의 시작 부분에 정확하게 닿도록하는 것이 었습니다. 또한 다른 버전과의 간섭이 발생할 수 있습니다 (예 : 버전 16 print이 라인 5 의 명령으로 바로 이동하는 등) . 그래서 이것은 빠른 테스트를 위해 도우미 스크립트와 결합 된 많은 시행 착오였습니다.

통계:

• 캐릭터 : 1201 1137
• 해시 : 1066 1002 (88.1 %)
• 비해시 : 135 (11.9 %)

암호:

#
print 1#####
#p#r#i#n#t# #2######################
##p##r##i##n##t## ##3###
###p###r###i###n###t### ###4
####p####r####i####n####t#### ####5#########
#####p#####r#####i#####n#####t##### #####6##########
######p######r######i######n######t###### ######7###########
#######p#######r#######i#######n#######t####### #######8###
########p########r########i########n########t######## ########9##
#########p#########r#########i#########n#########t######### #########1#########0##
##########p##########r##########i##########n##########t########## ##########1##########1##
###########p###########r###########i###########n###########t########### ###########1###########2##
############p############r############i############n############t############ ############1############3##
#############p#############r#############i#############n#############t############# #############1#############4##
##############p##############r##############i##############n##############t############## ##############1##############5##
###############p###############r###############i###############n###############t############### ###############1###############6

테스트 스크립트 :

with open('printn.py', 'r') as f:
    c = f.read()

for n in range(1, 17):
    print "n =", n, "yields",
    exec c[::n]

산출:

n = 1 yields 1
n = 2 yields 2
n = 3 yields 3
n = 4 yields 4
n = 5 yields 5
n = 6 yields 6
n = 7 yields 7
n = 8 yields 8
n = 9 yields 9
n = 10 yields 10
n = 11 yields 11
n = 12 yields 12
n = 13 yields 13
n = 14 yields 14
n = 15 yields 15
n = 16 yields 16

업데이트 : 생성 스크립트!

내 솔루션에 대해 생각했으며 알고리즘을 생성하는 패턴이 있어야한다고 생각했습니다. 그래서 우리는 간다 :

lines = ['#']
for i in range(1, 17):
    lines.append(('#' * (i - 1)).join('\nprint ' + `i`))
    fail = True
    while fail:
        while ''.join(lines)[::i].find('print ' + `i`) < 0:
            lines[i] = '#' + lines[i]
        fail = False
        for n in range(1, 17):
            try:
                exec ''.join(lines)[::n]
            except:
                lines[i] = '#' + lines[i]
                fail = True
                break
print ''.join(lines)

프로그램을 한 줄씩 작성합니다.

1. 해시로 시작하십시오.
2. 명령 으로 새 줄 i을 추가하고 두 인접 문자 사이에 해시를 추가하십시오 .print ii - 1
3. 현재 프로그램의 "i-version"(모든 i 번째 문자)에 명령이 포함되어 있지 않거나 print i(잘못된 정렬로 인해) 예외가 발생 하는 n-version이 있으면 n in range(1, 17)이전 행에 다른 해시를 추가하십시오.

실제로 오늘 아침에 수동으로 찾은 것보다 짧은 프로그램을 반환했습니다. (따라서 위의 솔루션을 업데이트했습니다.) 또한이 패턴 다음에 더 짧은 구현이 없다고 확신합니다. 그러나 당신은 모른다!

Golfed 버전 - (241) 218 :

h='#';L=[h];I=range(1,17);J=''.join
for i in I:
 p='print '+`i`;L+=[(h*(i-1)).join('\n'+p)]
 while 1:
  while J(L)[::i].find(p)<0:L[i]=h+L[i]
  try:
   for n in I:exec J(L)[::n]
   break
  except:L[i]=h+L[i]
print J(L)

예를 들어, 각 라인에 필요한 수의 후속 해시를 하드 코딩하여 생성기가 더 짧을 수 있습니다. 그러나 이것은 스스로 계산하고 N> 16에 사용될 수 있습니다.

Befunge 93-5 백만 칠 십육 만 칠십 오만 칠십 육십 자

나는 진지하게 받아 들일 것을 요구합니다 ...

v                                                                               &(720 720 - 80) X SPACE
""""""""""""""""                                                                &(720 720 - 80) X SPACE
1234567890123456                                                                &(720 720 - 80) X SPACE
"""""""""1111111                                                                &(720 720 - 80) X SPACE
,,,,,,,,,"""""""                                                                &(720 720 - 80) X SPACE
@@@@@@@@@,,,,,,,                                                                &(720 720 - 80) X SPACE
         ,,,,,,,                                                                &(720 720 - 80) X SPACE
         @@@@@@@                                                                &(720 720 - 80) X SPACE

3 가지 이유. 첫 번째 이유 : befunge 스크립트는 항상 80x25이므로 무엇이든간에 코드가 줄어드는 것이 있어야합니다. 두 번째 이유 : 왜 약 550 만 개의 공백이 있는지 720 720은 1에서 16의 가장 작은 공통 배수이기 때문입니다 ... 문자를 건너 뛸 때 혼란을 감쌀 수는 없습니다. 세 번째 이유 : 와우, 이것은 터무니없는 것입니다.

209 자 (다양한 언어)

방금 일을 단순하게 유지하고 많은 주요 요소가있는 위치에 물건을 두지 마십시오. 많은 스크립팅 언어로 실행할 수 있다는 장점이 있습니다. 의도적으로 왜곡되지 않고 다음과 같은 기능이있는 언어로 작동해야합니다.

• 정수 리터럴
• 기본 산술 연산자 +,-(빼기 및 부정), *, /
• 베어 표현의 평가를 인쇄합니다
• 행 주석을 시작하는 단일 문자가 있습니다

예를 들어

파이썬 2 명령 줄 인터프리터 (파일은 아니지만) :

+                1 #            4 /   23      #    #   5            #            9   #            7   6 *         #    # -        5     2   *  -        ##  2        6   #2                     *   2       6   4

MATLAB ( '#'을 '%'로 간단히 대체) :

                 1 %            4 /   23      %    %   5            %            9   %            7   6 *         %    % -        5     2   *  -        %%  2        6   %2                     *   2       6   4

NB 첫 번째 '1'앞에 17 개의 공백이 있어야합니다. 많은 언어를 알고 있으므로 (: :

편집 : 줄 들여 쓰기를 피하기 위해 Python의 위치 0에 단항 +를 추가했습니다.

CJam, 89 바이트

GiiAHH(5A5(7ii)ii;(;(-i((i(-i)i)ii)i()i((i(i(iiii(iii(iiiii(iiiii(i-i(iiiiiii(ii(ii(-ii-

이 접근법은 어떤 종류의 주석도 사용하지 않습니다.

i정수로 캐스트되므로 여기는 noop입니다. 공백으로 대체 될 수 있지만 문자는 더 읽기 쉽습니다.

다음 코드 를 실행하여 온라인 으로 사용해보십시오 .

G,{)
"GiiAHH(5A5(7ii)ii;(;(-i((i(-i)i)ii)i()i((i(i(iiiii(iii(iiiii(iiiii(i-i(iiiiiii(ii(ii(-ii-"
%_~}%N*

예제 실행

$ cat nth-char.cjam 
G,{)"GiiAHH(5A5(7ii)ii;(;(-i((i(-i)i)ii)i()i((i(i(i
iii(iii(iiiii(iiiii(i-i(iiiiiii(ii(ii(-ii-"%_~}%N*N
$ cjam nth-char.cjam 
GiiAHH(5A5(7ii)ii;(;(-i((i(-i)i)ii)i()i((i(i(i
iii(iii(iiiii(iiiii(i-i(iiiiiii(ii(ii(-ii-
1
GiH(A(i)i((i((iii)(i(((
i(i(ii(ii(-(iii(ii(i-
2
GA(5ii(-(-ii(((iii(i(i(iii(((i
3
GHAii((ii(((iii(i-iii(-
4
GH(i(iii(i(i(i(ii-
5
G(i((i((i(((i((
6
G5)-ii(iii(i(
7
GAi(i(iiiii-
8
G5(-(i(ii(
9
G((i((((i
10
G7ii(i(i-
11
Gi((i(i(
12
Gi((ii(
13
G)i(i((
14
Giii(i
15
Giiiii
16

GolfScript, 61 바이트

1})_#;#;;00123358_(_};}_}_}} _}_(__6
_})4_)_+)__(__}__;_}___6

이것은 주석 ( #)과 문서화되지 않은 "슈퍼-코멘트"를 활용합니다 (매칭되지 않은 이후의 모든 }것은 자동으로 무시됩니다).

_noop입니다. 공백으로 바꿀 수 있지만 밑줄은 더 읽기 쉽습니다.

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

예제 실행

$ cat nth-char.gs
16,{)"1})_#;#;;00123358_(_};}_}_}} _}_(__6
_})4_)_+)__(__}__;_}___6"\%.~}%n*
$ golfscript nth-char.gs
1})_#;#;;00123358_(_};}_}_}} _}_(__6
_})4_)_+)__(__}__;_}___6
1
1)##;0238(}}}} }(_
}4)+_(__;}_6
2
1_#025(;}}}_
)))(};_6
3
1#;28}} (
4+(_}6
4
1;05}_}64)__6
5
1#2(}}
)(;6
6
1;3; 6)_}
7
1;8}(4(}
8
10(}
);
9
10}}4_6
10
11}_+_
11
12}
(6
12
13})_
13
13 )}
14
15})6
15
18((
16