Défi

Ecrivez un programme / fonction non vide pqui, à partir d’une chaîne d’entrée non vide s, affiche la position de la première occurrence de chaque caractère sdans le code source de p.

Par exemple, si votre programme est

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

et il reçoit une entrée abcd{, la sortie doit être

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

Ici, xreprésente une sortie qui n'est pas une sortie valide pour une position de caractère (par exemple, un numéro de négatif, 0si vous utilisez une indexation de base 1, NaN, Inf, la chaîne potato, un nombre supérieur à la longueur de votre programme, etc.).

Les restrictions

La lecture du code source n'est pas autorisée (comme dans un bon quine). L'utilisation de commentaires est autorisée, mais compte pour votre score.

Entrée et la sortie peut être fait dans un format raisonnable, mais doit être sans ambiguïté (seulement délimiteurs supplémentaires, aucun randcours d' eau et affirmant que la réponse est quelque part là - dedans), cohérente (par exemple, en xhaut doit toujours être la même valeur) et origine humaine lisible ; par exemple, une chaîne ou un tableau de caractères. Vous pouvez supposer que l'entrée est une chaîne (ou un tableau) de caractères ASCII imprimables. pas besoin de gérer l'ensemble du jeu Unicode.

Page de code personnalisée ou ASCII non imprimable dans votre code?

Si votre langue utilise une page de code personnalisée (Jelly, APL, etc.), vous devez en tenir compte (un programme €æÆdoit donc générer [1, x, 2]une sortie pour une entrée €%æ). Utiliser toujours uniquement des caractères non-ASCII pour la sortie -1(puisque l'entrée est uniquement en ASCII) n'est pas une solution valide. Vous pouvez supposer que votre programme accepte nativement votre page de code personnalisée, c'est-à-dire que si votre programme dispose d'une méthode de conversion d'un caractère Aen entier 65(codage ASCII), vous pouvez supposer qu'il convertit maintenant le 65e caractère de votre page de code en 65.

Inspiré par le défi suivant: sensibilisation positionnelle

Python2, 55 octets

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

Commence avec une chaîne contenant tous les caractères utilisés dans le code, puis recherche dans les index

Lenguage , 56,623 octets

Ci-dessous se trouve un hexdump des 256 premiers octets. Les octets restants peuvent être choisis arbitrairement.

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

La sortie est en octets, comme il est d'usage pour brainfuck et al.

Comment ça marche

Ceci est un programme de chat simple, en particulier ,[.,].

Le code source contient toutes les valeurs de 256 octets dans l'ordre, de sorte que l'index de chaque octet correspond à sa valeur.

Lenguage , 1.22e7 octets

Se compose d' 12263215 NULoctets, (Hex 0x00) .

Affiche un NULpour chaque caractère qui n'apparaît pas dans la source.

La ruse est que l’entrée ne contiendra jamais de NUL, nous générons donc toujours la quantité de NULs qu’il ya des caractères dans l’entrée.

Cela se traduit par le programme Brainfuck suivant

,[[-].,]

Et avec une panne ...

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

Cela montre simplement le pouvoir absolu de Lenguage en tant que langue de golf. Craignez ça.

Gelée , 10 à 9 octets

“ṾiЀƓv”v

Essayez-le en ligne!

Comment ça marche

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

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

Ouf, @KritixiLithos et moi travaillons dessus depuis 4 jours maintenant.

Imprime 0x00si le caractère en entrée n'est pas dans le programme, index du caractère (basé sur 1) en hexadécimal sinon. Essayez-le en ligne!

Explication:

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

Cette dernière fonction est la boucle. Il parcourt les caractères sélectionnés [(:<>)+,-.]dans l'ordre et compare l'entrée avec le caractère. Maintenant, je vais donner une explication plus profonde du fonctionnement de cette boucle.

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

La pile ressemble à cela alors que dans une boucle. La boucle durera jusqu’à 12-nest 0. Ensuite, nous avons le compteur qui est n+2. Ce compteur est également le numéro de la fonction pour chacun des caractères sélectionnés. Alors, quand n=0, n+2correspondra au premier caractère, c'est-à-dire [. >[->+>+<<]>>[-<<+>>]<:fait exactement cela, il convertit le compteur en personnage.

Une fois que le pointeur se trouve à la position du curseur, nous comparerons le caractère produit à partir de la variable compteur avec l’entrée tout en les préservant.

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

Zest 0lorsque le caractère est égal à l'entrée, ou un autre entier non nul sinon.

Nous trouvons maintenant une déclaration if pour vérifier cette égalité.

[[-]>+<]

Si Zest différent de zéro, c'est-à-dire que le caractère et l'entrée ne sont pas identiques, nous incrémentons l'emplacement de mémoire suivant.

Lorsque nous sortons de cette instruction if, nous décrémentons le prochain emplacement mémoire. Maintenant, cet endroit de la mémoire contient !Z. Enfin, en utilisant cela, nous produisons l’index du caractère s’il correspond à l’entrée, puis nous sortons de la boucle de force. Sinon, nous continuons avec la boucle jusqu'à ce qu'elle soit terminée ou qu'une correspondance soit trouvée.

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

CJam , 14 12 octets

{sq\f#p_~}_~

Utilise l'indexation basée sur 0 et -1pour les caractères qui n'apparaissent pas dans la source.

Essayez-le en ligne!

Javascript, 34 octets

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

Il prend en entrée sous forme de tableau de chaînes, xsoit -1(indexation basée sur 0).

C, 153 152 143 octets

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

Essayez-le en ligne!

Ruby, 41 88 86 71 69 67 61 56 56 octets

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

Thx Lynn pour avoir tué 6 octets

> <> (Poisson) 70 octets

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

Probablement le plus long> <> 1 paquebot que j'ai jamais fabriqué.

Il imprimera la sortie pour chaque caractère trouvé sur une ligne distincte (0 indexé).

Un caractère non trouvé affichera toujours la longueur du code + 1 (je pourrais le changer si cela n’est pas acceptable dans son état actuel). Dans ce cas, 71 seront toujours les caractères "Introuvable".

Je vais lancer une explication une fois que j'ai le temps.

Quelques cas de test;

## K = 1 \ n1 \ n71

# "# = 1 \ n69 \ n1

Essayez-le en ligne

> <> langue

Perl 6 , 50 52 octets

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

Traduction de la solution Ruby de GB et de la solution Python de Rod .

Un lambda qui entre une liste de caractères et une liste d'index de base zéro ( Nilpour les caractères inexistants).

EDIT: Correction d'un oubli - obligatoire d'ajouter 2 octets :(

Clojure, 43 56 48 octets

Edit: Zut j'ai oublié à propos 2! Augmenté de 43 à 56.

Edit 2: Mise à jour de l'exemple de code sous ce texte, mise à jour du nombre d'octets à ne pas inclure (def f ...) mais uniquement de la partie hash-map.

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

La carte de hachage se compose uniquement de caractères 01234{\\}et code leur emplacement. Dans Clojure, les fonctions de hash-maps peuvent être utilisées, comme le montre cet exemple complet ( fpeut être remplacé par la définition de 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{\\}"

Je suppose que ça compte :)

JavaScript, 39 octets

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

console.log( p('mapP') )

Pyth, 11 octets

xL_+N"N+_Lx

Un programme qui prend en entrée un "quoted string", avec tous les guillemets dans la chaîne échappée avec un précédent \, et imprime une liste de valeurs indexées à zéro avec -1des caractères qui ne sont pas dans la source.

Essayez-le en ligne!

Comment ça marche

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 octets

"'ìsvDyk,"'"ìsvDyk,

Essayez-le en ligne!

Cela génère -1 à la place des caractères manquants.

Luis Mendo a posté ce (légèrement modifié) sur Golf vous un quine pour un grand bien! , en ajoutant "s" et "k" à cette quine, on obtient également cette réponse. Cependant, je ne peux pas prendre le crédit de cette modification triviale ... Luis, vous pouvez m'envoyer un message si vous souhaitez le republier et je vais simplement le supprimer. Si vous voulez voir mes progrès avant de trouver cette question, consultez les modifications. Eh bien ... Il était beaucoup comme son à un moment donné.

SmileBASIC, 128 96 88 86 octets

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

Une chose importante à réaliser est que ce n’est pas vraiment un défi de taille. Vous avez seulement besoin du code source jusqu'au dernier caractère unique .

Je mets au moins 1 de chaque caractère au début du code: ?R<3+CD,4LINPUT(S$)WHILE"je n'ai donc qu'à stocker une copie du programme jusqu'au premier guillemet.

Python, 90 88 octets

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

Cas de test:

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

Empilé , non compétitif, 36 octets

Quand j'ai dit que cette langue était encore en développement, je le pensais vraiment. Apparemment, l' prompthabitude de consommer la pile entière. C'est pourquoi je ne peux pas avoir de belles choses. Essayez-le ici!

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

C'est le cadre standard de quine. En gros, :duplique la fonction [...]sur la pile, qui est ensuite exécutée avec !. Ensuite, l'intérieur de [...]s'exécute avec la fonction sur la pile. Il la convertit en chaîne, ajoute :!(le programme lui-même), puis prend une chaîne avec une entrée prompt. CSle convertit en une chaîne de caractères. Une chaîne de caractères est un peu différente d'une chaîne classique dans la mesure où elle est vectorisée par des opérateurs. Dans ce cas, indexvectorise sur l'entrée, donnant chaque indice de la chaîne d'entrée dans le programme, pour être finalement outmis.

Pour l'entrée Hello, World!, cela donne:

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

J'ai essayé d'utiliser celui sans quine (c'est-à-dire coder la chaîne de caractères qui apparaissent dans votre source), mais il n'y a qu'un seul type de guillemets dans Stacked, à savoir, 'il serait donc plus long de faire ce type de solution.

Coque , 12 octets

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

Essayez-le en ligne!

Explication

L'explication utilise ¨pour délimiter des chaînes et des 'caractères:

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 octets

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

0-indexé, et donne -1pour les caractères qui ne font pas partie du code source.

Explication:

Essayez-le en ligne.

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 octets

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

Essayez-le en ligne!

1-indexé, 0 pour les caractères qui ne sont pas présents dans le code. ''représente un seul devis. Recherchez chaque caractère dans la chaîne 11|1+i.~&', ajoutez 1, modulo 11.

> <> , 31 octets

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

Essayez-le en ligne!

La sortie est indexée sur 1, ce qui 32signifie que le caractère n'est pas dans le code.

Perl 5 avec -pl, 43 octets

Utilise une entrée séparée par une nouvelle ligne et imprime -1pour les caractères n'apparaissant pas dans le programme.

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

Essayez-le en ligne!

Stax , 19 octets

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

Exécuter et déboguer

Affiche un index basé sur 0, un caractère par ligne. Il s'avère que c'est plus court que de modifier le "34bL"34bLquine que j'ai écrit plus tôt.