Schreiben Sie das kürzestmögliche Programm, sodass die Ausgabe N ist, wenn Sie das erste Zeichen und jedes N-te Zeichen danach zu einem neuen Programm kombinieren. Dies muss für N = 1, 2, ..., 16 funktionieren.

Eine andere Art zu sagen ist, wenn Sie alle Zeichen aus Ihrem Programm entfernen , außer dem ersten und jedem N-ten danach, sollte die Ausgabe des verbleibenden Codes N sein.

Beispiel

Wenn Ihr Code war

ABCDEFGHIJKLMNOP

N = 1 ergibt ABCDEFGHIJKLMNOP. Wenn Sie dies ausführen, sollte 1 ausgegeben werden.
N = 2 ergibt ACEGIKMO. Wenn Sie dies ausführen, sollte 2 ausgegeben werden.
N = 3 ergibt ADGJMP. Wenn Sie dies ausführen, sollte 3 ausgegeben werden.
N = 4 ergibt AEIM. Wenn Sie dies ausführen, sollte 4 ausgegeben werden.
N = 5 ergibt AFKP. Wenn Sie dies ausführen, sollte 5 ausgegeben werden.
N = 6 ergibt AGM. Wenn Sie dies ausführen, sollte 6 ausgegeben werden.
N = 7 ergibt AHO. Wenn Sie dies ausführen, sollte 7 ausgegeben werden.
N = 8 ergibt AI. Wenn Sie dies ausführen, sollte 8 ausgegeben werden.
N = 9 ergibt AJ. Wenn Sie dies ausführen, sollte 9 ausgegeben werden.
N = 10 ergibt AK. Wenn Sie dies ausführen, sollte 10 ausgegeben werden.
N = 11 ergibt AL. Wenn Sie dies ausführen, sollte 11 ausgegeben werden.
N = 12 ergibtAM. Wenn Sie dies ausführen, sollte 12 ausgegeben werden.
N = 13 ergibt AN. Wenn Sie dies ausführen, sollte 13 ausgegeben werden.
N = 14 ergibt AO. Wenn Sie dies ausführen, sollte 14 ausgegeben werden.
N = 15 ergibt AP. Wenn Sie dies ausführen, sollte 15 ausgegeben werden.
N = 16 ergibt A. Das Ausführen von this sollte 16 ausgeben.

Einzelheiten

