"Talk" è un linguaggio basato sull'accumulatore barocco che viene creato in risposta alla citazione di Dennis su talk.tryitonline.net.

Waiting for someone to create an esolang called talk. 

. La lingua "Talk" ha 4 comandi:

• 00 Se l'accumulatore è 0, impostare l'accumulatore su 0.
• 01 Se l'accumulatore è 0, impostare l'accumulatore su 1.
• 10 Se l'accumulatore è 1, impostare l'accumulatore su 0.
• 11 Se l'accumulatore è 1, impostare l'accumulatore su 1.

Ingresso:

• L'input può essere preso tramite qualsiasi metodo di input accettabile dalle nostre regole I / O standard.

• Ci sono due ingressi, il valore iniziale dell'accumulatore e il programma. È possibile unire questi due input in un input o dividere l'input in comandi validi (ad es. Prenderli come elenco; ad es. [00, 01, 00]) Se lo si desidera.

Produzione:

• Al termine dell'esecuzione di un comando, l'accumulatore viene emesso implicitamente.

Regole:

• L'ingresso può essere una singola stringa o un elenco di caratteri.
• Poiché si tratta di code-golf , la risposta più breve, in byte, vince.
• Prendiamo cifre o stringhe / caratteri.

  Casi test:

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

Classifiche

Ecco uno snippet di stack per generare sia una classifica regolare che una panoramica dei vincitori per lingua.

Per assicurarti che la tua risposta venga visualizzata, ti preghiamo di iniziare la risposta con un titolo, usando il seguente modello Markdown:

# Language Name, N bytes

dov'è Nla dimensione del tuo invio. Se si migliora il punteggio, è possibile mantenere i vecchi punteggi nel titolo, colpendoli. Per esempio:

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

Se si desidera includere più numeri nell'intestazione (ad es. Perché il punteggio è la somma di due file o si desidera elencare separatamente le penalità del flag dell'interprete), assicurarsi che il punteggio effettivo sia l' ultimo numero nell'intestazione:

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

Puoi anche rendere il nome della lingua un collegamento che verrà quindi visualizzato nello snippet della classifica:

# [><>](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> 

Gelatina , 3 byte

y@/

L'input è un unico elenco: l'accumulatore, seguito dalle coppie.

Provalo online!

Come funziona

L' yatomo esegue la traslitterazione; [a, b] yc sostituisce una con b , quindi restituisce b se a = c e c se a ≠ c .

y@/piega / riduce l'input ycon argomenti scambiati, eseguendo una traslitterazione per coppia.

Python 3 , 43 byte

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

Provalo online!

La funzione accetta una singola stringa come input, in cui il primo carattere è lo stato iniziale e il resto della stringa rappresenta i comandi. Questa soluzione può essere facilmente trasferita in altre lingue che supportano meglio le espressioni regolari.

La parte difficile è dimostrare che la soluzione produce il risultato corretto. Per vedere questo, abbiamo bisogno di un'analisi approfondita dei comandi. Innanzitutto, possiamo vedere che i comandi hanno le seguenti proprietà:

• Proprietà (1) : comanda 00e 11mantiene lo stato dell'accumulatore.
• Proprietà (2) : comanda 01e 10rende lo stato dell'accumulatore uguale al secondo bit indipendentemente dal suo stato originale.

Pertanto, lo stato dell'accumulatore finale è:

• Caso 1 : se non esiste alcun comando 01o 10, lo stato finale è lo stesso dello stato iniziale.
• Caso 2 : Altrimenti, l'ultimo bit dell'ultimo 10o del 01comando.

Successivamente mostreremo che la soluzione produce il risultato corretto in entrambi i casi. Dimostreremo l'affermazione per lo stato finale 0e lo stato finale di 1può essere dimostrato in modo analogo. Se lo stato finale è 0l'input è in una delle seguenti forme:

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

  Per il caso 1 , la stringa di input sdeve iniziare con 2k+10s, seguita da 11e 00comandi. L'eliminazione di 00s e 11s produce un singolo 0, che è lo stato finale.

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

  Per il caso 2 , la stringa di input termina con un 10comando, seguito da zero o più 00e 11s. Questo modello equivale a 1seguito da 2k+10s, quindi zero o più 11s e 00s. L'eliminazione di 00s e 11s lascia l'ultimo degli 2k+10 alla fine della stringa, che rappresenta lo stato finale.

Riferiscono tutto quanto sopra, dopo aver eliminato 00s e 11s contemporaneamente in un unico passaggio ( 01001è un contro-esempio se 00viene eliminato in un solo passaggio e poi 11in un altro passaggio) dall'ingresso s, l'ultimo carattere è lo stato finale. Quindi la correttezza della soluzione è dimostrata.

Perl 6 , 17 byte

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

