Mümkün olan en kısa programı yazın, böylece ilk karakteri ve her Nth karakterini yeni bir programda birleştirdiğinizde, çıktı N olur. Bu, N = 1, 2, ..., 16 için çalışmalıdır.

Bunu söylemenin başka bir yolu da, programdan ilk karakterleri ve sonraki her Nth hariç tüm karakterleri kaldırırsanız , kalan kodun çıktısı N olmalıdır.

Misal

Kodunuz

ABCDEFGHIJKLMNOP

N = 1 sonuç ABCDEFGHIJKLMNOP. Bunu çalıştırdığınızda çıkış 1 olmalıdır.
N = 2 sonuç verir ACEGIKMO. Bunu çalıştırdığınızda çıkış 2 olmalıdır.
N = 3 sonuç verir ADGJMP. Bunu çalıştırdığınızda çıkış 3 olmalıdır.
N = 4 sonuç verir AEIM. Bunu çalıştırdığınızda çıkış 4 olmalıdır.
N = 5 sonuç verir AFKP. Bunu çalıştırdığınızda çıkış 5 olmalıdır.
N = 6 sonuç verir AGM. Bunu çalıştırdığınızda çıkış 6 olmalıdır.
N = 7 sonuç verir AHO. Bunu çalıştırdığınızda çıkış 7 olmalıdır.
N = 8 sonuç verir AI. Bunu çalıştırdığınızda çıkış 8 olmalıdır.
N = 9 sonuç verir AJ. Bunu çalıştırdığınızda çıkış 9 olmalıdır.
N = 10 sonuç verir AK. Bunu çalıştırdığınızda çıkış 10 olmalıdır.
N = 11 sonuç verir AL. Bunu çalıştırdığınızda çıkış 11 olmalıdır.
N = 12 sonuçAM. Bunu çalıştırdığınızda çıkış 12 olmalıdır.
N = 13 sonuç verir AN. Bunu çalıştırdığınızda çıkış 13 olmalıdır.
N = 14 sonuç verir AO. Bunu çalıştırdığınızda 14 çıktı alınmalıdır.
N = 15 sonuç AP. Bunu çalıştırdığınızda çıktı 15 alınmalıdır.
N = 16 sonuç verir A. Bunu çalıştırdığınızda çıktı 16 olmalıdır.

ayrıntılar

