Napisz program, który pobiera pojedynczy ciąg wiersza, o którym można założyć, że będzie zawierał tylko znaki /\_‾. (Jest to ukośnik do przodu i do tyłu, podkreślenie i overline . Możesz użyć ~zamiast overline, jeśli potrzebujesz, ponieważ overline nie jest wygodnym ASCII.)

Na przykład jednym z możliwych danych wejściowych jest:

__/‾‾\/\_/‾

Twój program musi wypisać wartość prawdy lub fałszu w zależności od tego, czy lewa krawędź łańcucha jest „połączona”, że tak powiem, z prawą krawędzią łańcucha za pomocą wierszy znaków. Tak więc, jeśli kerning byłby nieco mniejszy, istniałaby stała czarna (choć perwersyjna) linia od lewej krawędzi do prawej, jak nieprzerwany kawałek sznurka lub sznurka.

Wynik dla powyższego przykładu byłby prawdziwy, ponieważ krawędzie są połączone:

Aby wyjaśnić połączenia:

• / łączy w lewym dolnym i prawym górnym rogu
• \ łączy w lewym górnym i prawym dolnym rogu
• _ łączy w lewym dolnym i prawym dolnym rogu
• ‾(lub ~) łączy się w lewym górnym i prawym górnym rogu

Również:

• Nie ma znaczenia, czy krawędzie struny zaczynały się na górze, czy na dole, liczy się tylko to, że łączą się poziomo na całej długości struny.

• Możesz założyć, że łańcuch wejściowy jest niepusty i oczywiście tylko jeden wiersz.

Oto kilka przykładów, po których następuje 1 (prawda), jeśli są połączone, lub 0 (fałsz), jeśli nie:

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

Najkrótszy kod jest zwycięzcą.

Galaretka , 9 bajtów

-1 bajt dzięki @EriktheOutgolfer

Spodziewaj się ~zamiast ‾. Zwraca lub .$0$$1$

O*Ɲ:⁽8ƇḂẠ

Wypróbuj online! , Zestaw testowy Truthy , zestaw testowy Falsy

Za pomocą tej formuły (ale poza tym podobna do 11-bajtowej wersji poniżej):

Przejście jest poprawne, jeśli jest nieparzyste, lub niepoprawne, jeśli jest parzyste.$n$$n$

Skomentował

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

Galaretka ,  14 12  11 bajtów

Obsługuje (i oczekuje) ‾znak w ciągu wejściowym. Zwraca lub .$0$$1$

O*Ɲ%276%7ỊẠ

Wypróbuj online! , Zestaw testowy Truthy , zestaw testowy Falsy

W jaki sposób?

Biorąc pod uwagę dwa kolejne znaki kodów ASCII i , chcemy funkcję, która sprawdza, czy stanowią one ważny przejście.$x$$y$

Potrzebujemy operacji nieprzemiennej, ponieważ wynik może ulec zmianie po odwróceniu znaków. Na przykład _/jest poprawny, ale /_nie jest.

Używając potęgowania, możliwa formuła ¹ to:

jest ważne, jeśli , lub nieprawidłowe, jeśli .$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. Znaleziono przy wyszukiwaniu metodą brute-force w Node.js (przy użyciu BigInts)}

Skomentował

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

Rubin -n , 30 bajtów

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

Wypróbuj online!

Zmniejsza wszystkie sekwencje rozdzielające ciąg do dwóch przypadków przy użyciu klas znaków Regex.

JavaScript (ES6), 45 bajtów

Naiwny sposób.

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

Wypróbuj online!

R , 89 87 81 78 bajtów

-2 bajty dzięki @Giuseppe

-6 bajtów dzięki @Nick Kennedy

-3 bajtów wymiana 1:length(y)z seq(a=y), gdzie ajest skrótemalong.with

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

wykorzystuje \ / _ ~. Prawdopodobnie nie jest to tak krótkie jak rozwiązanie oparte na wyrażeniach regularnych, ale chciałem zrobić coś innego niż wszyscy inni.

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

Znaki mniejsze niż 93 przełączają stan z góry na dół (lub odwrotnie) i jako takie zachowują się tak -1, jak inni nic nie robią i zachowują się tak 1, jak cumprod śledzi stan w odniesieniu do początku. Liczby parzyste są na górze (reprezentowane przez -1), liczby nieparzyste są na dole ( 1). Jeśli ciąg nie zostanie przerwany, śledzony stan pomnożony przez pozycję góra / dół nie powinien się zmienić, zawsze będzie to warunek początkowy ( -1lub 1)

