Napisz możliwie najkrótszy program, tak aby po połączeniu pierwszego znaku i każdego N-tego znaku po nim w nowy program, wynikiem było N. To musi działać dla N = 1, 2, ..., 16.

Innym sposobem na powiedzenie tego jest, że jeśli usuniesz wszystkie znaki ze swojego programu, z wyjątkiem pierwszego, a następnie co N-tego, wynik pozostałych kodów powinien wynosić N.

Przykład

Jeśli twój kod był

ABCDEFGHIJKLMNOP

N = 1 powoduje ABCDEFGHIJKLMNOP. Uruchomienie tego powinno dać wynik 1.
N = 2 powoduje ACEGIKMO. Uruchomienie tego powinno dać wynik 2.
N = 3 powoduje ADGJMP. Uruchomienie tego powinno dać wynik 3.
N = 4 powoduje AEIM. Uruchomienie tego powinno dać wynik 4.
N = 5 powoduje AFKP. Uruchomienie tego powinno dać wynik 5.
N = 6 powoduje AGM. Uruchomienie tego powinno dać wynik 6.
N = 7 powoduje AHO. Uruchomienie tego powinno dać wynik 7.
N = 8 powoduje AI. Uruchomienie tego powinno dać wynik 8.
N = 9 powoduje AJ. Uruchomienie tego powinno dać wynik 9.
N = 10 powoduje AK. Uruchomienie tego powinno dać wynik 10.
N = 11 powoduje AL. Uruchomienie tego powinno dać wynik 11.
N = 12 powodujeAM. Uruchomienie tego powinno dać wynik 12.
N = 13 powoduje AN. Uruchomienie tego powinno dać wynik 13.
N = 14 powoduje AO. Uruchomienie tego powinno dać wynik 14.
N = 15 powoduje AP. Uruchomienie tego powinno dać wynik 15.
N = 16 powoduje A. Uruchomienie tego powinno dać wynik 16.

Detale

• Wszystkie znaki są dozwolone, ASCII i inne niż ASCII. (Dozwolone są również znaki nowej linii i niedrukowalne ASCII. Zwróć uwagę, że znak powrotu karetki i znak wiersza liczą się jako odrębne znaki).
• Twój wynik to długość znaków w niezmienionym programie (na przykład 15). Najniższy wynik wygrywa.
• Wynik poniżej 16 jest oczywiście niemożliwy, ponieważ co najmniej dwa ze zmienionych programów byłyby identyczne.
• Dane wyjściowe mogą być wysyłane do pliku lub standardowego pliku lub do dowolnego innego rozsądnego rozwiązania. Jednak wyjście 16 różnych programów musi przejść do tego samego miejsca (np. Nie jest ok, jeśli AOidzie na standardowe wyjście, aleA do pliku). Brak danych wejściowych.
• Dane wyjściowe muszą być dziesiętne, a nie szesnastkowe. Rzeczywiste wyjście powinno zawierać tylko 1 lub 2 znaki, które składają się na liczbę od 1 do 16, nic więcej. (Rzeczy takie jak Matlab ans =są w porządku.)
• Twój program nie musi działać dla N = 17 lub wyższej.

APL, 49

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

Zmienione programy

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

Wyjaśnienie

Zacznę od dołu, ponieważ ułatwi to wyjaśnienie

Należy pamiętać o dwóch cechach językowych APL. Po pierwsze, APL nie ma pierwszeństwa operatora, instrukcje są zawsze oceniane od prawej do lewej. Po drugie, wiele funkcji APL zachowuje się zupełnie inaczej, w zależności od tego, czy podano jeden argument po jego prawej stronie (monadyczny), czy dwa argumenty po jego lewej i prawej stronie (dyadyczny).

Monadic ⌊jest zaokrąglony w dół (funkcja podłogi), Dyadic ×jest oczywiście mnożeniem, ⍝komentuje resztę linii
To powinno uczynić to oczywistym:

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

9:⌊/9×1
/ jest Zmniejsz. Zasadniczo bierze funkcję lewej i tablicy po prawej, wstaw funkcję między każdą parą elementów tablicy i oceń. (W niektórych językach nazywa się to „fold”)
. Właściwym argumentem jest skalar, więc /nic nie robi.

8:⌊|8×× 2
Monadyczny ×jest funkcją signum, a monadyczny |jest funkcją wartości bezwzględnej. Więc × 2ocenia 1i |8×1jest oczywiście8

7:⌊11-4 ⍝ powinno być oczywiste

6:⌊⍟19×51⍝2
Monadyczny ⍟jest logarytmiczny,
więc ⍟19×51ocenia go ln(19×51) = 6.87626...i ⌊zaokrągla w dół do6

5:⌊⍟21×○5
Monadic ○mnoży swój argument przez π
⍟21×○5jestln(21×5π) = 5.79869...

4:⌊7|18××4×1 ⍝2
Dyadic |to funkcja mod, która
×4×1ocenia 1i 7|18×1jest18 mod 7 = 4

3:⌊○⍟/119-××5 1 ⍝ 2
Wartości rozdzielone spacją to tablica. Zauważ, że w APL, gdy większość funkcji skalarnych podaje argumenty tablicowe, jest to mapa niejawna.
Dyadic ⍟to log
Tak więc ××5 1jest to signum z signum na 5 i 1, co daje 1 1, 119-1 1jest ¯118 ¯118( ¯to tylko znak minus. APL musi rozróżniać liczby ujemne od odejmowania) i ⍟/¯118 ¯118jest log _-118 (-118) = 1

