Giới thiệu

Có 3 cái đinh trên tường. Bạn đã có một đoạn dây được cố định vào khung hình bằng cả hai đầu. Để treo bức tranh, bạn vướng dây bằng đinh. Nhưng trước khi để hình ảnh biến mất: Bạn có thể dự đoán liệu hình ảnh sẽ rơi xuống hay không, chỉ bằng cách nhìn vào cách chuỗi được quấn quanh móng tay?

Trong ví dụ đầu tiên, hình ảnh sẽ không rơi. Trong ví dụ thứ hai, bức tranh sẽ rơi.

Thử thách

Đưa ra đường dẫn của chuỗi xung quanh Nmóng, xác định xem hình ảnh có bị rơi hay không. Quay trở lại một truthy giá trị nếu hình ảnh sẽ giảm, và một giá trị falsy khác.

Chi tiết

• Bạn có thể giả định rằng móng tay và hình ảnh được sắp xếp theo một N+1đường chéo thông thường , với hình ảnh ở phía dưới.
• Bạn có thể giả định rằng không có nút thắt nào trong sợi dây, tức là sợi dây có thể liên tục được kéo ra từ một trong hai đầu.
• Mỗi móng được liệt kê theo chiều kim đồng hồ với một chữ cái của bảng chữ cái. Bạn có thể cho rằng có nhiều nhất là 26 móng tay (AZ).
• Một bọc theo chiều kim đồng hồ xung quanh một cái đinh được ký hiệu bằng chữ in thường, một bọc ngược chiều kim đồng hồ được ký hiệu bằng một chữ cái viết hoa.

Ví dụ đầu tiên từ phía trên sẽ được mã hóa thành BcA, ví dụ thứ hai được mã hóa thành CAbBac.

Đối với người đọc nghiêng: Vấn đề này tương đương với việc xác định xem một phần tử của nhóm tự do - được tạo bởi bộ móng - có phải là danh tính hay không. Điều này có nghĩa là đủ để hủy bỏ liên tục các chuỗi con như aAhoặc Aacho đến khi bạn đạt đến một điểm cố định. Nếu điểm cố định là một chuỗi rỗng, đây là phần tử trung tính, nếu không thì không.

Ví dụ

Picture will fall:
Aa
CAbBac
aBbA
DAacAaCdCaAcBCBbcaAb
ARrQqRrUuVHhvTtYyDdYyEKRrkeUWwua
AKkQqEeVvBESWwseYQqyXBbxVvPpWwTtKkVHLlWwNBbAanYYyyhWwEJZUuNnzjYyBLQqQqlEGgebeEPLlTtZzpUuevZzSsbXSGgsUuLlHhUQquPpHUuFfhTZzIitGgFAaBRrBbbYXxOoDZTDdtzVvXxUudHhOVvoUuXKkxyBEeLlbFfKkHhfVAaQqHAaJjODdoVvhSsZzMZzmPpXNBbnxBbUuSSsUuDRrdNnUusJDIiUuIidCEGgeMmcLlDPOopdTEeQqCAETtNnYyeGUuPEFfSsWwHheAaBbpgCcOHUuhAaCcoEFBbfeaFHhfcCFFffNncGFfgtjMVUuKAakvKkXxLlTMmtmOFfoUuXSsYZzLXxlyxUuRPZzTtprSsWwRrPLlpGgMmKRrDHhdRCcUurYNnKCckykXJjxWwUSsJjKkLlKkuBbBbOoWwWwIiUuPDdBbCcWHBbCFfcDdYBbLlyVvSsWGgEewCchDdYywAaJjEepPpPpQXxZzFfLGXxglNnZzYDdyqCcKWXxwXxQqXTtxkFfBSSAasTFftZzsXGgxSsLlLlbZzAaCCccXVvYyxTIiOoBbFftCVQqDdBbGgAavQqKkDPpKTCctRrkdcvAaQWOowLOolqVMmvZAaHCBbcPphIiRKkrLlzFMOomDIiXJjIixMmdNnMHhmfNTtIiKkSDdTtsVvHhnAaNSVvTUutNnXxsGIiXxPpPHhUupgNnAaAAOoaaIiHJjhVvLlnYyXxQqSsTtKJjkBbNnVvEYCcFfMHGghBbmNnEeJTtjJjWYywyeNWwDIiZYyzOodnMQqmVvCcQqxVvGNnEeNBbngVvUGgYyBbDdVvIiAAaauPpQKDdEekNnVLlvHhGSDIidPZzpsPCcpgQqKkQqNOonLlIiLlJjqPAaPXxTtppYyCPpHhCIicARBbracXxWwXEVUuUuGgZHhzBSsbvGgFfeVvxLlNKknWwBLlIibWOowNnRSsrSEeKAakOosLZzZRrHhzTtTFfUuNnOKkotXxTtla


