Interprète de conversation

10

"Talk" est un langage basé sur un accumulateur baroquifié qui est créé en réponse à la citation de Dennis sur talk.tryitonline.net.

Waiting for someone to create an esolang called talk.

. Le langage "Talk" a 4 commandes:

  • 00 Si l'accumulateur est 0, réglez l'accumulateur sur 0.
  • 01 Si l'accumulateur est 0, réglez l'accumulateur sur 1.
  • 10 Si l'accumulateur est 1, réglez l'accumulateur sur 0.
  • 11 Si l'accumulateur est 1, réglez l'accumulateur sur 1.

Contribution:

  • L'entrée peut être prise via n'importe quelle méthode d'entrée acceptable par nos règles d'E / S standard.

  • Il y a deux entrées, la valeur initiale de l'accumulateur et le programme. Vous pouvez fusionner ces deux entrées en une seule entrée ou diviser votre entrée en commandes valides (par exemple en les prenant comme liste; par exemple [00, 01, 00]) si vous le souhaitez.

Production:

  • À la fin de l'exécution d'une commande, l'accumulateur est émis implicitement.

Règles:

  • L'entrée peut être une chaîne unique ou une liste de caractères.
  • Comme il s'agit de code-golf , la réponse la plus courte, en octets, l'emporte.
  • Nous prenons des chiffres ou des chaînes / caractères.

    Cas de test:

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

Classements

Voici un extrait de pile pour générer à la fois un classement régulier et un aperçu des gagnants par langue.

Pour vous assurer que votre réponse apparaît, veuillez commencer votre réponse avec un titre, en utilisant le modèle Markdown suivant:

# Language Name, N bytes

où Nest la taille de votre soumission. Si vous améliorez votre score, vous pouvez conserver les anciens scores dans le titre, en les rayant. Par exemple:

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

