เขียนโปรแกรมที่สั้นที่สุดเท่าที่จะเป็นไปได้เช่นเมื่อคุณรวมอักขระตัวแรกและอักขระ Nth ทุกตัวลงในโปรแกรมใหม่เอาต์พุตจะเป็น N ซึ่งต้องใช้กับ N = 1, 2, ... , 16

อีกวิธีหนึ่งที่จะกล่าวคือถ้าคุณลบอักขระทั้งหมดออกจากโปรแกรมของคุณยกเว้นตัวอักษรตัวแรกและตัวที่ Nth ทุกตัวหลังจากนั้นผลลัพธ์ของรหัสที่เหลือควรเป็น N

ตัวอย่าง

หากรหัสของคุณคือ

ABCDEFGHIJKLMNOP

N = 1 ABCDEFGHIJKLMNOPผลลัพธ์ใน เล่นนี้ควรเอาท์พุท 1.
ไม่มีผล = 2 ACEGIKMOใน เล่นนี้ควรเอาท์พุท 2.
N = 3 ADGJMPผลใน เล่นนี้ควรเอาท์พุท 3.
N = 4 AEIMผลใน เล่นนี้ควรเอาท์พุท 4.
ไม่มีผล = AFKP5 เล่นนี้ควรเอาท์พุท 5.
ไม่มีผล = 6 AGMใน เล่นนี้ควรเอาท์พุท 6.
N = 7 AHOผลใน เล่นนี้ควรเอาท์พุท 7.
ไม่มีผล = 8 AIใน เล่นนี้ควรเอาท์พุท 8.
N = 9 AJผลใน เล่นนี้ควรเอาท์พุท 9.
ไม่มีผล = AK10 เล่นนี้ควรเอาท์พุท 10
ยังไม่มีผล = AL11 การรันสิ่งนี้ควรเอาต์พุต 11
N = 12 ผลลัพธ์AM. เล่นนี้ควรเอาท์พุท 12
ยังไม่มีผล = AN13 เล่นนี้ควรเอาท์พุท 13
N = 14 AOผลใน เล่นนี้ควรเอาท์พุท 14
ยังไม่มีผล = AP15 เล่นนี้ควรเอาท์พุท 15
ยังไม่มีผล = A16 การรันสิ่งนี้ควรจะได้ผลลัพธ์ 16

รายละเอียด

• อนุญาตให้ใช้อักขระทั้งหมด, ASCII และไม่ใช่ ASCII (อนุญาตให้ขึ้นบรรทัดใหม่และ ASCII ที่ไม่สามารถพิมพ์ได้เช่นกันโปรดทราบว่าการขึ้นบรรทัดใหม่และจำนวนบรรทัดป้อนเป็นอักขระที่แตกต่างกัน)
• คะแนนของคุณคือความยาวเป็นอักขระของโปรแกรมที่ไม่เปลี่ยนแปลง (ตัวอย่าง 15 ตัว) คะแนนต่ำสุดชนะ
• คะแนนต่ำกว่า 16 นั้นเป็นไปไม่ได้อย่างชัดเจนเพราะอย่างน้อยสองโปรแกรมที่เปลี่ยนแปลงจะเหมือนกัน
• ผลลัพธ์อาจเป็นไฟล์หรือ stdout หรือสิ่งอื่นใดที่เหมาะสม อย่างไรก็ตามผลลัพธ์ของโปรแกรมที่แตกต่างกัน 16 โปรแกรมจะต้องไปที่เดียวกัน (เช่นมันไม่เป็นไรถ้าAOไปที่ stdout แต่Aไปที่ไฟล์) ไม่มีอินพุต
• ผลลัพธ์จะต้องเป็นทศนิยมไม่ใช่ฐานสิบหก ผลลัพธ์ที่แท้จริงควรประกอบด้วย 1 หรือ 2 ตัวอักษรที่ประกอบขึ้นจากตัวเลข 1 ถึง 16 ไม่มีอะไรอื่น (สิ่งที่ชอบของ 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)

Monadic ⌊กลม (ฟังก์ชั่นพื้น), Dyadic ×เป็นการคูณที่เห็นได้ชัด, ⍝แสดงความคิดเห็นส่วนที่เหลือของบรรทัด
นี้ควรทำให้ชัดเจน:

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

9:⌊/9×1
/ลดลง โดยทั่วไปจะใช้ฟังก์ชั่นของด้านซ้ายและอาร์เรย์ทางด้านขวาแทรกฟังก์ชั่นระหว่างองค์ประกอบของอาร์เรย์ทุกคู่และประเมิน (ซึ่งเรียกว่า "พับ" ในบางภาษา)
นี่อาร์กิวเมนต์ขวาเป็นสเกลาจึง/ไม่ทำอะไรเลย

8:⌊|8×× 2
Monadic ×เป็นฟังก์ชัน signumและ monadic |เป็นฟังก์ชันค่าสัมบูรณ์ดังนั้น× 2ประเมิน1และ|8×1แน่นอน8

7:⌊11-4 ⍝ควรชัดเจน

6:⌊⍟19×51⍝2
Monadic ⍟เป็นบันทึกตามธรรมชาติ
ดังนั้น⍟19×51ประเมินln(19×51) = 6.87626...และ⌊ปัดเศษลงเป็น6

