Sfida

Scrivi un programma / funzione non vuoto pche, data una stringa di input non vuota s, genera la posizione della prima occorrenza di ciascun carattere snel codice sorgente di p.

Ad esempio, se il tuo programma lo è

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

e riceve un input abcd{, l'output dovrebbe essere

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

Qui, xrappresenta qualsiasi output che non è un'uscita valida per una posizione di carattere (ad esempio, un numero negativo, 0se si utilizza l'indicizzazione in base 1, NaN, Inf, la stringa potato, un numero maggiore della lunghezza del tuo programma, ecc).

restrizioni

La lettura del codice sorgente non è consentita (come in un vero quine). L'uso dei commenti è consentito, ma conta per il tuo punteggio.

L'input e l'output possono essere fatti in un formato ragionevole, ma devono essere inequivocabili (solo delimitatori aggiuntivi, nessun randflusso e affermando che la risposta è da qualche parte lì dentro), coerenti (ad esempio, il xprecedente dovrebbe sempre avere lo stesso valore) e umano- leggibile ; ad esempio, una stringa o una matrice di caratteri. Si può presumere che l'input sia una stringa (o matrice) di caratteri ASCII stampabili; non è necessario gestire l'intero set Unicode.

Codepage personalizzata o ascii non stampabili nel tuo codice?