• Tüm karakterlere izin verilir, ASCII ve ASCII dışı. (Yeni satırlara ve yazdırılamaz ASCII'ye de izin verilir. Satır başı ve satır besleme ayrı karakterler olarak sayılır.)
• Puanınız değiştirilmemiş programınızın karakter cinsinden uzunluğudur (örnek olarak 15). En düşük puan kazanır.
• 16'nın altında bir puan açıkça imkansızdır, çünkü o zaman değiştirilen programlardan en az ikisi aynı olacaktır.
• Çıktı bir dosyaya veya stdout'a veya makul başka bir şeye olabilir. Bununla birlikte, 16 farklı programın çıktısının hepsi aynı yere gitmelidir (örneğin AO, stdout'a Agiderse ancak bir dosyaya giderse sorun olmaz). Hiçbir girdi yok.
• Çıktı onaltılı değil ondalık olmalıdır. Gerçek çıktı yalnızca 1'den 16'ya kadar sayıyı oluşturan 1 veya 2 karakter içermelidir, başka bir şey olmamalıdır. (Matlab'ınki gibi şeyler ans =iyi.)
• Programınızın N = 17 veya üstü için çalışması gerekmez.

APL, 49

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

Değiştirilmiş programlar

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

Açıklama

Açıklamayı kolaylaştıracağı için alttan başlayacağım

APL'nin akılda tutulması gereken iki dil özelliği vardır. Birincisi, APL'nin operatör önceliği yoktur, ifadeler her zaman sağdan sola değerlendirilir. İki, birçok APL işlevi, sağında bir argüman (monadik) veya solunda ve sağında (ikili) iki argüman verilmesine bağlı olarak oldukça farklı davranır .

Monadic ⌊yuvarlaktır (zemin fonksiyonu), Dyadic ×açıkça çarpmadır , ⍝satırın geri kalanını yorumlar
Bu açık olmalıdır:

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

9: ⌊/9×1
/ Azalt. Temel olarak sol ve sağdaki dizinin işlevini alır, işlevi dizinin her öğe çifti arasına ekler ve değerlendirir. (Buna bazı dillerde "katlama" denir)
Burada doğru argüman skalerdir ve /hiçbir şey yapmaz.

8:⌊|8×× 2
Monadic ×, signum fonksiyonudur ve monadic |Yani mutlak değer fonksiyonu × 2için değerlendirir 1ve |8×1elbette8

7:⌊11-4 ⍝ açık olmalı

6:⌊⍟19×51⍝2
Monadic ⍟doğal kütüktür
Yani, ⍟19×51değerlendirir ln(19×51) = 6.87626...ve ⌊yuvarlar6

5:⌊⍟21×○5
Monadik○ tt tarafından argüman çarpar
⍟21×○5olduğunuln(21×5π) = 5.79869...

4:⌊7|18××4×1 ⍝2
Dyadic |mod işlevidir
×4×1 olarak değerlendirilir 1ve 7|18×1bir18 mod 7 = 4

3:⌊○⍟/119-××5 1 ⍝ 2
Boşlukla ayrılmış değerler bir dizidir. APL'de, çoğu skaler fonksiyon dizi argümanları verdiğinde, örtük bir harita olduğunu unutmayın.
Diyadik ⍟log olan
So ××5 1verir 5 ve 1, üzerine sinyalnum sinyalnum olduğu 1 1, 119-1 1olduğu ¯118 ¯118(¯ APL negatif sayılar çıkarma arasındaki ayrım vardır. Sadece eksi işaretidir) ve ⍟/¯118 ¯118bir günlük _-118 (-118) = 1

2:⌊⍟7⍟|21189×1×345× 1 ⍝⍝_2
Kendiniz çalışabilirsiniz

1:⌊⊃⍟○7⍟⍟1|/2111118 9⍝×-1 ×○3×4_5_× 1_ _⍝_⍝ __2
Bu daha karmaşık bir kullanımdan oluşur /. Eğer nbir sayıdır, Fbir fonksiyondur ve Aardından bir dizidir nF/Aher grup alır nardışık girişleri Ave uygulamak F/. Örneğin, 2×/1 2 3(olan ardışık girişlerinin her çiftini alır 1 2ve 2 3) ve uygulamak ×/vermek için her gruba 2 6
, Yani 1|/2111118 9sadece döner 2111118 9(o uygulandığı gibi |/skalerler kadar). Ardından, ⍟○7⍟⍟ln'yi uygulayın, sonra _7'yi bu sayılara günlüğe kaydedin, sonra tekrar π ve ln ile çarpar. Diğer tarafta çıkan sayılar 1.46424... 0.23972...
İşte, ⊃sadece bir dizinin ilk elemanını seçmek için kullanılır.

Python - 1201 1137 (jeneratör: 241 218) - Yaşasın karma!

Strateji:

Her satıra istenen çıktı kadar karma ile başlamaya çalıştım n. Sonra diğer tüm sürümler bu satırı tamamen atlayacaktır.

Bununla birlikte, ana zorluk, doğru sayıda hash eklemekti, böylece bir sonraki koşu bir sonraki satırın başlangıcına tam olarak çarpacaktı. Ayrıca, diğer sürümlerle etkileşimler de meydana gelebilir, örn. Sürüm 16 doğrudan printsatır 5'in komutuna atlar vb. Bu, hızlı test için yardımcı bir komut dosyasıyla birleştirilen çok sayıda deneme yanılma yöntemiydi.

İstatistik:

• Karakterler: 1201 1137
• Hash'ler: 1066 1002 (% 88.1)
• Karma olmayanlar: 135 (% 11.9)

Kod:

#
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

Test komut dosyası:

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

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

Çıktı:

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

Güncelleme: Üreten bir script!

Çözümümü düşündüm ve algoritmik olarak üretmek için bir kalıp olması gerektiğini düşündüm. İşte başlıyoruz:

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)