Picture will not fall:
A
BcA
ABCD
aBaA
bAaBcbBCBcAaCdCaAcaCAD
ARrQqRrUatuVHhvTYyDdYyEKRrkeUAua
AEEeQqNneHhLlAIiGgaECXxcJjZzeJFfVWwDdKkvYWwyTJjtCXxANIinaXWwxcTWwtUuWwMmTBbVWIiFLlWwZzfwPLlEepvWZzwKkEYEeWXxwySXTtEexRIiNBbnWAaTtQqNnBMSsWwOombwWwPVPpGPpgYyvDdpBbrQqHhUusKRrDAVvadLlWwOZzokGJCXSSssXxxJPpGIigZzjJjLlOoNRrnPpcMZzmjgJjNDEeQqWKkNTtnSswIidCcnYBGgbyJSsjPpIiMmMmMmSNnWVvwZzIQqLXHhxTPptlisOoeTtTtYMmVvPpyKNnMFfmkXxSVvsCGJjXxgXYJPpjWwQIiXxqyDdxFfDdAaRNnJjrctHBbZzhEQqMmeCcRBbrGgAaAaJNnRrYyWwSDdVvsJOojQGgWWwIBbiwRrqJjjWwOoFPMmDdRrQOoqNnRrDPJjpMmdPpGFfVvWUuwgpWCcNnPpwfUXCcZzJjUSsuXxxUuuRGgHhrSQqJjOosMMTtmHhmKkXxDdLlWwjSUuAaMmKYyksZzVvPZzVEeVvvHhZZOozBbzMmZCczYyGgISsiQqpXxMmXxEMmeRrAGgaGgMOGgomZFfDdzSSssBGPpgbTtBbOoRWWwGgLJjlEeGgLDdRrUulNnZzJjJjUKkuXxFfwATtaZzLVvlWwSsMmrBAaELleGBLFflbgHhbIFfiBbPpTWZzwKkKLASsaTJYyjtBbBbWwIiZCcWwzIiZLlUTtuBbYyBbIizTJjtLTtDOOoBbodBbllSsUGgLlAKkauYykUuUNnPpuDFfAaLNVvnVvlHhdMmBAaBbIiVRrGWOoPpwgWXwKkvJjOoTtYCUucVGgYyLlVvFfvRrMmySsDdbtICZzcNnINSOosDQAaXoxRGgKkrqdZznDdXxZzMGgmiJjNnACcMQqmaNnWZzUOuwTVvAJjSsaRrGgSsTtOMmRroVvRrtAVGgvMmaINniDGCcOogRrWwMVvYFfyTtmTtVvOoOIiodRrGgAxaSsGgiJja

Võng mạc , 21 byte

