"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

var QUESTION_ID=190819;
var OVERRIDE_USER=8478;
var ANSWER_FILTER="!t)IWYnsLAZle2tQ3KqrVveCRJfxcRLe",COMMENT_FILTER="!)Q2B_A2kjfAiU78X(md6BoYk",answers=[],answers_hash,answer_ids,answer_page=1,more_answers=!0,comment_page;function answersUrl(d){return"https://api.stackexchange.com/2.2/questions/"+QUESTION_ID+"/answers?page="+d+"&pagesize=100&order=desc&sort=creation&site=codegolf&filter="+ANSWER_FILTER}function commentUrl(d,e){return"https://api.stackexchange.com/2.2/answers/"+e.join(";")+"/comments?page="+d+"&pagesize=100&order=desc&sort=creation&site=codegolf&filter="+COMMENT_FILTER}function getAnswers(){jQuery.ajax({url:answersUrl(answer_page++),method:"get",dataType:"jsonp",crossDomain:!0,success:function(d){answers.push.apply(answers,d.items),answers_hash=[],answer_ids=[],d.items.forEach(function(e){e.comments=[];var f=+e.share_link.match(/\d+/);answer_ids.push(f),answers_hash[f]=e}),d.has_more||(more_answers=!1),comment_page=1,getComments()}})}function getComments(){jQuery.ajax({url:commentUrl(comment_page++,answer_ids),method:"get",dataType:"jsonp",crossDomain:!0,success:function(d){d.items.forEach(function(e){e.owner.user_id===OVERRIDE_USER&&answers_hash[e.post_id].comments.push(e)}),d.has_more?getComments():more_answers?getAnswers():process()}})}getAnswers();var SCORE_REG=function(){var d=String.raw`h\d`,e=String.raw`\-?\d+\.?\d*`,f=String.raw`[^\n<>]*`,g=String.raw`<s>${f}</s>|<strike>${f}</strike>|<del>${f}</del>`,h=String.raw`[^\n\d<>]*`,j=String.raw`<[^\n<>]+>`;return new RegExp(String.raw`<${d}>`+String.raw`\s*([^\n,]*[^\s,]),.*?`+String.raw`(${e})`+String.raw`(?=`+String.raw`${h}`+String.raw`(?:(?:${g}|${j})${h})*`+String.raw`</${d}>`+String.raw`)`)}(),OVERRIDE_REG=/^Override\s*header:\s*/i;function getAuthorName(d){return d.owner.display_name}function process(){var d=[];answers.forEach(function(n){var o=n.body;n.comments.forEach(function(q){OVERRIDE_REG.test(q.body)&&(o="<h1>"+q.body.replace(OVERRIDE_REG,"")+"</h1>")});var p=o.match(SCORE_REG);p&&d.push({user:getAuthorName(n),size:+p[2],language:p[1],link:n.share_link})}),d.sort(function(n,o){var p=n.size,q=o.size;return p-q});var e={},f=1,g=null,h=1;d.forEach(function(n){n.size!=g&&(h=f),g=n.size,++f;var o=jQuery("#answer-template").html();o=o.replace("{{PLACE}}",h+".").replace("{{NAME}}",n.user).replace("{{LANGUAGE}}",n.language).replace("{{SIZE}}",n.size).replace("{{LINK}}",n.link),o=jQuery(o),jQuery("#answers").append(o);var p=n.language;p=jQuery("<i>"+n.language+"</i>").text().toLowerCase(),e[p]=e[p]||{lang:n.language,user:n.user,size:n.size,link:n.link,uniq:p}});var j=[];for(var k in e)e.hasOwnProperty(k)&&j.push(e[k]);j.sort(function(n,o){return n.uniq>o.uniq?1:n.uniq<o.uniq?-1:0});for(var l=0;l<j.length;++l){var m=jQuery("#language-template").html(),k=j[l];m=m.replace("{{LANGUAGE}}",k.lang).replace("{{NAME}}",k.user).replace("{{SIZE}}",k.size).replace("{{LINK}}",k.link),m=jQuery(m),jQuery("#languages").append(m)}}

body{text-align:left!important}#answer-list{padding:10px;float:left}#language-list{padding:10px;float:left}table thead{font-weight:700}table td{padding:5px}

 <script src="https://ajax.googleapis.com/ajax/libs/jquery/2.1.1/jquery.min.js"></script> <link rel="stylesheet" type="text/css" href="https://cdn.sstatic.net/Sites/codegolf/primary.css?v=f52df912b654"> <div id="language-list"> <h2>Winners by Language</h2> <table class="language-list"> <thead> <tr><td>Language</td><td>User</td><td>Score</td></tr></thead> <tbody id="languages"> </tbody> </table> </div><div id="answer-list"> <h2>Leaderboard</h2> <table class="answer-list"> <thead> <tr><td></td><td>Author</td><td>Language</td><td>Size</td></tr></thead> <tbody id="answers"> </tbody> </table> </div><table style="display: none"> <tbody id="answer-template"> <tr><td>{{PLACE}}</td><td>{{NAME}}</td><td>{{LANGUAGE}}</td><td><a href="{{LINK}}">{{SIZE}}</a></td></tr></tbody> </table> <table style="display: none"> <tbody id="language-template"> <tr><td>{{LANGUAGE}}</td><td>{{NAME}}</td><td><a href="{{LINK}}">{{SIZE}}</a></td></tr></tbody> </table> 

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.

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.

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.

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}

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.

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.

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=01_2)$$(a=1,x=10_2)$

  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

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!

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.

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.

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.

Python 2 , 56 octets

f=lambda a,c:f([a,1,0,a][int(c[:2],2)],c[2:])if c else a

Essayez-le en ligne!

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.

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!

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!

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.

05AB1E , 3 octets

ø`:

Essayez-le en ligne!

Zip, vidage sur la pile, remplacement.

Stax , 3 octets

F|t

Exécuter et déboguer

Pour chaque instruction, effectuez la traduction des caractères.

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

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.

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.

MATL , 13 12 octets

!dh2Ol4$Ys0)

Prend l'entrée comme une matrice à 2 colonnes où chaque ligne est une commande et un nombre

Essayez-le en ligne! Ou vérifiez tous les cas de test

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

PHP , 38 octets

<?=strtr($argn,['00'=>'',11=>''])[-1];

Essayez-le en ligne!

Port fondamentalement de l'idée de Jo King .

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

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

C (gcc) , 45 41 octets

f(a,i)char*i;{a=*i?f(a^*i?a:i[1],i+2):a;}

Essayez-le en ligne!

4 octets rasés grâce à @ErikF!

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.

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

Java (JDK) , 38 octets

a->p->p.reduce(a,(s,c)->c<1|c>2?s:c%2)

Essayez-le en ligne!

Les entrées sont un intet un IntStreamde 0, 1, 2ou 3, ce qui correspond à 00, 01, 10, 11de binaire.