Reto

Escriba un programa / función no vacío pque, dada una cadena de entrada no vacía s, muestre la posición de la primera aparición de cada carácter sen el código fuente de p.

Por ejemplo, si su programa es

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

y recibe una entrada abcd{, la salida debe ser

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

En este caso, xrepresenta cualquier salida que no es una salida válida para una posición de carácter (por ejemplo, un número negativo, 0si se utiliza la indexación basada en 1, NaN, Inf, la cadena potato, un número mayor que la longitud de su programa, etc.).

Restricciones

No está permitido leer el código fuente (como en una quine adecuada). El uso de comentarios está permitido, pero cuenta para su puntaje.

La entrada y la salida se pueden hacer en un formato razonable, pero deben ser inequívocas (solo delimitadores adicionales, sin randflujo y alegando que la respuesta está en algún lugar), consistente (por ejemplo, lo xde arriba siempre debe ser el mismo valor) y humano. LEGIBLE ; por ejemplo, una cadena o una matriz de caracteres. Puede suponer que la entrada es una cadena (o matriz) de caracteres ASCII imprimibles; no es necesario manejar todo el conjunto Unicode.

Página de códigos personalizada o ascii no imprimible en su código?

Si su idioma utiliza una página de códigos personalizada (Jelly, APL, etc.), debe tener eso en cuenta (por lo que un programa €æÆdebe generar [1, x, 2]una entrada €%æ). Usar solo caracteres no ASCII para generar -1siempre (dado que la entrada es solo ASCII) no es una solución válida. Puede suponer que su programa acepta de forma nativa su página de códigos personalizada, es decir, si su programa tiene un método para convertir un carácter Aen un entero 65(codificación ASCII), puede suponer que ahora convierte el 65º carácter en su página de códigos 65.

Inspirado en el siguiente desafío: conciencia posicional

Python2, 55 bytes

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

Comienza con una cadena que contiene todos los caracteres utilizados en el código y luego busca en los índices

Lenguage , 56,623 bytes

A continuación hay un hexdump de los primeros 256 bytes. Los bytes restantes se pueden elegir 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  ................

La salida está en bytes, como es habitual en brainfuck et al.

Cómo funciona

Este es un programa simple para gatos, específicamente ,[.,].

El código fuente contiene todos los valores de 256 bytes en orden, por lo que el índice de cada byte coincide con su valor.

Lenguaje , 1.22e7 bytes

Consiste en 12263215 NULbytes, (Hex 0x00) .

Emite un NULpara cada personaje que no aparece en la fuente.

El truco es que la entrada nunca contendrá un NUL, por lo que siempre sacamos la cantidad de NULs que hay caracteres en la entrada.

Esto se traduce en el siguiente programa Brainfuck

,[[-].,]

Y con un colapso ...

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

Esto solo muestra el gran poder de Lenguage como lenguaje de golf. Temerlo

Jalea , 10 9 bytes

“ṾiЀƓv”v

Pruébalo en línea!

Cómo 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

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

Uf, @KritixiLithos y yo hemos estado trabajando en esto durante 4 días.

Imprime 0x00si input char no está en el programa, de lo contrario, el índice del char (basado en 1) en hexadecimal. Pruébalo en línea!

Explicación:

[(:<>)+,-.]
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 función es el bucle. Recorre los caracteres seleccionados [(:<>)+,-.]en orden y compara la entrada con el carácter. Ahora voy a dar una explicación más profunda sobre cómo funciona este ciclo.

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

La pila se ve así mientras está en un bucle. El bucle se ejecutará hasta que 12-nsea 0. Luego tenemos el contador que es n+2. Este contador también es el número de la función para cada uno de los caracteres seleccionados. Entonces n=0, cuando n+2corresponderá al primer carácter, es decir [. >[->+>+<<]>>[-<<+>>]<:hace exactamente eso, convierte el contador en el personaje.

Una vez que el puntero está donde está el cursor, compararemos el carácter producido a partir de la variable del contador con la entrada mientras los conservamos.

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

Zes 0cuando el carácter es igual a la entrada, o algún otro entero distinto de cero de lo contrario.

Ahora se nos ocurre una declaración if para verificar esta igualdad.

[[-]>+<]

Si Zno es cero, es decir, el carácter y la entrada no son iguales, incrementamos el siguiente lugar de memoria.

Después de salir de esta declaración if, disminuimos el siguiente lugar de memoria. Ahora este lugar de memoria contiene !Z. Finalmente, usando esto, sacamos el índice del carácter si coincide con la entrada y luego salimos del ciclo por la fuerza. De lo contrario, continuamos con el ciclo hasta que termine o se encuentre una coincidencia.

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

CJam , 14 12 bytes

{sq\f#p_~}_~

Utiliza indexación basada en 0 y -1para caracteres que no aparecen en la fuente.

Pruébalo en línea!

Javascript, 34 bytes

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

Toma la entrada como una matriz de cadenas, xes -1(indexación basada en 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);}

Pruébalo en línea!

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

> <> (Pescado) 70 bytes

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

Probablemente el más largo> <> 1 liner que he hecho.

Imprimirá la salida para cada carácter encontrado en una línea separada (0 indexado).

Un carácter no encontrado siempre imprimirá la longitud del código + 1 (podría cambiar esto si no se considera correcto en su estado actual), por lo que en este caso 71 siempre serán los caracteres "No encontrado".

Encontraré una explicación una vez que tenga tiempo.

Algunos casos de prueba;

## K = 1 \ n1 \ n71

# "# = 1 \ n69 \ n1

Pruébalo en línea

> <> idioma

Perl 6 , 50 52 bytes

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

Traducción de la solución Ruby de GB y la solución Python de Rod .

Una lambda que ingresa una lista de caracteres y genera una lista de índices basados ​​en cero ( Nilpara caracteres inexistentes).

EDITAR: se corrigió un descuido; se requiere agregar 2 bytes :(

Clojure, 43 56 48 bytes

Editar: ¡Maldición, me olvidé 2! Incrementado de 43 a 56.

Edición 2: se actualizó el código de muestra debajo de este texto, se actualizó el número de bytes que no se incluirán (def f ...), sino solo la parte del mapa hash.

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

El mapa hash consta solo de caracteres 01234{\\}y codifica sus ubicaciones. En Clojure, los mapas hash pueden usarse para funciones, como se muestra en este ejemplo completo ( fpodría reemplazarse por la definición del mapa hash):

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

Supongo que esto cuenta :)

JavaScript, 39 bytes

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

console.log( p('mapP') )

Pyth, 11 bytes

xL_+N"N+_Lx

Un programa que toma la entrada de a "quoted string", con las comillas en la cadena escapó con un precedente \, e imprime una lista de valores indexados a cero con -1caracteres que no están en la fuente.

Pruébalo en línea!

Cómo 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,

Pruébalo en línea!

Esto genera -1 en lugar de caracteres faltantes.

Luis Mendo publicó esto (ligeramente modificado) en Golf, ¡una quine para bien! , agregar "s" y "k" a ese resultado también da como resultado esta respuesta. Sin embargo, no puedo tomar el crédito por esa modificación trivial ... Luis, puedes enviarme un mensaje si deseas volver a publicar esto y lo eliminaré. Si desea ver mi progreso antes de encontrar esa pregunta, vea las ediciones. Bueno ... fue significativamente al igual que su en un punto.

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

Una cosa importante a tener en cuenta es que esto no es realmente un desafío quine. Solo necesita el código fuente hasta el último carácter único .

Puse al menos 1 de cada carácter al comienzo del código: ?R<3+CD,4LINPUT(S$)WHILE"así que solo tengo que almacenar una copia del programa hasta la primera comilla.

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 prueba:

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

Apilado , no competitivo, 36 bytes

Cuando dije que este lenguaje aún estaba en desarrollo, lo dije en serio. Aparentemente, promptsolía consumir toda la pila. Por eso no puedo tener cosas buenas. Pruébalo aquí!

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

Este es el marco de trabajo estándar. Básicamente, :duplica la función [...]en la pila, que luego se ejecuta con !. Luego, el interior de se [...]ejecuta con la función en la pila. Lo convierte en una cadena, agrega :!(el programa en sí), luego toma una entrada de cadena con prompt. CSlo convierte en una cadena de caracteres. Una cadena de caracteres es un poco diferente de una cadena normal en que tiene operadores vectorizados sobre ella. En este caso, se indexvectoriza sobre la entrada, produciendo cada índice de la cadena de entrada en el programa, finalmente se outpone.

Para la entrada Hello, World!, esto da:

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

Intenté usar el que no tiene una quine (es decir, codificar la cadena de caracteres que aparecen en su fuente), pero solo hay un tipo de comillas en Apilado, a saber ', por lo que sería más largo hacer ese tipo de solución.

Casco , 12 bytes

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

Pruébalo en línea!

Explicación

La explicación se usa ¨para delimitar cadenas y '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, 172122 bytes

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

Indexado a 0, y proporciona -1caracteres que no son parte del código fuente.

Explicación:

Pruébalo en línea.

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.~&'''

Pruébalo en línea!

1 indexado, 0 para caracteres que no están presentes en el código. ''representa una cita simple. Encuentre cada carácter en la cadena 11|1+i.~&', agregue 1, módulo 11.

> <> , 31 bytes

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

Pruébalo en línea!

La salida está indexada en 1, lo que 32significa que el carácter no está en el código.

Perl 5 con -pl43 bytes

Utiliza entradas separadas por nueva línea e imprime -1caracteres que no aparecen en el programa.

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

Pruébalo en línea!

Stax , 19 bytes

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

Ejecutar y depurarlo

Emite un índice basado en 0, un carácter por línea. Resulta que es más corto que modificar la "34bL"34bLquine que escribí anteriormente.