Yalnızca karakter içereceğini varsayabileceğiniz tek bir satır dizesi alan bir program yazın /\_‾. (Bu öne ve arkaya doğru eğik çizgi, altı çizili ve üstü çizilidir . ~Gerekirse overline yerine ASCII kullanmayacağınız için overline yerine kullanabilirsiniz .)

Örneğin, olası bir giriş:

__/‾‾\/\_/‾

Programınızın, dizginin sol kenarının "bağlı" olup olmamasına bağlı olarak, karakter dizileri üzerinden dizenin sağ kenarına bağlı olarak bir kabahat ya da sahte bir değer vermesi gerekir. Bu nedenle, karakter aralığı biraz daha az olsaydı, kırılmamış bir ip veya sicim parçası gibi sol kenardan sağa doğru tamamen koyu siyah (sapıkça da olsa) bir çizgi olurdu.

Yukarıdaki örneğin çıktısı, kenarlar bağlı olduğu için doğru olacaktır:

Bağlantılardan açık olmak için:

• / sol alt ve sağ üste bağlanır
• \ sol üst ve sağ alt tarafa bağlanır
• _ sol alt ve sağ alt bağlanır
• ‾(veya ~) üst sol ve sağ üste bağlanır

Ayrıca:

• İpin kenarlarının tepenin üstünde mi yoksa altında mı olduğu önemli değildir, sadece ipin tüm uzunluğu boyunca yatay olarak bağlandıkları önemlidir.

• Giriş dizesinin boş olmadığını ve elbette sadece bir satır olduğunu varsayabilirsiniz.

Aşağıda, eğer bağlıysa 1 (truthy) veya eğer değilse 0 (falsy) ile takip edilen bazı örnekler verilmiştir:

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

En kısa kod kazanır.

Jöle , 9 bayt

@EriktheOutgolfer sayesinde -1 bayt

Expect ~yerine ‾. veya döndürür .$0$$1$

O*Ɲ:⁽8ƇḂẠ

Çevrimiçi deneyin! , Truthy test takımı , Falsy test takımı

Bu formülü kullanarak (ancak aşağıdaki 11 byte sürümüne benzer):

Eğer geçiş geçerlidir ise tek veya geçersiz bile değildir.$n$$n$

Yorumlananlar

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

Jöle ,  14 12  11 bayt

‾Giriş dizesindeki karakteri destekler (ve bekler) . veya döndürür .$0$$1$

O*Ɲ%276%7ỊẠ

Çevrimiçi deneyin! , Truthy test takımı , Falsy test takımı

Nasıl?

İki ardışık ASCII karakteri ve verildiğinde, geçerli bir geçiş oluşturup oluşturmadıklarını kontrol eden bir işlev istiyoruz.$x$$y$

Değişmeli olmayan bir işleme ihtiyacımız var, çünkü karakterler ters çevrildiğinde sonuç değişebilir. Örneğin _/, geçerli ancak geçerli /_değil.

Üstelik, olası bir formül ^1'dir :

Geçiş ise geçerli , ise geçersiz .$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. Node.js'de (BigInts kullanarak) bir kaba kuvvet aramasıyla bulundu}

Yorumlananlar

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

Yakut -n , 30 bayt

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

Çevrimiçi deneyin!

Regex karakter sınıflarını kullanarak dizge kırma dizilerinin tümünü iki duruma indirir.

JavaScript (ES6), 45 bayt

Saf yol.

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

Çevrimiçi deneyin!

R , 89 87 81 78 bayt

@Giuseppe sayesinde -2 bayt

@Nick Kennedy sayesinde -6 bayt

Değiştirilmesi -3 bayt 1:length(y)ile seq(a=y)burada, akısaltmasıdıralong.with

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

kullanır \ / _ ~. Bu muhtemelen regex tabanlı bir çözüm kadar kısa değil, ama diğerlerinden biraz farklı bir şey yapmayı hayal ettim.

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

93'ten küçük karakterler durumu yukarıdan aşağıya (ya da tam tersi) değiştirir ve -1diğerleri hiçbir şey yapmıyormuş gibi davranır ve 1cumprod başlangıca göre durumu izler gibi davranır . Çift sayılar şehir dışındadır (ile temsil edilir -1), tek sayılar aşağı durumdadır ( 1). İp kırılmamışsa, izlenen durum yukarı / aşağı pozisyonuyla çarpılır, değişmemelidir, her zaman başlangıç ​​koşulu olacaktır ( -1, veya 1)

