Trong một thử thách trước đó, tôi đã yêu cầu những người chơi golf mã tạo ra các chuỗi sao chép từng ký tự trong một chuỗi. Ví dụ:

TThhiiss  iiss  ddoouubbllee  ssppeeaakk!!

Thách thức này chỉ đơn giản là phát hiện nếu một số văn bản đáp ứng định nghĩa của chuỗi nói kép.

• Có một số lượng nhân vật chẵn.
• Khi chia thành từng cặp, mỗi cặp bao gồm hai nhân vật giống nhau.

Các thách thức

• Đó là mã golf, làm điều đó trong vài byte.
• Sử dụng bất kỳ ngôn ngữ bạn chọn.
• Vui lòng bao gồm một liên kết đến một thông dịch viên trực tuyến.
• Mã sẽ chấp nhận một số văn bản.
  • Để đơn giản, đầu vào sẽ chỉ bao gồm các ký tự ASCII có thể in
• Nó sẽ trả về một dấu hiệu cho biết đầu vào có nói hai lần hay không. Nó có thể là:
  • Boolean
  • Chuỗi ('đúng', 'sai', 'có', 'không', v.v.)
  • Số nguyên 0 hoặc 1

Các trường hợp thử nghiệm:

• aba - sai
• abba - sai
• aabb - đúng
• aaabb - sai
• tthhiiss - đúng
• ttthhhiiisss - sai

Python 3 , 24 byte

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

Hãy thử trực tuyến!

Brainfuck , 20 byte

Lưu được 1 byte nhờ Jo King.

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

Hãy thử trực tuyến!

Đầu ra dễ đọc!

Đưa hai ký tự vào cùng một lúc và di chuyển khỏi số 1 trên băng nếu bất kỳ cặp nào không khớp. EOF được coi là 0 và do đó được xử lý tự động.

Đầu ra là một byte rỗng nếu chuỗi không nói hai lần và 0x01 nếu có. Phiên bản có thể đọc được xuất ra dưới dạng các ký tự với chi phí 14 byte.

MATL , 4 byte

Heda

Đầu vào là một chuỗi, kèm theo các qout đơn. Đầu ra là 0để nói đôi, 1nếu không.

Hãy thử trực tuyến!

Giải trình

Hãy xem xét đầu vào 'TThhiiss iiss ddoouubbllee ssppeeaakk!!'là một ví dụ.

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

ιË

Nhập dưới dạng danh sách các ký tự.

-3 byte bằng cách chuyển câu trả lời Japt của @ Shaggy , vì vậy hãy đảm bảo nâng cao anh ấy!

Hãy thử trực tuyến hoặc xác minh một vài trường hợp thử nghiệm .

Giải trình:

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

Thử nó

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

Thay thế

ó
¥o

Thử nó

Võng mạc , 9 byte

(.)\1

^$

Hãy thử trực tuyến.

Giải trình:

Xóa tất cả các cặp ký tự giống nhau:

(.)\1

Kiểm tra nếu không còn ký tự nào:

^$

Thạch , 3 byte

ŒœE

Hãy thử trực tuyến!

Stax , 5 byte

■◄┼$Δ

Chạy và gỡ lỗi nó

Thủ tục:

• Tính độ dài đường chạy.
• Lấy GCD của mảng.
• Là thậm chí?

PHP ,58 56 byte

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

Hãy thử trực tuyến!

Là một hàm đệ quy.

PHP ,61 56 52 byte

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

Hãy thử trực tuyến!

Hoặc chương trình độc lập. Chuỗi đầu vào thông qua STDIN, đầu ra là truthy( 1) nếu nó nói hai lần và falsey( 0) nếu nó không nói hai lần.

-4 byte thx đến @ Night2 !

mã máy 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

Chuỗi đầu vào trong SI, độ dài chuỗi đầu vào trong CX. Đầu ra ZFnếu nói gấp đôi.

Hoặc là 14 byte dưới dạng thực thi PC DOS hoàn chỉnh:

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 

Đầu vào là thông qua STDIN , hoặc đường ống hoặc tương tác. Sẽ lặp lại đầu vào "nhân đôi" cho đến khi phát hiện một ký tự không nhân đôi, tại thời điểm đó sẽ thoát (có thể bẻ cong quy tắc I / O một chút, nhưng đây chỉ là câu trả lời bổ sung).

Xây dựng và kiểm tra ISDBL2.COM bằng cách sử dụng xxd -r :

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

24 byte gốc hoàn chỉnh PC DOS thực thi:

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

Nhập từ dòng lệnh, xuất ra màn hình 'Y'nếu gấp đôi, 'N'nếu không.

Xây dựng và kiểm tra ISDBL.COM bằng cách sử dụng xxd -r :

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

Tín dụng:

• -2 byte thx đến @ErikF!

Lua , 67 66 63 59 33 32 byte

-25 byte nhờ Giuseppe
-1 byte nhờ val

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

Hãy thử trực tuyến!

Xóa mọi ký tự nhân đôi, sau đó kiểm tra xem kết quả có trống không.