Wypróbuj online

Python , 46 bajtów

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

Wypróbuj online!

Potwierdza, że ​​każda sąsiadująca para znaków łączy się, sprawdzając, czy pojawiają się one kolejno __/~~\/\_. Ten ciąg może być traktowany jako ciąg De_Bruijn_sequence na potrójnych wysokich / niskich pozycjach.$2^3=8$

Próbowałem innych mniej nieprzyzwoitych metod, aby sprawdzić pary znaków, ale wszystkie one były dłużej twarde kodujące wszystkie legalne pary takie jak ten.

C (gcc) , 93 bajty

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

Wypróbuj online!

Chip -z , 17 bajtów

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

Wypróbuj online! (TIO obejmuje -vułatwienie zrozumienia wyników.)

Oczekuje _/~\zestawu. Zwraca albo \x00(fałsz), albo \x01(prawda).

Strategia dla mojej odpowiedzi wykorzystuje następujące informacje:

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

A: Ta pozycja bitowa zdarza się, 1gdy lewa strona symbolu jest niska, a 0gdy jest wysoka
F: Ta pozycja bitowa dzieje się, 0gdy prawa strona symbolu jest niska, a 1gdy jest wysoka
C: Ta pozycja bitowa ma miejsce zawsze będzie1

Korzystając z tych informacji, muszę po prostu sprawdzić, czy Fkażda postać pasuje not Ado następnej. xorBrama jest wygodnym sposobem do osiągnięcia tego celu.

Poniższy kod to robi, ale podaje dane wyjściowe dla każdej pary (plus dodatkową 1na początku) (7 bajtów):

FZ!
A}a

Chcemy zatrzymać się przy pierwszym niepowodzeniu, a także wypisać, czy zatrzymaliśmy się w ciągu, czy na terminatorze zerowym (dodajemy również, -zaby dać nam terminator zerowy). Możemy użyć not Cdo wskazania miejsca zatrzymania, a to daje nam ten program (13 bajtów):

FZ!C~a
A}^]~t

Ale nadal mamy „wiodące zera” (np. \_/\Daje 00 00 00 00 01), więc jest to przekształcane na odpowiedź podaną u góry.

05AB1E , 29 14 9 bajtów

ÇümŽb‘÷ÈP

Port odpowiedzi Galaretki @Arnauld , więc upewnij się, że go również głosujesz!

Wprowadź za pomocą ‾.

Wypróbuj online lub sprawdź wszystkie przypadki testowe .

Oryginalna odpowiedź 29 bajtów :

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

Wprowadź za pomocą ~zamiast ‾.

W mojej głowie zabrzmiało to krócej. Spróbuję stąd zagrać w golfa.

Wypróbuj online lub sprawdź wszystkie przypadki testowe .

Objaśnienie: „

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

