Écrivez le programme le plus court possible de sorte que lorsque vous combinez le premier caractère et chaque Nième caractère suivant dans un nouveau programme, la sortie soit N. Cela doit fonctionner pour N = 1, 2, ..., 16.

Une autre façon de le dire est que si vous supprimez tous les caractères de votre programme à l' exception du premier et de tous les N après, la sortie du code restant doit être N.

Exemple

Si votre code était

ABCDEFGHIJKLMNOP

N = 1 résulte en ABCDEFGHIJKLMNOP. L'exécution de cela devrait produire 1.
N = 2 résultats ACEGIKMO. L'exécution de ceci devrait produire 2.
N = 3 résultats ADGJMP. L'exécution devrait produire 3.
N = 4 résultats AEIM. L'exécution de ceci devrait produire 4.
N = 5 résultats AFKP. L'exécution devrait produire 5.
N = 6 résultats AGM. L'exécution devrait produire 6.
N = 7 résultats AHO. L'exécution devrait produire 7.
N = 8 résultats AI. L'exécution devrait produire 8.
N = 9 entraîne AJ. L'exécution devrait produire 9.
N = 10 résultats AK. L'exécution devrait produire 10.
N = 11 entraîne AL. L'exécution de ceci devrait produire 11.
N = 12 entraîneAM. L'exécution de ceci devrait produire 12.
N = 13 résultats AN. L'exécution devrait produire 13.
N = 14 résultats AO. L'exécution de ceci devrait produire 14.
N = 15 résultats AP. L'exécution devrait produire 15.
N = 16 résultats A. L'exécution devrait produire 16.

Détails

• Tous les caractères sont autorisés, ASCII et non ASCII. (Les retours à la ligne et les caractères ASCII non imprimables sont également autorisés. Notez que le retour chariot et le saut de ligne comptent comme des caractères distincts.)
• Votre score est la longueur en caractères de votre programme inchangé (15 par exemple). Le score le plus bas l'emporte.
• Un score inférieur à 16 est clairement impossible car alors au moins deux des programmes modifiés seraient identiques.
• La sortie peut être vers un fichier ou une sortie standard ou toute autre chose raisonnable. Cependant, la sortie des 16 programmes différents doit tous aller au même endroit (par exemple, ce n'est pas ok si AOva à stdout mais Ava dans un fichier). Il n'y a aucune entrée.
• La sortie doit être décimale et non hexadécimale. La sortie réelle ne doit contenir que les 1 ou 2 caractères qui composent le nombre de 1 à 16, rien d'autre. (Des choses comme Matlab ans =sont ok.)
• Votre programme ne doit pas fonctionner pour N = 17 ou supérieur.

APL, 49

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

Programmes modifiés

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

Explication

Je vais commencer par le bas car cela faciliterait l'explication

Il y a deux fonctionnalités linguistiques d'APL à garder à l'esprit. Premièrement, APL n'a pas de priorité d'opérateur, les instructions sont toujours évaluées de droite à gauche. Deux, de nombreuses fonctions APL se comportent très différemment selon qu'on lui donne un argument à droite (monadique) ou deux arguments à gauche et à droite (dyadique).

Monadic ⌊est arrondi (fonction plancher), Dyadic ×est évidemment une multiplication, ⍝commente le reste de la ligne
Cela devrait rendre cela évident:

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

9:⌊/9×1
/ est Réduire. Fondamentalement, il prend la fonction de gauche et le tableau de droite, insère la fonction entre chaque paire d'éléments du tableau et évalue. (Ceci est appelé "fold" dans certaines langues)
Ici, le bon argument est un scalaire donc /ne fait rien.

8:⌊|8×× 2
Monadic ×est la fonction de signum et monadic est la fonction de| valeur absolue Donc, × 2évalue 1et |8×1est bien sûr8

7:⌊11-4 ⍝ devrait être évident

6:⌊⍟19×51⍝2
Monadic ⍟est un logarithme naturel
Donc, ⍟19×51évalue ln(19×51) = 6.87626...et ⌊arrondit à6

5:⌊⍟21×○5
Monadic ○multiplie son argument par π
⍟21×○5estln(21×5π) = 5.79869...

4:⌊7|18××4×1 ⍝2
Dyadique |est la fonction mod
×4×1évaluée 1et 7|18×1est18 mod 7 = 4

3:⌊○⍟/119-××5 1 ⍝ 2
Les valeurs séparées par des espaces sont un tableau. Notez que dans APL, lorsque la plupart des fonctions scalaires donnent des arguments de tableau, il s'agit d'une carte implicite.
Dyadique ⍟est log
Donc ××5 1, est signum de signum sur 5 et 1, ce qui donne 1 1, 119-1 1est ¯118 ¯118( ¯est juste le signe moins. APL doit faire la distinction entre les nombres négatifs et la soustraction), et ⍟/¯118 ¯118est log _-118 (-118) = 1

2:⌊⍟7⍟|21189×1×345× 1 ⍝⍝_2
Vous pouvez vous débrouiller seul

1:⌊⊃⍟○7⍟⍟1|/2111118 9⍝×-1 ×○3×4_5_× 1_ _⍝_⍝ __2
Celui-ci consiste en une utilisation plus compliquée de /. Si nest un nombre, Fest une fonction et Aest un tableau, nF/Aprend alors chaque groupe d' nentrées consécutives de Aet s'applique F/. Par exemple, 2×/1 2 3prend chaque paire d'entrées consécutives (qui sont 1 2et 2 3) et s'appliquent ×/à chaque groupe pour donner 2 6
So, 1|/2111118 9renvoie simplement 2111118 9(comme cela s'applique |/aux scalaires). Ensuite, ⍟○7⍟⍟applique ln, puis connectez ₇ à ces nombres, puis multipliez-les par π et ln à nouveau. Les nombres qui sortent de l'autre côté sont 1.46424... 0.23972...
ici, ⊃est juste utilisé pour sélectionner le premier élément d'un tableau.

Python - 1201 1137 (générateur: 241 218) - Vive les hachages!

Stratégie:

J'ai essayé de démarrer chaque ligne avec autant de hachages que la sortie souhaitée n. Ensuite, toutes les autres versions ignoreront complètement cette ligne.

La principale difficulté, cependant, a été d'ajouter le nombre correct de hachages afin que la prochaine exécution atteigne exactement le début de la ligne suivante. De plus, des interférences avec d'autres versions peuvent se produire, par exemple la version 16 sautant directement dans la printcommande de la ligne 5 et ainsi de suite. C'était donc beaucoup d'essais et d'erreurs combinés avec un script d'aide pour des tests rapides.

Statistiques:

• Caractères: 1201 1137
• Hachage: 1066 1002 (88,1%)
• Sans hachage: 135 (11,9%)

Code:

#
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 de test:

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

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

Production:

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

Mise à jour: un script générateur!

J'ai pensé à ma solution et qu'il doit y avoir un modèle pour la générer de manière algorithmique. Alors c'est parti:

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)

Il construit le programme ligne par ligne:

1. Commencez avec un hachage.
2. Ajoutez une nouvelle ligne iavec la print icommande et i - 1hache entre chacun des deux caractères voisins.
3. Bien que la «i-version» (chaque i-ème caractère) du programme en cours ne contienne pas la commande print i(en raison d'un mauvais alignement) ou toute nversion avec n in range(1, 17)lève une exception, ajoutez un autre hachage à la ligne précédente.

Il a en fait renvoyé un programme plus court que ce que j'ai trouvé manuellement ce matin. (J'ai donc mis à jour ma solution ci-dessus.) De plus, je suis sûr qu'il n'y a pas d'implémentation plus courte suivant ce modèle. Mais tu ne sais jamais!

Version golfed - 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)