Çevrimiçi deneyin

Python , 46 bayt

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

Çevrimiçi deneyin!

Her bir bitişik karakter çiftinin arka arkaya göründüklerini kontrol ederek bağlandıklarını onaylar __/~~\/\_. Bu dizi, bir şekilde izlenebilir De_Bruijn_sequence ile , yüksek / düşük pozisyon üçlü.$2^3=8$

Karakter çiftlerini kontrol etmek için diğer daha az neme yöntemlerini denedim, fakat hepsi daha uzun sürdüler.

C (gcc) , 93 bayt

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

Çevrimiçi deneyin!

Çip -z , 17 bayt

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

Çevrimiçi deneyin! (TIO -v, çıktının anlaşılmasını kolaylaştırmayı içerir .)

Kümesini bekliyor _/~\. İade ya \x00(falsy) ya da \x01(truthy).

Cevabımın stratejisi aşağıdaki bilgileri kullanıyor:

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

A: Bu bit pozisyonu 1, sembolün sol tarafı düşük olduğunda ve 0yüksek
Folduğunda olur: Bu bit pozisyonu 0, sembolün sağ tarafı düşük olduğunda ve 1yüksek
Colduğunda olur: Bu bit pozisyonu, Her zaman ol1

Bu bilgiyi kullanarak F, her karakterden birinin diğerininkiyle eşleştiğini kontrol etmem gerekiyor not A. Bir xorkapı bunu başarmanın uygun bir yoludur.

Aşağıdaki kod bunu yapar, ancak her eşleştirme için çıktı verir (artı 1başlangıçta ekstra ) (7 bayt):

FZ!
A}a

İlk başarısızlıkta durmak istiyoruz ve ayrıca dizgide durduğumuzu mu yoksa boş sonlandırıcıyı mı yazdırıyoruz (ayrıca -zbize boş sonlandırıcı eklemek için ekleriz ). not CNerede durduğumuzu belirtmek için kullanabiliriz ve bu bize bu programı veriyor (13 byte):

FZ!C~a
A}^]~t

Ama biz hala "baştaki sıfırlar" (ör. \_/\Verir 00 00 00 00 01) var, bu yüzden bu tepede verilen cevaba dönüşüyor.

05AB1E , 29 14 9 bayt

ÇümŽb‘÷ÈP

Port @Arnauld 'ın Jelly cevap , bu yüzden de onu upvote emin olun!

İle giriş yapın ‾.

Çevrimiçi deneyin veya tüm test durumlarını doğrulayın .

Orijinal 29 baytlık cevap:

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

İle Girdi ~yerine ‾.

Kafamda daha kısa geliyordu .. Buradan golf oynamaya çalışacağım.

Çevrimiçi deneyin veya tüm test durumlarını doğrulayın .

Açıklama: "

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