+`(.)(?!\1)(?i)\1

^$

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

Giống như giải pháp của flawr, điều này chỉ cần lặp đi lặp lại xóa các cặp chữ hoa / chữ thường liền kề và sau đó kiểm tra xem kết quả có trống hay không.

Đối với cách một người khớp với một cặp chữ hoa / chữ thường:

(.)     # Match and capture a letter.
(?!\1)  # Ensure that the next character is not the same, to avoid matching
        # "aa" and "AA".
(?i)    # Turn on case-insensitivity.
\1      # Match the backreference. In .NET, when using case insensitivity,
        # backreferences also get case-insensitive, so this *can* still match
        # iff the cases of the two letters are different.

MATLAB, Octave 76 byte , 82 79 77 byte

Đây có thể là lần đầu tiên tôi thấy MATLAB thực sự ngắn hơn Octave (bằng toàn bộ byte)!

Câu trả lời mới trong MATLAB:

c=input('');k='Aa';while k<1e5,k=k+1;c=strrep(c,65+mod(k,64),'');end;~nnz(c)

Trả lời trong Octave:

c=input('');k='Aa';while k++<1e5,c=strrep(c,['',65+mod(k,64)],'');end;~nnz(c)

Đã lưu ba năm byte nhờ flawr. ~nnz(c)ngắn hơn isempty(c)và 'Aa'ngắn hơn hai byte [0,32].

Hãy dùng thử phiên bản Octave trực tuyến!

Giải trình:

c=input('')yêu cầu người dùng nhập liệu. Chúng tôi định nghĩa k='Aa'là một mảng ký tự.

while k++<1e5: Trong khi loop nơi cả hai yếu tố trong kđược tăng lên mỗi lần lặp, Aa, Bb, Ccvà vân vân. Vòng lặp sẽ tiếp tục cho đến khi phần tử lớn nhất là 1e5, đủ cao cho hầu hết các chuỗi. Nó có thể được tăng lên 9e9mà không tăng số byte.

Chúng tôi sẽ thực hiện các strrepchức năng trong các bước, bắt đầu từ giữa.

Bằng cách sử dụng, mod(k,64)chúng tôi sẽ nhận được những điều sau đây khi chúng tôi đến cuối bảng chữ cái (nếu chúng tôi chuyển đổi klại thành ký tự):

ans = Yy
ans = Zz
ans = [{
ans = \|
ans = ]}
ans = ^~
ans = _
ans = `�
ans = aA
ans = bB

Như bạn có thể thấy, sẽ có một số ký hiệu ở giữa, nhưng sau đó nó sẽ bao quanh và bắt đầu lại với bảng chữ cái, nhưng bây giờ với các chữ cái viết thường trước. Đây là một cách rất ngắn để kiểm tra cả Aavà aA.

['',65+mod(k,64)]nối các giá trị số từ mod-call, với một chuỗi rỗng, chuyển đổi các số thành ký tự.

strrepđược sử dụng để loại bỏ các phần tử khỏi chuỗi cvà trả về nó. Nó sẽ tìm kiếm tất cả các lần xuất hiện ktrong chuỗi và thay thế nó bằng một chuỗi rỗng.

Sau khi 1e5lặp lại, chúng ta sẽ có một chuỗi rỗng hoặc một chuỗi không trống. Chúng tôi kiểm tra nếu có bất kỳ yếu tố trong cviệc sử dụng nnz(c). Chúng tôi trở lại not(nnz(c)), do đó, 1nếu nó trống và 0nếu có các ký tự còn lại trongc

Chồn 0,15 , 30 byte

od4&x,N.I1=$6&d3~c-$~48*=,2&xx

Hãy thử nó ở đây!

Giải trình

od                            Take character from input and duplicate it
  4&                          If top of stack is truthy, jump 4 spaces
    x                         Dump top of stack
     ,                        NOT top of stack
      N.                      Output as number and stop

    I1=                       1 if stack has 1 element, 0 otherwise
       $6&                    If top of stack is truthy, jump 16 spaces (to the beginning)
          d3~c                Duplicate top two items of stack, in reversed order
              -               Subtract
               $~             Absolute value
                 48*          Push 32
                    =,        0 if top two items are equal, 1 otherwise
                      2&xx    If top of stack is truthy, dump two elements from top

Bản chất hình xuyến của Minkolang được tận dụng ở đây để loại bỏ sự cần thiết của một vòng ngoài. Ý tưởng chung ở đây là kiểm tra xem hai phần tử trên cùng của ngăn xếp có cách nhau 32 đơn vị hay không (nghĩa là chúng là một cặp chữ hoa / chữ thường) và nếu có, hãy tắt cả hai phần tử đó. Vì việc này được thực hiện "trong thời gian thực", nên có thể nói, việc lồng các cặp được xử lý đúng cách.

Haskell, 62 byte

