In una precedente sfida ho chiesto ai golfisti del codice di produrre stringhe che copiano ogni carattere in una stringa. Per esempio:

TThhiiss  iiss  ddoouubbllee  ssppeeaakk!!

Questa sfida consiste semplicemente nel rilevare se un testo soddisfa la definizione di una stringa a doppio parlato.

• C'è un numero pari di personaggi.
• Quando diviso in coppie, ogni coppia è composta da due dello stesso personaggio.

La sfida

• È un codice golf, fallo in pochi byte.
• Usa qualsiasi lingua tu scelga.
• Si prega di includere un collegamento a un interprete online.
• Il codice accetterà del testo.
  • Per semplicità, l'input consisterà solo di caratteri ASCII stampabili
• Restituirà un'indicazione se l'ingresso è doppio parlato o meno. Potrebbe essere:
  • Un booleano
  • Stringhe ('true', 'false', 'yes', 'no' ecc.)
  • Numeri interi 0 o 1

Casi test:

• aba: falso
• abba: falso
• aabb: vero
• aaabb: falso
• tthhiiss: vero
• ttthhhiiisss: false

Python 3 , 24 byte

lambda s:s[::2]==s[1::2]

Provalo online!

Brainfuck , 20 byte

Salvato 1 byte grazie a Jo King.

+>,[>,[-<->]<[<],]<.

Provalo online!

Uscita leggibile!

Accetta due caratteri alla volta e si allontana dall'1 sul nastro se una coppia non corrisponde. EOF viene trattato come 0 e quindi gestito automaticamente.

L'output è un byte null se la stringa non è double speak e 0x01 se lo è. La versione leggibile li genera come caratteri al costo di 14 byte.

MATL , 4 byte

Heda

L'input è una stringa, racchiusa tra singoli qoutes. L'output è 0per il doppio parlato, 1altrimenti.

Provalo online!

Spiegazione

Considera l'input 'TThhiiss iiss ddoouubbllee ssppeeaakk!!'come esempio.

H    % Push 2
     % STACK: 2
     % Implicit input (triggered because the next function requires two inputs): string 
     % STACK: 'TThhiiss  iiss  ddoouubbllee  ssppeeaakk!!', 2
e    % Reshape as a 2-column matrix of chars, in column-major order. Pads with char(0)
     % if needed. Note that char(0) cannot be present in the input
     % STACK: ['This is double speak!';
               'This is double speak!']
d    % Difference of each column
     % STACK: [0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0]
a    % Any: gives 0 if and only if all elements are 0
     % STACK: 0
     % Implicit display

05AB1E , 6 5 2 byte

ιË

Inserisci come un elenco di caratteri.

-3 byte eseguendo il porting della risposta Japt di Shaggy , quindi assicurati di votarlo!

Provalo online o verifica alcuni altri casi di test .

Spiegazione:

ι   # Uninterleave the (implicit) input-list of characters
    #  i.e. ["t","t","t","t","e","e","s","s","t","t","!","!","!"]
    #   → [["t","t","e","s","t","!","!"],["t","t","e","s","t","!"]]
 Ë  # Check if both inner lists are equal
    #  → 0 (falsey)
    # (after which the result is output implicitly)

Japt , 4 byte

ó r¶

Provalo

ó r¶     :Implicit input of string
ó        :Uniterleave
  r      :Reduce by
   ¶     :  Testing equality

Alternativa

ó
¥o

Provalo

Retina , 9 byte

(.)\1

^$

Provalo online.

Spiegazione:

Rimuovi tutte le coppie degli stessi personaggi:

(.)\1

Controlla se non ci sono caratteri rimasti:

^$

Gelatina , 3 byte

ŒœE

Provalo online!

Stax , 5 byte

■◄┼$Δ

Esegui ed esegui il debug

Procedura:

• Calcola le lunghezze.
• Ottieni GCD di array.
• È anche?

PHP ,58 56 byte

function f($s){return!$s?:$s[0]==$s[1]&f(substr($s,2));}

Provalo online!

Come funzione ricorsiva.

PHP ,61 56 52 byte

while(''<$l=$argn[$i++])$r|=$l!=$argn[$i++];echo!$r;

Provalo online!

O programma autonomo. Stringa di input tramite STDIN, output è truthy( 1) se è double speak e falsey( 0) se non è double speak.

-4 byte grazie a @ Night2 !

codice macchina x86, 9 7 byte

D1 E9       SHR  CX, 1          ; divide length in half 
AD          LODSW               ; load next two chars into AH/AL 
3A E0       CMP  AH, AL         ; compare AH and AL 
E1 FB       LOOPE -5            ; if equal, continue loop