Se la tua lingua utilizza una tabella codici personalizzata (Jelly, APL, ecc.), Devi tenerne conto (quindi un programma €æÆdeve generare [1, x, 2]un input €%æ). L'uso di soli caratteri non ASCII per l'output -1sempre (poiché l'input è solo ASCII) non è una soluzione valida. Puoi presumere che il tuo programma accetti nativamente la tua codepage personalizzata, cioè se il tuo programma ha un metodo per convertire un carattere Ain un intero 65(codifica ASCII), puoi supporre che ora converta il 65 ° carattere nella tua codepage 65.

Ispirato alla seguente sfida: consapevolezza della posizione

Python2, 55 byte

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

Inizia con una stringa che contiene tutti i caratteri utilizzati nel codice, quindi cerca gli indici

Lenguage , 56.623 byte

Di seguito è riportato un hexdump dei primi 256 byte. I byte rimanenti possono essere scelti in modo arbitrario.

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  ................

L'output è in byte, come di consueto per brainfuck et al.

Come funziona

Questo è un semplice programma per gatti, in particolare ,[.,].

Il codice sorgente contiene tutti i valori di 256 byte in ordine, quindi l'indice di ogni byte in esso corrispondente corrisponde al suo valore.

Lenguage , 1,22e7 byte

È composto da 12263215 NULbyte (esadecimale 0x00) .

Emette a NULper ogni personaggio che non appare nella fonte.

Lo stratagemma è che l'input non conterrà mai a NUL, quindi emettiamo sempre la quantità di NULs che ci sono caratteri nell'input.

Questo si traduce nel seguente programma Brainfuck

,[[-].,]

E con un guasto ...

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

Questo dimostra solo il puro potere di Lenguage come linguaggio del golf. Temilo.

Gelatina , 10 9 byte

“ṾiЀƓv”v

Provalo online!

Come funziona

“Ṿ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 byte

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

Accidenti, @KritixiLithos e ci stiamo lavorando da 4 giorni.

Stampa 0x00se il carattere di input non è in programma, altrimenti l'indice del carattere (basato su 1) in esadecimale. Provalo online!

Spiegazione:

[(:<>)+,-.]
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
+([>[->+>+<<]>>[-<<+>>]<:>>+:[[-]>+<]>-[<‌​<<<[-.>]>>>>>>+>>>>>]<<[-]<<+<-]>>>)

Quest'ultima funzione è il loop. Passa in rassegna i caratteri selezionati [(:<>)+,-.]in ordine e confronta l'input con il carattere. Ora darò una spiegazione più approfondita su come funziona questo ciclo.

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

Lo stack si presenta così mentre è in loop. Il ciclo verrà eseguito fino a quando non 12-nè 0. Quindi abbiamo il contatore che è n+2. Questo contatore è anche il numero della funzione per ciascuno dei caratteri selezionati. Quindi n=0, quando , n+2sarà corrispondente al primo carattere, ad es [. >[->+>+<<]>>[-<<+>>]<:fa proprio questo, converte il segnalino nel personaggio.

Una volta che il puntatore è dove si trova il cursore, confronteremo il carattere prodotto dalla variabile contatore con l'input preservandoli.

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

Zè 0quando il carattere è uguale all'input o in caso contrario un altro numero intero diverso da zero.

Ora elaboriamo un'istruzione if per verificare questa uguaglianza.

[[-]>+<]

Se Zè diverso da zero, ovvero il carattere e l'input non sono gli stessi, incrementiamo il successivo spazio di memoria.

Dopo essere usciti da questa dichiarazione if, decrementiamo il prossimo luogo di memoria. Ora questo posto di memoria contiene !Z. Infine, usando questo, produciamo l'indice del carattere se corrisponde all'input e quindi usciamo forzatamente dal ciclo. Altrimenti, continuiamo con il ciclo fino a quando non è finito o non viene trovata una corrispondenza.

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

CJam , 14 12 byte

{sq\f#p_~}_~

Utilizza l'indicizzazione basata su 0 e -1per i caratteri che non compaiono nella fonte.

Provalo online!

Javascript, 34 byte

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

Prende l'input come array di stringhe, xè -1(indicizzazione basata su 0).

C, 153 152 143 byte

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);}

Provalo online!

Rubino, 41 88 86 71 69 67 61 56 byte

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

Grazie Lynn per aver ucciso 6 byte

> <> (Pesce) 70 byte

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

Probabilmente il più lungo> <> 1 rivestimento che abbia mai realizzato.

Stampa l'output per ogni carattere trovato su una riga separata (0 indicizzato).

Un carattere non trovato stamperà sempre la lunghezza del codice + 1 (potrei cambiarlo se ritenuto non corretto nello stato attuale), in questo caso 71 saranno sempre i caratteri "Non trovato".

Eseguirò una spiegazione una volta che avrò il tempo.

Alcuni casi di test;

## K = 1 \ n1 \ n71

# "# = 1 \ n69 \ n1

Provalo online

> <> lingua

Perl 6 , 50 52 byte

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

Traduzione della soluzione Ruby di GB e della soluzione Python di Rod .

Un lambda che inserisce un elenco di caratteri e genera un elenco di indici in base zero ( Nilper caratteri inesistenti).

EDIT: risolto un problema - richiesta aggiunta di 2 byte :(

Clojure, 43 56 48 byte

Modifica: Accidenti, mi sono dimenticato 2! Aumentato da 43 a 56.

Modifica 2: aggiornato il codice di esempio sotto questo testo, aggiornato il numero di byte da non includere (def f ...) ma solo la parte della mappa hash.

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

La mappa hash è composta solo da caratteri 01234{\\}e codifica le loro posizioni. In Clojure è possibile utilizzare le funzioni hash-map, come mostrato in questo esempio completo ( fpotrebbe essere sostituito dalla definizione di hash-map):

; 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{\\}"

Immagino che questo conti :)

JavaScript, 39 byte

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

console.log( p('mapP') )

Pyth, 11 byte

xL_+N"N+_Lx

Un programma che accetta l'input di a "quoted string", con le virgolette nella stringa sfuggite a un precedente \, e stampa un elenco di valori con indice zero con -1caratteri non presenti nell'origine.

Provalo online!

Come funziona

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 byte

"'ìsvDyk,"'"ìsvDyk,

Provalo online!

Questo genera -1 al posto dei caratteri mancanti.

Luis Mendo ha pubblicato questo (leggermente modificato) su Golf, un vero vantaggio! , aggiungendo "s" e "k" a quel quine si ottiene anche questa risposta. Tuttavia, non posso prendermi il merito per quella banale di una modifica ... Luis, puoi inviarmi un messaggio se vuoi ripubblicare questo e lo cancellerò. Se vuoi vedere i miei progressi prima di trovare quella domanda, visualizza le modifiche. Bene ... A un certo punto è stato significativamente come il suo.

SmileBASIC, 128 96 88 86 byte

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

Una cosa importante da capire è che questa non è una vera sfida. Hai solo bisogno del codice sorgente fino all'ultimo carattere univoco .

Metto almeno 1 di ogni carattere all'inizio del codice: ?R<3+CD,4LINPUT(S$)WHILE"quindi devo solo conservare una copia del programma fino alla prima virgoletta.

Python, 90 88 byte

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

Caso di prova:

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

Impilato , non competitivo, 36 byte

Quando ho detto che questa lingua era ancora in sviluppo, lo intendevo. Apparentemente, promptusato per consumare l'intero stack. Questo è il motivo per cui non posso avere cose carine. Provalo qui!

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

Questo è il framework quine standard. Fondamentalmente, :duplica la funzione [...]nello stack, che viene quindi eseguita con !. Quindi, l'interno di [...]viene eseguito con la funzione nello stack. Lo lancia in una stringa, aggiunge :!(il programma stesso), quindi accetta un input di stringa con prompt. CSlo converte in una stringa di caratteri. Una stringa di caratteri è un po 'diversa da una stringa normale in quanto ha operatori che vettorizzano su di essa. In questo caso, indexvettorializza sull'input, producendo ogni indice della stringa di input nel programma, e infine viene messo out.

Per input Hello, World!, questo dà:

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

Ho provato a usare quello senza un quine (cioè codificare la stringa di caratteri che appare nella tua fonte), ma c'è solo un tipo di virgolette in Stacked, vale a dire ', quindi sarebbe più lungo fare quel tipo di soluzione.

Buccia , 12 byte

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

Provalo online!

Spiegazione

La spiegazione sta usando ¨per delimitare le stringhe e 'per delimitare i caratteri:

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 byte

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

0 indicizzato e indica i -1caratteri che non fanno parte del codice sorgente.

Spiegazione:

Provalo online.

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 byte

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

Provalo online!

1 indicizzato, 0 per i caratteri che non sono presenti nel codice. ''sta per una sola citazione. Trova ogni carattere nella stringa 11|1+i.~&', aggiungi 1, modulo 11.

> <> , 31 byte

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

Provalo online!

L'output è 1 indicizzato, il che 32significa che il carattere non è nel codice.

Perl 5 con -pl, 43 byte

Utilizza input separati da nuova riga e stampa -1per i caratteri che non compaiono nel programma.

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

Provalo online!

Stax , 19 byte

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

Esegui ed esegui il debug

Emette un indice basato su 0, un carattere per riga. Si scopre che è più breve della modifica del "34bL"34bLquine che ho scritto in precedenza.