Ihre Aufgabe ist einfach. Veröffentlichen Sie ein Snippet in einer beliebigen Sprache, die bei n-maliger Wiederholung des Snippets n in der angegebenen Reihenfolge in Dezimal-, Oktal- und Hexadezimalzeichen und in Leerzeichen getrennt ausgibt. n ist eine ganze Zahl größer als Null. Es gibt keine führenden Nullen. Kürzeste Antwort gewinnt

Beispiel

Wenn das Snippet ist, ABCist der Testfall

ABC 
1 1 1
ABCABC
2 2 2
ABCABCABCABCABCABCABCABCABC
9 11 9
ABCABCABCABCABCABCABCABCABCABCABCABC
12 14 C
ABCABCABCABCABCABCABCABCABCABCABCABCABCABCABCABCABCABC
18 22 12

Japt, 12 Bytes

[°TTs8 TsG]¸

Vielen Dank an @ETHproductions für das Speichern von 2 Bytes!

Gleich wie meine Antwort.

Perl, 30 Bytes

printf"\r%d %o %x",++$n,$n,$n;

Zurück zum Zeilenanfang, Zähler erhöhen und Zähler drucken überschreiben die alte Ausgabe.

JavaScript, 54 53 51 47 Bytes

4 Bytes dank @ user81655 gespeichert

var d=-~d;d+` ${d[b='toString'](8)} `+d[b](16);

Ich bin eigentlich ein bisschen überrascht, dass dies funktioniert.

Erläuterung

var d=-~d;  // `var` let's `d` not throw an error if it's not defined 
            // -~ essentially increments the variable
d+                    // decimal
` ${                  // space character
   d[b='toString'](8) // octal
} `                   // space character
+d[b](16)             // Hexadecimal

Probieren Sie es online aus

C ++ 205 179 Bytes

int main(){};static int c=1;
#define v(x) A##x
#define u(x) v(x)
#define z u(__LINE__)
#include <cstdio>
class z{public:z(){++c;};~z(){if(c){printf("%d %o %x",--c,c,c);c=0;}}}z;//

(Keine nachgestellte neue Zeile - beim Kopieren sollten die erste Zeile der Kopie und die letzte Zeile des Originals übereinstimmen.)

Grundsätzlich funktioniert dies, indem eine Folge von statischen Variablen erstellt wird, die beim Aufbau einen globalen Variablenzähler inkrementieren. Wenn der Zähler bei der Zerstörung nicht 0 ist, wird die gesamte Ausgabe ausgeführt und der Zähler auf Null gesetzt.

Um eine Folge von Variablen ohne Namenskonflikte zu definieren, verwenden wir das Makro, das wie folgt erklärt wird:

#define v(x) A##x    //This concatenates the string "A" with the input x.
#define u(x) v(x)    //This slows down the preprocessor so it expands __LINE__ rather than yielding A__LINE__ as v(__LINE__) would do.
#define z u(__LINE__)//Gives a name which is unique to each line.

was etwas von den Macken des String-Prozessors abhängt. Wir verwenden zviele Male, um Klassen / Variablen zu definieren, die nicht miteinander in Konflikt stehen, wenn sie in separate Zeilen kopiert werden. Außerdem werden die Definitionen, die nur einmal vorkommen müssen, in die erste Zeile gestellt, die in Kopien des Codes auskommentiert ist. Die #defineund #include-Anweisungen kümmern sich nicht darum, dass sie wiederholt werden, daher ist keine besondere Behandlung erforderlich.

Dieser Code zeigt auch undefiniertes Verhalten in der Anweisung:

printf("%d %o %x",--c,c,c)

da es keine Sequenzpunkte gibt, aber c geändert wird und zugegriffen wird. LLVM 6.0 gibt eine Warnung aus, kompiliert sie jedoch wie gewünscht - --cdie zuvor ausgewertet wurde c. Man könnte auf Kosten von zwei Bytes, fügen Sie die Anweisung --c;vor den Ausgängen und Änderung --cin printfan c, die der Warnung loswerden würde.

Ersetzt std::coutdurch printfSpeichern von 26 Bytes dank eines Vorschlags meines Bruders.

CJam, 20 19 18 Bytes

];U):USU8bSU"%X"e%

Danke an @ MartinBüttner für das Golfen ab 1 Byte!

Probieren Sie es online!

Wie es funktioniert

]                  e# Wrap the entire stack in an array.
 ;                 e# Discard the array.
  U                e# Push U (initially 0).
   ):U             e# Increment and save in U.
      S            e# Push a space.
       U8b         e# Convert U to base 8 (array of integers).
          S        e# Push a space.
           U"%X"e% e# Convert U to hexadecimal (string).

𝔼𝕊𝕄𝕚𝕟 14 Zeichen / 28 Byte

[⧺Ḁ,Ḁß8,Ḁⓧ]ø⬭;

Try it here (Firefox only).

Erste Antwort! Obwohl es wahrscheinlich bessere Möglichkeiten gibt, damit umzugehen.

Erläuterung

