Em um desafio anterior , pedi aos jogadores de código que produzissem strings que copiam cada caractere em uma string. Por exemplo:

TThhiiss  iiss  ddoouubbllee  ssppeeaakk!!

Esse desafio é simplesmente detectar se algum texto atende à definição de uma string de fala dupla.

• Há um número par de caracteres.
• Quando dividido em pares, cada par consiste em dois do mesmo personagem.

O desafio

• É código de golfe, faça em poucos bytes.
• Use qualquer idioma que você escolher.
• Inclua um link para um intérprete online.
• O código aceitará algum texto.
  • Para simplificar, a entrada consistirá apenas em caracteres ASCII imprimíveis
• Ele retornará uma indicação sobre se a entrada é ou não de fala dupla. Poderia ser:
  • Um booleano
  • Strings ('verdadeiro', 'falso', 'sim', 'não' etc)
  • Inteiros 0 ou 1

Casos de teste:

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

Python 3 , 24 bytes

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

Experimente online!

brainfuck , 20 bytes

Guardou 1 byte graças a Jo King.

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

Experimente online!

Saída legível!

Pega dois caracteres de cada vez e se afasta do 1 na fita se algum par não corresponder. O EOF é tratado como 0 e, portanto, tratado automaticamente.

A saída é um byte nulo se a sequência não for de fala dupla e 0x01 se for. A versão legível gera esses caracteres como um custo de 14 bytes.

MATL , 4 bytes

Heda

Input é uma string, delimitada por qoutes únicos. A saída é 0para fala dupla, 1caso contrário.

Experimente online!

Explicação

Considere a entrada 'TThhiiss iiss ddoouubbllee ssppeeaakk!!'como um exemplo.

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

ιË

Insira como uma lista de caracteres.

-3 bytes, portando a resposta Japt de @ Shaggy , certifique-se de votá-lo!

Experimente online ou verifique mais alguns casos de teste .

Explicação:

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

Japonês , 4 bytes

ó r¶

Tente

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

Alternativa

ó
¥o

Tente

Retina , 9 bytes

(.)\1

^$

Experimente online.

Explicação:

Remova todos os pares dos mesmos caracteres:

(.)\1

Verifique se não há caracteres restantes:

^$

Geléia , 3 bytes

ŒœE

Experimente online!

Stax , 5 bytes

■◄┼$Δ

Execute e depure

Procedimento:

• Calcular comprimentos de execução.
• Obtenha o GCD da matriz.
• É mesmo?

PHP ,58 56 bytes

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

Experimente online!

Como uma função recursiva.

PHP ,61 56. 52 bytes

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

Experimente online!

Ou programa autônomo. Seqüência de entrada via STDIN, output é truthy( 1) se for de fala dupla e falsey( 0) se não for de fala dupla.

-4 bytes thx para @ Night2 !

código de máquina x86, 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

Entrada da string SI, comprimento da string de entrada CX. Saída ZFse for falar duas vezes.

Ou 14 bytes como um executável completo do 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 

A entrada é via STDINpipe ou interativa. Irá ecoar a entrada "duplicada" até que um caractere não duplicado seja detectado, e nesse ponto será encerrado (talvez regras de E / S flexíveis sejam um pouco, mas essa é apenas uma resposta bônus).

Crie e teste o ISDBL2.COM usando xxd -r:

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

Executável completo do PC DOS original de 24 bytes :

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 da linha de comando, saída para a tela 'Y'se dupla, 'N'se não.

Crie e teste 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 thx para @ErikF!

Lua , 67 66 63 59 33 32 bytes

-25 bytes graças a Giuseppe
-1 byte graças a val

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

Experimente online!

Remove todos os caracteres dobrados e verifica se o resultado está vazio.

Perl 5 , 15 bytes

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

Experimente online!

Saídas 1 para fala dupla, nada para não fala dupla.

MathGolf , 2 bytes

½=

Experimente online!

