Viết chương trình ngắn nhất có thể sao cho khi bạn kết hợp ký tự đầu tiên và mỗi ký tự N sau nó vào một chương trình mới, đầu ra là N. Điều này phải hoạt động cho N = 1, 2, ..., 16.

Một cách khác để nói là, nếu bạn loại bỏ tất cả các ký tự khỏi chương trình của bạn ngoại trừ ký tự đầu tiên và mỗi Nth sau đó, đầu ra của mã còn lại sẽ là N.

Thí dụ

Nếu mã của bạn là

ABCDEFGHIJKLMNOP

N = 1 kết quả trong ABCDEFGHIJKLMNOP. Chạy này sẽ xuất 1.
N = 2 kết quả trong ACEGIKMO. Chạy này sẽ xuất ra 2.
N = 3 kết quả ADGJMP. Chạy này sẽ xuất 3.
N = 4 kết quả trong AEIM. Chạy này sẽ xuất 4.
N = 5 kết quả trong AFKP. Chạy này sẽ xuất 5.
N = 6 kết quả trong AGM. Chạy này sẽ xuất ra 6.
N = 7 kết quả AHO. Chạy này sẽ xuất ra 7.
N = 8 kết quả AI. Chạy này sẽ xuất 8.
N = 9 kết quả trong AJ. Chạy này sẽ xuất 9.
N = 10 kết quả trong AK. Chạy này sẽ xuất 10.
N = 11 kết quả trong AL. Chạy này sẽ xuất 11.
N = 12 kết quả trongAM. Chạy này sẽ xuất 12.
N = 13 kết quả trong AN. Chạy này sẽ xuất ra 13.
N = 14 kết quả AO. Chạy này sẽ xuất 14.
N = 15 kết quả trong AP. Chạy này sẽ xuất ra 15.
N = 16 kết quả A. Chạy này nên xuất 16.

Chi tiết

• Tất cả các ký tự được cho phép, ASCII và không ASCII. (Các dòng mới và ASCII không thể in cũng được cho phép. Lưu ý rằng lợi nhuận vận chuyển và nguồn cấp dữ liệu được tính là các ký tự riêng biệt.)
• Điểm của bạn là độ dài tính bằng ký tự của chương trình chưa thay đổi của bạn (ví dụ 15). Điểm thấp nhất sẽ thắng.
• Điểm dưới 16 rõ ràng là không thể vì sau đó ít nhất hai trong số các chương trình bị thay đổi sẽ giống hệt nhau.
• Đầu ra có thể là một tập tin hoặc thiết bị xuất chuẩn hoặc bất cứ điều gì hợp lý. Tuy nhiên, đầu ra của 16 chương trình khác nhau đều phải đi đến cùng một nơi (ví dụ: không ổn nếu AOđi đến thiết bị xuất chuẩn nhưng Ađi đến một tệp). Không có đầu vào.
• Đầu ra phải ở dạng thập phân, không phải là hex. Đầu ra thực tế chỉ nên chứa 1 hoặc 2 ký tự tạo nên số từ 1 đến 16, không có gì khác. (Những thứ như Matlab ans =đều ổn.)
• Chương trình của bạn không phải làm việc cho N = 17 trở lên.

APL, 49

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

Thay đổi chương trình

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

Giải thích

Tôi sẽ bắt đầu từ phía dưới vì nó sẽ giúp giải thích dễ dàng hơn

Có hai tính năng ngôn ngữ của APL cần ghi nhớ. Một, APL không có quyền ưu tiên của nhà điều hành, các câu lệnh luôn được đánh giá từ phải sang trái. Hai, nhiều hàm APL hoạt động hoàn toàn khác nhau tùy thuộc vào việc nó được đưa ra một đối số ở bên phải (đơn âm) hay hai đối số ở bên trái và bên phải (dyadic).

Monadic ⌊được làm tròn xuống (chức năng sàn), Dyadic ×rõ ràng là nhân, ⍝nhận xét ra phần còn lại của dòng
Điều này sẽ làm cho những điều này rõ ràng:

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

