Schreiben Sie ein Programm, das eine einzeilige Zeichenfolge verwendet, von der Sie annehmen können, dass sie nur die Zeichen enthält /\_‾. (Dies sind Schrägstriche in Vorwärts- und Rückwärtsrichtung, Unterstreichungen und Überstriche . Sie können diese ~anstelle von Überstrichen verwenden, wenn Sie dies benötigen, da Überstriche kein bequemes ASCII-Format sind.)

Eine mögliche Eingabe ist beispielsweise:

__/‾‾\/\_/‾

Ihr Programm muss einen Wahrheits- oder Falschwert ausgeben, je nachdem, ob der linke Rand des Strings sozusagen über die Zeilen der Zeichen mit dem rechten Rand des Strings "verbunden" ist. Wenn das Kerning also etwas geringer wäre, gäbe es eine durchgehende schwarze (wenn auch verworrene) Linie vom linken Rand bis zum rechten, wie ein ungebrochenes Stück Schnur oder Faden.

Die Ausgabe für das obige Beispiel wäre wahr, da die Kanten verbunden sind:

Um die Verbindungen zu verdeutlichen:

• / verbindet links unten und rechts oben
• \ verbindet oben links und unten rechts
• _ Verbindet links unten und rechts unten
• ‾(oder ~) verbindet oben links und oben rechts

Ebenfalls:

• Es ist egal, ob die Kanten der Saite oben oder unten beginnen, es ist nur wichtig, dass sie horizontal über die gesamte Länge der Saite verbunden sind.

• Sie können davon ausgehen, dass die Eingabezeichenfolge nicht leer ist, und natürlich nur eine Zeile.

Hier sind einige weitere Beispiele, gefolgt von 1 (wahr), wenn sie verbunden sind, oder 0 (falsch), wenn nicht:

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

Der kürzeste Code ist der Gewinner.

Gelee , 9 Bytes

-1 Byte dank @EriktheOutgolfer

Erwarten ~statt ‾. Gibt $0$ oder $1$ .

O*Ɲ:⁽8ƇḂẠ

Probieren Sie es online! , Wahrheitstestsuite , Falsche Testsuite

Mit dieser Formel (aber ansonsten ähnlich der 11-Byte-Version unten):

Der Übergang ist gültig, wenn $n$ ungerade ist, oder ungültig, wenn $n$ ist.

Kommentiert

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

Jelly ,  14 12  11 Bytes

Unterstützt (und erwartet) das ‾Zeichen in der Eingabezeichenfolge. Gibt $0$ oder $1$ .

O*Ɲ%276%7ỊẠ

Probieren Sie es online! , Wahrheitstestsuite , Falsche Testsuite

Wie?

Bei zwei aufeinanderfolgenden Zeichen der ASCII-Codes $x$ und $y$ wollen wir eine Funktion, die prüft, ob sie einen gültigen Übergang bilden.

Wir benötigen eine nicht kommutative Operation, da sich das Ergebnis ändern kann, wenn die Zeichen vertauscht werden. Zum Beispiel _/ist gültig, aber /_nicht.

Unter Verwendung der Potenzierung ist eine mögliche Formel ¹ :

Der Übergang ist gültig, wenn $n\le1$ , oder ungültig, wenn $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. Gefunden mit einer Brute-Force-Suche in Node.js (unter Verwendung von BigInts)}

Kommentiert

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 Bytes

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

Probieren Sie es online!

Reduziert alle Zeichenfolgen mit Regex-Zeichenklassen auf zwei Fälle.

JavaScript (ES6), 45 Byte

Der naive Weg.

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

Probieren Sie es online!

R , 89 87 81 78 Bytes

-2 Bytes dank @Giuseppe

-6 Bytes dank @Nick Kennedy

-3 Bytes ersetzen 1:length(y)durch seq(a=y), wobei adie Abkürzung für stehtalong.with

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

verwendet \ / _ ~. Dies ist wahrscheinlich nicht so kurz wie eine auf Regex basierende Lösung, aber ich wollte etwas tun, das sich von allen anderen unterscheidet.

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

