Scrivi un programma che accetta una stringa a riga singola che puoi assumere conterrà solo i caratteri /\_‾. (Questo è in avanti e barra rovesciata, sottolineato e overline . È possibile utilizzare ~al posto di overline se avete bisogno dal momento overline non è conveniente ASCII.)

Ad esempio, un possibile input è:

__/‾‾\/\_/‾

Il tuo programma deve generare un valore di verità o falsa a seconda che il bordo sinistro della stringa sia "collegato", per così dire, al bordo destro della stringa attraverso le linee dei caratteri. Quindi, se la crenatura fosse un po 'meno, ci sarebbe una linea nera solida (anche se crespa) dal bordo sinistro a destra, come un pezzo di spago o spago ininterrotto.

L'output dell'esempio precedente sarebbe vero perché i bordi sono collegati:

Per essere chiari sui collegamenti:

• / si collega in basso a sinistra e in alto a destra
• \ si collega in alto a sinistra e in basso a destra
• _ si collega in basso a sinistra e in basso a destra
• ‾(o ~) si connette in alto a sinistra e in alto a destra

Anche:

• Non importa se i bordi della stringa sono iniziati in alto o in basso, importa solo che si collegano orizzontalmente per tutta la lunghezza della stringa.

• Puoi presumere che la stringa di input non sia vuota e, naturalmente, solo una riga.

Ecco alcuni altri esempi seguiti da 1 (verità) se sono collegati o 0 (falsa) in caso contrario:

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

Il codice più corto è il vincitore.

Gelatina , 9 byte

-1 byte grazie a @EriktheOutgolfer

Aspetta ~invece di ‾. Restituisce o .$0$$1$

O*Ɲ:⁽8ƇḂẠ

Provalo online! , Verity test suite , Falsy test suite

Utilizzando questa formula (ma altrimenti simile alla versione a 11 byte di seguito):

La transizione è valida se è dispari o non valida se è pari.$n$$n$

Commentate

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

Gelatina ,  14 12  11 byte

Supporta (e si aspetta) il ‾carattere nella stringa di input. Restituisce o .$0$$1$

O*Ɲ%276%7ỊẠ

Provalo online! , Verity test suite , Falsy test suite

Come?

Dati due caratteri consecutivi di codici ASCII ed , vogliamo una funzione che controlla se essi formano una transizione valida.$x$$y$

Abbiamo bisogno di un'operazione non commutativa, perché il risultato può cambiare quando i personaggi sono invertiti. Ad esempio, _/è valido ma /_non lo è.

Usando l'espiazione, una possibile formula ¹ è:

La transizione è valida se o non valida se .$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. Trovato con una ricerca di forza bruta in Node.js (usando BigInts)}

Commentate

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 !/[_\\][\\‾]|[\/‾][_\/]/

Provalo online!

Riduce tutte le sequenze che spezzano le stringhe in due casi usando le classi di caratteri Regex.

JavaScript (ES6), 45 byte

Il modo ingenuo.

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

Provalo online!

R , 89 87 81 78 byte

-2 byte grazie a @Giuseppe

-6 byte grazie a @Nick Kennedy

-3 byte in sostituzione 1:length(y)di seq(a=y), dove aè l'abbreviazione dialong.with

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

usi \ / _ ~. Probabilmente questa non è breve come una soluzione basata su regex, ma ho pensato di fare qualcosa di leggermente diverso da tutti gli altri.

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

I caratteri inferiori a 93 cambiano lo stato da su a giù (o viceversa), e in quanto tali si comportano come -1mentre gli altri non fanno nulla e si comportano come 1, la cumprod segue lo stato rispetto all'inizio. I numeri pari sono in uno stato (rappresentati con -1), i numeri dispari sono in uno stato ( 1). Se la stringa non viene spezzata, lo stato tracciato moltiplicato per la posizione su / giù, non dovrebbe cambiare, sarà sempre la condizione iniziale ( -1, o 1)

Provalo online

Python , 46 byte

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

Provalo online!

Conferma che ogni coppia di caratteri adiacente si collega verificando che compaiano consecutivamente __/~~\/\_. Questa stringa può essere visualizzata come De_Bruijn_sequence su triple di posizioni alte / basse.$2^3=8$

Ho provato altri metodi meno banali per controllare le coppie di caratteri, ma erano tutti più lunghi che codificavano tutte le coppie legali in questo modo.

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

Provalo online!

Chip -z , 17 byte

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

