Desafio

Escreva um programa / função não vazio pque, dada uma sequência de entrada não vazia s, produza a posição da primeira ocorrência de cada caractere sno código fonte de p.

Por exemplo, se o seu programa for

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

e recebe uma entrada abcd{, a saída deve ser

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

Aqui, xrepresenta qualquer saída que não é uma saída válida para uma posição de caractere (por exemplo, um número negativo, 0se você usa indexação baseada em 1, NaN, Inf, a string potato, um número maior do que o comprimento do seu programa, etc).

Restrições

A leitura do código fonte não é permitida (como em um quine apropriado). O uso de comentários é permitido, mas conta para a sua pontuação.

A entrada e a saída podem ser feitas em um formato razoável, mas devem ser inequívocas (apenas delimitadores adicionais, sem randfluxo e alegando que a resposta está em algum lugar), consistente (por exemplo, o xacima deve sempre ser o mesmo valor) e humano. legível ; por exemplo, uma sequência ou uma matriz de caracteres. Você pode assumir que a entrada é uma sequência (ou matriz) de caracteres ASCII imprimíveis; não há necessidade de lidar com todo o conjunto Unicode.

Página de código personalizada ou ascii não imprimível no seu código?

Se o seu idioma usa uma página de código personalizada (Jelly, APL, etc), você deve levar isso em conta (para que um programa €æÆexiba [1, x, 2]uma entrada €%æ). Usar apenas caracteres não ASCII para gerar -1sempre (uma vez que a entrada é somente ASCII) não é uma solução válida. Você pode assumir que seu programa aceita nativamente sua página de códigos personalizada, ou seja, se seu programa possui um método de converter um caractere Aem um número inteiro 65(codificação ASCII), você pode assumir que agora ele converte o 65º caractere em sua página de código em 65.

Inspirado no seguinte desafio: Consciência posicional

Python2, 55 bytes

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

Inicia com uma sequência que contém todos os caracteres usados ​​no código e, em seguida, procura nos índices

Linguagem , 56.623 bytes

Abaixo está um hexdump dos primeiros 256 bytes. Os bytes restantes podem ser escolhidos arbitrariamente.

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

A saída é em bytes, como é habitual para brainfuck et al.

Como funciona

Este é um programa simples para gatos, especificamente ,[.,].

O código fonte contém todos os valores de 256 bytes em ordem, portanto, o índice de cada byte corresponde ao seu valor.

Linguagem , 1.22e7 bytes

Consiste em 12263215 NULbytes (Hex 0x00) .

Emite a NULpara cada caractere que não aparece na fonte.

O truque é que a entrada nunca conterá a NUL, portanto sempre produzimos a quantidade de NULs que existem caracteres na entrada.

Isso se traduz no seguinte programa Brainfuck

,[[-].,]

E com um colapso ...

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

Isso apenas mostra o poder absoluto do Lenguage como uma linguagem de golfe. Tema isso.

Geléia , 10 9 bytes

“ṾiЀƓv”v

Experimente online!

Como funciona

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

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

Ufa, @KritixiLithos e eu estamos trabalhando nisso há 4 dias.

Imprime 0x00se o char de entrada não estiver no programa, o índice do char (baseado em 1) em hexadecimal. Experimente online!

Explicação:

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

Esta última função é o loop. Ele percorre os caracteres selecionados [(:<>)+,-.]em ordem e compara a entrada com o caractere. Agora vou dar uma explicação mais profunda sobre como esse loop funciona.

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

A pilha fica assim em um loop. O loop será executado até que 12-nseja 0. Então nós temos o contador que é n+2. Esse contador também é o número da função para cada um dos caracteres selecionados. Então n=0, quando , n+2será correspondente ao primeiro caractere, ie [. >[->+>+<<]>>[-<<+>>]<:faz exatamente isso, converte o contador para o personagem.

Quando o ponteiro estiver onde está o cursor, compararemos o caractere produzido a partir da variável do contador com a entrada, preservando-o.

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

Zé 0quando o caractere é igual à entrada ou algum outro número inteiro diferente de zero.

Agora, criamos uma declaração if para verificar essa igualdade.

[[-]>+<]

Se Zfor diferente de zero, ou seja, o caractere e a entrada não são os mesmos, incrementamos o próximo local de memória.

Depois que saímos dessa instrução if, diminuímos o próximo local de memória. Agora, este local de memória contém !Z. Finalmente, usando isso, produzimos o índice do caractere se ele corresponder à entrada e, em seguida, saímos do loop forçosamente. Senão, continuamos com o loop até que ele termine ou seja encontrada uma correspondência.

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

CJam , 14 12 bytes

{sq\f#p_~}_~

Usa indexação baseada em 0 e -1para caracteres que não aparecem na fonte.

Experimente online!

Javascript, 34 bytes

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

Ele recebe a entrada como matriz de seqüências de caracteres, xé -1(indexação baseada em 0).

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

Experimente online!

Ruby, 41 88 86 71 69 67 61 56 bytes

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

Thx Lynn por matar 6 bytes

> <> (Peixe) 70 bytes

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

Provavelmente o forro mais longo que já fiz.

Ele imprimirá a saída para cada caractere encontrado em uma linha separada (0 indexado).

Um caractere não encontrado sempre imprimirá o comprimento do código + 1 (eu poderia alterar isso se não for considerado bom em seu estado atual), portanto, nesse caso, 71 sempre serão os caracteres "Não encontrados".

Vou dar uma explicação assim que tiver tempo.

Alguns casos de teste;

## K = 1 \ n1 \ n71

# "# = 1 \ n69 \ n1

Experimente online

> <> idioma

Perl 6 , 50 52 bytes

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

Tradução da solução Ruby da GB e da solução Python da Rod .

Um lambda que insere uma lista de caracteres e gera uma lista de índices baseados em zero ( Nilpara caracteres inexistentes).

EDIT: Corrigido um descuido - necessário adicionar 2 bytes :(

Clojure, 43 56 48 bytes

Edit: Porra, eu esqueci 2! Aumentado de 43 para 56.

Editar 2: atualizado o código de exemplo abaixo deste texto, atualizado o número de bytes para não incluir (def f ...), mas apenas a parte do mapa de hash.

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

O mapa de hash consiste apenas de caracteres 01234{\\}e codifica suas localizações. No Clojure, os hash-maps podem ser funções usadas, como mostrado neste exemplo completo ( fpode ser substituído pela definição do 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{\\}"

Eu acho que isso conta :)

JavaScript, 39 bytes

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

console.log( p('mapP') )

Pitão, 11 bytes

xL_+N"N+_Lx

Um programa que recebe entrada de a "quoted string", com quaisquer aspas na cadeia de caracteres escapada com uma precedente \, e imprime uma lista de valores indexados a zero com -1caracteres que não estão na origem.

Experimente online!

Como funciona

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,

Experimente online!

Isso gera -1 no lugar de caracteres ausentes.

Luis Mendo postou isso (um pouco modificado) no Golf you a quine for great good! , adicionar "s" e "k" a esse quine também resulta nessa resposta. No entanto, não posso me responsabilizar por essa modificação trivial ... Luis, você pode me enviar uma mensagem se quiser repassar isso e eu vou excluí-lo. Se você quiser ver meu progresso antes de encontrar essa pergunta, veja as edições. Bem ... Ele era significativamente como o seu em um ponto.

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

Uma coisa importante a entender é que esse não é realmente um desafio simples. Você só precisa do código fonte até o último caractere exclusivo .

Coloquei pelo menos 1 de cada caractere no início do código: ?R<3+CD,4LINPUT(S$)WHILE"portanto, só tenho que armazenar uma cópia do programa até a primeira aspa.

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]

Caso de teste:

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

Empilhados , não concorrentes, 36 bytes

Quando eu disse que essa linguagem ainda estava em desenvolvimento, eu quis dizer isso. Aparentemente, promptcostumava consumir toda a pilha. É por isso que não posso ter coisas boas. Experimente aqui!

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

Essa é a estrutura padrão do quine. Basicamente, :duplica a função [...]na pilha, que é então executada com !. Em seguida, o interior de é [...]executado com a função na pilha. Ele o converte em uma string, anexa :!(o próprio programa) e, em seguida, recebe uma entrada de string prompt. CSconverte-o em uma cadeia de caracteres. Uma cadeia de caracteres é um pouco diferente de uma cadeia regular, pois possui operadores vetorizados sobre ela. Nesse caso, indexvetoriza sobre a entrada, produzindo cada índice da string de entrada no programa, sendo finalmente outcolocado.

Para entrada Hello, World!, isso fornece:

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

Tentei usar o sem quine (ou seja, codificando a sequência de caracteres que aparece na sua fonte), mas há apenas um tipo de aspas no Stacked, a saber ', então seria mais demorado fazer esse tipo de solução.

Casca , 12 bytes

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

Experimente online!

Explicação

A explicação está usando ¨para delimitar seqüências de caracteres e 'delimitar caracteres:

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

Indexado com 0 e fornece -1caracteres que não fazem parte do código-fonte.

Explicação:

Experimente 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 bytes

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

Experimente online!

1 indexado, 0 para caracteres que não estão presentes no código. ''significa uma única citação. Encontre cada caractere na string 11|1+i.~&', adicione 1, módulo 11.

> <> , 31 bytes

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

Experimente online!

A saída é indexada em 1, 32significando que o caractere não está no código.

Perl 5 com -pl, 43 bytes

Usa entrada separada por nova linha e imprime -1para caracteres que não aparecem no programa.

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

Experimente online!

Stax , 19 bytes

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

Execute e depure

Gera índice baseado em 0, um caractere por linha. Acontece que é mais curto do que modificar o "34bL"34bLquine que escrevi anteriormente.