Notez qu'il peut y avoir un générateur plus court, par exemple en codant en dur le nombre requis de hachages successifs pour chaque ligne. Mais celui-ci les calcule lui-même et pourrait être utilisé pour tout N> 16.

Befunge 93 - Cinq millions sept cent soixante-cinq mille sept cent soixante-seize caractères

Je demande à être pris au sérieux ...

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 raisons pour lesquelles. 1ère raison: un script befunge est toujours 80x25, donc quoi qu'il arrive , il devait y avoir quelque chose qui se réduisait sur les lignes avec du code. 2ème raison: pourquoi quelque chose représente environ 5,5 millions d'espaces, parce que 720 720 est le plus petit multiple commun de 1 à 16 ... Cela signifie qu'il n'y aura pas de désordre autour lorsque nous sautons des personnages. 3e raison: wow, c'est assez absurde.

209 caractères (plusieurs langues)

J'ai juste essayé de garder les choses simples et d'éviter de mettre quoi que ce soit dans des positions avec beaucoup de facteurs premiers. L'avantage est la possibilité de s'exécuter dans de nombreux langages de script. Il devrait fonctionner dans n'importe quelle langue qui n'est pas délibérément perverse et qui présente les caractéristiques suivantes:

• Littéraux entiers
• Opérateurs arithmétiques de base +, - (soustraction et négation), *, /
• Imprime l'évaluation d'une expression nue
• A un seul caractère qui commence un commentaire de ligne

Par exemple,

Interpréteur de ligne de commande Python 2 (mais pas à partir d'un fichier):

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

MATLAB (remplacez simplement '#' par '%'):

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

NB Il doit y avoir 17 espaces avant le premier «1». Vous connaissez beaucoup de langues, alors s'il vous plaît, aidez-moi à en énumérer plus sur lesquelles il pourrait fonctionner (:

EDIT: ajout d'unaire + à la position 0 pour Python pour éviter que la ligne ne soit indentée.

CJam, 89 octets

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

Cette approche n'utilise aucun type de commentaires.

itransforme en entier, c'est donc un noop ici. Il pourrait être remplacé par des espaces, mais les lettres me semblent plus lisibles ...

Essayez-le en ligne en exécutant le code suivant :

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*

Exemple d'exécution

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

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

Cela profite des commentaires ( #) et des "super-commentaires" non documentés (tout ce qui suit un inégalé }est ignoré en silence).

_est un noop. Il pourrait être remplacé par des espaces, mais les soulignements me semblent plus lisibles ...

Essayez-le en ligne.

Exemple d'exécution

$ 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