Herausforderung

Schreiben Sie ein nicht leeres Programm / eine nicht leere Funktion p, die bei einer nicht leeren Eingabezeichenfolge sdie Position des ersten Vorkommens jedes Zeichens sim Quellcode von ausgibt p.

Zum Beispiel, wenn Ihr Programm ist

main() { cout << magic << cin }
^0   ^5   ^10  ^15  ^20  ^25

und es erhält eine Eingabe abcd{, die Ausgabe sollte sein

[1, x, 9, x, 7] (0-based)        [2, x, 10, x, 8] (1-based)

Dabei xstellt jede Ausgabe , die keine gültige Ausgabe für eine Zeichenposition ist (zB eine negative Zahl, 0wenn Sie verwenden 1-basierte Indizierung NaN, Infdie Zeichenfolge potato, eine Zahl , die größer ist als die Länge Ihres Programms, etc.).

Beschränkungen

Das Lesen des Quellcodes ist nicht erlaubt (wie in einem richtigen Quine). Die Verwendung von Kommentaren ist zulässig, wird jedoch für Ihre Punktzahl berücksichtigt.

Die Ein- und Ausgabe kann in einem vernünftigen Format erfolgen, muss jedoch eindeutig sein (nur zusätzliche Begrenzer, kein randDatenstrom und die Behauptung, dass die Antwort irgendwo darin enthalten ist), konsistent (z. B. xsollte der Wert von oben immer der gleiche sein) und menschlich. lesbar ; Zum Beispiel eine Zeichenfolge oder ein Zeichenarray. Sie können davon ausgehen, dass die Eingabe eine Zeichenfolge (oder ein Array) druckbarer ASCII-Zeichen ist. Es muss nicht der gesamte Unicode-Satz verarbeitet werden.

Benutzerdefinierte Codepage oder nicht druckbare ASCII-Dateien in Ihrem Code?

Wenn Ihre Sprache eine benutzerdefinierte Codepage (Jelly, APL usw.) verwendet, müssen Sie dies berücksichtigen (ein Programm €æÆmuss also [1, x, 2]für eine Eingabe ausgeben €%æ). Die Verwendung von Nicht-ASCII-Zeichen für die Ausgabe -1(da die Eingabe nur ASCII-Zeichen enthält) ist keine gültige Lösung. Sie können davon ausgehen, dass Ihr Programm Ihre benutzerdefinierte Codepage nativ akzeptiert. Wenn Ihr Programm über eine Methode zum Konvertieren eines Zeichens Ain eine Ganzzahl 65(ASCII-Codierung) verfügt, können Sie davon ausgehen, dass es jetzt das 65. Zeichen in Ihrer Codepage in konvertiert 65.

Inspiriert von der folgenden Herausforderung: Positionsbewusstsein

Python2, 55 Bytes

a=" )dfi(+m,nprut.';";print map(('a="'+a).find,input())

Beginnt mit einer Zeichenfolge, die alle im Code verwendeten Zeichen enthält, und durchsucht dann die Indizes

Sprache , 56.623 Bytes

Unten ist ein Hexdump der ersten 256 Bytes. Die restlichen Bytes können beliebig gewählt werden.

0000000: 00 01 02 03 04 05 06 07 08 09 0a 0b 0c 0d 0e 0f  ................
0000010: 10 11 12 13 14 15 16 17 18 19 1a 1b 1c 1d 1e 1f  ................
0000020: 20 21 22 23 24 25 26 27 28 29 2a 2b 2c 2d 2e 2f   !"#$%&'()*+,-./
0000030: 30 31 32 33 34 35 36 37 38 39 3a 3b 3c 3d 3e 3f  0123456789:;<=>?
0000040: 40 41 42 43 44 45 46 47 48 49 4a 4b 4c 4d 4e 4f  @ABCDEFGHIJKLMNO
0000050: 50 51 52 53 54 55 56 57 58 59 5a 5b 5c 5d 5e 5f  PQRSTUVWXYZ[\]^_
0000060: 60 61 62 63 64 65 66 67 68 69 6a 6b 6c 6d 6e 6f  `abcdefghijklmno
0000070: 70 71 72 73 74 75 76 77 78 79 7a 7b 7c 7d 7e 7f  pqrstuvwxyz{|}~.
0000080: 80 81 82 83 84 85 86 87 88 89 8a 8b 8c 8d 8e 8f  ................
0000090: 90 91 92 93 94 95 96 97 98 99 9a 9b 9c 9d 9e 9f  ................
00000a0: a0 a1 a2 a3 a4 a5 a6 a7 a8 a9 aa ab ac ad ae af  ................
00000b0: b0 b1 b2 b3 b4 b5 b6 b7 b8 b9 ba bb bc bd be bf  ................
00000c0: c0 c1 c2 c3 c4 c5 c6 c7 c8 c9 ca cb cc cd ce cf  ................
00000d0: d0 d1 d2 d3 d4 d5 d6 d7 d8 d9 da db dc dd de df  ................
00000e0: e0 e1 e2 e3 e4 e5 e6 e7 e8 e9 ea eb ec ed ee ef  ................
00000f0: f0 f1 f2 f3 f4 f5 f6 f7 f8 f9 fa fb fc fd fe ff  ................

Die Ausgabe erfolgt in Bytes, wie bei Brainfuck et al.

Wie es funktioniert

Dies ist insbesondere ein einfaches Katzenprogramm ,[.,].

Der Quellcode enthält alle 256-Byte-Werte in der angegebenen Reihenfolge, sodass der Index jedes Bytes mit seinem Wert übereinstimmt.

Sprache , 1.22e7 Bytes

Besteht aus 12263215 NULBytes (Hex 0x00) .

Gibt ein NULfür jedes Zeichen aus, das nicht in der Quelle erscheint.

Der Trick ist, dass die Eingabe niemals a enthält NUL, also geben wir immer die Anzahl von NULs aus, die Zeichen in der Eingabe enthalten.

Dies übersetzt in das folgende Brainfuck-Programm

,[[-].,]

Und mit einer Panne ...

,[[-].,]
,[    ,]    #Basic Input loop.
  [-]       #Zero out the cell.
     .      #Print it (A NUL).

Dies zeigt nur die schiere Kraft von Lenguage als Golfsprache. Fürchte es.

Gelee , 10 9 Bytes

“ṾiЀƓv”v

Probieren Sie es online!

Wie es funktioniert

“ṾiЀƓv”v  Main link. No arguments.

“ṾiЀƓv”   Set the left argument and the return value to s := 'ṾiЀƓv'.
        v  Execute the string s as a monadic Jelly program with argument s.

 Ṿ         Uneval; yield a string representation of s, i.e., r := '“ṾiЀƓv”'.
     Ɠ     Read one line from STDIN and evaluate it like Python would.
  iЀ      Find the index of each character in the input in r.
      v    Eval the list of indices as a monadic Jelly program with argument s.
           Why?
             This is the shortest way to add the character 'v' to the string s,
             meaning that we can use r without having to append anything.
           What?
             The v atom vectorizes at depth 1 for its left argument, meaning that
             it acts on arrays of numbers and/or characters. When fed an array of
             integers, it first converts them to strings, then concatenates the
             strings and evaluates them as a Jelly program. For example, the array
             [1, 2, 3] gets cast to the string '123', then evaluates, yielding 123.
             Something slightly different happens if the array starts with a 0. For
             example, the array [0, 1, 2] gets cast to '012' just as before, but
             Jelly views '0' and '12' as two separate tokens; numeric literals
             cannot start with a 0. Since the Jelly program is monadic, the first
             token – '0' – sets the return value to 0. Since the second token –
             '12' – is also a niladic link, the previous return value is printed
             before changing the return value to 12. Then, the program finishes
             and the last return value is printed implicitly.

pbrain, 402 356 340 338 329 Bytes

[(:<>)+,-.](>>>>>>)+([-]<<[->+>+<<]>>[-<<+>>]>>[-<+<+>>]<[->+<]<[-<->]<)+([-]+++++++[>+++++++++++++<-]>)+([-]+++++[>++++++++<-]>)+(-:<+++[->++++++<]>)+(-:++)+(-:++)+(----:+)+(-:++)+(-:+)+(-:+)+(-:+)+([-]++:++)+([>[->+>+<<]>>[-<<+>>]<:>>+:[[-]>+<]>-[<<<<[-.>]>>>>>>+>>>>>]<<[-]<<+<-]>>>)[-]>>>>>>>,[<<<<<<++<+++++++++++++:>>>>>>,]

Puh, @KritixiLithos und ich arbeiten seit 4 Tagen daran.

Gibt aus, 0x00wenn das eingegebene Zeichen nicht im Programm enthalten ist, andernfalls den Index des Zeichens (1-basiert) in hexadezimal. Probieren Sie es online!

Erläuterung:

[(:<>)+,-.]
All chars listed here; like other submissions 
(>>>>>>)
@KritixiLithos added this part; I don't know what it does but saves the program
+([-]<<[->+>+<<]>>[-<<+>>]>>[-<+<+>>]<[->+<]<[-<->]<)
Comparison ;calculates z=x!=y and puts it in between x and y
Start; X _ _ _ Y
           ^
End;   X Z _ _ Y
         ^
+([-]+++++++[>+++++++++++++<-]>)
Function to add 91 to the tape
+([-]+++++[>++++++++<-]>)
Function to add 40 to the tape
+(-:<+++[->++++++<]>)
Function to add 58 to the tape
+(-:++)
Function to add 60 to the tape
+(-:++)
Function to add 62 to the tape
+(----:+)
Function to add 41 to the tape
+(-:++)
Function to add 43 to the tape
+(-:+)
Function to add 44 to the tape
+(-:+)
Function to add 45 to the tape
+(-:+)
Function to add 46 to the tape
+([-]++:++)
Function to add 93 to the tape
+([>[->+>+<<]>>[-<<+>>]<:>>+:[[-]>+<]>-[<‌​<<<[-.>]>>>>>>+>>>>>]<<[-]<<+<-]>>>)

Diese letzte Funktion ist die Schleife. Es durchläuft die ausgewählten Zeichen der [(:<>)+,-.]Reihe nach und vergleicht die Eingabe mit dem Zeichen. Jetzt werde ich genauer erklären, wie diese Schleife funktioniert.

12-n n+2 _ n+2: _ _ _ i _ _ _ _ _ _;  n=loop counter
                  ^                ;  i=input

Der Stapel sieht in einer Schleife so aus. Die Schleife läuft bis 12-nist 0. Dann haben wir den Zähler, der ist n+2. Dieser Zähler ist auch die Nummer der Funktion für jedes der ausgewählten Zeichen. Also , wenn n=0, n+2wird auf das erste Zeichen wird entsprechend, dh [. >[->+>+<<]>>[-<<+>>]<:Um genau das zu tun, konvertiert es den Zähler in das Zeichen.

Sobald sich der Zeiger an der Stelle befindet, an der sich das Caret befindet, vergleichen wir das aus der Zählervariablen erzeugte Zeichen mit der Eingabe, während wir sie beibehalten.

12-n n+2 _ n+2: Z _ _ i _ _ _ _ _ _;  n=loop counter
                ^                  ;  i=input

Zist, 0wenn das Zeichen gleich der Eingabe ist oder eine andere Ganzzahl, die nicht Null ist.

Nun überlegen wir uns eine if-Anweisung, um diese Gleichheit zu überprüfen.

[[-]>+<]

Wenn Zungleich Null ist, dh das Zeichen und die Eingabe nicht identisch sind, erhöhen wir den nächsten Speicherplatz.

Nachdem wir diese if-Anweisung verlassen haben, dekrementieren wir den nächsten Speicherplatz. Nun enthält dieser Speicherplatz !Z. Abschließend geben wir den Index des Zeichens aus, wenn er mit der Eingabe übereinstimmt, und verlassen dann die Schleife mit Gewalt. Ansonsten fahren wir mit der Schleife fort, bis sie beendet ist oder eine Übereinstimmung gefunden wurde.

[-]>>>>>>>
Clears first byte; goes to position to start program
,[<<<<<<++<+++++++++++++:>>>>>>,]
Loops inputs

CJam , 14 12 Bytes

{sq\f#p_~}_~

Verwendet die 0-basierte Indizierung und -1für Zeichen, die nicht in der Quelle enthalten sind.

Probieren Sie es online!

Javascript, 34 Bytes

f=a=>a.map(v=>('f='+f).indexOf(v))

Es nimmt Eingaben als Array von Strings an, xist -1(0-basierte Indizierung).

C 153 152 143 Bytes

char s[99],p[]="odeflnrti%()*+-0;<={}\\";c;f(char*i){sprintf(s,"char s[99],p[]=\"%s",p);for(c=0;c<strlen(i);)printf("%d ",strchr(s,i[c++])-s);}

Probieren Sie es online!

Ruby, 41 88 86 71 69 67 61 56 Bytes

a='p$<.chrs{| #index};"';$<.chars{|c|p"a='#{a}".index c}

Thx Lynn für das Töten von 6 Bytes

> <> (Fisch) 70 Bytes

 #.0+4*a5;!?l|!?f4*b+l1--naolc3*1+0.01?!|~ed+0.0+2e-{:;!?+1:i-1:r}+2:"

Wahrscheinlich der längste> <> 1 Liner, den ich je gemacht habe.

Es wird die Ausgabe für jedes Zeichen gedruckt, das in einer separaten Zeile gefunden wird (0 indiziert).

Ein nicht gefundenes Zeichen gibt immer die Länge des Codes + 1 aus (ich könnte dies ändern, wenn es in seinem aktuellen Status als nicht in Ordnung erachtet wird), sodass in diesem Fall 71 immer die Zeichen "Nicht gefunden" sind.

Sobald ich die Zeit habe, werde ich eine Erklärung abgeben.

Einige Testfälle;

## K = 1 \ n1 \ n71

# "# = 1 \ n69 \ n1

Probieren Sie es online aus

> <> Sprache

Perl 6 , 50 52 Bytes

{(('R~.index$_) for}\\'R~'{((\'').index($_) for $_)}

Übersetzung von GBs Ruby-Lösung und Rods Python-Lösung .

Ein Lambda, das eine Liste von Zeichen eingibt und eine Liste von nullbasierten Indizes ausgibt ( Nilfür nicht vorhandene Zeichen).

BEARBEITEN: Ein Versehen wurde behoben - Hinzufügen von 2 Bytes erforderlich :(

Clojure, 43 56 48 Bytes

Edit: Verdammt habe ich vergessen 2! Erhöht von 43 auf 56.

Bearbeiten 2: Der Beispielcode unter diesem Text wurde aktualisiert, die Anzahl der nicht einzuschließenden Bytes wurde aktualisiert, (def f ...aber nur der Hash-Map-Teil.

{\{ 0\\   1\  3\0   4\1 10\3 14\4 20\2 34 \} 43}

Die Hash-Map besteht nur aus Zeichen 01234{\\}und kodiert deren Position. In Clojure können Hash-Maps Funktionen verwendet werden, wie in diesem vollständigen Beispiel gezeigt ( fkönnte durch die Hash-Map-Definition ersetzt werden):

; Keeping track of the zero-based index:
;      00000000001111111111222222222233333333334444444444
;      01234567890123456789012345678901234567890123456789
(def f {\{ 0\\   1\  3\0   4\1 10\3 14\4 20\2 34 \} 43})

(map f "0123456789{} \\abcdef") ; (4 10 34 14 20 nil nil nil nil nil 0 43 3 1 nil nil nil nil nil nil)
(apply str (keys f))            ; " 01234{\\}"

Ich denke das zählt :)

JavaScript, 39 Bytes

p=s=>[...s].map(c=>`p=${p}`.indexOf(c))

console.log( p('mapP') )

Pyth, 11 Bytes

xL_+N"N+_Lx

Ein Programm, das die Eingabe von a annimmt "quoted string", wobei Anführungszeichen in der Zeichenfolge mit einem vorangestellten Escapezeichen versehen sind \, und eine Liste von mit Nullen indizierten Werten -1für Zeichen ausgibt, die nicht in der Quelle enthalten sind.

Probieren Sie es online!

Wie es funktioniert

xL_+N"N+_Lx    Program. Input: Q
xL_+N"N+_Lx"Q  Implicit quote closure and implicit input
     "N+_Lx"   Yield the string "N+_Lx"
   +N          Prepend a quote
  _            Reverse
 L          Q  Map over Q:
x               Yield the index of the character in the string
               Implicitly print

05AB1E , 19 Bytes

"'ìsvDyk,"'"ìsvDyk,

Probieren Sie es online!

Dies gibt -1 anstelle von fehlenden Zeichen aus.

Luis Mendo hat dies (leicht modifiziert) auf Golf you a quine für great good gepostet ! Das Hinzufügen von "s" und "k" zu diesem Quine führt ebenfalls zu dieser Antwort. Ich kann diese Kleinigkeit einer Änderung jedoch nicht würdigen ... Luis, du kannst mir eine Nachricht senden, wenn du dies erneut posten möchtest, und ich werde es einfach löschen. Wenn Sie meinen Fortschritt sehen möchten, bevor Sie diese Frage finden, sehen Sie sich die Änderungen an. Nun ... Es war an einem Punkt deutlich wie bei ihm.

SmileBASIC, 128 96 88 86 Bytes

?R<3+CD,4LINPUT(S$)WHILE""<S$?INSTR("?R<3+CD,4LINPUT(S$)WHILE"+CHR$(34),SHIFT(S$))WEND

Eine wichtige Erkenntnis ist, dass dies keine echte Herausforderung ist. Sie benötigen nur den Quellcode bis zum letzten eindeutigen Zeichen .

Ich füge mindestens 1 jedes Zeichens am Anfang des Codes ein, ?R<3+CD,4LINPUT(S$)WHILE"so dass ich nur eine Kopie des Programms bis zum ersten Anführungszeichen speichern muss.

Python, 90 88 Bytes

a,b,d=" ()+.7:[]efilmnor","a,b,d=\"",lambda e:[[b.find(d),a.find(d)+7][d in a]for d in e]

Testfall:

print(d("a,b(]q"))
#[0, 1, 2, 8, 15, -1]

Gestapelt , nicht konkurrierend, 36 Bytes

Als ich sagte, diese Sprache sei noch in der Entwicklung, meinte ich es auch so. Anscheinend promptverwendet, um den gesamten Stapel zu verbrauchen. Deshalb kann ich keine schönen Dinge haben. Probieren Sie es hier aus!

[tostr ':!' + prompt CS index out]:!

Dies ist das Standard-Quine-Framework. Grundsätzlich :dupliziert sich die Funktion [...]auf dem Stack, der dann mit ausgeführt wird !. Dann wird das Innere von [...]mit der Funktion auf dem Stapel ausgeführt. Es wandelt es in einen String um, hängt :!(das Programm selbst) an und nimmt dann eine String-Eingabe mit an prompt. CSkonvertiert es in eine Zeichenkette. Eine Zeichenkette unterscheidet sich insofern von einer regulären Zeichenkette, als Operatoren über sie vektorisieren. In diesem Fall wird indexüber die Eingabe vektorisiert, wobei jeder Index der Eingabezeichenfolge im Programm outausgegeben und schließlich geputtet wird.

Für die Eingabe Hello, World!gibt dies:

(-1 27 -1 -1 2 -1 6 -1 2 5 -1 26 9)

Ich habe versucht, die Zeichenfolge ohne Quine zu verwenden (dh die Zeichenfolge zu codieren, die in Ihrer Quelle enthalten ist), aber es gibt nur eine Art von Anführungszeichen in Stacked, dh, 'es wäre länger, diese Art von Lösung durchzuführen.

Schale , 12 Bytes

m€`:'""m€`:'

Probieren Sie es online!

Erläuterung

Die Erklärung dient ¨zum Abgrenzen von Zeichenfolgen und 'zum Abgrenzen von Zeichen:

m€`:'""m€`:'  -- implicit input, for example: ¨m"a1`¨
      "m€`:'  -- string literal: ¨m€`:'¨
  `:'"        -- append character '"': ¨m€`:'"¨
m             -- map function over each character (example with 'a'):
 €            -- | index of first occurrence (1-indexed): 0
              -- : [1,6,0,0,3]

Java 8, 172 122 Bytes

a->{/*.indexOf(c)+\" ;}orh:Systmup*/for(char c:a)System.out.print("a->{/*.indexOf(c)+\\\" ;}orh:Systmup".indexOf(c)+" ");}

0-indiziert und gibt -1Zeichen an, die nicht Teil des Quellcodes sind.

Erläuterung:

Probieren Sie es online aus.

a->{                         // Method with character-array parameter and no return-type
  /*.indexOf(c)+\" ;}orh:Systmup*/
                             //  Comment containing the remaining characters of the code
  for(char c:a)              //  Loop over the input-array
    System.out.print(        //   Print:
      "a->{/*.indexOf(c)+\\\" ;}orh:Systmup"
                             //    String containing all the characters used in the code
      .indexOf(c)+" ");}     //    Print the index of the char, plus a space as delimiter

J , 31 22 Bytes

11|1+i.~&'11|1+i.~&'''

Probieren Sie es online!

1-indiziert, 0 für Zeichen, die im Code nicht vorhanden sind. ''steht für ein einfaches Anführungszeichen. Suchen Sie jedes Zeichen in der Zeichenfolge 11|1+i.~&', fügen Sie 1, Modulo 11 hinzu.

> <> 31 Bytes

'rd3*i:0(?;}{:}-&b0&?.75*l-nao]

Probieren Sie es online!

Die Ausgabe ist 1-indiziert, 32dh das Zeichen befindet sich nicht im Code.

Perl 5 mit -pl43 Bytes

Verwendet durch Zeilenvorschub getrennte Eingaben und druckt -1für Zeichen, die nicht im Programm erscheinen.

$s=q{$_=index"\$s=q{$s};eval\$s",$_};eval$s

Probieren Sie es online!

Stax , 19 Bytes

"'sym[]I+"'"s+ym[]I

Führen Sie es aus und debuggen Sie es

Gibt einen 0-basierten Index mit einem Zeichen pro Zeile aus. Es stellt sich heraus, dass es kürzer ist, als das "34bL"34bLQuine zu modifizieren, das ich zuvor geschrieben habe.