Scrivi il programma più breve possibile in modo tale che quando combini il primo carattere e ogni N carattere dopo di esso in un nuovo programma, l'output è N. Questo deve funzionare per N = 1, 2, ..., 16.

Un altro modo per dirlo è che se rimuovete tutti i caratteri dal vostro programma tranne il primo e ogni N successivo, l'output del codice rimanente dovrebbe essere N.

Esempio

Se il tuo codice era

ABCDEFGHIJKLMNOP

N = 1 risulta in ABCDEFGHIJKLMNOP. L'esecuzione di questo dovrebbe produrre 1.
N = 2 risultati in ACEGIKMO. L'esecuzione di questo dovrebbe produrre 2.
N = 3 risultati in ADGJMP. L'esecuzione di questo dovrebbe generare 3.
N = 4 risultati in AEIM. L'esecuzione di questo dovrebbe produrre 4.
N = 5 risultati in AFKP. L'esecuzione di questo dovrebbe produrre 5.
N = 6 risultati in AGM. L'esecuzione di questo dovrebbe generare 6.
N = 7 risultati in AHO. L'esecuzione di questo dovrebbe generare 7.
N = 8 risultati in AI. L'esecuzione di questo dovrebbe generare 8.
N = 9 risultati in AJ. L'esecuzione di questo dovrebbe produrre 9.
N = 10 risultati in AK. L'esecuzione di questo dovrebbe produrre 10.
N = 11 risultati in AL. L'esecuzione di questo dovrebbe produrre 11.
N = 12 risultati inAM. L'esecuzione di questo dovrebbe produrre 12.
N = 13 risultati in AN. L'esecuzione di questo dovrebbe produrre 13.
N = 14 risultati in AO. L'esecuzione di questo dovrebbe generare 14.
N = 15 risultati in AP. L'esecuzione di questo dovrebbe produrre 15.
N = 16 risultati in A. L'esecuzione di questo dovrebbe generare 16.

Dettagli

• Sono ammessi tutti i caratteri, ASCII e non ASCII. (Sono consentiti anche newline e ASCII non stampabili. Si noti che il ritorno a capo e l'avanzamento riga contano come caratteri distinti.)
• Il tuo punteggio è la lunghezza in caratteri del tuo programma inalterato (15 in esempio). Vince il punteggio più basso.
• Un punteggio inferiore a 16 è chiaramente impossibile perché almeno due dei programmi modificati sarebbero identici.
• L'output può essere in un file o stdout o qualsiasi altra cosa ragionevole. Tuttavia, l'output dei 16 programmi diversi deve andare tutti nello stesso posto (ad es. Non AOva bene se va su stdout ma Ava su un file). Non ci sono input.
• L'output deve essere decimale, non esadecimale. L'output effettivo dovrebbe contenere solo 1 o 2 caratteri che compongono il numero da 1 a 16, nient'altro. (Cose come quelle di Matlab ans =sono ok.)
• Il tuo programma non deve funzionare per N = 17 o superiore.

APL, 49

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

Programmi alterati

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

spiegazione

Inizierò dal basso in quanto faciliterebbe la spiegazione

Vi sono due funzioni linguistiche di APL da tenere a mente. Uno, APL non ha la precedenza di operatore, le dichiarazioni sono sempre valutate da destra a sinistra. Due, molte funzioni APL si comportano in modo abbastanza diverso a seconda che ricevano un argomento alla sua destra (monadico) o due argomenti alla sua sinistra e a destra (diadico).

Monadic ⌊è arrotondato per difetto (funzione floor), Dyadic× è ovviamente moltiplicazione, ⍝commenta il resto della linea
Questo dovrebbe rendere ovvi questi:

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

9: ⌊/9×1
/ è Riduci. Fondamentalmente prende la funzione di sinistra e l'array a destra, inserisce la funzione tra ogni coppia di elementi dell'array e valuta. (Questo è chiamato "fold" in alcune lingue)
Qui, l'argomento giusto è uno scalare, quindi /non fa nulla.

8:⌊|8×× 2
Monadic ×è la funzione signum e monadic |è la funzione di valore assoluto Quindi,× 2 valuta 1ed |8×1è ovviamente8

7:⌊11-4 ⍝ dovrebbe essere ovvio

6:⌊⍟19×51⍝2
Monadic ⍟è log naturale
Quindi, ⍟19×51valutaln(19×51) = 6.87626... e ⌊arrotonda a6

5:⌊⍟21×○5
Monadic ○moltiplica il suo argomento per π
⍟21×○5 èln(21×5π) = 5.79869...

4:⌊7|18××4×1 ⍝2
Dyadic |è la funzione mod
×4×1valutata1 , ed 7|18×1è18 mod 7 = 4

3: i⌊○⍟/119-××5 1 ⍝ 2
valori separati da spazio sono un array. Si noti che in APL, quando la maggior parte delle funzioni scalari fornisce argomenti array, si tratta di una mappa implicita.
Dyadic ⍟è log
Quindi ××5 1, è signum di signum su 5 e 1, che dà 1 1, 119-1 1è ¯118 ¯118( ¯è solo il segno meno. APL deve distinguere tra numeri negativi e sottrazione), e⍟/¯118 ¯118 è log _-118 (-118) = 1

2: ⌊⍟7⍟|21189×1×345× 1 ⍝⍝_2
puoi risolverlo da solo

1:⌊⊃⍟○7⍟⍟1|/2111118 9⍝×-1 ×○3×4_5_× 1_ _⍝_⍝ __2
Questo consiste in un uso più complicato di /. If nè un numero, Fè una funzione ed Aè un array, quindi nF/Aaccetta ogni gruppo di nvoci consecutive Ae si applica F/. Ad esempio, 2×/1 2 3accetta ogni coppia di voci consecutive (che sono 1 2e 2 3) e si applica ×/a ciascun gruppo per dare 2 6
So, quindi 1|/2111118 9restituisce 2111118 9(come si applica |/agli scalari). Quindi, ⍟○7⍟⍟applica ln, quindi registra ₇ per quei numeri, quindi li moltiplica per π e di nuovo. I numeri che escono dall'altra parte sono 1.46424... 0.23972...
Qui, ⊃è solo usato per selezionare il primo elemento di un array.

Python - 1201 1137 (generatore: 241 218) - Lunga vita agli hash!

Strategia:

Ho provato a iniziare ogni riga con tutti gli hash quanti sono i risultati desiderati n. Quindi tutte le altre versioni salteranno completamente questa linea.

La difficoltà principale, tuttavia, era quella di aggiungere il numero corretto di hash in modo che la corsa successiva colpisse esattamente l'inizio della riga successiva. Inoltre, potrebbero verificarsi interferenze con altre versioni, ad esempio la versione 16 che salta a destraprint comando della riga 5 e così via. Quindi questo è stato un sacco di tentativi ed errori combinati con uno script di supporto per test rapidi.

Statistiche:

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

Codice:

#
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

Script di prova:

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

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

Produzione:

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

Aggiornamento: uno script di generazione!

Ho pensato alla mia soluzione e che ci deve essere uno schema per generarla algoritmicamente. Quindi eccoci qui:

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)