Basicamente, o mesmo que a resposta 05AB1E, ½divide a sequência em caracteres pares e ímpares e, em seguida, verifique a igualdade. Passa para a sequência vazia.

JavaScript, 28 bytes

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

Experimente online!

23 bytes usando o regex de wastl

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

Experimente online!

Haskell , 28 23 bytes

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

Experimente online!

Muito simples. A fala dupla é apenas vazia ou um caractere repetido é prefixado para falar duas vezes.

Menos direto agora. Resultados via presença ou ausência de erro, por meta consenso ; nenhum erro significa falar duas vezes. A correspondência de padrões falha quando os dois primeiros caracteres diferem ou quando há um número ímpar de caracteres. Obrigado a Laikoni por essas economias!

V (vim) , 7 bytes

Óˆ±
ø^$

Experimente online! ou Verificar casos de teste

Hexdump:

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

Apenas duas regexes. Explicação:

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

Braquilog , 5 bytes

ġ₂z₂=

Experimente online!

Sucesso ou falha.

ġ₂       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)

Experimente online!

onde $pcontém um caractere anterior.

Sem recursão , sem regex :). Recebe a entrada como um array de caracteres por meio de uma string de splatting (consulte o link TIO).

PowerShell , 48 bytes

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

Experimente online!

Sem recursão , sem regex e sem pipe: D. Ele também recebe a entrada como um array de caracteres por meio de uma string de splatting. Em $b-eq$avez disso, usa $a-eq$bpara um caso em que um último caractere possui o código # 0.

PowerShell , 64 59 bytes

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

Experimente online!

Função recursiva, sem regex. Recebe a entrada como uma charmatriz (consulte o link TIO). Descasca os dois primeiros elementos em $ae $barmazena o restante em $r. Se ainda tivermos elementos restantes, recorra junto com $a -eq $b. Caso contrário, basta verificar se $a -eq $b. A saída está implícita.

-5 bytes graças ao mazzy

Julia 1.0 , 25 bytes

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

Experimente online!

J , 13 11 10 bytes

-:2#_2{.\]

Experimente online!

-2 bytes graças a Adám

-1 byte graças a milhas

Explicação do TLDR: A entrada é igual a todos os outros caracteres da entrada duplicada?

Linguagem de programação de Shakespeare , 204 156 bytes

-48 bytes graças a Jo King (principalmente alterando o método de saída)

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.

Experimente online!

Sai com erro se a entrada for de fala dupla e com aviso se não for de fala dupla (o que é permitido por padrão).

Barril , 19 17 caracteres

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

Explicação:

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

Experimente online!

R , 53 34 bytes

-19 bytes graças a Giuseppe

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

Experimente online!

Flak cerebral , 26 , 22 bytes

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

Experimente online!

Saídas 1 para falso e 0 para verdadeiro.

Versão legível:

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

Eu originalmente tinha isso:

{
    ({}[{}])

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

Qual é 10 bytes mais longo.

QuadR , 11 bytes

''≡⍵
(.)\1

Experimente online!

''≡⍵ o resultado é uma string vazia quando

(.)\1 um personagem seguido por ele mesmo

 é substituído por nada

JavaScript, 26 23 bytes

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

Experimente online!

Solução Recursiva, 30 bytes

Agradecimentos a Arnauld por uma correção ao custo de 0 bytes.

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

Experimente online!

Vermelho , 36 bytes

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

Experimente online!

Alternativa mais longa:

Vermelho , 40 bytes

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

Experimente online!

Zsh , 36 bytes

Minha resposta do Zsh para o desafio anterior pode ser encontrada aqui.

Sai verdadeiramente (0) se NÃO falar duas vezes e falso (1) se falar duas vezes. (Conforme permitido em um comentário.)

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

Experimente online!

Prolog (SWI) , 60 45 bytes

graças a String não relacionada

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

Experimente online!

Convertê-lo de uma string para uma lista de átomos arruinou a pontuação, mas bem ..