Salida de la primera posición en su programa para cada carácter de entrada

43

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

Sanchises
fuente
¿Importa la capitalización?
Kritixi Lithos
@KritixiLithos por defecto, sí .
Martin Ender
@KritixiLithos De hecho lo hace.
Sanchises
Si mi programa solo usa índices del 0 al 9 , ¿necesito un separador o podría generar, por ejemplo 01030708070,?
Dennis
@ Dennis No, no lo haces. Es inequívoco, consistente y legible para los humanos. Requerir un separador no agregaría nada interesante al desafío, por lo que abusar de su bajo recuento de bytes. ;)
Sanchises

Respuestas:

24

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

Barra
fuente
55
No veo cómo esta es la respuesta aburrida. Creo que usar la quine estándar es mucho menos interesante que esto. :)
Martin Ender
Como se trata de Python 2, ¿no se rompería en la mayoría de las entradas? Si se rompe, deberías usarlo raw_input.
TidB
@TidB hmm, ¿supongo que no? ¿Qué aportes tienes en mente?
Rod
@ Rod Nevermind, estaba siendo un poco tonto. Siempre funcionará cuando ingreses un iterable. Tonto de mí.
TidB
12

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.

Dennis
fuente
44
Hmmm, creo que el lenguaje es el único idioma en el que las personas son superadas por tres órdenes de magnitud ...
Sanchises
2
El lenguaje también es el único idioma que constantemente encuentra formas de hacer trampa que ni siquiera sería remotamente competitivo en otros idiomas. : P
Dennis
¿No sería +[,.]una puntuación mucho mejor?
Sanchises
@Sanchises Eso ahorraría aproximadamente 12,000 bytes, pero también imprimiría un byte nulo adicional al final.
Dennis
2
Bueno, supongo que el byte nulo está en la entrada (aunque su función es terminar la cadena), y estaría en la posición 0 de su programa ...;)
Sanchises
10

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

Un taco
fuente
2
Una artimaña tan inteligente que casi ganaste ... ¿Intentaste lo contrario también, es decir, 0x00 bytes y 1 indexación?
Sanchises
Me hubiera encantado, pero Brainfuck / Lenguage (o al menos, el intérprete que estoy usando) no puede diferenciar entre EOF y 0x00, por lo que no podría responder el desafío.
ATaco
Brainfuck y col. generalmente se les permite imprimir enteros como bytes, es decir, imprimirías SOH para 1, NUL para 0.
Dennis
@Sanchises ¿Podría confirmar que ese es el caso aquí?
Dennis
1
¿No ,[>.,]sería más corto?
Jo King
8

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.
Dennis
fuente
8

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
Betseg
fuente
7

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!

Martin Ender
fuente
6

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

LarsW
fuente
Está permitido, ya que ese método también es aceptable para quines. No abre su archivo fuente y lo lee o usa una variable inicializada en la fuente.
mbomb007
1
@ mbomb007 No puedo hablar para todos los motores de JavaScript, pero en Firefox Function.toString funciona leyendo la fuente. En un momento, se bloqueará en las compilaciones de depuración si la fuente ya no está allí cuando intenta leerlo. (No lo he probado recientemente porque las compilaciones de depuración son muy complicadas en general).
Neil
No creo que sea diferente a hacerlo s='s=%s;print s%%s';print s%sen Python. No incluye el f=, así que está bien
mbomb007
1
Realmente no puedes hacer eso, porque ase supone que la entrada es una cadena. No hay mapfunción para las cadenas.
manonthemat
@manonthemat "Se puede suponer que la entrada es una cadena (o matriz)"
LarsW
5

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!

Betseg
fuente
5

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

GB
fuente
1
a='p$<.chrsm{| #index};"';p$<.chars.map{|c|"a='#{a}".index c}debería funcionar también, tomando la entrada de STDIN.
Lynn
4

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

Pelícano verde azulado
fuente
Creo que 71 está bien como salida para no encontrado. Es coherente, inequívoco y legible para los humanos, lo que creo que es más importante que ser "... cualquier salida que no sea un entero positivo". Expandí las reglas para reflejar esta decisión.
Sanchises
3

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

smls
fuente
3

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

NikoNyrh
fuente
2

JavaScript, 39 bytes

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

console.log( p('mapP') )

Washington Guedes
fuente
1
puedes explicar [...s]por favor?
Erresen
Se conoce como operador de propagación, puede ver un poco más en los consejos de golf ES6 .
Washington Guedes
2
No está permitido leer el código fuente
Arnauld
2

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
TheBikingViking
fuente
2

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.

Urna de pulpo mágico
fuente
¡@Sanchises funciona para mí!
Urna mágica del pulpo
Genial genial genial!
Sanchises
@MagicOctopusUrn ¡Bien hecho!
Luis Mendo
2

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.

12Me21
fuente
1

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]
TidB
fuente
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.

Conor O'Brien
fuente
1

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]
ბიმო
fuente
1

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
Kevin Cruijssen
fuente
1

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.

FrownyFrog
fuente
1

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

Jo King
fuente
1

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!

Dom Hastings
fuente
@Sanchises Corregido ahora, perdón por eso. ¡Claramente no leí correctamente!
Dom Hastings
No hay problema. ¡Gracias por traer nueva vida a este desafío!
Sanchises
1

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.

Weijun Zhou
fuente