Provalo online!

Approfitta di "Puoi unire questi due input in un input se vuoi" prendendo input come valore dell'accumulatore concatenato con i comandi, ad esempio 1,[00,11]è10011 . Se questo non va bene, allora è solo 5 byte extra per prenderlo come f(accumulator, commands). Restituisce un oggetto match che può essere forzato in una stringa.

Spiegazione:

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

Fondamentalmente funziona perché i comandi 00e 11non fanno letteralmente nulla, mentre i comandi 01e 10impostano semplicemente l'accumulatore sulla seconda cifra del comando. Se non ci sono comandi, prende invece il valore iniziale dell'accumulatore.

Zsh , 33 byte

L'elenco dei caratteri viene passato come argomenti, il valore iniziale dell'accumulatore viene passato come stdin.

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

Provalo online!

39 byte : se i comandi devono essere una singola stringa

L'input è accumulator commandscome argomento.

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

Provalo online!

Per divertimento, ecco un one-liner ( TIO ) ricorsivo da 50 byte :

<<<${${2+`f $[$1^${2[1]}?$1:${2[2]}] ${2:2}`}:-$1}

Python 3 , 52 byte

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

Provalo online!

Risolto un tipo di ritorno incoerente grazie a Chas Brown

Accetta input come due stringhe; l'accumulatore e il codice.

Brachylog , 11 9 byte

tġ₂≠ˢtt|h

Provalo online!

Dal momento che è stato abbastanza a lungo che sono stato in grado di dimenticare l'idea di stampare l'accumulatore dopo ogni comando , ho formulato una soluzione significativamente meno ingenua con qualche ispirazione dalla risposta Perl di 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.

Vecchia soluzione:

Brachylog , 18 16 byte

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

Provalo online!

-2 byte dalla modifica del formato di input.

JavaScript (ES6), 27 byte

Accetta input come (a)(code), dove code è un è un elenco di numeri interi a 2 bit.

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

Provalo online!

JavaScript (ES6),  47  40 byte

Accetta input come (a)(code), dove code è una stringa.

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

Provalo online!

Come?

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

Funziona anche un enorme -7 byte da @Cowsquack realizzando la rimozione di tutte le coppie.

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

Accetta input concatenati insieme su stdin. Ispirato dalla risposta Perl di Jo King . Elimina le coppie finali Rimuovi tutte le coppie, quindi ottieni l'ultima cifra.

Provalo online! Provalo online!

Retina 0.8.2 , 18 11 byte

(.)\1

!`.$

Provalo online! Il link include casi di test. Accetta input concatenati. Hai salvato 6 byte grazie a @CowsQuack per aver sottolineato che rimuovere tutti i personaggi raddoppiati e quindi prendere l'ultimo personaggio rimanente funziona, anche se in effetti il ​​porto della risposta originale di @ JoKing avrebbe potuto essere golfato di 3 byte anche senza quel trucco.

Python 3 , 38 byte

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

Provalo online!

Basato su soluzione di Joel . Accetta l'input come un elenco del valore iniziale dell'accumulatore (lunghezza-una stringa) seguito dai comandi (lunghezza-due stringhe). Trova l'ultimo comando con due valori diversi e genera il suo secondo carattere.

Per far sì che questo cada al valore dell'accumulatore iniziale quando non ci sono tali comandi, lo facciamo in modo che la stringa del valore iniziale a carattere singolo passi il test. Lo facciamo controllando se un elenco singleton con l'ultimo carattere non è uguale a un elenco di tutti i caratteri precedenti, che viene passato da qualsiasi lunghezza-una stringa o lunghezza-due stringa con due caratteri diversi.

Perl 5 -p , 37 33 byte

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

Provalo online!

L'input è di due righe: la prima riga è la sequenza di comando, la seconda è l'accumulatore.

Python 2 , 56 byte

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

Provalo online!

Gelatina , 8 6 byte

EÐḟṪṪo

Provalo online!

-2 byte grazie a Nick Kennedy che mi informa di un cambio di regole. (La sua proposta di golf,EÐḟFȯṪ sembra un po 'più intelligente ma ha la stessa lunghezza della mia soluzione precedente meno s2.) Il formato di input ora prende i comandi come un elenco di stringhe di due caratteri, ma il piè di pagina del test si traduce dal vecchio formato per comodità.

Tradotto dalla mia nuova soluzione Brachylog.

Vecchia versione:

Gelatina , 13 byte

ḢẎ⁼⁹a⁸o
s2ç@ƒ

Provalo online!

Non sono sicuro al 100% che questo sia corretto, ma ha successo su tutti e tre i casi di test. Prende i comandi come argomento sinistro e l'accumulatore iniziale come argomento destro.

Haskell , 29 byte

Definisce una funzione senza nome sulla prima riga con type (Foldable t, Eq b) => b -> t [b] -> b. Ai fini di questo codice golf, possiamo creare un'istanza come Char -> [String] -> Chardove il primo argomento è l'accumulatore e il secondo è un elenco di stringhe in cui ogni stringa è un singolo comando.

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

Provalo online!

Python, 111 byte

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

Ungolfed. EDIT: AHHH Qualcuno mi ha battuto!

Haskell , 36 byte

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

Provalo online!

Prende l'input come f(string)(char)dove il carattere è l'accumulatore e la stringa è l'elenco di comandi.

05AB1E , 3 byte

ø`:

Provalo online!

Zip, dump in pila, sostituzione.

Stax , 3 byte

F|t

Esegui ed esegui il debug

Per ogni istruzione, esegui la traduzione dei caratteri.

Barilotto , -ir, 16 byte

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

Provalo online!

Ha spiegato:

1. Prende l'input implicito e sposta a destra il valore degli accumulatori verso il basso

2. Ripeti le seguenti (lunghezza dello stack - 1 diviso per 2) volte

2.1. Riporta l'accumulatore verso l'alto

2.2. Confronta per l'uguaglianza con la prima parte del comando

2.2.1. Se vero, sostituire l'accumulatore, altrimenti far apparire la sostituzione

L'input viene preso come valore iniziale acc concatenato con la sorgente. Per esempio

010011000

• Il primo carattere è il valore acc
• Il resto è programma

Bash , 58 40 byte

Aggiungi un byte per un programma completo: cambia fin $0.

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

58 byte Provalo online!

Il ternario tornerà falso quando $1è impostato su 0, ma ,1alla fine assicura che tutto ((expression))ritorni vero, tranne un errore di sintassi.

Quando tutti gli argomenti vengono consumati, si verifica un errore di sintassi e la ricorsione termina.

Carbone , 16 byte

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

Provalo online! Il collegamento è alla versione dettagliata del codice. Accetta argomenti separati. Spiegazione:

Ｆ⪪η²

Dividi le istruzioni in coppie di cifre e passaci sopra.

Ｆ⁼θ§ι⁰

Se l'accumulatore è uguale alla prima cifra ...

≔§ι¹θ

... quindi assegnare ad essa la seconda cifra.

θ

Stampa l'accumulatore alla fine del ciclo.

MATL , 13 12 byte

!dh2Ol4$Ys0)

Prende l'input come una matrice a 2 colonne in cui ogni riga è un comando e un numero

Provalo online! Oppure verifica tutti i casi di test

Gelatina , 7 byte

fؽḂ⁹;Ṫ

Un collegamento diadico che accetta il programma come un elenco di numeri interi a sinistra e l'accumulatore iniziale a destra che produce un numero intero.

Provalo online! O vedi una suite di test

PHP , 38 byte

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

Provalo online!

Fondamentalmente porto dell'idea di Jo King .

Incantesimi runici , 28 byte

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

Provalo online!

Accetta input come una serie di byte separati da spazi (Runic non comprende gli elenchi). Il primo byte è lo stato iniziale e ogni altro byte è il programma. Non viene eseguita alcuna convalida (ovvero presuppone che vengano immessi solo programmi validi come input e non importa quale valore viene utilizzato per rappresentare 0e 1).

x86 Assembly, 33 byte

Accetta lo stato dell'accumulatore iniziale in CL(intero 0o 1) e l'indirizzo dei comandi come stringa ASCII con terminazione zero ESI. Lascia lo stato dell'accumulatore finale inCL .

Puntare l'istruzione di chiamata sull'offset 0x1B(etichetta interpretnella Spiegazione).

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

Spiegazione (utilizzando la sintassi 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 byte

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

Provalo online!

4 byte eliminati grazie a @ErikF!

Cristallo , 46 byte

Con i comandi in un Array(Tuple(Int32,Int32)), come ad esempio [{0,0}, {0,1}, {0,0}].

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

Provalo online!

È abbastanza semplice da capire in una forma più leggibile:

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

La funzione scorre attraverso ogni comando, scompattando automaticamente i valori di tupla in ce v. Quindi imposta il statedalla formula

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

a cui sono arrivato principalmente per tentativi ed errori. Una volta elaborati tutti i comandi, restituisce il valore dello stato.

C (clang) , 68 62 byte

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

Provalo online!

Porta un puntatore all'inizio della stringa di origine, un puntatore alla fine della stringa di origine (start + strlen (start)) e il valore iniziale dell'accumulatore.

Vecchia versione (stampa ASCII 48/49 per 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 byte

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

Provalo online!

Gli ingressi sono una inted una IntStreamdi 0, 1, 2o 3, che corrispondono a 00, 01, 10, 11dal binario.