Die Zeichen unter 93 wechseln den Status von oben nach unten (oder umgekehrt) und verhalten sich als solche, -1während die anderen nichts tun und sich als 1solche verhalten . Cumprod verfolgt den Status in Bezug auf den Start. Die geraden Zahlen befinden sich in einem Aufwärtszustand (dargestellt mit -1), die ungeraden Zahlen in einem Abwärtszustand ( 1). Wenn die Zeichenfolge ungebrochen ist, sollte sich der Verfolgungsstatus multipliziert mit der Auf- / Ab-Position nicht ändern. Dies ist immer die Startbedingung ( -1, oder 1).

Probieren Sie es online aus

Python , 46 Bytes

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

Probieren Sie es online!

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

Ich habe andere weniger einfache Methoden zum Überprüfen von Zeichenpaaren ausprobiert, aber sie waren alle länger als das Hardcodieren aller zulässigen Paare wie dieses.

C (gcc) 93 Bytes

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

Probieren Sie es online!

Chip -z , 17 Bytes

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

Probieren Sie es online! (TIO enthält -v, um das Verständnis der Ausgabe zu erleichtern.)

Erwartet das _/~\Set. Gibt entweder \x00(falsch) oder \x01(wahr) zurück.

Die Strategie für meine Antwort verwendet die folgenden Informationen:

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

A: Diese Bitposition ist zufällig, 1wenn die linke Seite des Symbols niedrig ist, und 0wenn sie hoch ist
F: Diese Bitposition ist zufällig, 0wenn die rechte Seite des Symbols niedrig ist, und 1wenn sie hoch ist
C: Diese Bitposition ist zufällig sei immer1

Anhand dieser Informationen muss ich nur überprüfen, ob die FZeichen der einzelnen Zeichen mit denen not Ader nächsten übereinstimmen . Ein xorTor ist ein bequemer Weg, um dies zu erreichen.

Der folgende Code erledigt dies, gibt jedoch für jede Kopplung eine Ausgabe aus (plus eine zusätzliche 1am Anfang) (7 Bytes):

FZ!
A}a

Wir möchten beim ersten Fehler anhalten und auch ausgeben, ob wir in der Zeichenfolge angehalten haben, oder am Nullterminator (wir fügen hinzu -z, um uns einen Nullterminator zu geben). Wir können not Cangeben, wo wir aufgehört haben, und das gibt uns dieses Programm (13 Bytes):

FZ!C~a
A}^]~t

Wir haben aber immer noch "führende Nullen" (zB \_/\gibt 00 00 00 00 01), so dass dies in die oben angegebene Antwort umgewandelt wird.

05AB1E , 29 14 9 Bytes

ÇümŽb‘÷ÈP

Antwort von Port of @Arnauld 's Jelly , also stelle sicher, dass du ihn auch positiv bewertest!

Eingabe mit ‾.

Probieren Sie es online aus oder überprüfen Sie alle Testfälle .

Ursprüngliche 29- Byte- Antwort:

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

Eingabe mit ~statt ‾.

In meinem Kopf klang es kürzer. Ich werde versuchen, es von hier aus nach unten zu spielen.

Probieren Sie es online aus oder überprüfen Sie alle Testfälle .

Erläuterung: "

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

