Viết chương trình lấy một chuỗi dòng đơn mà bạn có thể giả sử sẽ chỉ chứa các ký tự /\_‾. (Đó là dấu gạch chéo về phía trước và phía sau, gạch chân và đường viền . Bạn có thể sử dụng ~thay cho đường viền nếu bạn cần vì đường viền quá mức không thuận tiện ASCII.)

Ví dụ: một đầu vào có thể là:

__/‾‾\/\_/‾

Chương trình của bạn cần xuất ra một giá trị trung thực hoặc sai lệch tùy thuộc vào việc cạnh trái của chuỗi có được "kết nối" hay không, có thể nói, đến cạnh phải của chuỗi thông qua các dòng của các ký tự. Vì vậy, nếu k sâu ít hơn một chút, sẽ có một đường màu đen (mặc dù kinky) suốt từ mép trái sang phải, giống như một chuỗi hoặc dây bện không bị đứt.

Đầu ra cho ví dụ trên sẽ đúng vì các cạnh được kết nối:

Để rõ ràng về các kết nối:

• / kết nối ở phía dưới bên trái và trên cùng bên phải của nó
• \ kết nối trên cùng bên trái và dưới cùng bên phải của nó
• _ kết nối ở dưới cùng bên trái và dưới cùng bên phải của nó
• ‾(hoặc ~) kết nối ở trên cùng bên trái và trên cùng bên phải của nó

Cũng thế:

• Việc các cạnh của chuỗi bắt đầu ở phía trên hay phía dưới không thành vấn đề, chỉ có vấn đề là chúng kết nối theo chiều ngang thông qua toàn bộ chiều dài của chuỗi.

• Bạn có thể giả sử chuỗi đầu vào không trống và tất nhiên chỉ có một dòng.

Dưới đây là một số ví dụ khác theo sau 1 (trung thực) nếu chúng được kết nối hoặc 0 (giả mạo) nếu không:

__/‾‾\/\_/‾
1

_
1

\
1

/
1

‾
1

___
1

\/
1

/\/
1

/\/\
1

‾‾‾
1

\\
0

‾‾
1

_‾
0

‾_
0

\_____/
1

\/\\/\\___
0

\/\__/‾‾\
1

______/\_____
1

‾‾‾‾‾‾\\_____
0

‾‾‾‾‾‾\______
1

_____/‾‾‾‾‾
1

\___/‾‾‾\___/‾‾‾
1

\_/_\_
0

\_/\_
1

/\/\/\/\/\/\/\/\/\/\/\/
1

____________________
1

‾‾‾‾‾‾‾‾‾‾‾‾‾‾‾‾‾‾‾‾‾‾‾
1

‾‾‾‾‾‾‾‾‾‾‾‾‾‾‾‾‾‾‾‾‾‾‾‾/
0

‾‾‾‾‾‾‾‾‾‾‾‾‾‾‾‾‾‾‾‾‾‾‾‾\
1

/\‾/\‾___/\_\/__\/\‾‾
0

Mã ngắn nhất là người chiến thắng.

Thạch , 9 byte

-1 byte nhờ @EriktheOutgolfer

Mong đợi ~thay vì ‾. Trả về hoặc .$0$$1$

O*Ɲ:⁽8ƇḂẠ

Hãy thử trực tuyến! , Bộ kiểm tra Truthy , bộ kiểm tra Falsy

Sử dụng công thức này (nhưng khác với phiên bản 11 byte bên dưới):

Quá trình chuyển đổi là hợp lệ nếu là số lẻ hoặc không hợp lệ nếu là số chẵn.$n$$n$

Đã bình luận

O*Ɲ:⁽8ƇḂẠ     - main link, taking a string          e.g. "\_/"
O             - get ASCII codes                     -->  [92, 95, 47]
 *Ɲ           - exponentiation on all pairs         -->  [92**95, 95**47]
   :⁽8Ƈ       - integer division by 15145           -->  [23964828…8421, 59257069…0485]
       Ḃ      - least significant bit (i.e. parity) -->  [1, 1]
        Ạ     - all values equal to 1?              -->  1

Thạch ,  14 12  11 byte

Hỗ trợ (và mong đợi) ‾ký tự trong chuỗi đầu vào. Trả về hoặc .$0$$1$

O*Ɲ%276%7ỊẠ

