En un desafío anterior, le pedí a los golfistas de código que produjeran cadenas que copiaran cada carácter en una cadena. Por ejemplo:

TThhiiss  iiss  ddoouubbllee  ssppeeaakk!!

Este desafío es simplemente detectar si algún texto cumple con la definición de una cadena de doble voz.

• Hay un número par de caracteres.
• Cuando se divide en pares, cada par consta de dos del mismo personaje.

El reto

• Es código de golf, hazlo en pocos bytes.
• Utiliza el idioma que elijas.
• Incluya un enlace a un intérprete en línea.
• El código aceptará algún texto.
  • Para simplificar, la entrada solo consistirá en caracteres ASCII imprimibles
• Devolverá una indicación de si la entrada es de doble voz. Podría ser:
  • Un booleano
  • Cadenas ('verdadero', 'falso', 'sí', 'no', etc.)
  • Enteros 0 o 1

Casos de prueba:

• aba - falso
• abba - falso
• aabb - cierto
• aaabb - falso
• tthhiiss - cierto
• ttthhhiiisss - falso

Python 3 , 24 bytes

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

Pruébalo en línea!

brainfuck , 20 bytes

Guardado 1 byte gracias a Jo King.

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

Pruébalo en línea!

Salida legible!

Toma la entrada de dos caracteres a la vez y se aleja del 1 en la cinta si algún par no coincide. EOF se trata como 0 y, por lo tanto, se maneja automáticamente.

La salida es un byte nulo si la cadena no es de doble habla, y 0x01 si lo es. La versión legible los genera como caracteres a un costo de 14 bytes.

MATL , 4 bytes

Heda

La entrada es una cadena, encerrada con qoutes individuales. La salida es 0para doble hablar, de lo 1contrario.

Pruébalo en línea!

Explicación

Considere la entrada 'TThhiiss iiss ddoouubbllee ssppeeaakk!!'como un ejemplo.

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 bytes

ιË

Entrada como una lista de caracteres.

-3 bytes portando la respuesta de @ Shaggy's Japt , ¡así que asegúrate de votarlo!

Pruébelo en línea o verifique algunos casos de prueba más .

Explicación:

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

ó r¶

Intentalo

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

Alternativa

ó
¥o

Intentalo

Retina , 9 bytes

(.)\1

^$

Pruébalo en línea.

Explicación:

Elimina todos los pares de los mismos personajes:

(.)\1

Comprueba si no quedan caracteres:

^$

Jalea , 3 bytes

ŒœE

Pruébalo en línea!

Stax , 5 bytes

■◄┼$Δ

Ejecutar y depurarlo

Procedimiento:

• Calcular longitudes de carrera.
• Obtenga GCD de matriz.
• ¿Incluso?

PHP ,58 56 bytes

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

Pruébalo en línea!

Como una función recursiva.

PHP ,61 56 52 bytes

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

Pruébalo en línea!

O programa independiente. Cadena de entrada vía STDIN, la salida es truthy( 1) si es de doble habla y falsey( 0) si no es de doble habla.

-4 bytes gracias a @ Night2 !

código de máquina x86, 9 9 7 bytes

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

Cadena de SIentrada, longitud de cadena de entrada CX. Salida ZFsi es doble hablar.

O 14 bytes como un ejecutable completo de 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 

La entrada es vía STDIN, ya sea tubería o interactiva. Se hará eco de la entrada "desdoblada" hasta que se detecte un carácter no doblado, en cuyo punto saldrá (tal vez flexionar las reglas de E / S un poco, pero esto es solo una respuesta adicional).

Compile y pruebe ISDBL2.COM usando xxd -r:

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

Original ejecutable de PC de DOS de 24 bytes completo:

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

Entrada desde la línea de comando, salida a la pantalla 'Y'si es doble, 'N'si no.

Compile y pruebe ISDBL.COM usando xxd -r:

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

Créditos

• -2 bytes gracias a @ErikF!

Lua , 67 66 63 59 33 32 bytes

-25 bytes gracias a Giuseppe
-1 byte gracias a val

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

Pruébalo en línea!

Elimina todos los caracteres duplicados, luego verifica si el resultado está vacío.

Perl 5 , 15 bytes

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

Pruébalo en línea!

Salidas 1 para doble habla, nada para no doble hablar.

