Lors d'un défi précédent, j'avais demandé aux golfeurs de code de produire des chaînes qui copient chaque caractère d'une chaîne. Par exemple:

TThhiiss  iiss  ddoouubbllee  ssppeeaakk!!

Ce défi consiste simplement à détecter si un texte correspond à la définition d'une chaîne de parole double.

• Il y a un nombre pair de caractères.
• Lorsqu'il est divisé en paires, chaque paire est constituée de deux du même caractère.

Le défi

• C'est du code golf, faites-le en quelques octets.
• Utilisez n'importe quelle langue que vous choisissez.
• Veuillez inclure un lien vers un interprète en ligne.
• Le code acceptera du texte.
  • Pour des raisons de simplicité, la saisie ne comportera que des caractères ASCII imprimables.
• Il retournera une indication indiquant si l'entrée est une double parole. Il pourrait être:
  • Un booléen
  • Chaînes ('true', 'false', 'yes', 'no' etc.)
  • Entiers 0 ou 1

Cas de test:

• aba - faux
• abba - faux
• aabb - true
• aaabb - faux
• tthhiiss - true
• ttthhhiiisss - false

Python 3 , 24 octets

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

Essayez-le en ligne!

brainfuck , 20 octets

Sauvé 1 octet grâce à Jo King.

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

Essayez-le en ligne!

Sortie lisible!

Prend deux caractères à la fois et s'éloigne du 1 sur la bande si aucune des paires ne correspond. EOF est traité comme 0 et est donc traité automatiquement.

La sortie est un octet nul si la chaîne n'est pas un double langage et 0x01 si c'est le cas. La version lisible les affiche sous forme de caractères au coût de 14 octets.

MATL , 4 octets

Heda

L'entrée est une chaîne, entourée de qoutes simples. La sortie est 0pour double parler, 1sinon.

Essayez-le en ligne!

Explication

Considérez l'entrée 'TThhiiss iiss ddoouubbllee ssppeeaakk!!'comme un exemple.

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 octets

ιË

Saisie sous forme de liste de caractères.

-3 octets en portant la réponse de @ Shaggy's Japt , alors assurez-vous de le réévaluer!

Essayez-le en ligne ou vérifiez quelques autres cas de test .

Explication:

ι   # 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 octets

ó r¶

L'essayer

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

Alternative

ó
¥o

L'essayer

Retina , 9 octets

(.)\1

^$

Essayez-le en ligne.

Explication:

Supprimer toutes les paires des mêmes caractères:

(.)\1

Vérifiez s'il ne reste plus de caractères:

^$

Gelée , 3 octets

ŒœE

Essayez-le en ligne!

Stax , 5 octets

■◄┼$Δ

Exécuter et déboguer

Procédure:

• Calculer les longueurs d'exécution.
• Obtenir GCD du tableau.
• Est même?

PHP ,58 56 octets

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

Essayez-le en ligne!

En tant que fonction récursive.

PHP ,61 56 52 octets

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

Essayez-le en ligne!

Ou programme autonome. Chaîne d'entrée via STDIN, la sortie est truthy( 1) s'il s'agit d'un double langage et falsey( 0) s'il ne s'agit pas d'un double langage.

-4 octets merci à @ Night2 !

code machine x86, 9 7 octets

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

Chaîne d'entrée dans SI, longueur de chaîne d'entrée dans CX. Sortie ZFsi est double parler.

