Intérprete de conversación

10

"Talk" es un lenguaje baroquificado basado en acumuladores que se crea en respuesta a la cita de Dennis en talk.tryitonline.net.

Waiting for someone to create an esolang called talk.

. El lenguaje "Talk" tiene 4 comandos:

  • 00 Si el acumulador es 0, establezca el acumulador en 0.
  • 01 Si el acumulador es 0, configure el acumulador en 1.
  • 10 Si el acumulador es 1, establezca el acumulador en 0.
  • 11 Si el acumulador es 1, configure el acumulador en 1.

Entrada:

  • La entrada se puede tomar a través de cualquier método de entrada aceptable según nuestras reglas de E / S estándar.

  • Hay dos entradas, el valor inicial del acumulador y el programa. Puede fusionar estas dos entradas en una entrada o dividir su entrada en comandos válidos (por ejemplo, tomarlos como una lista; por ejemplo [00, 01, 00]) si lo desea.

Salida:

  • Al final de la ejecución de un comando, el acumulador se emite implícitamente.

Reglas:

  • La entrada puede ser una sola cadena o lista de caracteres.
  • Como se trata de código de golf , la respuesta más corta, en bytes, gana.
  • Tomamos dígitos o cadenas / caracteres.

    Casos de prueba:

0 0001111101 -> 1
0 000100 -> 1
0 11001000 -> 0

Tablas de clasificación

Aquí hay un fragmento de pila para generar una tabla de clasificación regular y una descripción general de los ganadores por idioma.

Para asegurarse de que su respuesta se muestre, comience con un título, usando la siguiente plantilla de Markdown:

# Language Name, N bytes

¿Dónde Nestá el tamaño de su envío? Si mejora su puntaje, puede mantener los puntajes antiguos en el título, tachándolos. Por ejemplo:

# Ruby, <s>104</s> <s>101</s> 96 bytes

Si desea incluir varios números en su encabezado (por ejemplo, porque su puntaje es la suma de dos archivos o desea enumerar las penalizaciones de la bandera del intérprete por separado), asegúrese de que el puntaje real sea el último número en el encabezado:

# Perl, 43 + 2 (-p flag) = 45 bytes

También puede hacer que el nombre del idioma sea un enlace que luego aparecerá en el fragmento de la tabla de clasificación:

# [><>](http://esolangs.org/wiki/Fish), 121 bytes

Mostrar fragmento de código