Hãy thử trực tuyến! , Bộ kiểm tra Truthy , bộ kiểm tra Falsy

Làm sao?

Cho hai ký tự liên tiếp của mã ASCII và , chúng tôi muốn một hàm kiểm tra xem chúng có tạo thành một chuyển tiếp hợp lệ hay không.$x$$y$

Chúng ta cần một hoạt động không giao hoán, vì kết quả có thể thay đổi khi các ký tự được đảo ngược. Ví dụ, _/là hợp lệ nhưng /_không.

Sử dụng lũy ​​thừa, công thức ¹ có thể là:

Quá trình chuyển đổi hợp lệ nếu hoặc không hợp lệ nếu .$n\le1$$n>1$

 chars |    x |    y | (x**y)%276 | %7 | valid
-------+------+------+------------+----+-------
   __  |   95 |   95 |      71    |  1 |  yes
   _/  |   95 |   47 |     119    |  0 |  yes
   _‾  |   95 | 8254 |     265    |  6 |   no
   _\  |   95 |   92 |     265    |  6 |   no
   /_  |   47 |   95 |      47    |  5 |   no
   //  |   47 |   47 |      47    |  5 |   no
   /‾  |   47 | 8254 |       1    |  1 |  yes
   /\  |   47 |   92 |       1    |  1 |  yes
   ‾_  | 8254 |   95 |     136    |  3 |   no
   ‾/  | 8254 |   47 |      88    |  4 |   no
   ‾‾  | 8254 | 8254 |     196    |  0 |  yes
   ‾\  | 8254 |   92 |     196    |  0 |  yes
   \_  |   92 |   95 |      92    |  1 |  yes
   \/  |   92 |   47 |      92    |  1 |  yes
   \‾  |   92 | 8254 |     184    |  2 |   no
   \\  |   92 |   92 |     184    |  2 |   no

_{1. Tìm thấy với tìm kiếm mạnh mẽ trong Node.js (sử dụng BigInts)}

Đã bình luận

O*Ɲ%276%7ỊẠ   - main link, taking a string          e.g. "\_/"
O             - get ASCII codes                     -->  [92, 95, 47]
 *Ɲ           - exponentiation on all pairs         -->  [92**95, 95**47]
   %276       - modulo 276                          -->  [92, 119]
       %7     - modulo 7                            -->  [1, 0]
         Ị    - ≤1?                                 -->  [1, 1]
          Ạ   - all values equal to 1?              -->  1

Ruby -n , 30 byte

p !/[_\\][\\‾]|[\/‾][_\/]/

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

Giảm tất cả các chuỗi phá vỡ chuỗi thành hai trường hợp bằng cách sử dụng các lớp ký tự Regex.

JavaScript (ES6), 45 byte

Cách ngây thơ.

s=>!/\/\/|\\\\|_~|~_|~\/|_\\|\/_|\\~/.test(s)

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

R , 89 87 81 78 byte

-2 byte nhờ @Giuseppe

-6 byte nhờ @Nick Kennedy

-3 byte thay thế 1:length(y)bằng seq(a=y), aviết tắt củaalong.with

y=utf8ToInt(scan(,''));all(!diff(cumprod(c(1,y>93)*2-1)[seq(a=y)]*(y%%2*2-1)))

sử dụng \ / _ ~. Điều này có lẽ không ngắn như một giải pháp dựa trên regex, nhưng tôi thích làm một cái gì đó hơi khác với mọi người khác.

utf8ToInt('\\/_~')
# [1]  92  47  95 126

Các ký tự nhỏ hơn 93 chuyển trạng thái từ lên xuống (hoặc ngược lại), và như vậy hành xử như -1trong khi những người khác không làm gì và hành xử như 1, cumprod theo dõi trạng thái đối với sự khởi đầu. Các số chẵn ở trạng thái ngoại tuyến (đại diện cho -1), các số lẻ ở trạng thái xuống ( 1). Nếu chuỗi không bị phá vỡ, trạng thái được theo dõi nhân với vị trí lên / xuống, không nên thay đổi, nó sẽ luôn là điều kiện bắt đầu ( -1, hoặc 1)

Dùng thử trực tuyến

Python , 46 byte

f=lambda s:s==''or s[:2]in"__/~~\/\_"*f(s[1:])

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