Ou 14 octets en tant qu’exécutable complet DOS PC:

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'entrée est via STDIN, soit pipe ou interactive. Répondra à l'entrée "dédoublée" jusqu'à la détection d'un caractère non doublé, à quel moment se terminera (peut-être que les règles d'E / S se pliant un peu, mais il ne s'agit que d'une réponse en prime).

Générez et testez ISDBL2.COM en utilisant xxd -r:

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

Exécutable original DOS sur 24 octets :

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

Entrée à partir de la ligne de commande, sortie à l'écran 'Y'si double, 'N'sinon.

Construisez et testez ISDBL.COM en utilisant xxd -r:

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

Crédits:

• -2 octets merci à @ErikF!

Lua , 67 66 63 59 33 32 octets

-25 octets grâce à Giuseppe
-1 octets grâce à val

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

Essayez-le en ligne!

Supprime chaque caractère doublé, puis vérifie si le résultat est vide.

Perl 5 , 15 octets

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

Essayez-le en ligne!

Sorties 1 pour le double langage, rien pour le non-double langage.

MathGolf , 2 octets

½=

Essayez-le en ligne!

Fondamentalement identique à la réponse 05AB1E, ½divise la chaîne en caractères pairs et impairs, puis vérifie l’égalité. Passe pour la chaîne vide.

JavaScript, 28 octets

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

Essayez-le en ligne!

23 octets utilisant l'expression régulière de wastl

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

Essayez-le en ligne!

Haskell , 28 23 octets

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

Essayez-le en ligne!

Très simple. Le double langage est seulement vide ou un caractère répété est destiné à un double langage.

Moins simple maintenant. Les sorties via la présence ou l'absence d'erreur, par méta consensus ; pas d'erreur signifie double parler. La correspondance de modèle échoue lorsque les deux premiers caractères diffèrent ou lorsqu'il existe un nombre impair de caractères. Merci à Laikoni pour ces économies!

V (vim) , 7 octets

Óˆ±
ø^$

Essayez-le en ligne! ou Vérifier les cas de test

Hexdump:

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

Juste deux regex. Explication:

Ó   " 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 octets

ġ₂z₂=

Essayez-le en ligne!

Réussit ou échoue.

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

PowerShell , 39 38 octets

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

Essayez-le en ligne!

où $pcontient un caractère précédent.

Pas de récursion , pas de regex :). Prend l'entrée sous forme de tableau de caractères via une chaîne de séparation (voir lien TIO).

PowerShell , 48 octets

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

Essayez-le en ligne!

Pas de récursion , pas de regex et pas de pipe: D. Il accepte également les entrées sous forme de tableau de caractères via une chaîne de séparation. Il utilise à la $b-eq$aplace $a-eq$bpour un cas où un dernier caractère a le code # 0.

PowerShell , 64 59 octets

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

Essayez-le en ligne!

Fonction récursive, pas de regex. Prend l'entrée sous forme de chartableau (voir lien TIO). Détache les deux premiers éléments dans $aet $b, stocke le reste dans $r. Si nous avons encore des éléments restants, recurse avec $a -eq $b. Sinon, vérifiez si $a -eq $b. La sortie est implicite.

-5 octets grâce à mazzy

Julia 1.0 , 25 octets

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

Essayez-le en ligne!

J , 13 11 10 octets

-:2#_2{.\]

Essayez-le en ligne!

-2 octets grâce à Adam

-1 octet grâce aux miles

Explication TLDR: l’entrée est-elle identique à tous les autres caractères de l’entrée doublée?

Langage de programmation Shakespeare , 204 156 octets

-48 octets grâce à Jo King (principalement en changeant la méthode de sortie)

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.

Essayez-le en ligne!

Quitte avec erreur si l’entrée est double parler et avec avertissement si elle n’est pas double (ce qui est autorisé par défaut).

Keg , 19 17 caractères

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

Explication:

?             # 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

Essayez-le en ligne!

R , 53 34 octets

-19 octets grâce à Giuseppe

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

Essayez-le en ligne!

Brain-Flak , 26 , 22 octets

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

Essayez-le en ligne!

Sorties 1 pour faux et 0 pour vrai.

Version lisible:

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

J'avais à l'origine ceci:

{
    ({}[{}])

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

Ce qui est 10 octets plus long.

QuadR , 11 octets

''≡⍵
(.)\1

Essayez-le en ligne!

''≡⍵ le résultat est une chaîne vide quand

(.)\1 un personnage suivi par lui-même

 est remplacé par rien

JavaScript, 26 23 octets

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

Essayez-le en ligne!

Solution récursive, 30 octets

Merci à Arnauld pour un correctif au coût de 0 octet.

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

Essayez-le en ligne!

Rouge , 36 octets

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

Essayez-le en ligne!

Alternative plus longue:

Rouge , 40 octets

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

Essayez-le en ligne!

Zsh , 36 octets

Ma réponse Zsh au défi précédent peut être trouvée ici.

Quitte la vérité (0) si vous ne parlez PAS en double, et la fausseté (1) si vous parlez en double. (Comme autorisé dans un commentaire.)

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

Essayez-le en ligne!

Prolog (SWI) , 60 45 octets

grâce à Unrelated String

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

Essayez-le en ligne!

Le convertir d'une chaîne en une liste d'atomes a en quelque sorte ruiné le score, mais bien ..