code-golf  interpreter 
3
¿Entonces hay dos entradas, la secuencia de comandos y el valor inicial del acumulador?
— xnor
44
Algunos casos de prueba que no cambian el acumulador, comienzan con 1 en el acumulador o no tienen instrucciones serían buenos
— Jo King
8
¿Puede Talk realmente considerarse un lenguaje de programación ?
— Luis Mendo
8
@A_ Ese comentario probablemente fue una broma. En el pasado , un idioma llamado Lang tendría una URL lang.tryitonline.net(ahora es tio.run/#lang). Entonces, un lenguaje llamado Talk causaría confusión con la URL de la sala de chat creada recientemente, que estalk.tryitonline.net
— Luis Mendo
77
En el futuro, evite cambiar las E / S después de que se hayan publicado varias respuestas. Regresé hoy y tener entradas asignadas permitidas hace que este sea un desafío completamente diferente de lo que respondí .
— GammaFunction

Respuestas:

21

Jalea , 3 bytes

y@/

La entrada es una lista única: el acumulador, seguido de los pares.

Pruébalo en línea!

Cómo funciona

El yátomo realiza transliteración; [a, b] yc reemplaza a con b , por lo que devuelve b si a = c y c si a ≠ c .

y@/pliega / reduce la entrada ycon argumentos intercambiados, realizando una transliteración por par.

— Dennis
fuente
14
Esta es la única respuesta de Jelly que he visto hasta ahora que solo usa caracteres ASCII.
2
Había unos pocos. Mira ma, no Unicode!
— Dennis
21

Python 3 , 43 bytes

lambda s:re.sub("00|11","",s)[-1]
import re

Pruébalo en línea!

La función toma una sola cadena como entrada, donde el primer carácter es el estado inicial y el resto de la cadena representa los comandos. Esta solución se puede portar fácilmente a otros idiomas que tengan un mejor soporte para expresiones regulares.

La parte difícil es demostrar que la solución produce el resultado correcto. Para ver esto, necesitamos un análisis profundo de los comandos. En primer lugar, podemos ver que los comandos tienen las siguientes propiedades:

  • Propiedad (1) : ordena 00y 11retiene el estado del acumulador.
  • Propiedad (2) : ordena 01y 10hace que el estado del acumulador sea el mismo que el segundo bit, independientemente de su estado original.

Por lo tanto, el estado final del acumulador es:

  • Caso 1 : si no0110 existe un comando o , el estado final es el mismo que el estado inicial.
  • Caso 2 : de lo contrario, la última parte de la última10 o 01comando.

A continuación, mostraremos que la solución produce el resultado correcto en ambos casos. Probamos la declaración para el estado final 0y el estado final de 1puede probarse de manera análoga. Si el estado final es 0la entrada está en cualquiera de las siguientes formas:

  • ^0{2k+1}11(11|00)*

    Para el caso 1 , la cadena de entrada sdebe comenzar con 2k+10s, seguida de 11y 00comandos. Eliminar 00sys 11produce un solo 0, que es el estado final.

  • .+10{2k+1}11(11|00)*

    Para el caso 2 , la cadena de entrada termina con un 10comando, seguido de cero o más 00y 11s. Este patrón es equivalente a un 1seguido por 2k+10s, y luego cero o más 11sy 00s. La eliminación de 00sys 11deja atrás el último de los 2k+10 al final de la cadena, que representa el estado final.

Basado en todo lo anterior, después de la eliminación de 00s y 11es simultáneamente en una sola pasada ( 01001es un contra-ejemplo, si 00se elimina en una sola pasada y luego 11en otro pase) a partir de la entrada s, el último carácter es el estado final. Por lo tanto, se demuestra la exactitud de la solución.

— Joel
fuente
Bienvenido a PPCG! Excelente respuesta, y una buena prueba formal para acompañarlo.
— GammaFunction
3
Gracias. Creo que la gente puede dudar de que una solución tan simple produzca el resultado correcto a primera vista. Por lo tanto, es necesario proporcionar una prueba de ello.
— Joel
9

Perl 6 , 17 bytes

{m/.)>[(.)$0]*$/}

Pruébalo en línea!

Aprovecha "Puede combinar estas dos entradas en una entrada si lo desea" tomando la entrada como el valor del acumulador concatenado con los comandos, por ejemplo, 1,[00,11]es 10011. Si esto no está bien, entonces solo son 5 bytes adicionales para tomarlo como f(accumulator, commands). Devuelve un objeto de coincidencia que se puede forzar a una cadena.

Explicación:

{                }  # Anonymous code block
 m/             /   # Find the first match from the input
   .)>              # Capture a number
      [     ]*      # Followed by any number of
       (.)$0        # Pairs of identical characters
              $     # Ending the string

Básicamente, esto funciona porque los comandos 00y 11no hacen literalmente nada, mientras que los comandos 01y 10simplemente configuran el acumulador en el segundo dígito del comando. Si no hay comandos, toma el valor inicial del acumulador.

— Jo King
fuente
6

Zsh , 33 bytes

La lista de caracteres se pasa como argumentos, el valor inicial del acumulador se pasa como stdin.

read a
for x y;a=$[x^a?a:y]
<<<$a

Pruébalo en línea!

39 bytes : si los comandos deben ser una sola cadena

La entrada es accumulator commandscomo argumentos. 

for x y (${(s::)2})1=$[x^$1?$1:y]
<<<$1

Pruébalo en línea!

Por diversión, aquí hay una línea recursiva de 50 bytes ( TIO ):

<<<${${2+`f $[$1^${2[1]}?$1:${2[2]}] ${2:2}`}:-$1}
— Función Gamma
fuente
6

Python 3 , 52 bytes

f=lambda a,s:s and f([s[1],a][s[0]==s[1]],s[2:])or a

Pruébalo en línea!

Se corrigió el tipo de retorno inconsistente gracias a Chas Brown

Toma entrada como dos cadenas; El acumulador y el código.

— siete negativo
fuente
Oh no, eso fue rápido.
— HighRadioactive
1
Agradable pero tiene este problema potencial - f(1,'11')==f(1,'01')es False; a veces devuelve un inty a veces un str. Entonces, ¿tal vez especifique que toma acc input como una cadena?
— Chas Brown el
@ChasBrown Buena llamada, eso es mucho más simple de lo que estaba pensando.
— negativo siete
Agradable, pero como su función es recursiva, no puede ser anónima. Debe ser de 52 bytes .
— Jitse
5

