Tuliskan program sesingkat mungkin sehingga ketika Anda menggabungkan karakter pertama dan setiap karakter ke-9 setelah itu ke dalam program baru, hasilnya adalah N. Ini harus bekerja untuk N = 1, 2, ..., 16.

Cara lain untuk mengatakannya adalah, jika Anda menghapus semua karakter dari program Anda kecuali yang pertama dan setiap yang ke-1 setelah itu, output dari kode yang tersisa harus N.

Contoh

Jika kode Anda

ABCDEFGHIJKLMNOP

N = 1 menghasilkan ABCDEFGHIJKLMNOP. Menjalankan ini seharusnya menghasilkan 1.
N = 2 menghasilkan ACEGIKMO. Menjalankan ini seharusnya menghasilkan 2.
N = 3 menghasilkan ADGJMP. Menjalankan ini seharusnya menghasilkan 3.
N = 4 menghasilkan AEIM. Menjalankan ini seharusnya menghasilkan 4.
N = 5 menghasilkan AFKP. Menjalankan ini harus menghasilkan 5.
N = 6 hasil dalam AGM. Menjalankan ini harus menghasilkan 6.
N = 7 hasil dalam AHO. Menjalankan ini seharusnya menghasilkan 7.
N = 8 menghasilkan AI. Menjalankan ini seharusnya menghasilkan 8.
N = 9 menghasilkan AJ. Menjalankan ini seharusnya menghasilkan 9.
N = 10 hasil dalam AK. Menjalankan ini akan menghasilkan 10.
N = 11 menghasilkan AL. Menjalankan ini seharusnya menghasilkan 11.
N = 12 menghasilkanAM. Menjalankan ini seharusnya menghasilkan 12.
N = 13 menghasilkan AN. Menjalankan ini seharusnya menghasilkan 13.
N = 14 menghasilkan AO. Menjalankan ini harus menghasilkan 14.
N = 15 hasil dalam AP. Menjalankan ini akan menghasilkan 15.
N = 16 menghasilkan A. Menjalankan ini seharusnya menghasilkan 16.

Detail

• Semua karakter diperbolehkan, ASCII dan non-ASCII. (Baris baru dan ASCII yang tidak dapat dicetak diizinkan juga. Perhatikan bahwa carriage return dan feed feed dihitung sebagai karakter yang berbeda.)
• Skor Anda adalah panjang karakter program yang tidak diubah (misalnya 15). Skor terendah menang.
• Skor di bawah 16 jelas tidak mungkin karena setidaknya dua program yang diubah akan sama.
• Output mungkin ke file atau stdout atau hal lain yang masuk akal. Namun, output dari 16 program yang berbeda semua harus pergi ke tempat yang sama (misalnya tidak ok jika AOpergi ke stdout tetapi Apergi ke file). Tidak ada input.
• Output harus dalam desimal, bukan hex. Output aktual seharusnya hanya berisi 1 atau 2 karakter yang membentuk angka dari 1 hingga 16, tidak ada yang lain. (Hal-hal seperti Matlab ans =tidak masalah.)
• Program Anda tidak harus bekerja untuk N = 17 atau lebih tinggi.

APL, 49

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

Program yang diubah

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

Penjelasan

Saya akan mulai dari bawah karena akan menjelaskan lebih mudah

Ada dua fitur bahasa APL yang perlu diingat. Satu, APL tidak memiliki prioritas operator, pernyataan selalu dievaluasi dari kanan ke kiri. Dua, banyak fungsi APL berperilaku sangat berbeda tergantung jika diberikan satu argumen di sebelah kanan (monadik) atau dua argumen di sebelah kiri dan kanan (diad).

Monadic ⌊adalah round down (fungsi lantai), Dyadic× jelas-jelas merupakan perkalian, ⍝komentar di luar baris.
Ini harus membuat ini jelas:

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

9: ⌊/9×1
/ adalah Mengurangi. Pada dasarnya dibutuhkan fungsi kiri dan array di sebelah kanan, masukkan fungsi antara setiap pasangan elemen array dan evaluasi. (Ini disebut "lipatan" dalam beberapa bahasa)
Di sini, argumen yang tepat adalah skalar jadi /tidak melakukan apa-apa.

8:⌊|8×× 2
Monadik ×adalah fungsi signum dan monadik| adalah fungsi nilai absolut. Jadi, × 2mengevaluasi 1dan |8×1tentu saja8

7:⌊11-4 ⍝ harus jelas

6:⌊⍟19×51⍝2
Monadic ⍟adalah log natural.
Jadi,⍟19×51 evaluasikan ke ln(19×51) = 6.87626..., dan ⌊bulatkan ke6

5:⌊⍟21×○5
Monadic ○mengalikan argumennya dengan π
⍟21×○5 adalahln(21×5π) = 5.79869...

4:⌊7|18××4×1 ⍝2
Dyadic |adalah fungsi mod yang
×4×1dievaluasi1 , dan 7|18×1sekarang18 mod 7 = 4

3: Nilai⌊○⍟/119-××5 1 ⍝ 2
-nilai yang dipisahkan ruang adalah sebuah array. Perhatikan bahwa dalam APL, ketika sebagian besar fungsi skalar memberikan argumen array, itu adalah peta implisit.
Dyadic ⍟adalah log
Jadi ××5 1, adalah signum dari signum pada 5 dan 1, yang memberi 1 1, 119-1 1adalah ¯118 ¯118( ¯hanya tanda minus. APL harus membedakan antara angka negatif dan pengurangan), dan ⍟/¯118 ¯118log _-118 (-118) = 1

2: ⌊⍟7⍟|21189×1×345× 1 ⍝⍝_2
Anda bisa mengatasinya sendiri