• Alle Zeichen sind zulässig, ASCII und Nicht-ASCII. (Zeilenumbrüche und nicht druckbares ASCII sind ebenfalls zulässig. Beachten Sie, dass Wagenrücklauf und Zeilenvorschub als unterschiedliche Zeichen gelten.)
• Ihre Punktzahl ist die Länge in Zeichen Ihres unveränderten Programms (15 im Beispiel). Die niedrigste Punktzahl gewinnt.
• Eine Punktzahl unter 16 ist eindeutig unmöglich, da dann mindestens zwei der geänderten Programme identisch wären.
• Die Ausgabe kann in einer Datei oder einem Standardformat oder in einem anderen vernünftigen Format erfolgen. Die Ausgabe der 16 verschiedenen Programme muss jedoch alle an derselben Stelle erfolgen (z. B. ist es nicht in Ordnung, wennAO stdout, sondern Aeine Datei abgelegt wird). Es erfolgt keine Eingabe.
• Die Ausgabe muss dezimal und nicht hexadezimal erfolgen. Die eigentliche Ausgabe sollte nur die 1 oder 2 Zeichen enthalten, aus denen die Zahl von 1 bis 16 besteht, sonst nichts. (Sachen wie Matlab'sans = sind in Ordnung.)
• Ihr Programm muss nicht für N = 17 oder höher funktionieren.

APL, 49

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

Geänderte Programme

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

Erklärung

Ich beginne von unten, da dies das Erklären erleichtern würde

Es gibt zwei Sprachfunktionen von APL, die berücksichtigt werden müssen. Erstens hat APL keine Operatorpriorität, Anweisungen werden immer von rechts nach links ausgewertet. Zweitens verhalten sich viele APL-Funktionen ganz unterschiedlich, je nachdem, ob sie ein Argument rechts (monadisch) oder zwei Argumente links und rechts (dyadisch) haben.

Monadic ⌊ist Abrundungs (Boden - Funktion), Dyadic ×offensichtlich Multiplikation ist, ⍝Kommentare aus Rest der Zeile
Dies sollte diese offensichtlich machen:

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

9:⌊/9×1
/ ist Reduzieren. Grundsätzlich übernimmt es die Funktion des linken und des rechten Arrays, fügt die Funktion zwischen jedes Elementepaar des Arrays ein und wertet aus. (Dies wird in einigen Sprachen als "Falz" bezeichnet.)
Hier ist das richtige Argument ein Skalar, /also nichts.

8:⌊|8×× 2
Monadic ×ist die Signum - Funktion und monadischen |ist der absolute Wert Funktion also × 2auswertet zu 1und |8×1ist natürlich8

7:⌊11-4 ⍝ sollte offensichtlich sein

6:⌊⍟19×51⍝2
Monadic ⍟ist natürlich log
So ⍟19×51auswertet zu ln(19×51) = 6.87626...und ⌊Runden es auf6

5:⌊⍟21×○5
Monadisch ○multipliziert sein Argument mit π
⍟21×○5istln(21×5π) = 5.79869...

4:⌊7|18××4×1 ⍝2
Dyadic |ist die Mod-Funktion, die
×4×1ausgewertet 1wird und 7|18×1ist18 mod 7 = 4

3: Durch⌊○⍟/119-××5 1 ⍝ 2
Leerzeichen getrennte Werte sind ein Array. Beachten Sie, dass es sich in APL um eine implizite Zuordnung handelt, wenn die meisten skalaren Funktionen Array-Argumente angeben.
Dyadisch ⍟ist log
Also ××5 1ist signum von signum auf 5 und 1, was ergibt 1 1, 119-1 1ist ¯118 ¯118( ¯ist nur das Minuszeichen. APL muss zwischen negativen Zahlen und Subtraktion unterscheiden) und ⍟/¯118 ¯118ist log _-118 (-118) = 1

2: ⌊⍟7⍟|21189×1×345× 1 ⍝⍝_2
Du kannst es selbst herausfinden

1:⌊⊃⍟○7⍟⍟1|/2111118 9⍝×-1 ×○3×4_5_× 1_ _⍝_⍝ __2
Diese bestehen aus einer komplizierteren Verwendung von /. Wenn neine Zahl, Feine Funktion und Aein Array ist, nF/Awird jede Gruppe von naufeinanderfolgenden Einträgen von Aund angewendet F/. Nimmt man beispielsweise 2×/1 2 3jedes Paar aufeinanderfolgender Einträge (welche 1 2und sind 2 3) und wendet sie ×/auf jede Gruppe an, 2 6
so ergibt sich 1|/2111118 9nur ein Rückgabewert 2111118 9(wie es für |/Skalare gilt). Dann ⍟○7⍟⍟ln gilt, dann melden Sie sich ₇ auf diese Zahlen, dann sie multipliziert mit π und ln wieder. Die Zahlen, die auf der anderen Seite erscheinen, werden 1.46424... 0.23972...
hier ⊃verwendet, um nur das erste Element eines Arrays auszuwählen.

Python - 1201 1137 (Generator: 241 218) - Es lebe die Hasch!

Strategie:

Ich habe versucht, jede Zeile mit so vielen Hashes wie der gewünschten Ausgabe zu beginnen n. Dann überspringen alle anderen Versionen diese Zeile vollständig.

Die Hauptschwierigkeit bestand jedoch darin, die richtige Anzahl von Hashes anzufügen, damit der nächste Lauf genau auf den Anfang der nächsten Zeile trifft. Darüber hinaus können Störungen bei anderen Versionen auftreten, z. B. bei Version 16, die direkt in dieprint Befehl von Zeile 5 und so weiter. Dies war also eine Menge Versuch und Irrtum, kombiniert mit einem Hilfsskript für schnelle Tests.

Statistiken:

• Zeichen: 1201 1137
• Hashes: 1066 1002 (88,1%)
• Nicht-Hashes: 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

Testskript:

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

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

Ausgabe:

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

Update: Ein generierendes Skript!

Ich dachte über meine Lösung nach und dass es ein Muster geben muss, um es algorithmisch zu generieren. Auf geht's:

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)