Inserire la stringa in SI, inserire la lunghezza della stringa in CX. Uscita ZFse è double speak.

O 14 byte come eseguibile completo per PC DOS:

B4 01       MOV  AH, 01H        ; DOS read char from STDIN (with echo) 
CD 21       INT  21H            ; read first char into AL
92          XCHG DX, AX         ; put first char into DL
B4 08       MOV  AH, 08H        ; DOS read char from STDIN (no echo) 
CD 21       INT  21H            ; read second char into AL
3A C2       CMP  AL, DL         ; compare first and second char 
74 F3       JE   -13            ; if the same, continue loop 
C3          RET                 ; otherwise exit to DOS 

L'input avviene tramite STDINpipe o interattivo. Fa eco all'input "raddoppiato" fino a quando non viene rilevato un carattere non raddoppiato, a quel punto uscirà (forse piegando leggermente le regole I / O, ma questa è solo una risposta bonus).

Costruisci e testa ISDBL2.COM usando xxd -r:

00000000: b401 cd21 92b4 08cd 213a c274 f3c3       ...!....!:.t..

Eseguibile completo DOS per PC originale 24 byte :

D1 EE       SHR  SI, 1          ; SI to DOS PSP (080H) 
AD          LODSW               ; load string length into AL 
D0 E8       SHR  AL, 1          ; divide length in half 
8A C8       MOV  CL, AL         ; put string length into BL 
        CLOOP: 
AD          LODSW               ; load next two chars into AH/AL 
3A E0       CMP  AH, AL         ; compare AH and AL 
E1 FB       LOOPE CLOOP         ; if equal, continue loop
        DONE: 
B8 0E59     MOV  AX, 0E59H      ; BIOS tty function in AH, 'Y' in AL 
74 02       JZ   DISP           ; if ZF, result was valid double 
B0 4E       MOV  AL, 'N'        ; if not, change output char to N 
        DISP: 
B4 0E       MOV  AH, 0EH 
CD 10       INT  10H 
C3          RET                 ; return to DOS

Input dalla riga di comando, output sullo schermo 'Y'se doppio, in 'N'caso contrario.

Costruisci e testa ISDBL.COM usando xxd -r:

00000000: d1ee add0 e88a c8ad 3ae0 e1fb b859 0e74  ........:....Y.t
00000010: 02b0 4eb4 0ecd 10c3                      ..N.....

Crediti:

• -2 byte grazie a @ErikF!

Lua , 67 66 63 59 33 32 byte

-25 byte grazie a Giuseppe
-1 byte grazie a val

print(#(...):gsub("(.)%1","")<1)

Provalo online!

Rimuove ogni carattere raddoppiato, quindi controlla se il risultato è vuoto.

Perl 5 , 15 byte

$_=/^((.)\2)*$/

Provalo online!

Uscite 1 per double-speak, niente per non-double-speak.

MathGolf , 2 byte

½=

Provalo online!

Sostanzialmente uguale alla risposta 05AB1E, ½divide la stringa in caratteri pari e dispari, quindi controlla l'uguaglianza. Passa per la stringa vuota.

JavaScript, 28 byte

s=>s.every((x,y)=>x==s[y|1])

Provalo online!

23 byte usando regex di wastl

s=>/^((.)\2)*$/.test(s)

Provalo online!

Haskell , 28 23 byte

f(x:y:z)|x==y=f z
f[]=1

Provalo online!

Molto semplice. Il doppio parlato è solo vuoto o un carattere ripetuto anteposto al doppio parlato.

Meno semplice ora. Output tramite presenza o assenza di un errore, per meta consenso ; nessun errore significa doppio parlare. La corrispondenza dei motivi ha esito negativo quando i primi due caratteri differiscono o quando è presente un numero dispari di caratteri. Grazie a Laikoni per questi risparmi!

V (vim) , 7 byte

Óˆ±
ø^$

Provalo online! o Verifica casi di test

hexdump:

00000000: d388 b10a d85e 24                        .....^$

Solo due regex. Spiegazione:

Ó   " Remove all occurrences...
 ˆ  "   Any character
  ± "   Followed by itself
    "   This regex is actually just the compressed form of (.)\1
ø   " Count the number of matches
 ^$ "   An empty line

Brachylog , 5 byte

ġ₂z₂=

Provalo online!

Riuscita o fallita.

ġ₂       The at-most-length-2 chunks of the input,
  z₂     which have equal length, zipped together,
    =    are equal.

PowerShell , 39 38 byte

!$($args|?{+$p*($p="$_"[$p-eq$_])};$p)

Provalo online!

dove $pcontiene un carattere precedente.

Nessuna ricorsione , nessuna regex :). Accetta input come char-array tramite una stringa splatting (vedi collegamento TIO).