Xác nhận rằng mỗi cặp ký tự liền kề kết nối bằng cách kiểm tra xem chúng có xuất hiện liên tiếp không __/~~\/\_. Chuỗi này có thể được xem dưới dạng De_Bruijn_ resultence trên bộ ba vị trí cao / thấp.$2^3=8$

Tôi đã thử các phương pháp ít nhàm chán khác để kiểm tra các cặp ký tự, nhưng tất cả chúng đều dài hơn mà mã hóa tất cả các cặp hợp pháp như thế này.

C (gcc) , 93 byte

w,o,r;k(char*_){for(r=0;w=*_,o=*++_;)r|=w-126&&w>47?w-95&&w-92?0:o>47&&o-95:o-92&&o<126;_=r;}

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

Chip -z , 17 byte

FZ!C~aS
A}^]--^~t

Hãy thử trực tuyến! (TIO bao gồm -vđể giúp dễ hiểu đầu ra hơn.)

Mong đợi _/~\bộ. Trả về một trong hai \x00(giả) hoặc \x01(trung thực).

Chiến lược cho câu trả lời của tôi sử dụng thông tin sau:

Symbol  Binary
   _    0101 1111
   /    0010 1111
   ~    0111 1110
   \    0101 1100
          ^   ^ ^
        HGFE DCBA

A: Vị trí bit này xảy ra 1khi bên trái của biểu tượng thấp và 0khi cao
F: Vị trí bit này xảy ra 0khi bên phải của biểu tượng thấp và 1khi cao
C: Vị trí bit này xảy ra luôn luôn là1

Sử dụng thông tin này, tôi chỉ cần kiểm tra xem Fmỗi ký tự có khớp với ký tự not Atiếp theo không. Một xorcổng là một cách thuận tiện để thực hiện điều này.

Đoạn mã sau thực hiện điều này, nhưng cung cấp đầu ra cho mỗi cặp (cộng thêm 1vào lúc bắt đầu) (7 byte):

FZ!
A}a

Chúng tôi muốn tạm dừng ở thất bại đầu tiên, và cũng in xem chúng tôi đã tạm dừng trong chuỗi hay tại bộ kết thúc null (chúng tôi cũng thêm -zđể cung cấp cho chúng tôi một bộ kết thúc null). Chúng tôi có thể sử dụng not Cđể biểu thị nơi chúng tôi dừng lại và điều đó mang lại cho chúng tôi chương trình này (13 byte):

FZ!C~a
A}^]~t

Nhưng chúng ta vẫn có "số 0 đứng đầu" (ví dụ: \_/\cho 00 00 00 00 01), vì vậy điều này được chuyển thành câu trả lời ở trên cùng.

05AB1E , 29 14 9 byte

ÇümŽb‘÷ÈP

Câu trả lời Jelly của @Arnauld , vì vậy hãy đảm bảo nâng cấp anh ấy!

Đầu vào với ‾.

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

Câu trả lời gốc 29 byte :