Benim bu 05AB1E ucu bakın (bölümler ne kadar büyük tamsayılar comrpess için? Ve tamsayı listeleri sıkıştırmak nasıl? ) Anlamak için •6_üê{↕olduğu 1781179816800959, ƵΔolduğunu 180ve •6_üê{↕ƵΔвbir [52,66,69,100,103,131,179].

Ek açıklama:

Doğrulamamız gereken 16 ( ) karakter çifti var. Her karakteri unicode değerine dönüştürürsek ve farkları hesaplarsak, bu farkları elde ederiz . 05AB1E'deki sıkıştırılmış tamsayı listelerinin yalnızca pozitif tamsayılara sahip olması gerektiğinden, her birine 100 eklerim . Geçersiz çiftleri ve bunların karşılık gelen değerler şunlardır: ; , , , , , , , Ben bu değerleri içeren benim kodunda sıkıştırılmış tamsayı listesi var olmasını sağlıyor. Yana ve sadece gibi olacak ve neden (ya da I-100 ekledikten sonra), ilk arasındaki komşu herhangi bir çiftleri kaldırmak ve$2^4$["/_", 52]["\~", 66]["_~", 69]["//", 100]["\\", 100]["_\", 103]["~_", 131]["~/", 179]
__~~//\\0100~_ giriş dizesinde, çift farklarını hesaplayıp doğrulamadan önce.

Python 3 , 79 70 63 bayt

Arnauld ve Jo King sayesinde 16 bayt kaydedildi, teşekkürler!

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

Çevrimiçi deneyin!

Python 3 , 67 60 bayt, instead yerine ~ ile

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

Çevrimiçi deneyin!

Python 3, 126 bayt

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 bayt

Bu değişken, ~genel hatlar yerine kullanır . Sekiz geçerli çiftin tümünü alır ve dizenin yalnızca bu içeriği içerip içermediğini denetler:

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

Çevrimiçi deneyin!

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 bayt

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

Çevrimiçi deneyin!

Dize geçersiz dizilim içermediğini kontrol eden bir regex çözümü.

Açıklama:

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

R , 43 karakter, 47 bayt

Diğer cevapların kullandığı aynı regex ama R için uyarlanmış.

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

Çevrimiçi deneyin!

Ve zorunlu xkcd .

İleri (gforth) , 100 98 bayt

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

Çevrimiçi deneyin!

açıklama

Dizgiyi gözden geçirin ve her karakterin öncekilerle aynı konumda (üst veya alt) başlayıp başlamadığını belirleyin. Eşleşmiyorsa 1'i bir sayaçtan çıkarın. Sonunda, sayaç değiştiyse, dize bir dize değildir.

Karakter /(47) veya ~(126) ise, son konum yüksektir . Aksi takdirde düşük

Char \(92) veya ~(126) ise Start Position yüksektir . Aksi takdirde düşük

Kod Açıklaması

\ 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 bayt

Gerçekten pek python kodu golf yapmıyorum ama bir deneyebilirim diye düşündüm

• -2 bayt: fark edilmedi (herhangi ()), hepsiyle aynı ((()) 'dır ve notu r-string'e taşıyabilir

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

Çevrimiçi deneyin!

Python 3.8 (yayın öncesi) , 71 bayt

Yeni :=ifade ödevini denemek istedim

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

Çevrimiçi deneyin!

Jöle ,  13 12  11 bayt

O*Ɲ%⁽wḃ%5ỊẠ

Karakter listesini kabul eden bir monadik Link ~, ‾seçenek yerine kullanır .

Çevrimiçi deneyin! Ya da bir test odasına bakın (... sonunda 8 tane falsey olanını yerleştirmeyi yeniden sıraladım)

Bu formül el ile etrafında dolaşarak bulundu: p (aşağıda olduğu gibi)

Bunun için ben de 16 çift karakterin ordinalinin üssü üstel muamele görmüş ve üç bayta sığacak büyük bir modulo arayıp ardından bir bayt modülo (1,2,3,4,5,6,7,8) aramıştım. bölümlenmiş 9,10,16,256) 16 bu şekilde kabul edilebilir sonuçların hepsi ya 1 ya da 0 ( "küçük") biliyorum çünkü Ịdaha kısa olan <5her açıdan kabul gören sonucu daha azdır arıyordu önceki çözelti içinde, kabul edilemez olanların hepsi.

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?

Muhtemel komşu karakterler ve iç değerlendirmeleri:

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

Önceki @ 12:

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

Çevrimiçi deneyin!

Önceki @ 13:

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

Çevrimiçi deneyin!

perl 5, 26 25 bayt

;sınırlayıcı olarak kullanarak son sınırlayıcı kaldırılabilir

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

TIO

26 bayt

Excel, 150 bayt

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

Geçersiz tüm çiftleri kaldırır, sonra trueorijinal dizede sonuçlanırsa geri dönün .

Haskell, 42 bayt

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

bu çözüm kullanır ~ve çağrılacak işlev h'dir (yani, h stringcevabı verir)

Çözüm, bir liste verilen bir g fonksiyonunu kullanır, listedeki tüm bitişik değer tuplerini döndürür.

Sonra izin verilen komşular listesini (in g"__/~~\\/\\_") ve ayrıca giriş listesindeki tüm komşu çiftlerin listesini oluşturmak için g kullanın . Sonra her komşu çiftin izin verilen bir çift olduğunu kontrol ederiz.

C (gcc) , 41 36 bayt

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

Çevrimiçi deneyin!

-5 Peter Cordes'ten&1 bir fikirden yola çıkarak elendi ; parantezleri kaldırmak için değiştirilmiş operatörler (öncelik)

Kullanır ~. İlk iki karakterin ikili gösterimlerinin ilk ve altıncı bitlerini kontrol eder:

_ 1011111
\ 1011100
/  101111
~ 1111110
   ^    ^

ve dize yinelemeli olarak geçer.

(*_ / 32) & 1Sadece yüksek sona eren karakterler *_ & 1için geçerlidir, yalnızca düşük başlayan karakterler için geçerlidir. (x&1) ^ (y&1) == (x+y)&1. XOR, taşıma eksizdir ve taşıma en düşük biti rahatsız etmez. 1Gelen f(_)dize geri kalanı lifli olsaydı, dönüş değeri.

Bash, 30 bayt

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

Giriş STDIN'dir. Çıkış kodu geçerli ise 1, geçersiz ise 0.

SNOBOL4 (CSNOBOL4) , 58 bayt

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

Çevrimiçi deneyin!

Doğruluktan ötürü hiçbir şey çıkarmaz ve sahtekarlık için pozitif bir tamsayı (dizideki ilk aralığın konumunu belirten) verir.

Kömür , 32 18 bayt

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

Çevrimiçi deneyin! Bağlantı, kodun ayrıntılı bir versiyonudur. Açıklama:

  θ                 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 makine kodu, 13 bayt.

(Veya önemsiz derecede çekirdekli tek karakterli dizeleri kullanmadan 11 bayt.)

@ Attinat'ın C cevabından bit pozisyonu kontrolü kullanır

Aynı makine kodu, 16, 32 ve 64 bit modlarında çalışır. Kaynak 64 bit modu için NASM'dir.

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

X86-64 unsigned char string_connected(int dummy_rdi, const char *s, int dummy_rdx, size_t transitions);System V arama kuralında olduğu gibi C'den okunabilir . Değil boolgeçişler nedeniyle = 0 vaka bir ASCII kodu, değil 1 döndürür.

RCX = len = strlen(s) - 1. yani, karakter sınırlarının sayısı = açık uzunluklu dizgide kontrol edilecek geçişler.

İçin transitions > 0, 0 (uyumsuzluk) veya 1'i (bağlı) döndürür ve ZF'yi buna göre ayarlı bırakır. Çünkü transitions == 0, dizgenin tek baytını döndürür (sıfır olmayan ve dolayısıyla truthy). Bu özel durum için değilse, erken çıkan JRCXZ'den ayrılabiliriz. Döngünün içinde sadece AL sıfır olmadığı için var.

Bit konumu mantığı, ASCII kodunun bit 0'ının size başlangıç ​​yüksekliğini ve bit 5'in bitiş yüksekliğini söylediğini gözlemlemeye dayanır.

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

Test kablo demeti (attinat'ın TIO bağlantısından modifiye edilmiş, bu C referans fonksiyonunda C sekansı UB'ye dikkat edin). Çevrimiçi deneyin! . Bu fonksiyon 30 vaka için de geçerlidir. (Dönüş değerinin eşleşmediği tek karakterli durumlar da dahil olmak üzere: ikisi de bu durumda sıfır olmayan farklı değerlerle gerçeğe yakın.)

Excel, 79 bayt

A1Giriş olarak hücre

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

Dart , 94 bayt

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

Çevrimiçi deneyin!

C ++, 132 110 bayt

Sadece ASCII sayesinde -22 bayt

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

Başlangıç ​​ve bitişin yukarı mı yoksa aşağı mı olduğunu bilmek için bir bit maskesi kullanır.

Retina , 26 bayt

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

Çevrimiçi deneyin!

Bunun ~yerine kullanır ‾, çünkü yazmayı kolaylaştırdı.

Regex, 34 bayt

Regex'i dil olarak kullanmayla ilgili kural bulamadım. Lütfen bunu ayarlamam gerekiyorsa bana bildirin.

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

Burada deneyin: https://regex101.com/r/s9kyPm/1/tests

APL + WIN, 58 bayt

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

Dize girişi için istekler, dizin kökenli 0 ve üst karakter için ~ kullanır

Çevrimiçi deneyin! Dyalog Classic'in İzniyle