Brachylog , 11 9 bytes

tġ₂≠ˢtt|h

Pruébalo en línea!

Dado que ha pasado tanto tiempo que he podido olvidar la noción de imprimir el acumulador después de cada comando , he formulado una solución significativamente menos ingenua con algo de inspiración de la respuesta de Perl de Jo King.

       |     The output is
     tt      the last element of the last element of
t            the last element of the input
 ġ₂          split into length-2 slices
   ≠ˢ        with equal pairs removed.
       |     If there is no such element, the input
        h    's first element is the output.

Vieja solución:

Brachylog , 18 16 bytes

ġ₂ᵗc{th~h?tt|h}ˡ

Pruébalo en línea!

-2 bytes de cambiar el formato de entrada.

— Cadena no relacionada
fuente
5

JavaScript (ES6), 27 bytes

Toma entrada como (a)(code), donde el código es una lista de enteros de 2 bits.

a=>c=>c.map(x=>a^=x==a+1)|a

Pruébalo en línea!

JavaScript (ES6),  47  40 bytes

Toma entrada como (a)(code), donde el código es una cadena.

a=>c=>c.replace(/../g,x=>a^=x%4==a+1)&&a

Pruébalo en línea!

¿Cómo?

(una=0 0,X=012)(una=1,X=102)

  a | x (bin) | int(x) % 4 | a + 1 | equal?
----+---------+------------+-------+--------
  0 |   "00"  |  0 % 4 = 0 |   1   |   N
  1 |   "00"  |  0 % 4 = 0 |   2   |   N
  0 |   "01"  |  1 % 4 = 1 |   1   |   Y
  1 |   "01"  |  1 % 4 = 1 |   2   |   N
  0 |   "10"  | 10 % 4 = 2 |   1   |   N
  1 |   "10"  | 10 % 4 = 2 |   2   |   Y
  0 |   "11"  | 11 % 4 = 3 |   1   |   N
  1 |   "11"  | 11 % 4 = 3 |   2   |   N
— Arnauld
fuente
4

sed -E, 26 19 bytes

Un enorme -7 bytes de @Cowsquack al darse cuenta de que eliminar todos los pares también funciona.

s/(.)\1//g
s/.*\B//

Toma datos concatenados juntos en stdin. Inspirado por la respuesta de Perl de Jo King . Elimine los pares finales Elimine todos los pares, luego obtenga el último dígito.

Pruébalo en línea! Pruébalo en línea!

— Función Gamma
fuente
1
La última línea puede ser simple s/.*\B//, pero de todos modos cambiar ligeramente el enfoque da 19 bytes aún más cortos. ¡ Pruébelo en línea!
— user41805
1
Huh, no pensé que s/(.)\1//gfuncionaría, ya que podría eliminar el final de un par y el comienzo del siguiente, pero aún funciona. ¡Excelente!
— GammaFunction
@GammaFunction s/(.)\1//ges equivalente a s/00|11//gcomo se muestra en mi solución.
— Joel
4

Retina 0.8.2 , 18 11 bytes

(.)\1

!`.$

Pruébalo en línea! El enlace incluye casos de prueba. Toma entrada concatenada. Ahorré 6 bytes gracias a @CowsQuack por señalar que eliminar todos los caracteres duplicados y luego tomar el último carácter restante funciona, aunque, de hecho, el puerto de la respuesta original de @ JoKing podría haber sido mejorado por 3 bytes incluso sin ese truco.

— Neil
fuente
— user41805
@Cowsquack D'oh, una vez que piensas en separar las etapas, eso ya es un ahorro de 2 bytes, luego otro byte guardado porque puedes usar !`.$, y luego otros 4 bytes porque no tienes que limitar a los pares finales ...
— Neil
4

Python 3 , 38 bytes

lambda l:[y for*x,y in l if[y]!=x][-1]

Pruébalo en línea!

Basado en la solución de Joel . Toma la entrada como una lista del valor del acumulador inicial (cadena de longitud uno) seguido de los comandos (cadenas de longitud dos). Encuentra el último comando con dos valores desiguales y genera su segundo carácter.