Programı satır satır oluşturur:

1. Bir karma ile başlayın.
2. Yeni bir satır ekleyin iile print ikomuta vei - 1Her iki komşu karakter arasına karma .
3. Geçerli programın "i-sürümü" (her i-th karakteri) komutu print i(yanlış hizalama nedeniyle) veya istisna niçeren herhangi bir -version içermezken n in range(1, 17), önceki satıra başka bir karma ekleyin.

Aslında bu sabah elle bulduğumdan daha kısa bir program döndürdü. (Bu yüzden yukarıdaki çözümümü güncelledim.) Ayrıca, bu kalıbı takip eden daha kısa bir uygulama olmadığından eminim. Ama sen asla bilemezsin!

Golfçüler versiyon - 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)

Daha kısa bir jeneratör olabileceğini, örneğin her bir satır için gereken sayıda ardh karma kodlamasını yaparak kodlayabileceğinizi unutmayın. Ancak bu onları hesaplar ve herhangi bir N> 16 için kullanılabilir.

Befunge 93 - Beş milyon yedi yüz altmış beş bin ve yedi yüz yetmiş altı karakter

Ciddiye alınmayı talep ediyorum ...

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 neden. 1. neden: Befunge komut dosyası her zaman 80x25'tir, bu yüzden ne olursa olsun, kodlu satırlarda azaltılmış bir şey olması gerekiyordu . 2. neden: Bir şeyin yaklaşık 5,5 milyon boşluk olması neden 720 720'nin 1 ila 16'nın en küçük ortak katı olması ... Karakterleri atlarken karışıklığın etrafına sarılmayacağı anlamına geliyor. 3. neden: vay, bu oldukça saçma.

209 karakter (Çeşitli diller)

Sadece işleri basit tutmaya çalıştım ve çok sayıda asal faktör içeren pozisyonlara herhangi bir şey koymaktan kaçındım. Avantajı birçok betik dilinde çalışabilme yeteneğidir. Kasten sapkın olmayan ve aşağıdaki özelliklere sahip herhangi bir dilde çalışmalıdır:

• Tam sayı değişmez değerleri
• Temel aritmetik işleçler +, - (çıkarma ve olumsuzlama), *, /
• Çıplak bir ifadenin değerlendirmesini yazdırır
• Satır yorumu başlatan tek bir karakter var

Örneğin,

Python 2 komut satırı yorumlayıcısı (bir dosyadan olmasa da):

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

MATLAB ('#' yerine '%' yazmanız yeterlidir):

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

Not: İlk '1'den önce 17 boşluk olmalıdır. Çok fazla dil biliyorsunuz, bu yüzden lütfen içinde çalışabileceği daha fazla şey listelememe yardımcı olun (:

DÜZENLE: Satırın girintisini önlemek için Python için 0 konumuna tekli + eklendi.

CJam, 89 bayt

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

Bu yaklaşım herhangi bir yorum kullanmaz.

itamsayıya çevirir, bu yüzden burada bir noop. Boşluk ile değiştirilebilir, ancak harfler benim için daha okunabilir görünüyor ...

Aşağıdaki Kodu uygulayarak çevrimiçi deneyin :

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*

Örnek çalışma

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

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

Bu, yorumlar ( #) ve belgesiz "süper yorumlar" dan yararlanır (eşleşmeden sonraki her şey }sessizce göz ardı edilir).

_bir noop. Boşluk ile değiştirilebilir, ancak alt çizgiler bana daha okunabilir görünüyor ...

Çevrimiçi deneyin.

Örnek çalışma

$ 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