Sehen Sie diese 05AB1E Spitze von mir (Abschnitte Wie groß ganzen Zahlen comrpess? Und Wie integer Listen komprimieren? ) Zu verstehen , warum •6_üê{↕ist 1781179816800959, ƵΔist 180und •6_üê{↕ƵΔвist[52,66,69,100,103,131,179] .

Zusätzliche Erklärung:

$2^4$ diese Unterschiede . Da komprimierte Ganzzahllisten in 05AB1E nur positive Ganzzahlen enthalten müssen, addiere ich jeweils 100 . Die ungültigen Paare und ihre entsprechenden Werte sind dann ["/_", 52]:; ["\~", 66], ["_~", 69], ["//", 100], ["\\", 100], ["_\", 103], ["~_", 131], ["~/", 179], Weshalb ich die komprimierte integer Liste in meinem Code enthält diese Werte haben.
Da __und ~~genauso gut gefällt //und \\ergibt 0(oder 100nachdem ich 100 addiert habe), entferne ich zuerst alle angrenzenden Duplikate von~und _ in der Eingabezeichenfolge, bevor die Paardifferenzen berechnet und überprüft werden.

Python 3 , 79 70 63 Bytes

Dank Arnauld und Jo King 16 Byte gespeichert, danke!

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

Probieren Sie es online!

Python 3 , 67 60 Bytes mit ~ anstelle von ‾

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

Probieren Sie es online!

Python 3, 126 Bytes

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 Bytes

Diese Variante verwendet ~anstelle von Überstrichen. Es nimmt alle acht gültigen Paare und prüft, ob der String nur diese enthält:

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

Probieren Sie es online!

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 Bytes

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

Probieren Sie es online!

Eine Regex-Lösung, die einfach überprüft, ob die Zeichenfolge keine ungültigen Sequenzen enthält.

Erläuterung:

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

R , 43 Zeichen, 47 Bytes

Es ist derselbe reguläre Ausdruck, den die anderen Antworten verwenden, aber für R angepasst.

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

Probieren Sie es online!

Und obligatorische xkcd .

Viertens (gviertens) , 100 bis 98 Bytes

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

Probieren Sie es online!

Erläuterung

Gehen Sie die Zeichenfolge durch und stellen Sie fest, ob jedes Zeichen an derselben Position (oben oder unten) beginnt, an der es endet. Subtrahieren Sie 1 von einem Zähler, wenn sie nicht übereinstimmen. Wenn sich der Zähler am Ende geändert hat, ist die Zeichenfolge keine Zeichenfolge.

Die Endposition ist hoch, wenn char /(47) oder ~(126) ist. Ansonsten ist es niedrig

Die Startposition ist hoch, wenn char \(92) oder ~(126) ist. Ansonsten ist es niedrig

Code-Erklärung

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

Ich mache nicht wirklich viele Python-Code-Golfspiele, aber ich dachte, ich könnte es versuchen

• -2 Bytes: realisiert nicht (any ()) ist das Gleiche wie alle (not ()) und könnte die not in den r-String verschieben

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

Probieren Sie es online!

Python 3.8 (Vorabversion) , 71 Byte

Ich wollte die neue :=Ausdruckszuweisung ausprobieren

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

Probieren Sie es online!

Jelly ,  13 12  11 Bytes

O*Ɲ%⁽wḃ%5ỊẠ

Ein monadischer Link, der eine Liste von Zeichen akzeptiert, verwendet die Option ~anstelle von ‾.

Probieren Sie es online! Oder sehen Sie sich eine Testsuite an (... in der ich die 8 Falseys am Ende nachbestellt habe)

Diese Formel wurde gefunden, indem man mit der Hand herumfummelte: p (wie auch die folgenden)

Auch für dieses habe ich alle 16 Paare von Zeichenordnungszahlen als Potenzierung behandelt und nach einem großen Modulo gesucht, das in drei Bytes passt, gefolgt von einem Ein-Byte-Modulo (1,2,3,4,5,6,7,8 , 9,10,16,256), die die 16 so aufteilten, dass alle akzeptablen Ergebnisse entweder 1 oder 0 waren ("unbedeutend"), da ich weiß, dass sie Ịkürzer sind als <5bei meiner vorherigen Lösung, bei der alle akzeptablen Ergebnisse kleiner als waren alle inakzeptabel.

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?

Die möglichen Nachbarzeichen und ihre internen Auswertungen:

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

Vorherige @ 12:

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

Probieren Sie es online!

Vorherige @ 13:

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

Probieren Sie es online!

Perl 5, 26 25 Bytes

mit ;dem endbegrenzer kann der endbegrenzer entfernt werden

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

TIO

26 Bytes

Excel, 150 Bytes

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

Entfernt ungültige Paare und gibt dann zurück, truewenn dies zur ursprünglichen Zeichenfolge führt.

Haskell, 42 Bytes

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

Diese Lösung verwendet ~, und die Funktion zum Aufrufen ist h (dh h stringgibt die Antwort)

Die Lösung verwendet eine Funktion g, die bei einer gegebenen Liste alle Tupel benachbarter Werte in der Liste zurückgibt.

Dann erzeugen wir mit g die Liste der erlaubten Nachbarn (in g"__/~~\\/\\_") und auch die Liste aller benachbarten Paare in der Eingabeliste. Dann prüfen wir, ob jedes benachbarte Paar ein erlaubtes Paar ist.

C (GCC) , 41 36 Bytes

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

Probieren Sie es online!

-5 beseitigt aufgrund &1einer Idee von Peter Cordes ; Operatoren geändert (Vorrang), um Klammern zu entfernen

Verwendet ~. Überprüft das erste und sechste Bit der Binärdarstellungen der ersten beiden Zeichen:

_ 1011111
\ 1011100
/  101111
~ 1111110
   ^    ^

und durchläuft die Zeichenfolge rekursiv.

(*_ / 32) & 1gilt nur für Zeichen, die hoch enden, während *_ & 1dies nur für Zeichen gilt, die niedrig beginnen. (x&1) ^ (y&1) == (x+y)&1. XOR ist Add-without-Carry und Carry stört nicht das niedrigste Bit. Das 1kommt vom f(_)Rückgabewert, wenn der Rest der Zeichenkette stringy war.

Bash, 30 Bytes

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

Die Eingabe ist STDIN. Der Beendigungscode ist 1, wenn er gültig ist, und 0, wenn er ungültig ist.

SNOBOL4 (CSNOBOL4) , 58 Bytes

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

Probieren Sie es online!

Gibt nichts für truthy und eine positive Ganzzahl (die die Position des ersten Bruchs in der Zeichenfolge angibt) für falsy aus.

Kohle , 32 18 Bytes

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

Probieren Sie es online! Link ist eine ausführliche Version des Codes. Erläuterung:

  θ                 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-Maschinencode, 13 Byte.

(Oder 11 Bytes, ohne einzelne Zeichenfolgen zu verarbeiten, die trivial stringy sind.)

Verwendet die Bitpositionsprüfung aus der C-Antwort von @ attinat

Der gleiche Maschinencode funktioniert im 16-, 32- und 64-Bit-Modus. Die Quelle ist NASM für den 64-Bit-Modus.

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

Aufrufbar von C wie unsigned char string_connected(int dummy_rdi, const char *s, int dummy_rdx, size_t transitions);bei der x86-64-System-V-Aufrufkonvention. Nicht, boolweil die Übergänge = 0 einen ASCII-Code zurückgeben, nicht 1.

RCX = len = strlen(s) - 1. dh die Anzahl der Zeichengrenzen = Übergänge zum Einchecken der Zeichenfolge mit expliziter Länge.

Für transitions > 0gibt 0 (nicht übereinstimmend) oder 1 (verbunden) zurück und lässt ZF entsprechend gesetzt. For transitions == 0gibt das einzelne Byte der Zeichenfolge zurück (das nicht Null ist und daher auch wahr ist). Wenn dies nicht der Fall wäre, könnten wir den JRCXZ-Early-Exit fallen lassen. Es ist nur innerhalb der Schleife, weil AL dort ungleich Null ist.

Die Bitpositionslogik basiert auf der Beobachtung, dass Bit 0 des ASCII-Codes die Starthöhe und Bit 5 die Endhöhe angibt.

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

Testkabelbaum (modifiziert von attinats TIO-Link, achten Sie auf den C-Sequenzpunkt UB in dieser C-Referenzfunktion). Probieren Sie es online! . Diese Funktion ist für alle 30 Fälle korrekt. (Einschließlich der Einzelzeichenfälle, in denen der Rückgabewert nicht übereinstimmt: In diesem Fall sind beide mit unterschiedlichen Werten ungleich Null wahr.)

Excel, 79 Bytes

Zelle A1als Eingabe

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

Dart , 94 Bytes

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

Probieren Sie es online!

C ++, 132 110 Bytes

-22 Bytes nur dank 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;}

Verwendet eine Bitmaske, um festzustellen, ob Anfang und Ende nach oben oder unten zeigen

Netzhaut , 26 Bytes

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

Probieren Sie es online!

Verwendet ~eher als ‾, weil dies das Tippen einfacher machte.

Regex, 34 Bytes

Ich konnte keine Regeln für die Verwendung von Regex als Sprache finden. Bitte lassen Sie mich wissen, wenn ich dies anpassen muss.

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

Versuchen Sie es hier: https://regex101.com/r/s9kyPm/1/tests

APL + WIN, 58 Byte

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

Fordert zur Eingabe eines Strings mit dem Indexursprung 0 auf und verwendet ~ für das obere Zeichen

Probieren Sie es online! Mit freundlicher Genehmigung von Dyalog Classic