a%l|b:t<-l,abs(a-b)==32=t|1>0=a:l
f=null.foldr((%).fromEnum)[]

Dùng thử trực tuyến

Tín dụng cho flawr choabs và Laikoni cho fromEnumbản đồ .

Hàm trợ giúp %lấy một chuỗi đã được đơn giản hóa lvà thêm ký hiệu atrước khi đơn giản hóa kết quả. Nếu lbắt đầu bằng ký tự nghịch đảo a, chúng sẽ hủy. Nếu không, achỉ đơn giản là chuẩn bị trước. Lưu ý rằng không cần đơn giản hóa thêm trong giai đoạn này.

Hàm chính bổ sung fvà đơn giản hóa từng ký tự lần lượt thông qua a foldr. Sau đó, nó kiểm tra xem kết quả có trống không.

Để kiểm tra xem hai ký tự có phải là trường hợp ngược nhau hay không và do đó nên hủy, xem giá trị ASCII của chúng có khác nhau không 32. Mỗi phần tử được xử lý fromEnumtrước khi được chuyển đến %.

05AB1E , 17 byte

DvADu‚øDíìvyK}}õQ

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

Giải trình

Dv                 # input number of times do:
  A                # push lowercase alphabet
   Du              # push uppercase alphabet
     ‚ø            # zip the alphabets together (['aA', ..., 'zZ'])
       Díì         # prepend a copy with each element reversed ('Aa' ...)
          v        # for each pair in the resulting list
           yK      # remove it from the accumulated string (starts as input)
             }}    # end loops
               õQ  # check result for equality to empty string

Haskell , 98 97 85 81 byte

Đây chỉ là một triển khai ngây thơ, liên tục cố gắng hủy các chữ cái phụ thuộc cho đến khi không còn thay đổi nào nữa, và sau đó xác định kết quả từ đó.

Cảm ơn @nimi cho -12 byte và @xnor cho -4 byte khác!

o=fromEnum
r(a:b:l)|abs(o a-o b)==32=l|1>0=a:r(b:l)
r x=x
f=null.until((==)=<<r)r

Hãy thử trực tuyến! hoặc Xác minh tất cả các ví dụ!

Toán học, 102 byte