Para hacer que esto caiga al valor del acumulador inicial cuando no hay tales comandos, hacemos que la cadena de valor inicial de un solo carácter pase la prueba. Lo hacemos comprobando si una lista singleton con el último carácter es desigual a una lista de todos los caracteres anteriores, que se pasa por cualquier cadena de longitud uno o cadena de longitud dos con dos caracteres diferentes.

— xnor
fuente
3

Perl 5 -p , 37 33 bytes

$\=<>;s/(.)(.)/$\=$2if$\==$1/ge}{

Pruébalo en línea!

La entrada es de dos líneas: la primera línea es la secuencia de comandos, la segunda es el acumulador.

— Xcali
fuente
3

Jalea , 8 6 bytes

EÐḟṪṪo

Pruébalo en línea!

-2 bytes gracias a que Nick Kennedy me informó de un cambio de reglas. (Su propuesta de golf EÐḟFȯṪparece algo más inteligente pero tiene la misma longitud que mi solución anterior menos s2). El formato de entrada ahora toma los comandos como una lista de cadenas de dos caracteres, pero el pie de página de prueba se traduce del formato anterior por conveniencia.

Traducido de mi nueva solución Brachylog.

Versión antigua:

Jalea , 13 bytes

ḢẎ⁼⁹a⁸o
s2ç@ƒ

Pruébalo en línea!

No estoy 100% seguro de que esto sea correcto, pero tiene éxito en los tres casos de prueba. Toma los comandos como argumento izquierdo y el acumulador inicial como argumento derecho.

— Cadena no relacionada
fuente
1
La entrada se puede dividir en una lista, por lo que podría tener EÐḟFȯṪcon la entrada como, por ejemplo [[0,0],[0,1],[1,1],[1,1],[0,1]].
— Nick Kennedy el
Wow, los cambios en la especificación realmente fueron bastante grandes ...
— Cadena no relacionada
3

Haskell , 29 bytes

Define una función sin nombre en la primera línea con tipo (Foldable t, Eq b) => b -> t [b] -> b. Para los propósitos de este código de golf, podemos instanciarlo como Char -> [String] -> Chardonde el primer argumento es el acumulador y el segundo es una lista de cadenas con cada cadena como un solo comando.

foldl(#)
a#[x,y]|a==x=y|1>0=a

Pruébalo en línea!

— ankh-morpork
fuente
1
Mismo bytecount si lo define usando la notación de prefijo . No puedo creer que escribí casi exactamente la misma respuesta, al mismo tiempo, incluso incluyendo la explicación tipo de firma ...
— cole
2

Python, 111 bytes

def f(a,b):
    c=a
    for i in range(0,len(b)-1,2):
        c=(not b[i])*(c or b[i] or b[i+1]) or c*b[i]*b[i+1]
    return c

Sin golf. EDITAR: AHHH ¡Alguien me ganó!

— Altamente radioactivo
fuente
2

Barrilete , -ir, 16 bytes

"(!;½|':"=['_"|_

Pruébalo en línea!

Explicado:

  1. Toma la entrada implícita y la derecha desplaza el valor de los acumuladores hacia abajo

  2. Repita lo siguiente (longitud de la pila - 1 dividido por 2) veces

2.1. Mueva el acumulador de regreso a la parte superior

2.2. Compare por igualdad con la primera parte del comando

2.2.1. Si es cierto, reemplace el acumulador, de lo contrario, haga estallar el reemplazo

La entrada se toma como el valor acc inicial concatenado con la fuente. P.ej

010011000
  • El primer carácter es el valor acc
  • El descanso es programa
— Lyxal
fuente
1

Bash , 58 40 bytes

Agregue un byte para un programa completo: cambie fa $0.

(($1=$2-a?a:$3,1))&&f $1 ${@:4}||echo $1

58 bytes ¡ Pruébelo en línea!

El ternario devolverá falso cuando $1se establece en 0, pero ,1al final asegura que todo ((expression))volverá verdadero, excepto un error de sintaxis.

Cuando se consumen todos los argumentos, se produce un error de sintaxis y finaliza la recursividad.

— Función Gamma
fuente
1

Carbón , 16 bytes

Ｆ⪪η²Ｆ⁼θ§ι⁰≔§ι¹θθ

Pruébalo en línea! El enlace es a la versión detallada del código. Toma argumentos separados. Explicación:

Ｆ⪪η²

Divide las instrucciones en pares de dígitos y repítelos.

Ｆ⁼θ§ι⁰

Si el acumulador es igual al primer dígito ...

≔§ι¹θ

... luego asignarle el segundo dígito.

θ

Imprima el acumulador al final del ciclo.

— Neil
fuente
1

Jalea , 7 bytes

fؽḂ⁹;Ṫ

Un enlace diádico que acepta el programa como una lista de enteros a la izquierda y el acumulador inicial a la derecha que produce un entero.

Pruébalo en línea! O ver un conjunto de pruebas

— Jonathan Allan
fuente
Estoy eliminando el mapeo de entrada porque @GammaFunction me recomendó hacer esto.
@A_ ah OK, no puedo eliminar en el móvil, así que tendré que abordar esto más tarde
— Jonathan Allan
@A_ arreglado para trabajar con 0,1,2,3 la versión sin asignar de las instrucciones como dígitos ¿está bien?
— Jonathan Allan
1
Si, esta bien.
1

Encantamientos rúnicos , 28 bytes

/~@/i~/i<
/=?/~iR:l}i{l1-=?!

Pruébalo en línea!

Toma la entrada como una serie de bytes separados por espacios (Runic no entiende las listas). El primer byte es el estado inicial y cualquier otro byte es el programa. No se realiza ninguna validación (es decir, se supone que solo se proporcionan programas válidos como entrada y no le importa qué valor se usa para representar 0y 1).

— Draco18s ya no confía en SE
fuente
1

Asamblea x86, 33 bytes

Toma el estado inicial del acumulador en CL(entero 0o 1) y la dirección de los comandos como una cadena ASCII terminada en cero ESI. Deja el estado final del acumulador en CL.

Apunte la instrucción de llamada al desplazamiento 0x1B(etiqueta interpreten la Explicación).

3C 30 74 03 B0 01 C3 30 C0 C3 E8 F1 FF FF FF 38
C8 AC 75 07 E8 E7 FF FF FF 88 C1 AC 84 C0 75 EA
C3

Explicación (Uso de la sintaxis de Intel):

; function to convert ASCII '1'/'0' into 0 or 1 int values (from AL to AL)
ctob:
        CMP AL, 0x30 ; '0'
        JE .zero
        MOV AL, 1
        RET
        .zero:
        XOR AL, AL
        RET

; interpreting function
        interp_lp:
                CALL ctob     ; convert to number
                CMP AL, CL    ; compare to current accumulator
                LODSB         ; read the next character of the string
                              ; this doesn't affect any flags and we need to do
                              ; it in both cases anyway
                JNE interpret ; if AL != CL (from above, not the new value of AL), skip forward
                CALL ctob     ; convert AL to number
                MOV CL, AL    ; store AL in CL
interpret:      LODSB         ; read the next character of the string
                TEST AL, AL   ; check if it is a zero byte
                JNZ interp_lp ; if not, jump back into the loop
        RET
— Fayti1703
fuente
0

Cristal , 46 bytes.

Con comandos en un Array(Tuple(Int32,Int32)), como [{0,0}, {0,1}, {0,0}].

def f(s,i);i.map{|c,v|s+=~(s^c)&(s^v)%2};s;end

Pruébalo en línea!

Es bastante simple de entender en una forma más legible:

def f(state, instructions)
  instructions.map do |check, value|
    state += ~(state ^ check) & (state ^ value) % 2
  end
  state
end

La función recorre cada comando, desempacando automáticamente los valores de tupla en cy v. Luego establece el statepor la fórmula

state = state + NOT(state XOR check) AND (state XOR value) mod 2

a lo que llegué principalmente por prueba y error. Una vez que se han procesado todos los comandos, devuelve el valor del estado.

— Kinxer
fuente
0

C (clang) , 68 62 bytes

t(s,e,a)char*s,*e;{for(;s<e;++s)a=*s++-48^a?a:*s-48;puts(&a);}

Pruébalo en línea!

Lleva un puntero al inicio de la cadena de origen, un puntero al final de la cadena de origen (inicio + strlen (inicio)) y el valor del acumulador inicial.

Versión anterior (imprime ASCII 48/49 para 0/1):

t(s,e,a)char*s,*e;{for(;s<e;++s)a=*s++-48^a?a:*s-48;putchar(a+48);}
— osuka_
fuente
Al usar nuestro sitio, usted reconoce que ha leído y comprende nuestra Política de Cookies y Política de Privacidad.
Licensed under cc by-sa 3.0 with attribution required.