Zapoznaj się z moją wskazówką 05AB1E (sekcje Jak zestawiać duże liczby całkowite? I Jak kompresować listy liczb całkowitych? ), Aby zrozumieć, dlaczego •6_üê{↕jest 1781179816800959, ƵΔjest 180i •6_üê{↕ƵΔвjest [52,66,69,100,103,131,179].

Dodatkowe wyjaśnienie:

Istnieje 16 ( ) możliwych par znaków, które musimy zweryfikować. Jeśli przekonwertujemy każdy znak na jego wartość Unicode i obliczymy różnice, otrzymamy te różnice . Ponieważ skompresowane listy liczb całkowitych w 05AB1E muszą mieć tylko dodatnie liczby całkowite, do każdego dodam 100 . Nieprawidłowe pary i odpowiadające im wartości są wówczas: ; , , , , , , , Dlatego mam sprężonego listy całkowitą w moim kodu zawierającego te wartości. Ponieważ i po prostu polubię i spowoduję (lub po dodaniu 100), najpierw usuwam wszelkie sąsiadujące duplikaty i$2^4$["/_", 52]["\~", 66]["_~", 69]["//", 100]["\\", 100]["_\", 103]["~_", 131]["~/", 179]
__~~//\\0100~_ w ciągu wejściowym, przed obliczeniem i weryfikacją różnic par.

Python 3 , 79 70 63 bajty

Zaoszczędź 16 bajtów dzięki Arnauldowi i Jo Kingowi, dzięki!

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

Wypróbuj online!

Python 3 , 67 60 bajtów z ~ zamiast ‾

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

Wypróbuj online!

Python 3, 126 bajtów

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 bajtów

Ten wariant wykorzystuje ~zamiast overline. Pobiera wszystkie osiem poprawnych par i sprawdza, czy ciąg zawiera tylko te:

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

Wypróbuj online!

Nie golfowany:

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

Perl 6 , 32 bajty

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

Wypróbuj online!

Rozwiązanie wyrażenia regularnego, które po prostu sprawdza, czy ciąg nie zawiera niepoprawnych sekwencji.

Wyjaśnienie:

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

R , 43 znaki, 47 bajtów

Jest to ten sam regex, którego używają inne odpowiedzi, ale dostosowany do R.

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

Wypróbuj online!

I obowiązkowe xkcd .

Dalej (gforth) , 100 98 bajtów

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

Wypróbuj online!

Wyjaśnienie

Przejdź przez ciąg i określ, czy każdy znak zaczyna się na tej samej pozycji (górnej lub dolnej), co przed końcem. Odejmij 1 od licznika, jeśli się nie zgadzają. Na koniec, jeśli zmienił się licznik, łańcuch nie jest łańcuchem.

Pozycja końcowa jest wysoka, jeśli char wynosi /(47) lub ~(126). W przeciwnym razie jest niski

Pozycja początkowa jest wysoka, jeśli char wynosi \(92) lub ~(126). W przeciwnym razie jest niski

Objaśnienie kodu

\ 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 bajtów

Naprawdę nie gram w golfa w Pythonie, ale pomyślałem, że mogę spróbować

• -2 bajty: zrealizowane not (any ()) jest takie samo jak wszystkie (not ()) i może przenieść not do r-string

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

Wypróbuj online!

Python 3.8 (wersja wstępna) , 71 bajtów

Chciałem wypróbować nowe :=przypisanie wyrażeń

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

Wypróbuj online!

Galaretka ,  13 12  11 bajtów

O*Ɲ%⁽wḃ%5ỊẠ

Monadyczny link akceptujący listę znaków korzysta ~z ‾opcji zamiast .

Wypróbuj online! Lub zobacz zestaw testowy (... w którym zamówiłem 8 falsey na końcu)

Ta formuła została znaleziona przez ręczne kręcenie się: p (jak te poniżej)

W tym przypadku ja również wszystkie 16 par rzędnych postaci traktowanych jako potęgowanie i szukałem dużego modułu, który zmieści się w trzech bajtach, a następnie w jednym bajcie modulo (1,2,3,4,5,6,7,8 , 9,10,16,256), który podzielił 16, tak że wszystkie dopuszczalne wyniki były równe 1 lub 0 („nieznaczne”), ponieważ wiem, że Ịjest on krótszy niż <5w moim poprzednim rozwiązaniu, w którym wszystkie akceptowalne wyniki były mniejsze niż wszystkie niedopuszczalne.

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?

Możliwe sąsiednie postacie i ich wewnętrzne oceny:

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

Poprzedni @ 12:

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

Wypróbuj online!

Poprzedni @ 13:

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

Wypróbuj online!

perl 5, 26 25 bajtów

używając ;jako separatora separator końcowy można usunąć

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

TIO

26 bajtów

Excel, 150 bajtów

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

Usuwa wszelkie nieprawidłowe pary, a następnie zwraca, truejeśli spowoduje to powstanie oryginalnego ciągu.

Haskell, 42 bajty

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

używa tego rozwiązania ~, a funkcją do wywołania jest h (tzn. h stringdaje odpowiedź)

Rozwiązanie wykorzystuje funkcję g, która dała listę, zwraca wszystkie krotki sąsiednich wartości na liście.

Następnie używamy g, aby wygenerować listę dozwolonych sąsiadów (in g"__/~~\\/\\_"), a także listę wszystkich sąsiednich par na liście wejściowej. Następnie sprawdzamy, czy każda sąsiednia para jest dozwoloną parą.

C (gcc) , 41 36 bajtów

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

Wypróbuj online!

-5 wyeliminowano, &1zaczynając od pomysłu Petera Cordesa ; zmieniono operatory (pierwszeństwo), aby usunąć nawiasy

Wykorzystuje ~. Sprawdza pierwszy i szósty bit reprezentacji binarnej pierwszych dwóch znaków:

_ 1011111
\ 1011100
/  101111
~ 1111110
   ^    ^

i rekurencyjnie przechodzi przez ciąg.

(*_ / 32) & 1jest prawdziwe tylko dla znaków kończących się na wysokim poziomie, podczas gdy *_ & 1jest prawdziwe tylko dla znaków rozpoczynających się na niskim poziomie. (x&1) ^ (y&1) == (x+y)&1. XOR to add-without-carry, a carry nie przeszkadza najniższemu bitowi. 1Pochodzi od f(_)zwracanej wartości, jeśli reszta ciąg był żylasty.

Bash, 30 bajtów

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

Dane wejściowe to STDIN. Kod zakończenia to 1, jeśli jest ważny, 0, jeśli jest nieprawidłowy.

SNOBOL4 (CSNOBOL4) , 58 bajtów

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

Wypróbuj online!

Nie podaje nic dla prawdy, a dodatnia liczba całkowita (wskazująca pozycję pierwszego przerwania łańcucha) dla fałszu.

Węgiel drzewny , 32 18 bajtów

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

Wypróbuj online! Link jest do pełnej wersji kodu. Wyjaśnienie:

  θ                 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

kod maszynowy x86, 13 bajtów.

(Lub 11 bajtów bez obsługi ciągów jednoznakowych, które są trywialnie ciągłe).

Wykorzystuje kontrolę pozycji bitów z odpowiedzi C @ attinat

Ten sam kod maszynowy działa w trybach 16, 32 i 64-bitowych. Źródłem jest NASM dla trybu 64-bitowego.

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

Można unsigned char string_connected(int dummy_rdi, const char *s, int dummy_rdx, size_t transitions);wywoływać z C jak w konwencji wywoływania Systemu x86-64. Nie booldlatego, że przypadek przejścia = 0 zwraca kod ASCII, a nie 1.

RCX = len = strlen(s) - 1. tzn. liczba granic znaków = przejścia w celu sprawdzenia ciągu o wyraźnej długości.

Dla transitions > 0zwraca 0 (niedopasowania) lub 1 (podłączony) i pozostawia ZF ustawić odpowiednio. Dla transitions == 0zwraca się jeden bajt na sznurkiem (który jest różny od zera, a tym samym również truthy). Gdyby nie ten specjalny przypadek, moglibyśmy porzucić JRCXZ z wczesnego wyjścia. Jest w pętli tylko dlatego, że AL jest tam niezerowe.

Logika pozycji bitowej opiera się na obserwacji, że bit 0 kodu ASCII mówi o wysokości początkowej, a bit 5 o wysokości końcowej.

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

Uprząż testowa (zmodyfikowana z łącza TIO attinat, strzeż się UB punktu sekwencji C w tej funkcji odniesienia C). Wypróbuj online! . Ta funkcja działa we wszystkich 30 przypadkach. (W tym przypadki jednoznakowe, w których zwracana wartość nie pasuje: oba są zgodne z różnymi wartościami niezerowymi w tym przypadku).

Excel, 79 bajtów

Komórka A1jako dane wejściowe

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

Dart , 94 bajty

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

Wypróbuj online!

C ++, 132 110 bajtów

-22 bajty dzięki tylko 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;}

Używa maski bitowej, aby wiedzieć, czy początek i koniec są w górę, czy w dół

Siatkówka , 26 bajtów

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

Wypróbuj online!

Używa ~raczej niż ‾, ponieważ ułatwiło to pisanie.

Regex, 34 bajty

Nie mogłem znaleźć zasad używania Regex jako języka. Daj mi znać, jeśli będę musiał to zmienić.

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

Wypróbuj tutaj: https://regex101.com/r/s9kyPm/1/tests

APL + WIN, 58 bajtów

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

Monituje o wprowadzenie ciągu znaków, początek indeksu 0 i używa ~ dla znaku górnego

Wypróbuj online! Dzięki uprzejmości Dyalog Classic