Costruisce il programma riga per riga:

1. Inizia con un hash.
2. Aggiungi una nuova riga icon il print icomando ei - 1 hash tra ogni due personaggi vicini.
3. Mentre la "versione i" (ogni i-esimo carattere) del programma corrente non contiene il comando print i(a causa di un disallineamento) o qualsiasi n-versione con n in range(1, 17)un'eccezione, aggiungi un altro hash alla riga precedente.

In realtà ha restituito un programma più breve di quello che ho trovato manualmente questa mattina. (Quindi ho aggiornato la mia soluzione sopra.) Inoltre, sono abbastanza sicuro che non ci sia implementazione più breve seguendo questo schema. Ma non lo sai mai!

Versione golfizzata - 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)

Si noti che potrebbe esserci un generatore più breve, ad esempio codificando il numero richiesto di hash successivi per ogni riga. Ma questo li calcola da solo e potrebbe essere usato per qualsiasi N> 16.

Befunge 93 - Cinque milioni settecentosessantacinquemilasettecentosettantasei caratteri

Chiedo di essere preso sul serio ...

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 motivi per cui. 1 ° motivo: uno script befunge è sempre 80x25, quindi, qualunque cosa accada, doveva esserci qualcosa che si riduceva sulle righe con il codice. 2 ° motivo: perché quel qualcosa ha circa 5,5 milioni di spazi è perché 720 720 è il più piccolo multiplo comune da 1 a 16 ... Significa che non ci sarà alcun disordine quando saltiamo i personaggi. Terza ragione: wow, questo è abbastanza assurdo.

209 caratteri (varie lingue)

Ho appena cercato di mantenere le cose semplici ed evitare di mettere qualsiasi cosa in posizione con molti fattori primi. Il vantaggio è la capacità di funzionare in molti linguaggi di scripting. Dovrebbe funzionare in qualsiasi lingua che non sia deliberatamente perversa e abbia le seguenti caratteristiche:

• Letterali interi
• Operatori aritmetici di base +, - (sottrazione e negazione), *, /
• Stampa la valutazione di un'espressione nuda
• Ha un singolo carattere che inizia un commento di riga

Per esempio,

Interprete della riga di comando di Python 2 (anche se non da un file):

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

MATLAB (sostituisci semplicemente '#' con '%'):

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

NB Dovrebbero esserci 17 spazi che precedono il primo '1'. Ragazzi conoscete molte lingue, quindi per favore aiutatemi a elencare di più in cui potrebbe funzionare (:

EDIT: aggiunto unario + in posizione 0 per Python per evitare che la linea sia rientrata.

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-

Questo approccio non utilizza alcun tipo di commento.

iesegue il cast di numeri interi, quindi qui è un noop. Potrebbe essere sostituito da spazi bianchi, ma le lettere mi sembrano più leggibili ...

Provalo online eseguendo il seguente codice :

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*

Esempio di esecuzione

$ 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

Questo sfrutta i commenti ( #) e i "super commenti" non documentati (tutto ciò che segue un ineguagliato }viene silenziosamente ignorato).

_è un noop. Potrebbe essere sostituito da spazi bianchi, ma i caratteri di sottolineatura mi sembrano più leggibili ...

Provalo online.

Esempio di esecuzione

$ 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