1: Yang⌊⊃⍟○7⍟⍟1|/2111118 9⍝×-1 ×○3×4_5_× 1_ _⍝_⍝ __2
ini terdiri dari penggunaan yang lebih rumit /. Jika nangka, Fadalah fungsi, dan Amerupakan array, maka nF/Aambil setiap grup nentri berturut - turut Adan terapkan F/. Misalnya, 2×/1 2 3ambil setiap pasangan entri berturut-turut (yang 1 2dan 2 3) dan berlaku ×/untuk masing-masing grup untuk memberikan 2 6
Jadi, 1|/2111118 9kembalikan saja 2111118 9(sebagaimana berlaku |/untuk skalar). Kemudian, ⍟○7⍟⍟terapkan ln, lalu login ₇ ke angka-angka itu, lalu gandakan dengan π dan ln lagi. Angka-angka yang keluar dari sisi lain adalah 1.46424... 0.23972...
Di Sini, ⊃hanya digunakan untuk memilih elemen pertama dari sebuah array.

Python - 1201 1137 (generator: 241 218) - Hidup hash!

Strategi:

Saya mencoba memulai setiap baris dengan hash sebanyak yang diinginkan n. Kemudian semua versi lain akan melewati baris ini sepenuhnya.

Kesulitan utama, bagaimanapun, adalah untuk menambahkan jumlah hash yang benar sehingga menjalankan berikutnya akan mencapai awal baris berikutnya dengan tepat. Lebih lanjut, gangguan dengan versi lain dapat terjadi, misalnya versi 16 melompat langsung keprint perintah baris 5 dan seterusnya. Jadi ini banyak percobaan dan kesalahan dikombinasikan dengan skrip pembantu untuk pengujian cepat.

Statistik:

• Karakter: 1201 1137
• Hash: 1066 1002 (88,1%)
• Non-hash: 135 (11,9%)

Kode:

#
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

Skrip uji:

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

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

Keluaran:

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

Pembaruan: Skrip penghasil!

Saya memikirkan solusi saya dan harus ada pola untuk menghasilkannya secara algoritmik. Jadi di sini kita mulai:

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)

Itu membangun program baris demi baris:

1. Mulai dengan hash.
2. Tambahkan baris baru idenganprint i perintah dan i - 1hash di antara masing-masing dua karakter tetangga.
3. Sementara "i-versi" (setiap karakter ke-i) dari program saat ini tidak mengandung perintah print i(karena misalignment) atau versi apa pun ndengan n in range(1, 17)melempar pengecualian, tambahkan hash lain ke baris sebelumnya.

Sebenarnya program yang dikembalikan lebih pendek daripada yang saya temukan secara manual pagi ini. (Jadi saya memperbarui solusi saya di atas.) Selanjutnya, saya cukup yakin tidak ada implementasi yang lebih pendek mengikuti pola ini. Tapi kamu tidak pernah tahu!

Versi golf - 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)

Perhatikan bahwa mungkin ada generator yang lebih pendek, misalnya dengan mengkode-keras jumlah hash yang diperlukan untuk setiap baris. Tapi yang ini menghitung sendiri dan bisa digunakan untuk N> 16.

Befunge 93 - Lima juta tujuh ratus enam puluh lima ribu tujuh ratus tujuh puluh enam karakter

Saya menuntut untuk ditanggapi dengan serius ...

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 alasan mengapa. Alasan pertama: skrip befunge selalu 80x25, jadi apa pun itu, pasti ada sesuatu yang dikurangi pada baris dengan kode. Alasan ke-2: mengapa sesuatu sekitar 5,5 juta ruang adalah karena 720 720 adalah kelipatan umum terkecil dari 1 hingga 16 ... Berarti tidak akan ada kekacauan di sekitar saat kita melewatkan karakter. Alasan ke-3: wow, ini sangat tidak masuk akal.

209 karakter (Berbagai bahasa)

Saya hanya mencoba untuk menjaga hal-hal sederhana dan menghindari meletakkan apa pun di posisi dengan banyak faktor utama. Keuntungannya adalah kemampuan untuk berjalan dalam banyak bahasa scripting. Ini harus bekerja dalam bahasa apa pun yang tidak sengaja disalahgunakan dan memiliki fitur berikut:

• Literal integer
• Operator aritmatika dasar +, - (pengurangan dan negasi), *, /
• Mencetak evaluasi ekspresi telanjang
• Memiliki karakter tunggal yang memulai komentar baris

Sebagai contoh,

Penerjemah baris perintah Python 2 (meskipun bukan dari file):

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

MATLAB (cukup ganti '#' dengan '%'):

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

NB Harus ada 17 ruang sebelum '1' pertama. Kalian tahu banyak bahasa, jadi tolong bantu saya daftar lebih banyak yang bisa dijalankan di (:

EDIT: Menambahkan unary + pada posisi 0 untuk Python untuk menghindari baris yang indentasi.

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-

Pendekatan ini tidak menggunakan komentar apa pun.

idilemparkan ke integer, jadi ini adalah noop di sini. Itu bisa diganti dengan spasi putih, tetapi surat-surat itu tampaknya lebih mudah dibaca bagi saya ...

Cobalah online dengan menjalankan Kode berikut :

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*

Contoh dijalankan

$ 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

Ini mengambil keuntungan dari komentar ( #) dan "super-komentar" yang tidak berdokumen (segala sesuatu yang mengikuti yang tidak cocok }itu diabaikan secara diam-diam).

_adalah noop. Itu bisa diganti dengan spasi putih, tetapi garis bawah tampaknya lebih mudah dibaca oleh saya ...

Cobalah online.

Contoh dijalankan

$ 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