9:⌊/9×1
/ là Giảm. Về cơ bản, nó có chức năng của bên trái và mảng bên phải, chèn chức năng giữa mỗi cặp phần tử của mảng và đánh giá. (Điều này được gọi là "gấp" trong một số ngôn ngữ)
Ở đây, đối số đúng là vô hướng nên /không có gì.

8:⌊|8×× 2
Monadic ×là hàm Signum và monadic |là hàm giá trị tuyệt đối Vì vậy, × 2đánh giá 1và |8×1tất nhiên8

7:⌊11-4 ⍝ nên rõ ràng

6:⌊⍟19×51⍝2
Monadic ⍟là nhật ký tự nhiên
Vì vậy, hãy ⍟19×51đánh giá ln(19×51) = 6.87626...và làm ⌊tròn nó xuống6

5:⌊⍟21×○5
Monadic ○nhân số đối số của nó bằng π
⍟21×○5làln(21×5π) = 5.79869...

4:⌊7|18××4×1 ⍝2
cặp đôi |là chức năng mod
×4×1đánh giá lại để 1, và 7|18×1là18 mod 7 = 4

3:⌊○⍟/119-××5 1 ⍝ 2
Các giá trị được phân tách bằng dấu cách là một mảng. Lưu ý rằng trong APL, khi hầu hết các hàm vô hướng đều đưa ra các đối số mảng, nó là một bản đồ ngầm.
Cặp đôi ⍟là log
Vì vậy ××5 1, là signum của signum trên 5 và 1, mang đến cho 1 1, 119-1 1là ¯118 ¯118( ¯chỉ là dấu trừ. APL có để phân biệt giữa số âm và trừ), và ⍟/¯118 ¯118là log _-118 (-118) = 1

2:⌊⍟7⍟|21189×1×345× 1 ⍝⍝_2
Bạn có thể tự mình giải quyết

1:⌊⊃⍟○7⍟⍟1|/2111118 9⍝×-1 ×○3×4_5_× 1_ _⍝_⍝ __2
Cái này bao gồm việc sử dụng phức tạp hơn /. Nếu nlà một số, Flà một hàm và Alà một mảng, sau đó nF/Alấy từng nhóm các nmục liên tiếp Avà áp dụng F/. Ví dụ: 2×/1 2 3lấy từng cặp mục nhập liên tiếp (được 1 2và 2 3) và áp dụng ×/cho từng nhóm để cung cấp 2 6
So, 1|/2111118 9chỉ trả về 2111118 9(vì nó áp dụng |/cho vô hướng). Sau đó, ⍟○7⍟⍟áp dụng ln, sau đó đăng nhập ₇ vào các số đó, sau đó nhân chúng với số π và ln một lần nữa. Các số xuất hiện ở phía bên kia là 1.46424... 0.23972...
Ở đây, ⊃chỉ được sử dụng để chọn phần tử đầu tiên của một mảng.

Python - 1201 1137 (trình tạo: 241 218) - Băm lâu!

Chiến lược:

Tôi đã cố gắng bắt đầu mọi dòng với nhiều giá trị băm như đầu ra mong muốn n. Sau đó, tất cả các phiên bản khác sẽ bỏ qua dòng này hoàn toàn.

Tuy nhiên, khó khăn chính là nối thêm số lượng băm chính xác để lần chạy tiếp theo sẽ chạm chính xác vào đầu dòng tiếp theo. Hơn nữa, các can nhiễu với các phiên bản khác có thể xảy ra, ví dụ phiên bản 16 nhảy ngay vào printlệnh của dòng 5, v.v. Vì vậy, đây là rất nhiều thử nghiệm và lỗi kết hợp với một kịch bản trợ giúp để thử nghiệm nhanh chóng.

Số liệu thống kê:

• Nhân vật: 1201 1137
• Băm: 1066 1002 (88,1%)
• Không băm: 135 (11,9%)

Mã số:

#
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

Kịch bản thử nghiệm:

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

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

Đầu ra:

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

Cập nhật: Một kịch bản tạo!

Tôi đã nghĩ về giải pháp của mình và rằng phải có một mô hình để tạo ra nó theo thuật toán. Vì vậy, ở đây chúng tôi đi:

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)

