/\_‾จงเขียนโปรแกรมที่ใช้สตริงบรรทัดเดียวที่คุณสามารถสันนิษฐานได้ว่าจะมีตัวอักษรที่ (นั่นคือไปข้างหน้าและข้างหลังเฉือน, ขีดเส้นใต้และoverlineคุณสามารถใช้~แทน overline ถ้าคุณต้องการเนื่องจาก overline ไม่สะดวก ASCII)

ตัวอย่างหนึ่งอินพุตที่เป็นไปได้คือ:

__/‾‾\/\_/‾

โปรแกรมของคุณจำเป็นต้องส่งออกค่าจริงหรือเท็จขึ้นอยู่กับว่าขอบด้านซ้ายของสตริงคือ "เชื่อมต่อ" ดังนั้นเพื่อพูดถึงขอบด้านขวาของสตริงผ่านบรรทัดของอักขระ ดังนั้นหากการปรับระยะสั้นลงเล็กน้อยจะมีเส้นสีดำทึบ (แม้ว่าจะเป็นเส้นหยัก) ตลอดทางจากขอบด้านซ้ายไปทางขวาเช่นสายอักขระหรือเส้นใหญ่ที่ไม่ขาด

เอาต์พุตสำหรับตัวอย่างด้านบนจะเป็นจริงเพราะขอบเชื่อมต่อ:

เพื่อให้ชัดเจนในการเชื่อมต่อ:

• / เชื่อมต่อที่ด้านล่างซ้ายและขวาบน
• \ เชื่อมต่อที่มุมบนซ้ายและขวาล่าง
• _ เชื่อมต่อที่ด้านล่างซ้ายและขวาล่าง
• ‾(หรือ~) เชื่อมต่อที่มุมบนซ้ายและขวาบน

นอกจากนี้:

• ไม่สำคัญว่าขอบของสตริงเริ่มต้นที่ด้านบนหรือด้านล่างมันสำคัญเพียงว่ามันจะเชื่อมต่อในแนวนอนผ่านความยาวทั้งหมดของสตริง

• คุณสามารถสันนิษฐานได้ว่าสตริงอินพุตนั้นไม่ว่างเปล่าและแน่นอนแค่หนึ่งบรรทัด

นี่คือตัวอย่างเพิ่มเติมตามด้วย 1 (ความจริง) หากพวกเขาเชื่อมต่อหรือ 0 (เท็จ) หากไม่:

__/‾‾\/\_/‾
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

รหัสที่สั้นที่สุดคือผู้ชนะ

เยลลี่ขนาด 9 ไบต์

-1 ไบต์ขอบคุณ @EriktheOutgolfer

คาดว่าแทน~ ‾ผลตอบแทน$0$หรือ1$1$

O*Ɲ:⁽8ƇḂẠ

ลองออนไลน์! , ชุดทดสอบ Truthy , ชุดทดสอบ Falsy

ใช้สูตรนี้ (แต่อย่างอื่นคล้ายกับรุ่น 11 ไบต์ด้านล่าง):

การเปลี่ยนแปลงที่ถูกต้องถ้า$n$เป็นเลขคี่หรือไม่ถูกต้องถ้า$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

เจลลี่ ,  14 12  11 ไบต์

รองรับ‾อักขระ(และคาดหวัง) ในสตริงอินพุต ผลตอบแทน$0$หรือ1$1$

O*Ɲ%276%7ỊẠ

ลองออนไลน์! , ชุดทดสอบ Truthy , ชุดทดสอบ Falsy

อย่างไร?

ด้วยอักขระ ASCII สองตัวติดต่อกัน$x$และ$y$เราต้องการฟังก์ชันที่ตรวจสอบว่ามีการเปลี่ยนแปลงที่ถูกต้องหรือไม่

เราต้องการการดำเนินการที่ไม่เปลี่ยนแปลงเนื่องจากผลลัพธ์อาจเปลี่ยนแปลงเมื่อมีการย้อนกลับอักขระ ตัวอย่างเช่น_/ถูกต้อง แต่/_ไม่ใช่

ใช้การยกกำลังสูตรที่เป็นไปได้¹คือ:

การเปลี่ยนแปลงที่ถูกต้องถ้า$n\le1$หรือไม่ถูกต้องถ้า$n>1$ 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. พบกับการค้นหาแบบ brute-force ใน Node.js (ใช้ BigInts)}

แสดงความคิดเห็น

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 ไบต์

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

ลองออนไลน์!

ลดลำดับการแบ่งสตริงทั้งหมดเป็นสองกรณีโดยใช้คลาสอักขระ Regex

JavaScript (ES6), 45 ไบต์

วิธีไร้เดียงสา

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

ลองออนไลน์!

R , 89 87 81 78 ไบต์

-2 ไบต์ขอบคุณ @Giuseppe

-6 ไบต์ขอบคุณ @Nick Kennedy

-3 ไบต์แทนที่1:length(y)ด้วยseq(a=y)ซึ่งaสั้นสำหรับalong.with

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

\ / _ ~การใช้งาน นี่อาจไม่สั้นเท่ากับโซลูชันจาก regex แต่ฉันเพ้อฝันว่าจะทำสิ่งที่แตกต่างจากคนอื่นเล็กน้อย

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

อักขระที่น้อยกว่า 93 เปลี่ยนสถานะจากบนลงล่าง (หรือในทางกลับกัน) และเป็นเช่นนั้นใน-1ขณะที่คนอื่นไม่ทำอะไรและทำตัวเหมือน1cumprod ติดตามสถานะด้วยความเคารพต่อการเริ่มต้น ตัวเลขคู่อยู่ในสถานะ upstate (แสดงด้วย-1), เลขคี่อยู่ในสถานะ down ( 1) หากสตริงไม่ถูกแบ่งสถานะที่ถูกติดตามคูณด้วยตำแหน่งขึ้น / ลงไม่ควรเปลี่ยนมันจะเป็นเงื่อนไขเริ่มต้นเสมอ ( -1หรือ1)

ลองออนไลน์

Pythonขนาด 46 ไบต์

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

ลองออนไลน์!

__/~~\/\_$2^3=8$

ฉันลองวิธี humdrum อื่น ๆ ที่น้อยกว่าเพื่อตรวจสอบคู่ของตัวละคร แต่พวกเขาทั้งหมดนั้นนานกว่านั้นที่จะเข้ารหัสรหัสคู่ที่ถูกกฎหมายทั้งหมดเช่นนี้

C (gcc) , 93 ไบต์

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;}

ลองออนไลน์!

ชิป -z 17 ไบต์

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

ลองออนไลน์! (TIO รวมถึง-vเพื่อให้ง่ายต่อการเข้าใจผลลัพธ์)

คาดว่า_/~\ชุด ส่งคืน\x00(เท็จ) หรือ\x01(จริง)

กลยุทธ์สำหรับคำตอบของฉันใช้ข้อมูลต่อไปนี้:

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

A: ตำแหน่งบิตนี้เกิดขึ้น1เมื่อด้านซ้ายของสัญลักษณ์ต่ำและ0เมื่อสูง
F: ตำแหน่งบิตนี้จะเกิดขึ้น0เมื่อด้านขวาของสัญลักษณ์ต่ำและ1เมื่อสูง
C: ตำแหน่งบิตนี้เกิดขึ้น อยู่เสมอ1

เมื่อใช้ข้อมูลนี้ฉันต้องตรวจสอบว่าFอักขระแต่ละตัวตรงกับตัวnot Aถัดไป xorประตูเป็นวิธีที่สะดวกในการบรรลุเป้าหมายนี้

รหัสต่อไปนี้ทำสิ่งนี้ แต่ให้ผลลัพธ์สำหรับการจับคู่แต่ละครั้ง (บวกส่วนเพิ่ม1เมื่อเริ่มต้น) (7 ไบต์):

FZ!
A}a

เราต้องการหยุดที่ความล้มเหลวครั้งแรกและพิมพ์ว่าเราได้หยุดภายในสตริงหรือที่ null terminator (เรายังเพิ่ม-zเพื่อให้เราเป็น null terminator) เราสามารถใช้not Cเพื่อบ่งบอกถึงที่ที่เราหยุดและนั่นทำให้โปรแกรมนี้ (13 ไบต์):

FZ!C~a
A}^]~t