Provalo online! (TIO include -vper facilitare la comprensione dell'output.)

Si aspetta il _/~\set. Restituisce \x00(falsa) o \x01(verità).

La strategia per la mia risposta utilizza le seguenti informazioni:

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

A: Questa posizione di bit si verifica 1quando la parte sinistra del simbolo è bassa e 0quando è alta
F: questa posizione di bit si trova 0quando la parte destra del simbolo è bassa e 1quando è alta
C: questa posizione di bit accade a essere sempre1

Usando queste informazioni, devo semplicemente verificare che il Fcarattere di ciascun personaggio corrisponda not Aal successivo. Un xorcancello è un modo conveniente per raggiungere questo obiettivo.

Il codice seguente esegue questa operazione, ma fornisce un output per ogni accoppiamento (più un extra 1all'inizio) (7 byte):

FZ!
A}a

Vogliamo fermarci al primo errore e stampare anche se ci siamo fermati all'interno della stringa o al terminatore null (aggiungiamo anche -zper darci un terminatore null). Possiamo usare not Cper indicare dove ci siamo fermati, e questo ci dà questo programma (13 byte):

FZ!C~a
A}^]~t

Ma abbiamo ancora "zero iniziali" (ad es. \_/\Dà 00 00 00 00 01), quindi questo si trasforma nella risposta data in alto.

05AB1E , 29 14 9 byte

ÇümŽb‘÷ÈP

La risposta di Port of @Arnauld 's Jelly , quindi assicurati di votare anche lui!

Ingresso con ‾.

Provalo online o verifica tutti i casi di test .

Risposta originale di 29 byte :

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

Inserire con ~invece di ‾.

Sembrava più corto nella mia testa. Proverò a giocarci giù da qui.

Provalo online o verifica tutti i casi di test .

Spiegazione: "

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