Si vous souhaitez inclure plusieurs nombres dans votre en-tête (par exemple, parce que votre score est la somme de deux fichiers ou que vous souhaitez répertorier les pénalités de drapeau d'interprète séparément), assurez-vous que le score réel est le dernier numéro de l'en-tête:

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

Vous pouvez également faire du nom de la langue un lien qui apparaîtra ensuite dans l'extrait de classement:

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

Afficher l'extrait de code

code-golf  interpreter 
3
Il y a donc deux entrées, la séquence de commandes et la valeur initiale de l'accumulateur?
— xnor
4
Certains cas de test qui ne changent pas l'accumulateur, commencent par 1 dans l'accumulateur ou n'ont pas d'instructions seraient bons
— Jo King
8
Talk peut-il vraiment être considéré comme un langage de programmation ?
— Luis Mendo
8
@A_ Ce commentaire était probablement censé être une blague. À l'époque, une langue appelée Lang aurait une URL lang.tryitonline.net(maintenant c'est le cas tio.run/#lang). Donc, une langue appelée Talk causerait de la confusion avec l'URL du salon de discussion alors récemment créé, qui esttalk.tryitonline.net
— Luis Mendo
7
À l'avenir, veuillez vous abstenir de modifier les E / S après la publication d'un certain nombre de réponses. Je suis revenu aujourd'hui et avoir permis des entrées cartographiées en fait un défi entièrement différent de ce que j'ai répondu .
— GammaFunction

Réponses:

21

Gelée , 3 octets

y@/

L'entrée est une seule liste: l'accumulateur, suivi des paires.

Essayez-le en ligne!

Comment ça fonctionne

L' yatome effectue une translittération; [a, b] yc remplace a par b , donc il renvoie b si a = c et c si a ≠ c .

y@/replie / réduit l'entrée yavec des arguments échangés, effectuant une translittération par paire.

— Dennis
source
14
C'est la seule réponse Jelly que j'ai vue jusqu'à présent qui n'utilise que des caractères ASCII.
2
Il y en avait quelques-uns. Regardez ma, pas d'Unicode!
— Dennis
21

Python 3 , 43 octets

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

Essayez-le en ligne!

La fonction prend une seule chaîne en entrée, où le premier caractère est l'état initial et le reste de la chaîne représente les commandes. Cette solution peut être facilement portée dans d'autres langages qui prennent mieux en charge les expressions régulières.

La partie difficile est de prouver que la solution donne le bon résultat. Pour voir cela, nous avons besoin d'une analyse approfondie des commandes. Tout d'abord, nous pouvons voir que les commandes ont les propriétés suivantes:

  • Propriété (1) : commande 00et 11conserve l'état de l'accumulateur.
  • Propriété (2) : commande 01et 10rend l'état de l'accumulateur identique au deuxième bit quel que soit son état d'origine.

Par conséquent, l'état final de l'accumulateur est:

  • Cas 1 : Si aucune commande 01ou 10n'existe, l'état final est le même que l'état initial.
  • Cas 2 : Sinon, le dernier bit de la dernière commande 10ou 01.

Ensuite, nous montrerons que la solution donne le résultat correct dans les deux cas. Nous prouverons la déclaration de l'état final 0et l'état final de 1peut être prouvé de façon analogue. Si l'état final est 0l'entrée est sous l'une des formes suivantes:

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

    Pour le cas 1 , la chaîne d'entrée sdoit commencer par 2k+10, suivi des commandes 11et 00. L'élimination de 00s et 11s donne un seul 0, qui est l'état final.

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

    Pour le cas 2 , la chaîne d'entrée se termine par une 10commande, suivie de zéro ou plus 00et 11s. Ce modèle équivaut à un 1suivi de 2k+10, puis de zéro ou plusieurs 11s et 00s. L'élimination de 00s et 11s laisse le dernier des 2k+10 à la fin de la chaîne, qui représente l'état final.

Sur la base de tout ce qui précède, après avoir éliminé 00s et 11s simultanément en une seule passe ( 01001c'est un contre-exemple si 00est éliminé en une passe puis 11en une autre) de l'entrée s, le dernier caractère est l'état final. Par conséquent, l'exactitude de la solution est prouvée.

— Joel
source
Bienvenue chez PPCG! Excellente réponse, et une belle preuve formelle pour l'accompagner!
— GammaFunction
3
Merci. Je pense que les gens peuvent douter qu'une solution aussi simple donne le résultat correct au premier coup d'œil. Il faut donc en fournir la preuve.
— Joel
9

Perl 6 , 17 octets

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

Essayez-le en ligne!

Profite de « Vous pouvez fusionner ces deux entrées dans une entrée si vous aimez » en prenant comme entrée la valeur de l' accumulateur concaténé avec les commandes , par exemple 1,[00,11]est 10011. Si ce n'est pas correct, alors ce n'est que 5 octets supplémentaires pour le prendre f(accumulator, commands). Renvoie un objet de correspondance qui peut être contraint à une chaîne.

Explication:

{                }  # 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

Fondamentalement, cela fonctionne parce que les commandes 00et 11ne font littéralement rien, tandis que les commandes 01et 10définissent simplement l'accumulateur au deuxième chiffre de la commande. S'il n'y a pas de commandes, il prend à la place la valeur initiale de l'accumulateur.

— Jo King
source
6

Zsh , 33 octets

La liste de caractères est passée en arguments, la valeur initiale de l'accumulateur est passée en stdin.

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

Essayez-le en ligne!

39 octets : si les commandes doivent être une seule chaîne

L'entrée est accumulator commandscomme arguments. 

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

Essayez-le en ligne!

Pour le plaisir, voici un one-liner récursif ( TIO ) de 50 octets :

<<<${${2+`f $[$1^${2[1]}?$1:${2[2]}] ${2:2}`}:-$1}
— GammaFunction
source
6

Python 3 , 52 octets

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

Essayez-le en ligne!

Correction du type de retour incohérent grâce à Chas Brown

Prend l'entrée en deux chaînes; l'accumulateur et le code.

— sept négatif
source
Oh non, c'était rapide.
— HighlyRadioactive
1
Nice mais il a ce problème potentiel - f(1,'11')==f(1,'01')est False; il renvoie parfois un intet parfois un str. Alors peut-être spécifier qu'il faut que l'entrée acc soit une chaîne?
— Chas Brown
@ChasBrown Bon appel, c'est beaucoup plus simple que ce à quoi je pensais.
— négatif sept
Bien, mais comme votre fonction est récursive, elle ne peut pas être anonyme. Il devrait être de 52 octets .
— Jitse
5

Brachylog , 11 9 octets

tġ₂≠ˢtt|h

Essayez-le en ligne!

Comme cela fait assez longtemps que j'ai pu oublier la notion d' imprimer l'accumulateur après chaque commande , j'ai formulé une solution beaucoup moins naïve avec une certaine inspiration de la réponse 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.

Ancienne solution:

Brachylog , 18 16 octets

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

Essayez-le en ligne!

-2 octets de changer le format d'entrée.

— Chaîne indépendante
source
5

JavaScript (ES6), 27 octets

Prend l'entrée comme (a)(code), où le code est une liste d'entiers de 2 bits.

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

Essayez-le en ligne!

JavaScript (ES6),  47  40 octets

Prend l'entrée comme (a)(code), où le code est une chaîne.

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

Essayez-le en ligne!

Comment?

(a=0,x=012)(a=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
source
4

sed -E, 26 19 octets

Un énorme -7 octets de @Cowsquack en réalisant que la suppression de toutes les paires fonctionne également.

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

Prend l'entrée concaténée ensemble sur stdin. Inspiré par la réponse Perl de Jo King . Dépouillent paires de fuite Retirer toutes les paires, puis obtenir le dernier chiffre.

Essayez-le en ligne! Essayez-le en ligne!

— GammaFunction
source
1
La dernière ligne peut être simple s/.*\B//, mais de toute façon changer légèrement l'approche donne 19 octets encore plus courts Essayez-le en ligne!
— user41805
1
Huh, je ne pensais pas que s/(.)\1//gcela fonctionnerait, car cela pourrait supprimer la fin d'une paire et le début de la suivante, mais cela fonctionne toujours. Excellent!
— GammaFunction
@GammaFunction s/(.)\1//gest équivalent à s/00|11//gcelui indiqué dans ma solution.
— Joel
4

Retina 0.8.2 , 18 11 octets

(.)\1

!`.$

Essayez-le en ligne! Le lien inclut des cas de test. Prend l'entrée concaténée. Sauvegardé 6 octets grâce à @CowsQuack pour avoir souligné que la suppression de tous les caractères doublés et la prise du dernier caractère restant fonctionnaient, bien qu'en fait le port de la réponse originale de @ JoKing aurait pu être joué sur 3 octets même sans cette astuce.

— Neil
source
— user41805
@Cowsquack D'oh, une fois que vous pensez à séparer les étapes, c'est déjà une économie de 2 octets, puis un autre octet enregistré parce que vous pouvez utiliser !`.$, puis encore 4 octets parce que vous n'avez pas à vous limiter aux paires de fin ...
— Neil
4

Python 3 , 38 octets

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

Essayez-le en ligne!

Basé sur la solution de Joel . Prend l'entrée comme une liste de la valeur initiale de l'accumulateur (chaîne de longueur un) suivie des commandes (chaînes de longueur deux). Recherche la dernière commande avec deux valeurs inégales et sort son deuxième caractère.

Pour que cela tombe à la valeur initiale de l'accumulateur quand il n'y a pas de telles commandes, nous faisons en sorte que la chaîne de valeur initiale à caractère unique passe le test. Nous le faisons en vérifiant si une liste singleton avec le dernier caractère n'est pas égale à une liste de tous les caractères précédents, qui est passée par n'importe quelle chaîne de longueur un ou chaîne de longueur deux avec deux caractères différents.

— xnor
source
3

Perl 5 -p , 37 33 octets

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

Essayez-le en ligne!

L'entrée est de deux lignes: la première ligne est la séquence de commandes, la seconde est l'accumulateur.

— Xcali
source
3

Gelée , 8 6 octets

EÐḟṪṪo

Essayez-le en ligne!

-2 octets merci à Nick Kennedy de m'informer d'un changement de règles. (Son golf proposé EÐḟFȯṪ, semble un peu plus intelligent mais a la même longueur que ma solution précédente moins s2.) Le format d'entrée prend maintenant les commandes comme une liste de chaînes de deux caractères, mais le pied de page de test se traduit de l'ancien format pour plus de commodité.

Traduit de ma nouvelle solution Brachylog.

Ancienne version:

Gelée , 13 octets

ḢẎ⁼⁹a⁸o
s2ç@ƒ

Essayez-le en ligne!

Je ne suis pas sûr à 100% que c'est correct, mais cela réussit sur les trois cas de test. Prend les commandes comme argument de gauche et l'accumulateur initial comme argument de droite.

— Chaîne indépendante
source
1
L'entrée est autorisée à être divisée en une liste, donc vous pourriez avoir EÐḟFȯṪavec l'entrée comme par exemple [[0,0],[0,1],[1,1],[1,1],[0,1]].
— Nick Kennedy du
Wow, les changements à la spécification étaient vraiment assez importants ...
— Unrelated String
3

Haskell , 29 octets

Définit une fonction sans nom sur la première ligne avec type (Foldable t, Eq b) => b -> t [b] -> b. Pour les besoins de ce code golf, nous pouvons l'instancier comme Char -> [String] -> Charoù le premier argument est l'accumulateur et le second est une liste de chaînes, chaque chaîne étant une seule commande.

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

Essayez-le en ligne!

— ankh-morpork
source
1
Même octet si vous le définissez en utilisant la notation de préfixe . Je ne peux pas croire que j'ai écrit presque la même réponse exacte en même temps, même en incluant l'explication de la signature de type…
— cole
2

Python, 111 octets

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

Non golfé. EDIT: AHHH Quelqu'un m'a battu!

— Hautement radioactif
source
2

Haskell , 36 octets

f(x:y:s)=f s.last.(:[y|x/=y])
f _=id

Essayez-le en ligne!

Prend l'entrée comme f(string)(char)où le caractère est l'accumulateur et la chaîne est la liste des commandes.

— Jo King
source
2

Keg , -ir, 16 octets

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

Essayez-le en ligne!

Expliqué:

  1. Prend l'entrée implicite et déplace à droite la valeur des accumulateurs vers le bas

  2. Répétez les étapes suivantes (longueur de la pile - 1 divisé par 2) fois

2.1. Déplacer l'accumulateur vers le haut

2.2. Comparer pour l'égalité avec la première partie de la commande

2.2.1. Si vrai, remplacez l'accumulateur, sinon éclatez le remplacement

L'entrée est prise comme la valeur acc initiale concaténée avec la source. Par exemple

010011000
  • Le premier caractère est la valeur acc
  • Le repos est un programme
— Lyxal
source
1

Bash , 58 40 octets

Ajoutez un octet pour un programme complet: passez fà $0.

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

58 octets Essayez-le en ligne!

Le ternaire retournera faux lorsque $1 est défini sur 0, mais le ,1à la fin garantit que l'ensemble ((expression))retournera vrai, sauf une erreur de syntaxe.

Lorsque tous les arguments sont consommés, une erreur de syntaxe se produit et la récursivité se termine.

— GammaFunction
source
1

Fusain , 16 octets

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

Essayez-le en ligne! Le lien est vers la version détaillée du code. Prend des arguments séparés. Explication:

Ｆ⪪η²

Divisez les instructions en paires de chiffres et passez-les en boucle.

Ｆ⁼θ§ι⁰

Si l'accumulateur est égal au premier chiffre ...

≔§ι¹θ

... puis affectez-lui le deuxième chiffre.

θ

Imprimez l'accumulateur à la fin de la boucle.

— Neil
source
1

Gelée , 7 octets

fؽḂ⁹;Ṫ

Un lien dyadique acceptant le programme comme une liste d'entiers à gauche et l'accumulateur initial à droite qui donne un entier.

Essayez-le en ligne! Ou voir une suite de tests

— Jonathan Allan
source
Je supprime le mappage d'entrée car @GammaFunction m'a recommandé de le faire.
@A_ ah OK ne peux pas supprimer sur mobile, il faudra donc y remédier plus tard
— Jonathan Allan
@A_ corrigé pour fonctionner avec 0,1,2,3 la version non mappée des instructions sous forme de chiffres est-ce correct?
— Jonathan Allan
1
Oui, ça va.
1

Enchantements runiques , 28 octets

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

Essayez-le en ligne!

Prend l'entrée comme une série d'octets séparés par des espaces (Runic ne comprend pas les listes). Le premier octet est l'état initial et tous les autres octets sont le programme. Aucune validation n'est effectuée (c'est-à-dire qu'elle suppose que seuls les programmes valides sont donnés en entrée et que la valeur utilisée pour représenter 0et ne importe pas 1).

— Draco18s ne fait plus confiance à SE
source
1

Assemblage x86, 33 octets

Prend l'état initial de l'accumulateur dans CL(entier 0ou 1) et l'adresse des commandes comme une chaîne ASCII terminée par zéro dans ESI. Laisse l'état final de l'accumulateur CL.

Pointez l'instruction d'appel sur offset 0x1B(libellé interpretdans l'explication).

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

Explication (à l'aide de la syntaxe 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
source
0

Cristal , 46 octets

Avec des commandes dans un Array(Tuple(Int32,Int32)), comme [{0,0}, {0,1}, {0,0}].

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

Essayez-le en ligne!

C'est assez simple à comprendre sous une forme plus lisible:

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

La fonction parcourt chaque commande, décompressant automatiquement les valeurs de tuple dans cet v. Il définit ensuite le statepar la formule

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

auquel je suis arrivé principalement par essais et erreurs. Une fois que toutes les commandes ont été traitées, il renvoie la valeur d'état.

— Kinxer
source
0

C (clang) , 68 62 octets

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

Essayez-le en ligne!

Prend un pointeur sur le début de la chaîne source, un pointeur sur la fin de la chaîne source (start + strlen (start)) et la valeur initiale de l'accumulateur.

Ancienne version (imprime ASCII 48/49 pour 0/1):

t(s,e,a)char*s,*e;{for(;s<e;++s)a=*s++-48^a?a:*s-48;putchar(a+48);}
— osuka_
source
En utilisant notre site, vous reconnaissez avoir lu et compris notre politique liée aux cookies et notre politique de confidentialité.
Licensed under cc by-sa 3.0 with attribution required.