PowerShell , 48 byte

for(;$b-eq$a-and$args){$a,$b,$args=$args}$b-eq$a

Provalo online!

Nessuna ricorsione , nessuna regex e nessuna pipa: D. Prende anche input come char-array tramite una stringa splatting. Usa $b-eq$ainvece $a-eq$bper un caso in cui un ultimo carattere ha il codice # 0.

PowerShell , 64 59 byte

filter f($n){$a,$b,$r=$n;$a-eq$b-and$(if($r){f $r}else{1})}

Provalo online!

Funzione ricorsiva, nessuna regex. Accetta input come un chararray (vedi link TIO). Stacca i primi due elementi in $ae $bmemorizza i rimanenti in $r. Se abbiamo ancora elementi rimanenti, ricorrere insieme a $a -eq $b. Altrimenti controlla se $a -eq $b. L'output è implicito.

-5 byte grazie a mazzy

Julia 1.0 , 25 byte

s->s[1:2:end]==s[2:2:end]

Provalo online!

J , 13 11 10 byte

-:2#_2{.\]

Provalo online!

-2 byte grazie ad Adám

-1 byte grazie alle miglia

Spiegazione TLDR: l'input è lo stesso di ogni altro carattere dell'input raddoppiato?

Shakespeare Programming Language , 204 156 byte

-48 byte grazie a Jo King (principalmente cambiando il metodo di output)

A.Ajax,.Puck,.Act I:.Scene I:.[Exeunt][Enter Ajax and Puck]Ajax:Open mind.Puck:Open
mind.Is I worse zero?If soSpeak thy.Is you as big as I?If soLet usAct I.

Provalo online!

Esce con errore se l'ingresso è double speak e con avviso se non è double speak (che è consentito per impostazione predefinita).

Keg , 19 17 caratteri

?{!1<|=[|0.(_)]}1

Spiegazione:

?             # read input

{             # while
    !1<       # stack length greater than 1?
|             # end of while condition and beginning of while block
    =         # compare the 2 top values in the stack
    [         # if (the condition is the top of stack)
    |         # end of then block and beginning of else block
        0.    # output 0
        (_)   # clear stack (discard top of stack in for loop stack length times)
    ]         # end if
}             # end while

1             # stack is already empty, push a truthy value

              # implicitly output the stack content if there was no explicit output

Provalo online!

R , 53 34 byte

-19 byte grazie a Giuseppe

function(a)gsub("(.)\\1","",a)==""

Provalo online!

Brain-Flak , 26 , 22 byte

({<({}[{}])>{()<>}{}})

Provalo online!

Emette 1 per falso e 0 per vero.

Versione leggibile:

({
    <({}[{}])>
    {
        ()
        <>
    }
    {}
})

Inizialmente avevo questo:

{
    ({}[{}])

    {
        <>([()])<>{{}}
    }{}
}
<>({}())

Che è di 10 byte in più.

QuadR , 11 byte

''≡⍵
(.)\1

Provalo online!

''≡⍵ il risultato è una stringa vuota quando

(.)\1 un personaggio seguito da solo

 non è sostituito da niente

JavaScript, 26 23 byte

s=>/^((.)\2)+$/.test(s)

Provalo online!

Soluzione ricorsiva, 30 byte

Grazie ad Arnauld per una correzione al costo di 0 byte.

f=([x,y,...s])=>x?x==y&f(s):!y

Provalo online!

Rosso , 36 byte

func[s][parse s[any[copy t skip t]]]

Provalo online!

Alternativa più lunga:

Rosso , 40 byte

func[s][(extract s 2)= extract next s 2]

Provalo online!

Zsh , 36 byte

La mia risposta Zsh alla sfida precedente può essere trovata qui.

Esce da true (0) se NON parla doppiamente e falsy (1) se parla doppia. (Come consentito in un commento.)

for a b (${(s::)1})r+=${a#$b}
[ $r ]

for a b (${(s::)1})r+=${a#$b}
         ${(s::)1}             # split $1 characterwise
for a b (         )            # take pairs of characters from ${(s::)1}, assign to $a and $b
                      ${a   }  # first character
                      ${ #$b}  # remove second character as prefix
                   r+=         # append to $r as string
[ $r ]                         # exit truthy if $r is non-empty

Provalo online!

Prolog (SWI) , 60 45 byte

grazie a Unrelated String

+[].
+[A,A|T]:- +T.
-X:-string_chars(X,Y),+Y.

Provalo online!

La conversione da una stringa in un elenco di atomi ha rovinato il punteggio, ma bene ...