[⧺Ḁ,Ḁß8,Ḁⓧ]ø⬭; // implicit: Ḁ = 0
[⧺Ḁ,             // increment Ḁ by 1
    Ḁß8,         // octal representation of Ḁ
        Ḁⓧ]     // hex representation of Ḁ
            ø⬭; // join above array with spaces
                 // repeat as desired until implicit output

MATL , 26 Bytes

Verwendet die aktuelle Version (6.0.0) . Funktioniert auf Oktave.

0$N1+ttYUb8YAb16YA3$XhZc1$

Beispiele

Einmal:

>> matl 0$N1+ttYUb8YAb16YA3$XhZc1$
1 1 1

Zweimal:

>> matl 0$N1+ttYUb8YAb16YA3$XhZc1$0$N1+ttYUb8YAb16YA3$XhZc1$
2 2 2

16 mal:

>> matl 0$N1+ttYUb8YAb16YA3$XhZc1$0$N1+ttYUb8YAb16YA3$XhZc1$0$N1+ttYUb8YAb16YA3$XhZc1$0$N1+ttYUb8YAb16YA3$XhZc1$0$N1+ttYUb8YAb16YA3$XhZc1$0$N1+ttYUb8YAb16YA3$XhZc1$0$N1+ttYUb8YAb16YA3$XhZc1$0$N1+ttYUb8YAb16YA3$XhZc1$0$N1+ttYUb8YAb16YA3$XhZc1$0$N1+ttYUb8YAb16YA3$XhZc1$0$N1+ttYUb8YAb16YA3$XhZc1$0$N1+ttYUb8YAb16YA3$XhZc1$0$N1+ttYUb8YAb16YA3$XhZc1$0$N1+ttYUb8YAb16YA3$XhZc1$0$N1+ttYUb8YAb16YA3$XhZc1$0$N1+ttYUb8YAb16YA3$XhZc1$
16 20 10

Erläuterung

Die Anzahl der Elemente im Stapel gibt an, wie oft das Snippet ausgeführt wurde

0$         % specify zero inputs for next function, in case this is not the first
           % occurence of the snippet.
N          % number of elements in stack
1+         % add one
tt         % duplicate twice. We now have three copies of the number
YU         % convert to string (decimal)
b8YA       % bubble up number and convert to octal string
b16YA      % bubble up number and convert to hex string
3$XhZc     % join top three elements (strings) with a space
1$         % specify one input for next function. If the program ends here, that next
           % function will be implicit display, so it will print the top of the stack.
           % Else the stack will be left with one element more than at the beginning of
           % the current snippet

OCaml, 198 Bytes

;;open Char
;;(if Sys.argv.(0).[0]='~'then Sys.argv.(0).[0]<-'\000'else Sys.argv.(0).[0]<-chr(1+int_of_char Sys.argv.(0).[0]));let n=1+int_of_char Sys.argv.(0).[0]in Printf.printf"\r%d %o %x"n n n

Enthält eine abschließende Newline und erfordert, dass der Dateiname mit einer Tilde beginnt (ich habe sie verwendet ~.ml; Sie können sie damit ausführen ocaml \~.ml), da es sich um das druckbare Standard-ASCII-Zeichen mit dem höchsten Wert handelt. Missbraucht die Tatsache, dass alle Zeichen in einer Zeichenfolge veränderlich sind und Sys.argv.(0).[0]das erste Zeichen im Dateinamen sind.

Es sollte nur für n = 1 bis 126 funktionieren, da der ASCII-Code für ~126 lautet und ich einen zur Ausgabe hinzufüge. Es könnte zwei Bytes kürzer gemacht werden, wenn wir nur n = 1 bis 125 wollen. Nachdem es 126 Mal wiederholt wurde, wird zurück zu n = 1 gewechselt.

Dies ist mein allererster Golf, daher sind Kommentare oder Verbesserungen sehr willkommen.

Ungolfed-Version:

;; open Char
;; if Sys.argv.(0).[0] = '~' 
   then Sys.argv.(0).[0] <- '\000'
   else Sys.argv.(0).[0] <- chr (1 + int_of_char Sys.argv.(0).[0])
;; let n = 1 + int_of_char Sys.argv.(0).[0] in
   Printf.printf "\r%d %o %x" n n n

TeaScript , 21 bis 20 Bytes

[┼d,dT8),dT16)]j(p);

Ich sollte es automatisch schließen lassen ;

Probieren Sie es online aus

Erläuterung

┼ wird ++

    // Implicit: d = 0
[   // Start array
 ++d,  // Increment d, decimal value
dT8),  // d to base 8
dT16)  // d to base 16
]j(p); // Join by spaces
    // Implicit: Output *last* expression

Perl, 40 Bytes