Vedi questo mio suggerimento 05AB1E (sezioni Come comprimere i numeri interi grandi? E Come comprimere gli elenchi di numeri interi? ) Per capire perché •6_üê{↕è 1781179816800959, ƵΔè 180e •6_üê{↕ƵΔвè [52,66,69,100,103,131,179].

Spiegazione aggiuntiva:

Ci sono 16 ( ) possibili coppie di caratteri che dobbiamo verificare. Se convertiamo ogni carattere nel suo valore unicode e calcoliamo le differenze, otterremmo queste differenze . Poiché gli elenchi di numeri interi compressi in 05AB1E devono avere solo numeri interi positivi, ne aggiungo 100 a ciascuno . Le coppie non valide e i loro valori corrispondenti sono quindi :; , , , , , , , Che è il motivo per cui ho la lista intero compresso nel mio codice che contiene questi valori. Poiché e mi piacerà e risulterà (o dopo aver aggiunto 100), rimuovo prima tutti i duplicati adiacenti di e$2^4$["/_", 52]["\~", 66]["_~", 69]["//", 100]["\\", 100]["_\", 103]["~_", 131]["~/", 179]
__~~//\\0100~_ nella stringa di input, prima di calcolare e verificare le differenze di coppia.

Python 3 , 79 70 63 byte

Risparmiato 16 byte grazie ad Arnauld e Jo King, grazie!

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

Provalo online!

Python 3 , 67 60 byte con ~ invece di ‾

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

Provalo online!

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

Questa variante utilizza ~invece di overline. Prende tutte e otto le coppie valide e controlla se la stringa contiene solo quelle:

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

Provalo 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 byte

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

Provalo online!

Una soluzione regex che verifica semplicemente che la stringa non contenga sequenze non valide.

Spiegazione:

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

R , 43 caratteri, 47 byte

È la stessa regex usata dalle altre risposte, ma adattata per R.

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

Provalo online!

E obbligatorio xkcd .

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

Provalo online!

Spiegazione

Passa attraverso la stringa e determina se ciascun carattere inizia nella stessa posizione (superiore o inferiore) di quella precedente. Sottrai 1 da un segnalino se non corrispondono. Alla fine, se il contatore è cambiato, la stringa non è una stringa.

La posizione finale è alta se char è /(47) o ~(126). Altrimenti è basso

La posizione iniziale è alta se char è \(92) o ~(126). Altrimenti è basso

Spiegazione del codice

\ 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

Non faccio molti golf in codice Python, ma ho pensato di provarlo

• -2 byte: realizzato not (any ()) uguale a tutto (not ()) e potrebbe spostare il non nella stringa r

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

Provalo online!

Python 3.8 (pre-release) , 71 byte

Volevo provare il nuovo :=incarico di espressione

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

Provalo online!

Gelatina ,  13 12  11 byte

O*Ɲ%⁽wḃ%5ỊẠ

Un collegamento monadico che accetta un elenco di caratteri, utilizza l' opzione ~al posto ‾dell'opzione.

Provalo online! Oppure guarda una suite di test (... dove ho riordinato per posizionare gli 8 falsi alla fine)

Questa formula è stata trovata armeggiando a mano: p (come quelli sotto)

Per questo anch'io anch'io tutte e 16 le coppie di ordinali del personaggio sono state trattate come una esponenziazione e ho cercato un modulo di grandi dimensioni che si inserisse in tre byte seguito da un modulo di un byte (1,2,3,4,5,6,7,8 , 9,10,16,256) che ha partizionato i 16 in modo tale che tutti i risultati accettabili fossero 1 o 0 ("insignificanti") poiché so che Ịè più breve di <5, nella mia precedente soluzione, che stava cercando tutti i risultati accettabili essendo inferiori a tutti inaccettabili.

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?

I possibili personaggi vicini e le loro valutazioni interne:

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

Precedente @ 12:

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

Provalo online!

Precedente @ 13:

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

Provalo online!

perl 5, 26 25 byte

usando ;come delimitatore il delimitatore finale può essere rimosso

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

TIO

26 byte

Excel, 150 byte

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

Rimuove eventuali coppie non valide, quindi restituisce truese ciò risulta nella stringa originale.

Haskell, 42 byte

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

questa soluzione utilizza ~e la funzione da chiamare è h (ovvero h stringfornisce la risposta)

La soluzione utilizza una funzione g che ha fornito un elenco, restituisce tutte le tuple di valori adiacenti nell'elenco.

Quindi usiamo g per generare l'elenco di vicini consentiti (in g"__/~~\\/\\_") e anche l'elenco di tutte le coppie vicine nell'elenco di input. Quindi controlliamo che ogni coppia vicina sia una coppia consentita.

C (gcc) , 41 36 byte

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

Provalo online!

-5 eliminato a &1partire da un'idea di Peter Cordes ; operatori modificati (precedenza) per rimuovere le parentesi

Usi ~. Controlla il primo e il sesto bit delle rappresentazioni binarie dei primi due caratteri:

_ 1011111
\ 1011100
/  101111
~ 1111110
   ^    ^

e attraversa la stringa in modo ricorsivo.

(*_ / 32) & 1è vero solo per i caratteri che finiscono in alto, mentre *_ & 1è vero solo per i caratteri che iniziano in basso. (x&1) ^ (y&1) == (x+y)&1. XOR è add-without-carry e carry non disturba il bit più basso. Il 1viene dal f(_)valore restituito, se il resto della stringa era filante.

Bash, 30 byte

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

L'ingresso è STDIN. Il codice di uscita è 1 se valido, 0 se non valido.

SNOBOL4 (CSNOBOL4) , 58 byte

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

Provalo online!

Non genera nulla per la verità e un numero intero positivo (che indica la posizione della prima interruzione nella stringa) per la falsità.

Carbone , 32 18 byte

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

Provalo online! Il collegamento è alla versione dettagliata del codice. Spiegazione:

  θ                 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

codice macchina x86, 13 byte.

(O 11 byte senza gestire stringhe a carattere singolo che sono banalmente filanti.)

Utilizza il controllo della posizione dei bit dalla risposta C di @ attinat

Lo stesso codice macchina funziona nelle modalità 16, 32 e 64 bit. La fonte è NASM per la modalità a 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

Richiamabile da C come unsigned char string_connected(int dummy_rdi, const char *s, int dummy_rdx, size_t transitions);per la convenzione di chiamata System V x86-64. Non boolperché il caso transitions = 0 restituisca un codice ASCII, non 1.

RCX = len = strlen(s) - 1. cioè il numero di caratteri-limiti = transizioni da verificare nella stringa di lunghezza esplicita.

Per transitions > 0, restituisce 0 (mancata corrispondenza) o 1 (connesso) e lascia ZF impostato di conseguenza. Per transitions == 0, restituisce il singolo byte della stringa (che è diverso da zero e quindi anche vero). Se non fosse per quel caso speciale, potremmo abbandonare JRCXZ con uscita anticipata. È all'interno del loop solo perché AL è diverso da zero lì.

La logica della posizione dei bit si basa sull'osservazione che il bit 0 del codice ASCII indica l'altezza iniziale e il bit 5 indica l'altezza finale.

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

Cablaggio di prova (modificato dal collegamento TIO di attinat, fare attenzione al punto UB in sequenza C in quella funzione di riferimento C). Provalo online! . Questa funzione è corretta per tutti e 30 i casi. (Compresi i casi a carattere singolo in cui il valore restituito non corrisponde: entrambi sono veritieri con valori diversi da zero in quel caso.)

Excel, 79 byte

Cella A1come input

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

Dardo , 94 byte

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

Provalo online!

C ++, 132 110 byte

-22 byte grazie solo a 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;}

Usa una maschera di bit per sapere se l'inizio e la fine sono su o giù

Retina , 26 byte

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

Provalo online!

Utilizza ~piuttosto che ‾, perché ciò ha reso più facile la digitazione.

Regex, 34 byte

Non sono riuscito a trovare le regole sull'uso di Regex come lingua. Per favore fatemi sapere se devo modificare questo.

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

Provalo qui: 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];

Richiede l'immissione di una stringa, origine dell'indice 0 e utilizza ~ per il carattere superiore

Provalo online! Per gentile concessione di Dyalog Classic