MathGolf , 2 bytes

½=

Pruébalo en línea!

Básicamente lo mismo que la respuesta 05AB1E, ½divide la cadena en caracteres pares e impares, luego verifica la igualdad. Pases para la cadena vacía.

JavaScript, 28 bytes

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

Pruébalo en línea!

23 bytes usando la expresión regular de wastl

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

Pruébalo en línea!

Haskell , 28 23 bytes

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

Pruébalo en línea!

Muy sencillo El doble discurso solo está vacío o un carácter repetido antepuesto al doble habla.

Menos sencillo ahora. Salidas por presencia o ausencia de un error, por meta consenso ; sin error significa doble hablar. La coincidencia de patrones falla cuando los dos primeros caracteres difieren o cuando hay un número impar de caracteres. ¡Gracias a Laikoni por estos ahorros!

V (vim) , 7 bytes

Óˆ±
ø^$

Pruébalo en línea! o Verificar casos de prueba

Hexdump:

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

Solo dos expresiones regulares. Explicación:

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

ġ₂z₂=

Pruébalo en línea!

Tiene éxito o falla.

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

PowerShell , 39 38 bytes

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

Pruébalo en línea!

donde $pcontiene un carácter anterior.

Sin recursividad , sin expresiones regulares :). Toma la entrada como una matriz de caracteres a través de una cadena de salpicaduras (ver enlace TIO).

PowerShell , 48 bytes

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

Pruébalo en línea!

Sin recursividad , sin expresiones regulares y sin tubería: D. También toma la entrada como una matriz de caracteres a través de una cadena de salpicaduras. En su $b-eq$alugar, se usa $a-eq$bpara un caso en el que un último personaje tiene el código # 0.

PowerShell , 64 59 bytes

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

Pruébalo en línea!

Función recursiva, no regex. Toma la entrada como una charmatriz (ver enlace TIO). Despega los primeros dos elementos en $ay $b, almacena el resto en $r. Si todavía tenemos elementos restantes, recurse junto con $a -eq $b. De lo contrario, solo verifique si $a -eq $b. La salida es implícita.

-5 bytes gracias a mazzy

Julia 1.0 , 25 bytes

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

Pruébalo en línea!

J , 13 11 10 bytes

-:2#_2{.\]

Pruébalo en línea!

-2 bytes gracias a Adám

-1 byte gracias a millas

Explicación de TLDR: ¿la entrada es la misma que cualquier otro carácter de la entrada duplicada?

Lenguaje de programación Shakespeare , 204156 bytes

-48 bytes gracias a Jo King (principalmente cambiando el método de salida)

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.

Pruébalo en línea!

Sale con error si la entrada es de doble voz, y con advertencia si no es de doble voz (lo cual está permitido por defecto).

Barril , 19 17 caracteres

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

Explicación:

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

Pruébalo en línea!

R , 53 34 bytes

-19 bytes gracias a Giuseppe

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

Pruébalo en línea!

Brain-Flak , 26 , 22 bytes

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

Pruébalo en línea!

Salidas 1 para falso y 0 para verdadero.

Versión legible:

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

Originalmente tuve esto:

{
    ({}[{}])

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

Que es 10 bytes más largo.

QuadR , 11 bytes

''≡⍵
(.)\1

Pruébalo en línea!

''≡⍵ el resultado es una cadena vacía cuando

(.)\1 un personaje seguido solo

 es reemplazado por nada

JavaScript, 26 23 bytes

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

Pruébalo en línea!

Solución recursiva, 30 bytes

Gracias a Arnauld por una solución al costo de 0 bytes.

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

Pruébalo en línea!

Rojo , 36 bytes

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

Pruébalo en línea!

Alternativa más larga:

Rojo , 40 bytes

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

Pruébalo en línea!

Zsh , 36 bytes

Mi respuesta Zsh al desafío anterior se puede encontrar aquí.

Sale de verdad (0) si NO habla dos veces, y falso (1) si habla dos veces. (Según lo permitido en un comentario).

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

Pruébalo en línea!

Prólogo (SWI) , 60 45 bytes

gracias a Cadena no relacionada

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

Pruébalo en línea!

Convertirlo de una cadena a una lista de átomos arruinó el puntaje, pero bueno ...