„_~SD2×s:Çü-т+•6_üê{↕ƵΔвåO_

Đầu vào với ~thay vì ‾.

Nó nghe có vẻ ngắn hơn trong đầu tôi .. Sẽ cố gắng đánh gôn từ đây.

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

Giải thích: "

„_~S                          # Push the characters ["_","~"]
    D2×                       # Duplicate it, and increase each to size 2: ["__","~~"]
       s:                     # Swap and replace all "__" with "_" and all "~~" with "~"
                              #  in the (implicit) input-string
         Ç                    # Convert the remaining characters to unicode values
          ü-                  # Calculate the difference between each pair
            т+                # Add 100 to each
              •6_üê{↕       # Push compressed integer 1781179816800959
                       ƵΔ     # Push compressed integer 180
                         в    # Convert the larger integer to Base-180 as list: 
                              #  [52,66,69,100,103,131,179]
                          å   # Check for each if it's in the difference-list
                              # (1 if present; 0 if not)
                           O  # Sum the truthy values
                            _ # Check if this sum is exactly 0 (1 if 0; 0 otherwise)
                              # (and output this result implicitly)

Xem mẹo 05AB1E này của tôi (phần Làm thế nào để kết hợp các số nguyên lớn? Và Cách nén danh sách số nguyên? ) Để hiểu tại sao •6_üê{↕là 1781179816800959, ƵΔđang 180và •6_üê{↕ƵΔвlà [52,66,69,100,103,131,179].

Giải thích thêm:

Có 16 ( ) cặp nhân vật có thể chúng tôi phải xác minh. Nếu chúng ta chuyển đổi từng ký tự thành giá trị unicode của nó và tính toán sự khác biệt, chúng ta sẽ nhận được những khác biệt này . Vì danh sách số nguyên nén trong 05AB1E chỉ phải có số nguyên dương, nên tôi thêm 100 vào mỗi số nguyên . Các cặp không hợp lệ và các giá trị tương ứng của chúng là : ; , , , , , , , Đó là lý do tôi có danh sách số nguyên nén trong mã của tôi có chứa những giá trị này. Vì và sẽ chỉ thích và dẫn đến (hoặc sau khi tôi thêm 100), trước tiên tôi xóa mọi bản sao liền kề của và$2^4$["/_", 52]["\~", 66]["_~", 69]["//", 100]["\\", 100]["_\", 103]["~_", 131]["~/", 179]
__~~//\\0100~_ trong chuỗi đầu vào, trước khi tính toán và xác minh sự khác biệt của cặp.

Python 3 , 79 70 63 byte

Đã lưu 16 byte nhờ Arnauld và Jo King, cảm ơn!

p=lambda s:len(s)<2or((ord(s[-2])%13>5)^ord(s[-1])%2)&p(s[:-1])

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

Python 3 , 67 60 byte với ~ thay vì

p=lambda s:len(s)<2or(~(ord(s[-2])//7^ord(s[-1]))&p(s[:-1]))

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

Python 3, 126 byte

lambda s,d={'‾':'\‾','_':'/_','/':'\‾','\\':'/_'}:len(s)<2or all([s[i+1] in d[s[i]]for i in range(len(s)-1)if s[i]in d])

Haskell , 70 byte

Biến thể này sử dụng ~thay vì overlines. Phải mất tất cả tám cặp hợp lệ và kiểm tra xem chuỗi chỉ chứa những cặp đó:

f(a:b:x)=[a,b]`elem`words"__ _/ /~ ~~ ~\\ \\_ \\/ /\\"&&f(b:x)
f _=1>0

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

Ung dung:

validate :: String -> Bool
validate xs = all valid $ zip xs (tail xs)
  where
    valid (a,b) = [a,b] `elem` starts
    starts      = words "__ _/ /~ ~~ ~\\ \\_ \\/ /\\"

Perl 6 , 32 byte

{!/< \\\ \~ ~/ // _~ ~_ _\ /_>/}

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

Một giải pháp regex chỉ đơn giản là kiểm tra xem chuỗi không chứa chuỗi không hợp lệ.

Giải trình:

{                              }   # Anonymous code block
  /<                         >/    # Find the longest sequence from
     \\\                           # \\
         \~                        # \‾
            ~/                     # ‾/
               //                  # //
                  _~               # _‾
                     ~_            # ‾_
                        _\         # _\
                           /_      # /_
 !                                 # And logically negate the match

R , 43 ký tự, 47 byte

Đó là cùng một biểu thức mà các câu trả lời khác sử dụng, nhưng được điều chỉnh cho R.

!grepl('[/‾][/_]|[\\\\_][\\\\‾]',scan(,''))

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

Và xkcd bắt buộc .

Forth (gforth) , 100 98 byte

: x = swap '~ = + ;
: f 1 tuck ?do over i + >r i 1- c@ r> c@ dup 92 x swap dup 47 x <> + loop 0> ;

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

Giải trình

Đi qua chuỗi và xác định xem mỗi ký tự bắt đầu trên cùng một vị trí (trên cùng hoặc dưới cùng) như trước khi kết thúc. Trừ 1 từ một quầy nếu chúng không khớp. Cuối cùng, nếu bộ đếm đã thay đổi, thì chuỗi không phải là một chuỗi.

Vị trí kết thúc cao nếu char là /(47) hoặc ~(126). Nếu không thì nó thấp

Vị trí bắt đầu cao nếu char là \(92) hoặc ~(126). Nếu không thì nó thấp

Giải thích mã

\ x is basically just extracting some common logic out into a function to save a few bytes
\ it checks if the first number is equal to the second number
\ or the third number is equal to 126   
: x                \ start a new word definition
  = swap           \ check if the first two numbers are equal then swap with the third
  '~ =             \ checks if the third number is equal to 126
  +                \ adds results together (cheaper version of or)
;                  \ end the word definition

: f                \ start a new word definition
  1 tuck           \ set up parameters for a loop (and create a bool/counter)
  ?do              \ start counted loop from 1 to string-length -1, 
                   \ ?do will skip if loop start and end are the same
    over i +       \ copy the string address and add the loop index to get the char address
    >r i           \ place char address on return stack and place a copy back on the stack
    1- c@          \ subtract 1 to get previous char address and grab ascii from memory
    r> c@          \ move char address back from return stack, then grab from memory
    dup 92 x       \ get the "output" position of the prev character
    swap dup 47 x  \ get the input position of the current character
    <> +           \ check if they aren't equal and add the result to the counter
                   \ the counter won't change if they're equal
  loop             \ end the loop
  0>               \ check if counter is less than 1 (any of the "links" was not valid)
;                  \ end word definition

Python 3 , 80 78 byte

Tôi thực sự không chơi nhiều golf mã trăn nhưng tôi nghĩ tôi có thể thử nó

• -2 byte: nhận ra không (any ()) giống với tất cả (không ()) và có thể di chuyển không vào chuỗi r

def f(x):*l,=map(r'_/\~'.find,x);return 1-any((i^j//2)%2for i,j in zip(l,l[1:]))

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

Python 3.8 (tiền phát hành) , 71 byte

Tôi muốn thử :=chuyển nhượng biểu thức mới

lambda x:all((i^j//2)%2for i,j in zip(l:=[*map(r'\~_/'.find,x)],l[1:]))

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

Thạch ,  13 12  11 byte

O*Ɲ%⁽wḃ%5ỊẠ

Liên kết đơn âm chấp nhận danh sách các ký tự, sử dụng ~thay cho ‾tùy chọn.

Hãy thử trực tuyến! Hoặc xem một bộ thử nghiệm (... nơi tôi đã sắp xếp lại để đặt 8 con chim ưng ở cuối)

Công thức này được tìm thấy bằng cách nghịch xung quanh bằng tay: p (như những người dưới đây)

Đối với điều này, tôi cũng có tất cả 16 cặp thứ tự nhân vật được coi là lũy thừa và tìm kiếm một modulo lớn sẽ phù hợp với ba byte theo sau là một modulo một byte (1,2,3,4,5,6,7,8 , 9,10,16,256) đã phân vùng 16 sao cho tất cả các kết quả có thể chấp nhận là 1 hoặc 0 ("không đáng kể") vì tôi biết Ịlà ngắn hơn <5, trong giải pháp trước đây của tôi, tìm kiếm tất cả các kết quả chấp nhận được nhỏ hơn tất cả những người không thể chấp nhận.

O*Ɲ%⁽wḃ%5ỊẠ - Link: list of characters
O           - ordinals
  Ɲ         - for each pair of neighbours:
 *          -   exponentiate
    ⁽wḃ     - 30982
   %        - modulo (vectorises)
        5   - five
       %    - modulo (vectorises)
         Ị  - insignificant? (abs(x) <=1) (vectorises)
          Ạ - all truthy?

Các nhân vật lân cận có thể và đánh giá nội bộ của họ:

(Ɲ)         (O)            (*%⁽wḃ)        (%5)      (Ị)
pair   a,b=ordinals   c=exp(a,b)%30982   d=c%5   abs(d)<=1
__       95,  95         28471             1         1
_/       95,  47         29591             1         1
/~       47, 126         19335             0         1
/\       47,  92          9755             0         1
~~      126, 126         28000             0         1
~\      126,  92         26740             0         1
\_       92,  95          9220             0         1
\/       92,  47         13280             0         1
~_      126,  95          3024             4         0
~/      126,  47         12698             3         0
\~       92, 126         27084             4         0
\\       92,  92         17088             3         0
_~       95, 126         28169             4         0
_\       95,  92          4993             3         0
/_       47,  95         22767             2         0
//       47,  47          7857             2         0

Trước @ 12:

O*Ɲ%⁽?K%⁴<8Ạ

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

Trước @ 13:

O%7ḅ6$Ɲ%⁵%8ỊẠ

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

perl 5, 26 25 byte

sử dụng ;như dấu phân cách, dấu phân cách cuối có thể được loại bỏ

$_=!m;[/~][_/]|[\\_][~\\]

TIO

26 byte

Excel, 150 byte

=SUBSTITUTE(SUBSTITUTE(SUBSTITUTE(SUBSTITUTE(SUBSTITUTE(SUBSTITUTE(SUBSTITUTE(SUBSTITUTE(A1,"_\",),"_‾",),"‾_",),"‾/",),"/_",),"//",),"\‾",),"\\",)=A1

Xóa mọi cặp không hợp lệ, sau đó trả về truenếu kết quả này trong chuỗi gốc.

Haskell, 42 byte

g=tail>>=zip
h=all(`elem`g"__/~~\\/\\_").g

giải pháp này sử dụng ~và hàm để gọi là h (nghĩa là h stringđưa ra câu trả lời)

Giải pháp sử dụng hàm g đưa ra danh sách, trả về tất cả các bộ giá trị liền kề trong danh sách.

Sau đó, chúng tôi sử dụng g để tạo danh sách các hàng xóm được phép (trong g"__/~~\\/\\_") và cả danh sách tất cả các cặp lân cận trong danh sách đầu vào. Sau đó, chúng tôi kiểm tra xem mỗi cặp lân cận là một cặp được phép.

C (gcc) , 41 36 byte

f(char*_){_=!_[1]||*_/32+*++_&f(_);}

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

-5 loại bỏ &1bắt đầu từ một ý tưởng từ Peter Cordes ; thay đổi toán tử (ưu tiên) để loại bỏ dấu ngoặc

Công dụng ~. Kiểm tra bit thứ nhất và thứ sáu của biểu diễn nhị phân của hai ký tự đầu tiên:

_ 1011111
\ 1011100
/  101111
~ 1111110
   ^    ^

và đi qua chuỗi đệ quy.

(*_ / 32) & 1chỉ đúng với các ký tự kết thúc cao, trong khi *_ & 1chỉ đúng với các ký tự bắt đầu thấp. (x&1) ^ (y&1) == (x+y)&1. XOR là add-without-carry, và carry không làm phiền bit thấp nhất. Giá trị 1xuất phát từ f(_)giá trị trả về, nếu phần còn lại của chuỗi là chuỗi.

Bash, 30 byte

grep -E '//|\\\\|_~|~_|~/|_\\|/_|\\~'

Đầu vào là STDIN. Mã thoát là 1 nếu hợp lệ, 0 nếu không hợp lệ.

SNOBOL4 (CSNOBOL4) , 58 byte

	INPUT '/_' | '_\' | '\\' | '//' | '~/' | '\~' @OUTPUT
END

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

Đầu ra không có gì cho sự thật và một số nguyên dương (cho biết vị trí của lần ngắt đầu tiên trong chuỗi) cho sai.

Than , 32 18 byte

⌊⭆θ∨¬κ⁼№_/ι№\_§θ⊖κ

Hãy thử trực tuyến! Liên kết là phiên bản dài dòng của mã. Giải trình:

  θ                 Input string
 ⭆                  Map over characters and convert to string
     κ              Current index
    ¬               Logical Not (i.e. is zero)
   ∨                Logical Or
          ι         Current character
       №            Count (i.e. contained in)
        _/          Literal _/ (i.e. begins at bottom)
      ⁼             Equals
               θ    Input string
              §     Indexed by
                 κ  Current index
                ⊖   Decremented (i.e. previous character)
           №        Count (i.e. contained in)
            \_      Literal \_ (i.e. ended at bottom)
⌊                   Minimum (i.e. if all true)
                    Implicitly print

mã máy x86, 13 byte.

(Hoặc 11 byte mà không xử lý các chuỗi ký tự đơn có chuỗi tầm thường.)

Sử dụng kiểm tra vị trí bit từ câu trả lời C của @ attinat

Mã máy tương tự hoạt động ở các chế độ 16, 32 và 64 bit. Nguồn là NASM cho chế độ 64 bit.

nasm -felf64 -l/dev/stdout  listing
    17   addr                  global string_connected
    18           code          string_connected:
    19           bytes         ;;; input: char *RSI, transitions to check=RCX
    20                         ;;; output: AL=non-zero => connected.  AL=zero disconnected
    21                         .loop:                      ; do {
    22 00000000 AC                 lodsb                   ;   al = *p++
    23 00000001 E309               jrcxz  .early_exit        ; transitions=0 special case.  Checking before the loop would require extra code to set AL.
    24 00000003 C0E805             shr    al, 5
    25 00000006 3206               xor    al, [rsi]          ; compare with next char
    26 00000008 2401               and    al, 1
    27 0000000A E0F4               loopne .loop            ; }while(--rcx && al&1);
    28                         .early_exit:
    29 0000000C C3                 ret

Có thể gọi từ C như unsigned char string_connected(int dummy_rdi, const char *s, int dummy_rdx, size_t transitions);với quy ước gọi System V x86-64. Không phải boolvì trường hợp chuyển đổi = 0 trả về mã ASCII chứ không phải 1.

RCX = len = strlen(s) - 1. tức là số lượng ký tự-ranh giới = chuyển tiếp để kiểm tra trong chuỗi độ dài rõ ràng.

Đối với transitions > 0, trả về 0 (không khớp) hoặc 1 (được kết nối) và đặt ZF tương ứng. Đối với transitions == 0, trả về byte đơn của chuỗi (không khác không và do đó cũng đúng). Nếu không phải trong trường hợp đặc biệt đó, chúng tôi có thể loại bỏ JRCXZ xuất cảnh sớm. Nó chỉ ở trong vòng lặp vì AL khác không.

Logic vị trí bit dựa trên quan sát rằng bit 0 của mã ASCII cho bạn biết chiều cao bắt đầu và bit 5 cho bạn biết chiều cao kết thúc.

;;;  _ 1011111
;;;  \ 1011100
;;;  /  101111
;;;  ~ 1111110
;;;     ^    ^

    ; end condition (c>>5) & 1 =>  0 = low
    ; start cond: c&1 => 0 = high
    ; (prev>>5)&1 == curr&1  means we have a discontinuity
    ; ((prev>>5) ^ curr) & 1 == 0  means we have a discontinuity

Kiểm tra khai thác (được sửa đổi từ liên kết TIO của attinat, hãy cẩn thận với UB điểm điểm C trong chức năng tham chiếu C đó). Hãy thử trực tuyến! . Chức năng này là chính xác cho tất cả 30 trường hợp. (Bao gồm các trường hợp ký tự đơn trong đó giá trị trả về không khớp: cả hai đều trung thực với các giá trị khác không khác nhau trong trường hợp đó.)

Excel, 79 byte

Di động A1là đầu vào

=1---SUMPRODUCT(--ISNUMBER(FIND({"//","/_","\~","\\","~/","~_","_\","_~"},A1)))

Phi tiêu , 94 byte

f(s)=>!(r'//,\\,~/,_\,~_,_~,/_,\~'.split(',').map((t)=>s.contains(t)).fold(false,(p,e)=>p|e));

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

C ++, 132 110 byte

-22 byte chỉ nhờ ASCII

int f(char*s){int t[128];t[95]=0;t[47]=1;t[92]=2;t[126]=3;for(;*++s;)if(t[s[-1]]%2^t[*s]/2)return 0;return 1;}

Sử dụng một bitmask để biết bắt đầu và kết thúc lên hay xuống

Võng mạc , 26 byte

C`[_\\][\\~]|[~\/][_\/]
^0

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

Sử dụng ~hơn là ‾, bởi vì điều đó làm cho nó dễ dàng hơn để gõ.

Regex, 34 byte

Tôi không thể tìm thấy các quy tắc sử dụng Regex làm ngôn ngữ. Xin vui lòng cho tôi biết nếu tôi cần điều chỉnh này.

^(‾+|(‾*\\)?(_*\/‾*\\)*_*(\/‾*)?)$

Dùng thử tại đây: https://regex101.com/r/s9kyPm/1/tests

APL + THẮNG, 58 byte

m ← 2 2⊤ '_ / \ ~' ←s ←, ⎕⋄ (1 + ⍴s) = + / ((↑ m [0;]), m [1;]) = m [0;], 1 ↑ m [1;]

Lời nhắc cho đầu vào của chuỗi, chỉ mục gốc 0 và sử dụng ~ cho ký tự phía trên

Hãy thử trực tuyến! Lịch sự của Dyalog Classic