Perl 5 , 15 byte

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

Hãy thử trực tuyến!

Đầu ra 1 cho nói hai lần, không có gì cho không nói hai lần.

MathGolf , 2 byte

½=

Hãy thử trực tuyến!

Về cơ bản giống như câu trả lời 05AB1E, ½chia chuỗi thành các ký tự chẵn và lẻ, sau đó kiểm tra sự bằng nhau. Truyền cho chuỗi trống.

JavaScript, 28 byte

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

Hãy thử trực tuyến!

23 byte sử dụng regex của Wastel

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

Hãy thử trực tuyến!

Haskell , 28 23 byte

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

Hãy thử trực tuyến!

Rất đơn giản. Nói đôi chỉ là trống rỗng hoặc một nhân vật lặp đi lặp lại dự kiến ​​nói đôi.

Ít đơn giản hơn bây giờ. Đầu ra thông qua sự hiện diện hoặc không có lỗi, theo sự đồng thuận meta ; không có lỗi có nghĩa là nói đôi. Khớp mẫu không thành công khi hai ký tự đầu tiên khác nhau hoặc khi có số lượng ký tự lẻ. Cảm ơn Laikoni vì những khoản tiết kiệm này!

V (vim) , 7 byte

Óˆ±
ø^$

Hãy thử trực tuyến! hoặc Xác minh các trường hợp kiểm tra

Hexdump:

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

Chỉ cần hai regex. Giải trình:

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

Hãy thử trực tuyến!

Thành công hay thất bại.

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

Hãy thử trực tuyến!

nơi $pchứa một char trước đó.

Không đệ quy , không regex :). Đưa đầu vào dưới dạng mảng char thông qua chuỗi nối (xem liên kết TIO).

PowerShell , 48 byte

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

Hãy thử trực tuyến!

Không đệ quy , không regex và không có đường ống: D. Nó cũng nhận đầu vào là một mảng char thông qua một chuỗi nối. Nó sử dụng $b-eq$athay thế $a-eq$bcho một trường hợp khi một char cuối cùng có mã # 0.

PowerShell , 64 59 byte

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

Hãy thử trực tuyến!

Hàm đệ quy, không có regex. Đưa đầu vào dưới dạng char-array (xem liên kết TIO). Loại bỏ hai yếu tố đầu tiên vào $avà $b, lưu trữ phần còn lại vào $r. Nếu chúng ta vẫn còn các yếu tố, hãy lặp lại cùng với $a -eq $b. Nếu không, chỉ cần kiểm tra xem$a -eq $b . Đầu ra là ẩn.

-5 byte nhờ mazzy

Julia 1.0 , 25 byte

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

Hãy thử trực tuyến!

J , 13 11 10 byte

-:2#_2{.\]

Hãy thử trực tuyến!

-2 byte nhờ Adám

-1 byte nhờ dặm

Giải thích về TLDR: Đầu vào có giống như mọi ký tự khác của đầu vào được nhân đôi không?

Ngôn ngữ lập trình Shakespeare , 204 156 byte

-48 byte nhờ Jo King (chủ yếu bằng cách thay đổi phương thức đầu ra)

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.

Hãy thử trực tuyến!

Thoát khỏi lỗi nếu đầu vào là nói kép và với cảnh báo nếu nó không nói hai lần (được cho phép theo mặc định).

keg , 19 17 ký tự

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

Giải trình:

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

Hãy thử trực tuyến!

R , 53 34 byte

-19 byte nhờ Giuseppe

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

Hãy thử trực tuyến!

Brain-Flak , 26 , 22 byte

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

Hãy thử trực tuyến!

Đầu ra 1 cho sai và 0 cho đúng.

Phiên bản dễ đọc:

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

Ban đầu tôi có cái này:

{
    ({}[{}])

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

Cái nào dài hơn 10 byte.

QuadR , 11 byte

''≡⍵
(.)\1

Hãy thử trực tuyến!

''≡⍵ kết quả là một chuỗi rỗng khi

(.)\1 một nhân vật theo sau chính nó

 được thay thế bởi không có gì

JavaScript, 26 23 byte

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

Hãy thử trực tuyến!

Giải pháp đệ quy, 30 byte

Cảm ơn Arnauld đã sửa lỗi với chi phí 0 byte.

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

Hãy thử trực tuyến!

Đỏ , 36 byte

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

Hãy thử trực tuyến!

Thay thế dài hơn:

Đỏ , 40 byte

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

Hãy thử trực tuyến!

Zsh , 36 byte

Câu trả lời Zsh của tôi cho thử thách trước có thể được tìm thấy ở đây.

Thoát khỏi sự thật (0) nếu KHÔNG nói hai lần và giả dối (1) nếu nói hai lần. (Như được cho phép trong một bình luận.)

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

Hãy thử trực tuyến!

Prolog (SWI) , 60 45 byte

nhờ Chuỗi không liên quan

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

Hãy thử trực tuyến!

Chuyển đổi nó từ một chuỗi thành một danh sách các nguyên tử loại làm hỏng điểm số, nhưng tốt ..