Bei einer früheren Herausforderung habe ich Codegolfer gebeten, Zeichenfolgen zu erstellen, die jedes Zeichen in einer Zeichenfolge kopieren. Zum Beispiel:

TThhiiss  iiss  ddoouubbllee  ssppeeaakk!!

Diese Herausforderung besteht einfach darin, festzustellen, ob ein Text die Definition einer Doppelsprechzeichenfolge erfüllt.

• Es gibt eine gerade Anzahl von Zeichen.
• Bei der Aufteilung in Paare besteht jedes Paar aus zwei gleichen Zeichen.

Die Herausforderung

• Es ist Codegolf, machen Sie es in wenigen Bytes.
• Verwenden Sie eine beliebige Sprache.
• Bitte fügen Sie einen Link zu einem Online-Dolmetscher bei.
• Der Code akzeptiert Text.
  • Der Einfachheit halber besteht die Eingabe nur aus druckbaren ASCII-Zeichen
• Es wird eine Anzeige zurückgegeben, ob der Eingang Doppelsprache ist oder nicht. Es könnte sein:
  • Ein Boolescher
  • Zeichenfolgen ('true', 'false', 'yes', 'no' usw.)
  • Ganzzahlen 0 oder 1

Testfälle:

• aba - falsch
• abba - falsch
• aabb - wahr
• aaabb - falsch
• tthhiiss - wahr
• ttthhhiiisss - falsch

Python 3 , 24 Bytes

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

Probieren Sie es online!

Brainfuck , 20 Bytes

Dank Jo King 1 Byte gespeichert.

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

Probieren Sie es online!

Lesbare Ausgabe!

Nimmt die Eingabe von zwei Zeichen gleichzeitig vor und entfernt sich von der 1 auf dem Band, wenn ein Paar nicht übereinstimmt. EOF wird als 0 behandelt und somit automatisch behandelt.

Die Ausgabe ist ein Null-Byte, wenn der String nicht doppelt gesprochen wird, und 0x01, wenn dies der Fall ist. Die lesbare Version gibt diese als Zeichen zum Preis von 14 Byte aus.

MATL , 4 Bytes

Heda

Die Eingabe ist eine Zeichenfolge, die von einzelnen qoutes eingeschlossen wird. Die Ausgabe ist 0für Doppelsprache, 1ansonsten.

Probieren Sie es online!

Erläuterung

Betrachten Sie die Eingabe 'TThhiiss iiss ddoouubbllee ssppeeaakk!!'als Beispiel.

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

ιË

Eingabe als Liste von Zeichen.

-3 Bytes, indem Sie @ Shaggy's Japt-Antwort portieren , also stellen Sie sicher, dass Sie ihn unterstützen!

Probieren Sie es online aus oder überprüfen Sie ein paar weitere Testfälle .

Erläuterung:

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

Versuch es

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

Alternative

ó
¥o

Versuch es

Netzhaut , 9 Bytes

(.)\1

^$

Probieren Sie es online aus.

Erläuterung:

Entferne alle Paare der gleichen Charaktere:

(.)\1

Überprüfen Sie, ob keine Zeichen mehr vorhanden sind:

^$

Gelee , 3 Bytes

ŒœE

Probieren Sie es online!

Stax , 5 Bytes

■◄┼$Δ

Führen Sie es aus und debuggen Sie es

Verfahren:

• Lauflängen berechnen.
• Holen Sie sich die GCD des Arrays.
• Ist gerade?

PHP ,58 56 Bytes

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

Probieren Sie es online!

Als rekursive Funktion.

PHP ,61 56 52 Bytes

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

Probieren Sie es online!

Oder eigenständiges Programm. Eingabezeichenfolge über STDIN, Ausgabe ist truthy( 1), wenn doppelt gesprochen wird, und falsey( 0), wenn nicht doppelt gesprochen wird.

-4 Bytes Danke an @ Night2 !

x86-Maschinencode, 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

Eingabezeichenfolge in der SIEingangszeichenfolgenlänge in CX. Ausgabe ZFwenn doppelt gesprochen wird.

Oder 14 Bytes als vollständige ausführbare PC-DOS-Datei:

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 

Die Eingabe erfolgt STDINentweder über Pipe oder interaktiv. Gibt die "de-doubled" -Eingabe wieder, bis ein nicht verdoppeltes Zeichen erkannt wird. An diesem Punkt wird die Eingabe beendet (möglicherweise gibt es ein wenig Regeln für die Biege-E / A, dies ist jedoch nur eine Bonusantwort).

Erstellen und testen Sie ISDBL2.COM mit xxd -r:

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

Ursprüngliche 24 Byte vollständige ausführbare PC-DOS-Datei:

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

Eingabe von der Kommandozeile, Ausgabe auf dem Bildschirm 'Y', 'N'wenn nicht, wenn doppelt .

Erstellen und testen Sie ISDBL.COM mit xxd -r:

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

Credits:

• -2 Bytes danke an @ErikF!

Lua , 67 66 63 59 33 32 Bytes

-25 Bytes dank Giuseppe
-1 Bytes dank val

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

Probieren Sie es online!