Nó xây dựng dòng chương trình theo từng dòng:

1. Bắt đầu với một hàm băm.
2. Nối một dòng mới ivới print ilệnh và i - 1băm ở giữa mỗi hai ký tự lân cận.
3. Trong khi "phiên bản i" (mỗi ký tự thứ i) của chương trình hiện tại không chứa lệnh print i(do điều chỉnh sai) hoặc bất kỳ chuyển đổi nào ncó n in range(1, 17)ném ngoại lệ, hãy thêm một hàm băm khác vào dòng trước đó.

Nó thực sự đã trả lại một chương trình ngắn hơn tôi tìm thấy bằng tay sáng nay. (Vì vậy, tôi đã cập nhật giải pháp của mình ở trên.) Hơn nữa, tôi khá chắc chắn rằng không có triển khai ngắn hơn theo mô hình này. Nhưng bạn không bao giờ biết!

Phiên bản chơi gôn - 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)

Lưu ý rằng có thể có một trình tạo ngắn hơn, ví dụ bằng cách mã hóa cứng số lượng băm thành công cần thiết cho mỗi dòng. Nhưng cái này sẽ tự tính toán chúng và có thể được sử dụng cho bất kỳ N> 16 nào.

Befunge 93 - Năm triệu bảy trăm sáu mươi lăm nghìn và bảy trăm bảy mươi sáu ký tự

Tôi yêu cầu được thực hiện nghiêm túc ...

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 lý do tại sao. Lý do thứ nhất: một tập lệnh befunge luôn là 80x25, vì vậy dù thế nào, phải có một cái gì đó đã được giảm trên các dòng có mã. Lý do thứ hai: tại sao thứ gì đó có khoảng 5,5 triệu khoảng trống là vì 720 720 là bội số chung nhỏ nhất từ ​​1 đến 16 ... Có nghĩa là sẽ không có sự bao bọc xung quanh khi chúng ta bỏ qua các ký tự. Lý do thứ 3: wow, điều này khá vô lý.

209 ký tự (Ngôn ngữ khác nhau)

Tôi chỉ cố gắng giữ mọi thứ đơn giản và tránh đặt bất cứ thứ gì vào vị trí có nhiều yếu tố chính. Ưu điểm là khả năng chạy trong nhiều ngôn ngữ kịch bản. Nó nên hoạt động trong bất kỳ ngôn ngữ nào không cố ý xuyên tạc và có các tính năng sau:

• Chữ nguyên
• Toán tử số học cơ bản +, - (trừ và phủ định), *, /
• In đánh giá biểu thức trần
• Có một ký tự bắt đầu một nhận xét dòng

Ví dụ,

Trình thông dịch dòng lệnh Python 2 (mặc dù không phải từ một tệp):

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

MATLAB (chỉ cần thay thế '#' bằng '%'):

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

NB Nên có 17 khoảng trắng trước '1' đầu tiên. Các bạn biết rất nhiều ngôn ngữ, vì vậy hãy giúp tôi liệt kê thêm các ngôn ngữ có thể chạy trong (:

EDIT: Đã thêm unary + ở vị trí 0 cho Python để tránh dòng bị thụt vào.

CJam, 89 byte

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

Cách tiếp cận này không sử dụng bất kỳ loại ý kiến.

iphôi thành số nguyên, vì vậy nó là một noop ở đây. Nó có thể được thay thế bằng khoảng trắng, nhưng các chữ cái dường như dễ đọc hơn đối với tôi ...

Dùng thử trực tuyến bằng cách thực thi Mã sau :

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*

Chạy ví dụ

$ 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 byte

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

Điều này tận dụng các bình luận ( #) và "siêu bình luận" không có giấy tờ (mọi thứ sau một không thể so sánh }được đều âm thầm bỏ qua).

_là một noop. Nó có thể được thay thế bằng khoảng trắng, nhưng phần dưới có vẻ dễ đọc hơn đối với tôi ...

Hãy thử trực tuyến.

Chạy ví dụ

$ 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