5:⌊⍟21×○5
Monadic ○คูณอาร์กิวเมนต์ด้วยπ
⍟21×○5คือln(21×5π) = 5.79869...

4:⌊7|18××4×1 ⍝2
Dyadic |เป็นฟังก์ชัน mod ที่
×4×1ประเมินค่า1และ7|18×1คือ18 mod 7 = 4

3:⌊○⍟/119-××5 1 ⍝ 2
ค่าที่คั่นด้วยช่องว่างคืออาร์เรย์ โปรดทราบว่าใน APL เมื่อฟังก์ชั่นสเกลาร์ส่วนใหญ่ให้อาเรย์อาร์กิวเมนต์มันเป็นแผนที่โดยปริยาย
dyadic ⍟คือการเข้าสู่
ดังนั้น××5 1เป็น Signum Signum ของวันที่ 5 และวันที่ 1 ซึ่งจะช่วยให้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
ดังนั้น1|/2111118 9เพียงแค่ส่งกลับ2111118 9(ตามที่ใช้|/กับสเกลาร์) จากนั้น⍟○7⍟⍟ใช้ ln แล้วบันทึก₇กับตัวเลขเหล่านั้นแล้วคูณด้วย by และ ln อีกครั้ง ตัวเลขที่ออกมาจากอีกด้านหนึ่งคือที่1.46424... 0.23972...
นี่⊃ใช้เพื่อเลือกองค์ประกอบแรกของอาร์เรย์

Python - 1201 1137 (ตัวกำเนิด: 241 218) - ลองแฮช!

กลยุทธ์:

ฉันพยายามที่จะเริ่มต้นทุกสายที่มีเป็นจำนวนมาก hashes nเป็นผลลัพธ์ที่ต้องการ จากนั้นเวอร์ชันอื่น ๆ ทั้งหมดจะข้ามบรรทัดนี้อย่างสมบูรณ์

อย่างไรก็ตามปัญหาหลักคือการผนวกจำนวนแฮชที่ถูกต้องเพื่อให้การเรียกใช้ครั้งต่อไปจะไปถึงจุดเริ่มต้นของบรรทัดถัดไปอย่างแน่นอน นอกจากนี้การรบกวนกับรุ่นอื่น ๆ อาจเกิดขึ้นเช่นเวอร์ชัน 16 กระโดดเข้าสู่printคำสั่งของบรรทัดที่ 5 และอื่น ๆ ดังนั้นนี่คือการทดลองและข้อผิดพลาดจำนวนมากรวมกับสคริปต์ผู้ช่วยสำหรับการทดสอบอย่างรวดเร็ว

สถิติ:

• ตัวละคร: 1201 1137
• Hashes: 1066 1002 (88.1%)
• non-hashes: 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 iคำสั่งและi - 1แฮชระหว่างอักขระสองตัวที่อยู่ใกล้เคียง
3. ในขณะที่ "i-version" (อักขระ i-th ทุกตัว) ของโปรแกรมปัจจุบันไม่มีคำสั่ง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 - ตัวละครห้าล้านเจ็ดร้อยหกสิบห้าพันและเจ็ดร้อยเจ็ดสิบหกตัวอักษร

ฉันต้องการที่จะดำเนินการอย่างจริงจัง ...

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 เหตุผลว่าทำไม เหตุผลที่ 1: สคริปต์ befunge อยู่เสมอ 80x25 ดังนั้นไม่ว่าจะเกิดอะไรขึ้นต้องมีบางอย่างที่ลดลงในบรรทัดที่มีรหัส เหตุผลที่สอง: ทำไมบางสิ่งบางอย่างประมาณ 5.5 ล้านช่องว่างเพราะ 720 720 เป็นตัวคูณสามัญที่เล็กที่สุดของ 1 ถึง 16 ... หมายความว่าจะไม่มีการพันกันยุ่งเมื่อเราข้ามตัวอักษร เหตุผลที่สาม: ว้าวนี่มันไร้สาระทีเดียว

209 ตัวอักษร (ภาษาต่าง ๆ )

ฉันพยายามทำให้สิ่งต่าง ๆ เรียบง่ายและหลีกเลี่ยงการวางตำแหน่งใด ๆ ด้วยปัจจัยสำคัญจำนวนมาก ข้อดีคือความสามารถในการทำงานในหลาย ๆ ภาษาสคริปต์ ควรทำงานในภาษาใด ๆ ที่ไม่บิดเบือนโดยเจตนาและมีคุณสมบัติดังต่อไปนี้:

• ตัวอักษรจำนวนเต็ม
• ตัวดำเนินการทางคณิตศาสตร์พื้นฐาน +, - (การลบและการปฏิเสธ), *, /
• พิมพ์การประเมินผลของการแสดงออกเปลือย
• มีอักขระตัวเดียวที่เริ่มต้นความคิดเห็นในบรรทัด

ตัวอย่างเช่น,

Python 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 ควรมีช่องว่าง 17 ช่องก่อนหน้า '1' ตัวแรก พวกคุณรู้ภาษามากมายดังนั้นโปรดช่วยฉันเขียนรายการให้มากขึ้นเพื่อที่จะสามารถทำงานได้ใน:

แก้ไข: เพิ่ม unary + ที่ตำแหน่ง 0 สำหรับ Python เพื่อหลีกเลี่ยงบรรทัดที่ถูกเยื้อง

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