Entfernt jedes doppelte Zeichen und prüft, ob das Ergebnis leer ist.

Perl 5 , 15 Bytes

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

Probieren Sie es online!

Ausgänge 1 für doppeltes Sprechen, nichts für nicht doppeltes Sprechen.

MathGolf , 2 Bytes

½=

Probieren Sie es online!

Im Grunde das gleiche wie die 05AB1E-Antwort, ½teilt die Zeichenfolge in gerade und ungerade Zeichen auf und prüft dann auf Gleichheit. Übergibt die leere Zeichenfolge.

JavaScript, 28 Bytes

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

Probieren Sie es online!

23 Bytes unter Verwendung des regulären Ausdrucks von wastl

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

Probieren Sie es online!

Haskell , 28 23 Bytes

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

Probieren Sie es online!

Sehr einfach. Double Speak ist nur leer oder ein wiederholtes Zeichen, das vor Double Speak steht.

Jetzt weniger einfach. Ausgaben über Vorhandensein oder Nichtvorhandensein eines Fehlers, per Metakonsens ; Kein Fehler bedeutet doppeltes Sprechen. Der Mustervergleich schlägt fehl, wenn sich die ersten beiden Zeichen unterscheiden oder wenn eine ungerade Anzahl von Zeichen vorhanden ist. Vielen Dank an Laikoni für diese Einsparungen!

V (vim) , 7 Bytes

Óˆ±
ø^$

Probieren Sie es online! oder Testfälle überprüfen

Hexdump:

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

Nur zwei reguläre Ausdrücke. Erläuterung:

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

Probieren Sie es online!

Erfolg oder Misserfolg.

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

Probieren Sie es online!

wo $penthält ein früheres Zeichen.

Keine Rekursion , kein Regex :). Übernimmt die Eingabe als Zeichen-Array über einen Splatting-String (siehe TIO-Link).

PowerShell , 48 Byte

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

Probieren Sie es online!

Keine Rekursion , kein Regex und keine Pipe: D. Es nimmt auch Eingaben als Zeichen-Array über eine Splatting-Zeichenfolge entgegen. Es wird $b-eq$astattdessen $a-eq$bfür den Fall verwendet, dass ein letztes Zeichen den Code # 0 hat.

Power , 64 59 Bytes

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

Probieren Sie es online!

Rekursive Funktion, kein regulärer Ausdruck. Nimmt die Eingabe als char-array (siehe TIO-Link). Schält die ersten beiden Elemente in $aund ab $bund speichert die verbleibenden in $r. Wenn noch Elemente übrig sind, greifen Sie mit zu $a -eq $b. Ansonsten einfach nachschauen ob $a -eq $b. Die Ausgabe ist implizit.

-5 Bytes dank mazzy

Julia 1.0 , 25 Bytes

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

Probieren Sie es online!

J , 13 11 10 Bytes

-:2#_2{.\]

Probieren Sie es online!

-2 Bytes dank Adám

-1 Byte dank Meilen

TLDR-Erklärung: Ist die Eingabe mit jedem anderen Zeichen der Eingabe identisch, das verdoppelt wurde?

Shakespeare Programming Language , 204 156 Bytes

-48 Bytes dank Jo King (hauptsächlich durch Ändern der Ausgabemethode)

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.

Probieren Sie es online!

Wird mit Fehler beendet, wenn die Eingabe Double Speak ist, und mit Warnung, wenn es sich nicht um Double Speak handelt (was standardmäßig zulässig ist).

Fass , 19 17 Zeichen

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

Erläuterung:

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

Probieren Sie es online!

R , 53 34 Bytes

-19 Bytes dank Giuseppe

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

Probieren Sie es online!

Brain-Flak , 26 , 22 Bytes

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

Probieren Sie es online!

Gibt 1 für falsch und 0 für wahr aus.

Lesbare Version:

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

Ich hatte ursprünglich folgendes:

{
    ({}[{}])

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

Welches ist 10 Bytes länger.

QuadR , 11 Bytes

''≡⍵
(.)\1

Probieren Sie es online!

''≡⍵ Das Ergebnis ist eine leere Zeichenfolge, wenn

(.)\1 ein Charakter von sich selbst gefolgt

 wird durch nichts ersetzt

JavaScript, 26 23 Bytes

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

Probieren Sie es online!

Rekursive Lösung, 30 Bytes

Vielen Dank an Arnauld für einen Fix zum Preis von 0 Bytes.

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

Probieren Sie es online!

Rot , 36 Bytes

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

Probieren Sie es online!

Längere Alternative:

Rot , 40 Bytes

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

Probieren Sie es online!

Zsh , 36 Bytes

Meine Antwort auf die vorherige Herausforderung finden Sie hier.

Beendet truey (0), wenn NICHT double speak, und false (1), wenn double speak. (Wie in einem Kommentar erlaubt.)

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

Probieren Sie es online!

Prolog (SWI) , 60 45 Bytes

Danke an Unrelated String

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

Probieren Sie es online!

Das Umwandeln von einem String in eine Liste von Atomen hat die Partitur irgendwie ruiniert, aber gut.