""==StringDelete[""|##&@@#<>#2&~MapThread~{Join[a=Alphabet[],A=ToUpperCase@a],A~Join~a}]~FixedPoint~#&

Hàm không tên lấy một chuỗi chữ cái làm đầu vào và trả về Truehoặc False.

Trung tâm của việc triển khai là tạo ra một hàm xóa bất kỳ cặp hủy nào, như "Pp"hoặc "gG", từ một chuỗi. Biểu thức {Join[a=Alphabet[],A=ToUpperCase@a],A~Join~a}tạo ra một cặp danh sách các ký tự, danh sách đầu tiên và danh sách {"a","b",...,"Z"}thứ hai {"A","B",...,"z"}. Sau đó #<>#2&~MapThread~tạo ra một danh sách trong đó các phần tử tương ứng của hai danh sách này đã được nối với nhau, nghĩa là , {"aA","bB",...,"Zz"}. Biểu thức vui nhộn ""|##&@@sau đó (thông qua phép thuật của chuỗi đối số ##) tạo ra một danh sách các lựa chọn thay thế "" | "aA" | "bB" | ... | "Zz"; cuối cùng, StringDelete[...]là một hàm xóa bất kỳ sự xuất hiện của bất kỳ sự thay thế nào trong chuỗi.

Bây giờ đủ để áp dụng chức năng đó cho chuỗi đầu vào cho đến khi kết quả không thay đổi, điều này được thực hiện bằng ~FixedPoint~#, và sau đó kiểm tra xem kết quả có phải là chuỗi rỗng không ""==.

JavaScript (ES6), 73 byte

f=(s,t=s.replace(/(.)\1+/gi,s=>s.replace(/(.)(?!\1)./,'')))=>s==t?!s:f(t)

Không giống như .NET, JavaScript không có cách tắt độ nhạy trường hợp ở giữa một trận đấu, vì vậy thay vào đó chúng ta phải tìm tất cả các chuỗi của các chữ cái lặp đi lặp lại một cách không nhạy cảm, và sau đó xóa bất kỳ cặp ký tự liền kề nào, mà đến thời điểm này phải một cặp chữ hoa / thường.

Perl, 28 byte

1 while s/.(??{$&^' '})//;$_

Giải trình:

Perl cho phép một người bao gồm một biểu thức chính quy được tạo động bên trong một biểu thức chính quy tiêu chuẩn.

Các .trận đấu bất cứ điều gì.

Đây (??{là sự khởi đầu của regex được tạo ra.

Các $&biến sẽ chứa toàn bộ phù hợp chuỗi cho đến nay, mà trong trường hợp này chỉ là bất cứ điều gì .phù hợp.

Các ^nhà điều hành thực hiện một trong hai số xor hoặc chuỗi xor, tùy thuộc vào giá trị của toán hạng. Trong trường hợp này, nó sẽ là chuỗi xor.

Đây ' 'chỉ là một chuỗi chứa một khoảng trắng, thuận tiện có giá trị ascii (hoặc unicode!) Là 32. Khi một không gian là xor-ed với một char trong phạm vi az hoặc AZ, nó sẽ thay đổi từ chữ hoa sang chữ thường hoặc chữ vise ngược lại

Sự })kết thúc của regex được tạo ra.

1 while s/whatever// sẽ liên tục tìm kiếm một mẫu và thay thế nó bằng chuỗi rỗng.

$_là biến mặc định. Biến này là những gì perl thực hiện công cụ thú vị và thú vị khi bạn không chỉ định một biến khác. Ở đây tôi đang sử dụng nó để trả về giá trị trung thực hoặc giả, vì chuỗi có độ dài bằng 0 là sai và chuỗi độ dài khác không không bằng "0"là đúng. Tôi cũng giả sử rằng chuỗi đầu vào ban đầu được đặt trong đó.

Hãy thử nó ở đây

Prolog (SWI) , 151 byte

f(S):-S="";string_code(I,S,X),string_code(J,S,Y),J is I+1,32is abs(X-Y),B is J+1,sub_string(S,0,I,_,T),sub_string(S,B,_,0,U),string_concat(T,U,V),f(V).

Mất một thời gian dài để chạy trên các trường hợp sai dài hơn vì quay lui.

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

Bị đánh cắp

f(S):-                       The string S corresponds to a falling picture if:
  S="";                      S is the empty string, or...
  string_code(I,S,X),        X is the character code at some index I
  string_code(J,S,Y),        Y is the character code at some index J
  J is I+1,                  J is I+1
  32 is abs(X-Y),            X and Y differ by 32 (difference between lower/upper case)
  B is J+1,                  ...
  sub_string(S,0,I,_,T),     ...
  sub_string(S,B,_,0,U),     ...
  string_concat(T,U,V),      ...
  f(V).                      The concatenation of the substrings before and after 
                             the letters X and Y corresponds to a falling picture.

MATL , 20 byte

t"[]yd|32=fX<tQh(]n~

Hãy thử trực tuyến! Hoặc xác minh tất cả các trường hợp thử nghiệm (phải mất một thời gian).

Giải trình

t       % Input string implicitly. Duplicate
"       % Do as many times as input size
  []    %   Push empty array
  y     %   Duplicate current string onto the top
  d|    %   Absolute consecutive differences
  32=   %   Convert to true if 32, false otherwise
  fX<   %   Index of first occurrence of true, or empty of all false
  tQ    %   Duplicate, add 1. This gives the next index, or empty
  h     %   Concatenate. Gives the two consecutive indices of letters
        %   to be removed, or empty
  (     %   Assign an empty array to those positions, i.e. delete them
]       % End
n~      % Number of elements, negate

Toán học, 65 byte

(ToCharacterCode@#//.{x___,y_,z_,w___}/;Abs[y-z]==32:>{x,w})=={}&

JavaScript (Node.js) , 47 byte

x=>![...x].reduce(x=>x.replace(/(.)\1/gi,''),x)

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

Python 3 , 71 byte

s=input()
for i in s*len(s):s=s.replace(i+i.swapcase(),'')
print(not s)

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