$_=<<'';printf"%d %o %x",(1+y/z//)x3;
:

Es gibt eine letzte Zeile hinter dem Doppelpunkt.

Behandelt alles nach der ersten Zeile als Here-Dokument und zählt das zdarin. Für jede weitere Kopie des Codes wird eine zhinzugefügt. Wir müssen 1die Anzahl erhöhen, da es für das erste Snippet (das, das ausgeführt wird) kein Snippet gibt.

Wenn eine zusätzliche Ausgabe nach stderr erlaubt ist, können wir die 2 einfachen Anführungszeichen weglassen ''und auf 38 Bytes reduzieren. Ohne ''Perl wird eine Warnung über ein veraltetes Feature ausgegeben.

Mathematica, 76 Bytes

Beachten Sie, dass nzuvor keine Definitionen vorhanden sein sollten.

0;If[ValueQ@n,++n,n=1];StringJoin@Riffle[IntegerString[n,#]&/@{10,8,16}," "]

Hier wird das Verhalten von ;verwendet. Das obige Snippet ist ein einzelnes CompoundExpression. Wenn jedoch ein paar Snippets zusammengefügt werden, gibt es immer noch eines, CompoundExpressionwie unten gezeigt. (Einige unnötige Umlagerungen werden vorgenommen.)

0;
If[ValueQ@n,++n,n=1]; StringJoin@Riffle[IntegerString[n,#]&/@{10,8,16}," "] 0;
If[ValueQ@n,++n,n=1]; StringJoin@Riffle[IntegerString[n,#]&/@{10,8,16}," "] 0;
If[ValueQ@n,++n,n=1]; StringJoin@Riffle[IntegerString[n,#]&/@{10,8,16}," "]

(* 3 3 3 *)

So kann man ein solches Snippet nicht zum Laufen bringen, wenn man es explizit schreibt CompoundExpression. Außerdem kann fast alles, was Sie möchten, vor dem ersten ;wie E, Pioder MandelbrotSetPlot[], gesetzt werden.

Bash, 49 Bytes

Datei count.bash:

((++n));trap 'printf "%d %o %x\n" $n $n $n' exit;

... kein nachlaufender Zeilenumbruch.

Lauf:

$ bash count.bash
1 1 1
$ cat count.bash count.bash count.bash | bash
3 3 3
$ for i in $(seq 10) ; do cat count.bash ; done | bash
10 12 a

Python 2, 54 Bytes

n=len(open(__file__).read())/54;print n,oct(n),hex(n)#

Keine nachgestellte Newline. Ausgaben im Formular 1 01 0x1.

Wenn das nicht in Ordnung ist, 56 Bytes

n=len(open(__file__).read())/56;print"%d %o %x"%(n,n,n)#

Beim Einfügen voreinander wird die Länge der Datei mit jedem Einfügen um eine Zeile länger. Der Basisfall beginnt mit 2 Zeilen, sodass Sie 1 von der Zeilenlänge abziehen müssen. Die Berechnung wird durch den Kommentar unterdrückt.

Python 2.x 140 Bytes

Dies sollte keine übermäßig wettbewerbsfähige Lösung sein, sondern eine Methode, die ich als amüsant empfand, zum einen als Versuch, einen Multithread- Code-Golf zu spielen.

import thread;n=eval("n+1")if"n"in globals()else 1;
def t(c):99**99;print("%s "*3)%(n,oct(n),hex(n))*(c==n)
thread.start_new_thread(t,(n,));

Behält einen Zähler bei, erzeugt einen Thread für jede Zählung und wenn sich der Zähler nicht geändert hat, wenn der Zähler-Timer nach Abschluss eines teuren mathematischen Problems abläuft (anstelle eines Timers zum Speichern von Bytes), wird die formatierte Zeichenfolge gedruckt.

Einige Beispielkonfigurationen und ihre Ausgaben:

import thread;n=eval("n+1")if"n"in globals()else 1;
def t(c):99**99;print("%s "*3)%(n,oct(n),hex(n))*(c==n)
thread.start_new_thread(t,(n,));

Outputs 1 01 0x1 

und fünfzehn Kopierpasten:

import thread;n=eval("n+1")if"n"in globals()else 1;
def t(c):99**99;print("%s "*3)%(n,oct(n),hex(n))*(c==n)
thread.start_new_thread(t,(n,));import thread;n=eval("n+1")if"n"in globals()else 1;
def t(c):99**99;print("%s "*3)%(n,oct(n),hex(n))*(c==n)
thread.start_new_thread(t,(n,));import thread;n=eval("n+1")if"n"in globals()else 1;

...


Outputs 15 017 0xf 

Perl 5 , 31 Bytes

exit+printf"%d %o %x",(++$-)x3,

Verwendet den gleichen Ansatz wie meine Antwort für "Ich verdopple die Quelle, du verdoppelst die Ausgabe!" .

Probieren Sie es online!

Ruby, 35 Bytes

1;$.+=1;$><<"#$. %1$o %1$x"%$.*-~-0

Jedes Snippet wird inkrementiert $.(was mit 0 beginnt, wenn keine Dateien gelesen wurden), aber nur das letzte gibt etwas aus. *-~-0ergibt *1, was bedeutet, dass die Zeichenfolge einmal gedruckt wird, bei Verkettung jedoch *-~-01ein oktaler Ausdruck, der zu 0 ausgewertet wird. Da $><<keine abschließende Newline enthalten ist, bedeutet das Drucken der leeren Zeichenfolge, dass nichts gedruckt wird.