2: ⌊⍟7⍟|21189×1×345× 1 ⍝⍝_2
Możesz sam to wypracować

1:⌊⊃⍟○7⍟⍟1|/2111118 9⍝×-1 ×○3×4_5_× 1_ _⍝_⍝ __2
Ten polega na bardziej skomplikowanym użyciu /. Jeśli njest liczbą, Fjest funkcją i Ajest tablicą, to nF/Apobiera każdą grupę nkolejnych wpisów Ai stosuje się F/. Na przykład, 2×/1 2 3bierze każdą parę kolejnych wpisów (które są 1 2i 2 3) i stosuje się ×/do każdej grupy, aby dać 2 6
So, 1|/2111118 9po prostu zwraca 2111118 9(jak to ma zastosowanie |/w skalarach). Następnie ⍟○7⍟⍟stosuje ln, następnie loguje ₇ do tych liczb, a następnie mnoży je przez π i ln ponownie. Liczby, które wychodzą po drugiej stronie, są 1.46424... 0.23972...
tutaj, ⊃służą tylko do wybrania pierwszego elementu tablicy.

Python - 1201 1137 (generator: 241 218) - Niech żyją skróty!

Strategia:

Próbowałem rozpocząć każdą linię od tylu skrótów, ile było pożądanych wyników n. Wtedy wszystkie inne wersje całkowicie pominą ten wiersz.

Główną trudnością było jednak dodanie poprawnej liczby skrótów, tak aby kolejny przebieg dokładnie trafił na początek następnego wiersza. Ponadto mogą wystąpić zakłócenia z innymi wersjami, np. Wersja 16 wskakująca bezpośrednio doprint wiersza 5 i tak dalej. Było to więc wiele prób i błędów w połączeniu ze skryptem pomocniczym do szybkiego testowania.

Statystyka:

• Znaki: 1201 1137
• Hashe: 1066 1002 (88,1%)
• Bez skrótów: 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

Skrypt testowy:

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

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

Wynik:

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

Aktualizacja: skrypt generujący!

Pomyślałem o moim rozwiązaniu i że musi istnieć wzorzec, aby wygenerować go algorytmicznie. Więc zaczynamy:

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)

Buduje program linia po linii:

1. Zacznij od skrótu.
2. Dodaj nowy wiersz iz print ipoleceniem i i - 1mieszaj między dwoma sąsiednimi znakami.
3. Podczas gdy „i-wersja” (każdy i-ty znak) bieżącego programu nie zawiera polecenia print i(z powodu niewspółosiowości) ani żadnej wersji nz wyrzuceniem n in range(1, 17)wyjątku, dodaj kolejny skrót do poprzedniej linii.

W rzeczywistości zwrócił krótszy program niż znalazłem dziś rano. (Więc zaktualizowałem moje rozwiązanie powyżej.) Ponadto jestem prawie pewien, że nie ma krótszej implementacji zgodnej z tym wzorcem. Ale nigdy nie wiesz!

Wersja golfowa - 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)

Zauważ, że może istnieć krótszy generator, np. Poprzez zakodowanie na stałe wymaganej liczby kolejnych skrótów dla każdej linii. Ale ten sam je oblicza i może być użyty dla dowolnego N> 16.

Befunge 93 - Pięć milionów siedemset sześćdziesiąt pięć tysięcy siedemset siedemdziesiąt sześć znaków

Domagam się poważnego traktowania ...

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 powody dlaczego. Pierwszy powód: skrypt befunge ma zawsze rozmiar 80x25, więc bez względu na wszystko musiało być coś , co zostało zmniejszone w wierszach z kodem. Drugi powód: dlaczego coś ma około 5,5 miliona spacji, ponieważ 720 720 to najmniejsza wspólna wielokrotność od 1 do 16 ... Oznacza to, że nie będzie zawijającego się bałaganu, gdy pomijamy postacie. Trzeci powód: wow, to jest dość absurdalne.

209 znaków (różne języki)

Po prostu starałem się uprościć sprawę i unikać umieszczania czegokolwiek na pozycjach z dużą liczbą czynników pierwotnych. Zaletą jest możliwość uruchamiania w wielu językach skryptowych. Powinien działać w każdym języku, który nie jest celowo przewrotny i ma następujące funkcje:

• Literały całkowite
• Podstawowe operatory arytmetyczne +, - (odejmowanie i negowanie), *, /
• Drukuje ocenę nagiego wyrażenia
• Ma pojedynczy znak rozpoczynający komentarz liniowy

Na przykład,

Interpretator wiersza polecenia Python 2 (choć nie z pliku):

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

MATLAB (po prostu zamień „#” na „%”):

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

Uwaga: Pierwsza „1” powinna zawierać 17 spacji. Znacie wiele języków, więc pomóżcie mi wymienić więcej, w których mógłby działać (:

EDYCJA: Dodano unary + w pozycji 0 dla Pythona, aby uniknąć wcięcia linii.

CJam, 89 bajtów

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

W tym podejściu nie stosuje się żadnych komentarzy.

irzutuje na liczbę całkowitą, więc tutaj jest noop. Można go zastąpić białymi spacjami, ale litery wydają mi się bardziej czytelne ...

Wypróbuj online , wykonując następujący kod :

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*

Przykładowy przebieg

$ 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 bajtów

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

Wykorzystuje to komentarze (# ) i nieudokumentowane „super-komentarze” (wszystko po niedopasowaniu }jest dyskretnie ignorowane).

_jest noop. Można go zastąpić białymi spacjami, ale podkreślenia wydają mi się bardziej czytelne ...

Wypróbuj online.

Przykładowy przebieg

$ 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