แต่เรายังคงมี "เลขศูนย์นำหน้า" (เช่น\_/\ให้00 00 00 00 01) ดังนั้นนี่จึงเปลี่ยนเป็นคำตอบที่ระบุไว้ด้านบน

05AB1E , 29 14 9 ไบต์

ÇümŽb‘÷ÈP

พอร์ตของ@Arnauld 's Jelly ตอบดังนั้นอย่าลืมโหวตให้เขาด้วย!

‾การป้อนข้อมูลด้วย

ลองมันออนไลน์หรือตรวจสอบกรณีทดสอบทั้งหมด

คำตอบเดิม 29 ไบต์ :

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

การป้อนข้อมูลด้วยแทน~‾

ฟังดูสั้นลงในหัวของฉัน .. จะลองตีมันจากที่นี่

ลองมันออนไลน์หรือตรวจสอบกรณีทดสอบทั้งหมด

คำอธิบาย: "

„_~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)

ดู 05AB1E นี้เคล็ดลับของฉัน (ส่วนวิธีการ comrpess จำนวนเต็มขนาดใหญ่?และวิธีการบีบอัดรายการจำนวนเต็ม? )จะเข้าใจว่าทำไม•6_üê{↕เป็น1781179816800959, ƵΔเป็น180และเป็น•6_üê{↕ƵΔв[52,66,69,100,103,131,179]

คำอธิบายเพิ่มเติม:

$2^4$["/_", 52]["\~", 66]["_~", 69]["//", 100]["\\", 100]["_\", 103]["~_", 131]["~/", 179]
__~~//\\0100~และ_ ในอินพุทสตริงก่อนคำนวณและตรวจสอบความแตกต่างของคู่

Python 3 , 79 70 63 ไบต์

บันทึกแล้ว 16 ไบต์ขอบคุณ Arnauld และ Jo King ขอบคุณ!

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

ลองออนไลน์!

Python 3 , 67 60 ไบต์ด้วย ~ แทนที่จะเป็น ‾

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

ลองออนไลน์!

Python 3, 126 ไบต์

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 ไบต์

ตัวแปรนี้ใช้~แทนการขีดเส้นทับ มันต้องใช้คู่ที่ถูกต้องทั้งแปดคู่และตรวจสอบว่าสตริงมีเพียงรายการนั้น

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

ลองออนไลน์!

Ungolfed:

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

Perl 6 , 32 ไบต์

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

ลองออนไลน์!

โซลูชัน regex ที่เพียงตรวจสอบว่าสตริงไม่มีลำดับที่ไม่ถูกต้อง

คำอธิบาย:

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

R , 43 ตัวอักษร, 47 ไบต์

มันเป็น regex เดียวกันกับคำตอบอื่น ๆ ที่ใช้ แต่ปรับให้เหมาะกับ R

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

ลองออนไลน์!

และบังคับxkcd

ออกมา (gforth) , 100 98 ไบต์

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

ลองออนไลน์!

คำอธิบาย

ผ่านสตริงและพิจารณาว่าอักขระแต่ละตัวเริ่มต้นที่ตำแหน่งเดียวกัน (ด้านบนหรือด้านล่าง) เหมือนกับอักขระก่อนจบ ลบ 1 จากเคาน์เตอร์ถ้าไม่ตรงกัน ในตอนท้ายหากตัวนับเปลี่ยนไปสตริงจะไม่เป็นสตริง

ตำแหน่งสุดท้ายจะสูงถ้า char คือ/(47) หรือ~(126) มิฉะนั้นมันจะต่ำ

ตำแหน่งเริ่มต้นนั้นสูงถ้า char คือ\(92) หรือ~(126) มิฉะนั้นมันจะต่ำ

รหัสคำอธิบาย

\ 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 ไบต์

ฉันไม่ได้เล่นกอล์ฟงูหลามมากนัก แต่ฉันคิดว่าฉันสามารถลองได้

• -2 ไบต์: รับรู้ว่าไม่ (ใด ๆ ()) เหมือนกับทั้งหมด (ไม่ใช่ ()) และสามารถย้ายไม่ใช่ลงในสตริง r

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

ลองออนไลน์!

Python 3.8 (เผยแพร่ล่วงหน้า) , 71 ไบต์

ฉันต้องการทดลองใช้:=งานการแสดงออกใหม่

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

ลองออนไลน์!

เยลลี่ ,  13 12  11 ไบต์

O*Ɲ%⁽wḃ%5ỊẠ

ลิงก์ monadic ยอมรับรายการของอักขระใช้~แทน‾ตัวเลือก

ลองออนไลน์! หรือดูทดสอบ (... ที่ฉันสั่งให้วาง 8 คนปลอมแปลงในตอนท้าย)

สูตรนี้พบโดยเล่นซอรอบ ๆ ด้วยมือ: p (ตามที่อยู่ด้านล่าง)

สำหรับอันนี้ฉันทั้งหมด 16 คู่ของอันดับตัวละครที่ถือว่าเป็นการยกกำลังและมองหาโมดูโลขนาดใหญ่ที่พอดีกับสามไบต์ตามด้วยโมดูโลไบต์เดียว (1,2,3,4,5,6,7,8 , 9,10,16,256) ที่แบ่ง 16 ดังกล่าวว่าผลลัพธ์ที่ยอมรับได้ทั้งหมดเป็น 1 หรือ 0 ("ไม่มีนัยสำคัญ") เนื่องจากฉันรู้ว่าỊสั้นกว่า<5ในโซลูชันก่อนหน้าของฉันซึ่งมองหาผลลัพธ์ที่ยอมรับได้ทั้งหมดซึ่งน้อยกว่า สิ่งที่ยอมรับไม่ได้ทั้งหมด

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?

อักขระข้างเคียงที่เป็นไปได้และการประเมินผลภายใน:

(Ɲ)         (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

ก่อนหน้า @ 12:

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

ลองออนไลน์!

ก่อนหน้า @ 13:

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

ลองออนไลน์!

Perl 5, 26 25 ไบต์

การใช้;เป็นตัวคั่นตัวคั่นท้ายสามารถลบออกได้

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

TIO

26 ไบต์

Excel, 150 ไบต์

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

ลบคู่ที่ไม่ถูกต้องใด ๆ แล้วส่งคืนtrueหากผลการค้นหาในสตริงเดิม

Haskell, 42 ไบต์

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

วิธีนี้ใช้~และฟังก์ชั่นการโทรคือ h (เช่นh stringให้คำตอบ)

วิธีการแก้ปัญหาใช้ฟังก์ชั่น g ที่ได้รับรายการส่งคืน tuples ทั้งหมดของค่าที่อยู่ติดกันในรายการ

จากนั้นเราใช้ g เพื่อสร้างรายการของเพื่อนบ้านที่อนุญาต (ในg"__/~~\\/\\_") และรายการของคู่เพื่อนบ้านทั้งหมดในรายการอินพุต จากนั้นเราตรวจสอบว่าแต่ละคู่ที่อยู่ใกล้เคียงเป็นคู่ที่อนุญาต

C (gcc) , 41 36 ไบต์

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

ลองออนไลน์!

-5 กำจัด&1เริ่มต้นจากแนวคิดจากPeter Cordes ; ตัวดำเนินการที่ถูกเปลี่ยน (ลำดับความสำคัญ) เพื่อลบวงเล็บ

~การใช้ประโยชน์ ตรวจสอบบิตที่หนึ่งและที่หกของการแทนเลขฐานสองของอักขระสองตัวแรก:

_ 1011111
\ 1011100
/  101111
~ 1111110
   ^    ^

และสำรวจสตริงซ้ำ ๆ

(*_ / 32) & 1เป็นจริงเฉพาะสำหรับตัวอักษรที่จบสูงในขณะที่*_ & 1เป็นจริงสำหรับตัวอักษรที่เริ่มต้นต่ำ (x&1) ^ (y&1) == (x+y)&1. แฮคเกอร์เสริมโดยไม่ต้องพกพาและพกพาไม่รบกวนบิตต่ำสุด 1มาจากf(_)ค่าตอบแทนถ้าส่วนที่เหลือของสตริงเป็นเส้น

Bash ขนาด 30 ไบต์

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

อินพุตคือ STDIN รหัสการออกคือ 1 ถ้าถูกต้อง 0 ถ้าไม่ถูกต้อง

SNOBOL4 (CSNOBOL4) , 58 ไบต์

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

ลองออนไลน์!

ไม่แสดงผลใด ๆ สำหรับความจริงและจำนวนเต็มบวก (ระบุตำแหน่งของตัวแบ่งแรกในสตริง) สำหรับค่าที่เป็นเท็จ

ถ่าน , 32 18 ไบต์

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

ลองออนไลน์! การเชื่อมโยงคือการใช้รหัสเวอร์ชันอย่างละเอียด คำอธิบาย:

  θ                 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

รหัสเครื่อง x86, 13 ไบต์

(หรือ 11 ไบต์โดยไม่มีการจัดการสตริงอักขระเดี่ยวที่มีความสำคัญเล็กน้อย)

ใช้การตรวจสอบตำแหน่งบิตจากคำตอบ C ของ @ attinat

รหัสเครื่องเดียวกันทำงานในโหมด 16, 32 และ 64 บิต แหล่งที่มาคือ NASM สำหรับโหมด 64 บิต

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 เช่นเดียวunsigned char string_connected(int dummy_rdi, const char *s, int dummy_rdx, size_t transitions);กับการประชุมแบบเรียกระบบ x86-64 ไม่ใช่boolเพราะกรณีการเปลี่ยน = 0 คืนค่ารหัส ASCII ไม่ใช่ 1

RCX = len = strlen(s) - 1. เช่นจำนวนของขอบเขตอักขระ = ช่วงการเปลี่ยนภาพเพื่อตรวจสอบในสตริงความยาวอย่างชัดเจน

สำหรับtransitions > 0, ส่งคืน 0 (ไม่ตรงกัน) หรือ 1 (เชื่อมต่อ) แล้วปล่อยให้ ZF ตั้งค่าตามนั้น สำหรับtransitions == 0, ส่งคืนไบต์เดียวของสตริง (ซึ่งไม่ใช่ศูนย์และดังนั้นจึงเป็นความจริงด้วย) ถ้าไม่ใช่สำหรับกรณีพิเศษนั้นเราสามารถดรอป JRCXZ ก่อนออกได้ มันอยู่ในลูปเพียงเพราะ AL ไม่ใช่ศูนย์ตรงนั้น

ตรรกะตำแหน่งบิตขึ้นอยู่กับการสังเกตว่าบิต 0 ของรหัส ASCII บอกความสูงเริ่มต้นและบิต 5 บอกระดับความสูงสิ้นสุด

;;;  _ 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

สายรัดทดสอบ (ดัดแปลงจากลิงก์ TIO ของ Attinat ระวัง UB ตามลำดับจุด C ในฟังก์ชั่นอ้างอิง C) ลองออนไลน์! . ฟังก์ชั่นนี้ถูกต้องสำหรับทั้ง 30 ราย (รวมถึงกรณีอักขระเดี่ยวที่ค่าส่งคืนไม่ตรงกัน: ทั้งสองเป็นจริงด้วยค่าที่ไม่ใช่ศูนย์ที่แตกต่างกันในกรณีนั้น)

Excel, 79 ไบต์

เซลล์A1เป็นอินพุต

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

Dart , 94 ไบต์

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

ลองออนไลน์!

C ++, 132 110 ไบต์

-22 ไบต์ขอบคุณ ASCII-only

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;}

ใช้ bitmask เพื่อทราบว่าจุดเริ่มต้นและจุดสิ้นสุดนั้นขึ้นหรือลง

เรติน่า 26 ไบต์

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

ลองออนไลน์!

ใช้งาน~มากกว่า‾เพราะมันทำให้การพิมพ์ง่ายขึ้น

Regex, 34 ไบต์

ฉันไม่พบกฎในการใช้ Regex เป็นภาษา โปรดแจ้งให้เราทราบหากฉันต้องการปรับเปลี่ยนนี้

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

ลองที่นี่: https://regex101.com/r/s9kyPm/1/tests

APL + WIN, 58 ไบต์

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

พรอมต์สำหรับการป้อนของสตริงกำเนิดดัชนี 0 และใช้ ~ สำหรับตัวละครบน

ลองออนไลน์! ความอนุเคราะห์จาก Dyalog Classic