Es baut das Programm Zeile für Zeile auf:

1. Beginnen Sie mit einem Hash.
2. Fügen Sie imit dem print iBefehl und eine neue Zeile hinzui - 1 hacken Sie zwischen zwei benachbarten Zeichen.
3. Während die "i-version" (jedes i-te Zeichen) des aktuellen Programms den Befehl print i(aufgrund von Fehlausrichtung) oder eine n-version mit n in range(1, 17)einer Ausnahme nicht enthält, fügen Sie der vorherigen Zeile einen weiteren Hash hinzu.

Es gab tatsächlich ein kürzeres Programm zurück, als ich heute Morgen manuell gefunden habe. (Also habe ich meine Lösung oben aktualisiert.) Außerdem bin ich mir ziemlich sicher, dass es nach diesem Muster keine kürzere Implementierung gibt. Aber du weißt nie!

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

Beachten Sie, dass es einen kürzeren Generator geben kann, z. B. indem Sie die erforderliche Anzahl aufeinanderfolgender Hashes für jede Zeile fest codieren. Aber dieser berechnet sie selbst und kann für jeden N> 16 verwendet werden.

Befunge 93 - Fünf Millionen siebenhundertfünfundsechzigtausend und siebenhundertsechsundsiebzig Zeichen

Ich fordere, ernst genommen zu werden ...

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 Gründe warum. 1. Grund: Ein befunge-Skript hat immer eine Größe von 80x25, also musste es etwas geben , das durch Code in den Zeilen reduziert wurde. 2. Grund: Warum das etwa 5,5 Millionen Leerzeichen sind, liegt daran, dass 720 720 das kleinste gemeinsame Vielfache von 1 bis 16 ist. 3. Grund: Wow, das ist ziemlich absurd.

209 Zeichen (verschiedene Sprachen)

Ich habe nur versucht, die Dinge einfach zu halten und zu vermeiden, etwas mit vielen Primfaktoren in Positionen zu bringen. Der Vorteil ist die Fähigkeit, in vielen Skriptsprachen ausgeführt zu werden. Es sollte in jeder Sprache funktionieren, die nicht absichtlich pervers ist und die folgenden Funktionen aufweist:

• Ganzzahlige Literale
• Grundrechenarten +, - (Subtraktion und Negation), *, /
• Gibt die Auswertung eines bloßen Ausdrucks aus
• Hat ein einzelnes Zeichen, das mit einem Zeilenkommentar beginnt

Beispielsweise,

Python 2-Befehlszeileninterpreter (wenn auch nicht aus einer Datei):

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

MATLAB (einfach '#' durch '%' ersetzen):

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

NB Vor der ersten '1' sollten 17 Leerzeichen stehen. Ihr kennt viele Sprachen, also helft mir bitte, mehr aufzulisten, in denen es laufen könnte (:

BEARBEITEN: Unäres + an Position 0 für Python hinzugefügt, um zu vermeiden, dass die Zeile eingerückt wird.

CJam, 89 Bytes

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

Dieser Ansatz verwendet keinerlei Kommentare.

iwird in eine Ganzzahl umgewandelt, daher ist es hier ein Noop. Es könnte durch Leerzeichen ersetzt werden, aber die Buchstaben scheinen mir besser lesbar zu sein ...

Probieren Sie es online aus, indem Sie den folgenden Code ausführen :

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*

Beispiellauf

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

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

Dies nutzt die Vorteile von comments ( #) und den undokumentierten "Superkommentaren" (alles, was auf einen nicht übereinstimmenden folgt }, wird stillschweigend ignoriert).

_ist ein Noop. Es könnte durch Leerzeichen ersetzt werden, aber die Unterstriche erscheinen mir lesbarer ...

Probieren Sie es online aus.

Beispiellauf

$ 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