Ecrivez un programme qui prend une seule ligne que vous pouvez supposer ne contiendra que les caractères /\_‾. (Il s'agit de barres obliques, soulignées et surlignées en avant et en arrière . Vous pouvez utiliser le ~surlignage si vous en avez besoin, car le surlignage n'est pas pratique en ASCII.)

Par exemple, une entrée possible est:

__/‾‾\/\_/‾

Votre programme doit générer une valeur de vérité ou de fausseté selon que le bord gauche de la chaîne est "connecté", pour ainsi dire, au bord droit de la chaîne via les lignes des caractères. Donc, si le crénage était un peu moins, il y aurait une ligne noire continue (du moins crépue) du bord gauche au droit, comme un morceau de ficelle ou de ficelle ininterrompu.

La sortie pour l'exemple ci-dessus serait vraie car les bords sont connectés:

Pour être clair sur les connexions:

• / se connecte en bas à gauche et en haut à droite
• \ se connecte en haut à gauche et en bas à droite
• _ se connecte en bas à gauche et en bas à droite
• ‾(ou ~) se connecte en haut à gauche et en haut à droite

Aussi:

• Peu importe que les bords de la chaîne commencent en haut ou en bas, il importe simplement qu'ils se connectent horizontalement sur toute la longueur de la chaîne.

• Vous pouvez supposer que la chaîne d'entrée est non vide et, bien entendu, sur une seule ligne.

Voici d'autres exemples suivis de 1 (vérité) s'ils sont connectés ou de 0 (falsie) sinon:

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

Le code le plus court est le gagnant.

Gelée , 9 octets

-1 octet grâce à @EriktheOutgolfer

Attendez-vous ~au lieu de ‾. Retourne ou .$0$$1$

O*Ɲ:⁽8ƇḂẠ

Essayez-le en ligne! , Suite de tests Truthy , suite de tests Falsy

En utilisant cette formule (mais similaire à la version 11 octets ci-dessous):

La transition est valide si est impair ou invalide si est pair.$n$$n$

Commenté

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 octets

Prend en charge (et attend) le ‾caractère dans la chaîne d'entrée. Retourne ou .$0$$1$

O*Ɲ%276%7ỊẠ

Essayez-le en ligne! , Suite de tests Truthy , suite de tests Falsy

Comment?

Étant donné deux caractères consécutifs des codes ASCII et , nous voulons une fonction qui vérifie s’ils forment une transition valide.$x$$y$

Nous avons besoin d'une opération non commutative, car le résultat peut changer lorsque les caractères sont inversés. Par exemple, _/est valide mais /_ne l’est pas.

En utilisant exponentiation, une formule possible ¹ est:

La transition est valide si , ou invalide si .$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. Trouvé avec une recherche par force brute dans Node.js (en utilisant BigInts)}

Commenté

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 octets

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

Essayez-le en ligne!

Réduit toutes les séquences de rupture de chaîne à deux cas en utilisant les classes de caractères Regex.

JavaScript (ES6), 45 octets

La manière naïve.

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

Essayez-le en ligne!

R , 89 87 81 78 octets

-2 octets grâce à @ Giuseppe

-6 octets grâce à @Nick Kennedy

-3 octets remplaçant 1:length(y)par seq(a=y), où aest un raccourci pouralong.with

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

utilise \ / _ ~. Ce n’est probablement pas aussi bref qu’une solution basée sur l’expression régulière, mais j’ai envie de faire quelque chose de différent de tout le monde.

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

Les personnages de moins de 93 commutent l’état de haut en bas (ou inversement) et se comportent comme tels -1tandis que les autres ne font rien et se comportent comme 1, cumprod suit l’état par rapport au début. Les nombres pairs sont dans un état de nord (représenté par -1), les nombres impairs sont à l'état bas ( 1). Si la chaîne n'est pas interrompue, l'état de suivi multiplié par la position haut / bas, ne doit pas changer, ce sera toujours la condition de départ ( -1, ou 1)

Essayez-le en ligne

Python , 46 octets

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

Essayez-le en ligne!

Confirme que chaque paire de caractères adjacents se connecte en vérifiant qu'ils apparaissent consécutivement dans __/~~\/\_. Cette chaîne peut être vue comme une séquence De_Bruijn_n sur les triplets de positions haute / basse.$2^3=8$

J'ai essayé d'autres méthodes moins banales pour vérifier les paires de caractères, mais elles étaient toutes plus longues que le codage en dur de toutes les paires légales comme celle-ci.

C (gcc) , 93 octets

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

Essayez-le en ligne!

Puce -z , 17 octets

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

Essayez-le en ligne! (TIO inclut -vpour faciliter la compréhension de la sortie.)

Attend l' _/~\ensemble. Retourne soit \x00(fausseté) ou \x01(vérité).

La stratégie pour ma réponse utilise les informations suivantes:

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

A: Cette position de bit se trouve 1quand le côté gauche du symbole est bas et 0quand il est haut
F: Cette position de bit se trouve 0quand le côté droit du symbole est bas et 1quand il est haut
C: Cette position de bit arrive à toujours être1

En utilisant ces informations, je dois simplement vérifier que le caractère Fde chaque caractère correspond à celui not Adu suivant. Une xorporte est un moyen pratique pour y parvenir.

Le code suivant fait cela, mais donne une sortie pour chaque paire (plus un extra 1au début) (7 octets):

FZ!
A}a

Nous voulons nous arrêter au premier échec, et indiquer également si nous nous sommes arrêtés dans la chaîne ou au terminateur null (nous ajoutons également -zpour nous donner un terminateur nul). Nous pouvons utiliser not Cpour indiquer où nous nous sommes arrêtés, et cela nous donne ce programme (13 octets):

FZ!C~a
A}^]~t

Mais nous avons toujours des "zéros non significatifs" (par exemple, \_/\donne 00 00 00 00 01), ceci est donc transformé en réponse donnée en haut.

05AB1E , 29 14 9 octets

ÇümŽb‘÷ÈP

La réponse du Port of @Arnauld 's Jelly , assurez-vous de l’avoir à son tour revigorée!

Entrée avec ‾.

Essayez-le en ligne ou vérifiez tous les cas de test .

Réponse originale de 29 octets :

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

Entrer avec ~au lieu de ‾.

Cela sonnait plus court dans ma tête .. Je vais essayer de jouer au golf ici.

Essayez-le en ligne ou vérifiez tous les cas de test .

Explication: "

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

Voir cette astuce 05AB1E (sections Comment compacter les grands nombres entiers? Et Comment compresser les listes d’entiers? ) Pour comprendre pourquoi •6_üê{↕est 1781179816800959, ƵΔest 180et •6_üê{↕ƵΔвest [52,66,69,100,103,131,179].

Explication supplémentaire:

$2^4$["/_", 52]["\~", 66]["_~", 69]["//", 100]["\\", 100]["_\", 103]["~_", 131]["~/", 179]
__~~//\\0100~et _ dans la chaîne d'entrée, avant de calculer et de vérifier les différences de paires.

Python 3 , 79 70 63 octets

16 octets sauvés grâce à Arnauld et Jo King, merci!

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

Essayez-le en ligne!

Python 3 , 67 60 octets avec ~ au lieu de

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

Essayez-le en ligne!

Python 3, 126 octets

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 octets

Cette variante utilise à la ~place des surlignages. Il prend les huit paires valides et vérifie si la chaîne ne contient que celles-ci:

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

Essayez-le en ligne!

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 octets

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

Essayez-le en ligne!

Une solution d'expression régulière qui vérifie simplement que la chaîne ne contient aucune séquence invalide.

Explication:

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

R , 43 caractères, 47 octets

C'est la même chose que les autres réponses utilisent, mais adaptée pour R.

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

Essayez-le en ligne!

Et obligatoire xkcd .

Forth (gforth) , 100 98 octets

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

Essayez-le en ligne!

Explication

Parcourez la chaîne et déterminez si chaque caractère commence à la même position (haut ou bas) que celle qui précède. Soustrayez 1 du compteur s’ils ne correspondent pas. A la fin, si le compteur a changé, la chaîne n'est pas une chaîne.

La position finale est haute si le caractère est /(47) ou ~(126). Sinon c'est bas

La position de départ est haute si le caractère est \(92) ou ~(126). Sinon c'est bas

Explication du code

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

Je ne fais pas vraiment beaucoup de golfs avec code python mais je pensais pouvoir essayer

• -2 octets: réalisé not (any ()) est identique à tout (not ()) et peut déplacer le non dans la chaîne de caractères

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

Essayez-le en ligne!

Python 3.8 (pré-version) , 71 octets

Je voulais essayer la nouvelle :=tâche d'expression

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

Essayez-le en ligne!

Jelly ,  13 12  11 octets

O*Ɲ%⁽wḃ%5ỊẠ

Un lien monadique acceptant une liste de caractères utilise l' option ~in place of ‾.

Essayez-le en ligne! Ou voir une suite de tests (... où j'ai réorganisé pour placer les 8 falsey à la fin)

Cette formule a été trouvée en jouant à la main: p (comme ceux ci-dessous)

Pour celui-ci, les 16 paires d'ordinaux de personnage sont également traitées comme une exponentiation et recherchent un grand modulo pouvant contenir trois octets, suivi d'un modulo d'un octet (1,2,3,4,5,6,7,8 , 9,10,16,256) qui a divisé le 16 de sorte que tous les résultats acceptables soient 1 ou 0 ("insignifiant"), car je sais qu’elle Ịest plus courte que <5dans ma solution précédente, qui recherchait tous les résultats acceptables inférieurs à tous inacceptables.

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?

Les personnages voisins possibles et leurs évaluations internes:

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

Précédent @ 12:

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

Essayez-le en ligne!

Précédent @ 13:

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

Essayez-le en ligne!

perl 5, 26 25 octets

en utilisant ;comme délimiteur, le délimiteur de fin peut être supprimé

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

TIO

26 octets

Excel, 150 octets

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

Supprime toutes les paires non valides, puis renvoie le truerésultat s'il en résulte la chaîne d'origine.

Haskell, 42 octets

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

cette solution utilise ~, et la fonction à appeler est h (c'est-à-dire, h stringdonne la réponse)

La solution utilise une fonction g qui donne une liste à tous les nuplets de valeurs adjacentes de la liste.

Ensuite, nous utilisons g pour générer la liste des voisins autorisés (en g"__/~~\\/\\_") ainsi que la liste de toutes les paires voisines de la liste en entrée. Ensuite, nous vérifions que chaque paire voisine est une paire autorisée.

C (gcc) , 41 36 octets

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

Essayez-le en ligne!

-5 éliminé à &1partir d'une idée de Peter Cordes ; opérateurs modifiés (priorité) pour supprimer les parenthèses

Utilise ~. Vérifie les premier et sixième bits des représentations binaires des deux premiers caractères:

_ 1011111
\ 1011100
/  101111
~ 1111110
   ^    ^

et traverse la chaîne récursivement.

(*_ / 32) & 1n'est vrai que pour les caractères qui se terminent haut, alors que ce *_ & 1n'est vrai que pour les caractères qui commencent bas. (x&1) ^ (y&1) == (x+y)&1. XOR est add-without-carry, et carry ne perturbe pas le bit le plus bas. Le 1provient de la f(_)valeur de retour, si le reste de la chaîne était stringy.

Bash, 30 octets

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

L'entrée est STDIN. Le code de sortie est 1 si valide, 0 si invalide.

SNOBOL4 (CSNOBOL4) , 58 octets

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

Essayez-le en ligne!

N'émet rien pour truey et un entier positif (indiquant la position de la première rupture dans la chaîne) pour fausseté.

Charbon de bois , 32 à 18 octets

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

Essayez-le en ligne! Le lien est vers la version verbeuse du code. Explication:

  θ                 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

Code machine x86, 13 octets.

(Ou 11 octets sans gérer les chaînes à caractère unique qui sont trivialement stringentes.)

Utilise le contrôle de position de bit de la réponse C de @ attinat

Le même code machine fonctionne en modes 16, 32 et 64 bits. La source est NASM pour le mode 64 bits.

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

Appelable à partir de C comme unsigned char string_connected(int dummy_rdi, const char *s, int dummy_rdx, size_t transitions);avec la convention d'appel System V x86-64. Non boolparce que le cas de transitions = 0 renvoie un code ASCII, pas 1.

RCX = len = strlen(s) - 1. c'est-à-dire le nombre de limites de caractère = transitions à archiver dans la chaîne de longueur explicite.

For transitions > 0, renvoie 0 (décalage) ou 1 (connecté) et laisse ZF défini en conséquence. Car transitions == 0, renvoie le seul octet de la chaîne (ce qui est différent de zéro et donc également vrai). Sans ce cas particulier, nous pourrions abandonner le JRCXZ à sortie anticipée. C'est à l'intérieur de la boucle uniquement parce qu'AL y est non nul.

La logique de position de bit est basée sur l'observation que le bit 0 du code ASCII vous indique la hauteur de départ et le bit 5, la hauteur de fin.

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

Faisceau de test (modifié à partir du lien TIO d’attinat, méfiez-vous du UB de séquence C dans cette fonction de référence C). Essayez-le en ligne! . Cette fonction est correcte pour les 30 cas. (Y compris les observations à caractère unique où la valeur renvoyée ne correspond pas: les deux sont la vérité avec différentes valeurs non nulles dans ce cas.)

Excel, 79 octets

Cellule A1en entrée

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

Dart , 94 octets

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

Essayez-le en ligne!

C ++, 132 110 octets

-22 octets grâce à ASCII uniquement

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

Utilise un bitmask pour savoir si le début et la fin sont hauts ou bas

Retina , 26 octets

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

Essayez-le en ligne!

Les utilisations ~plutôt que ‾parce que cela facilitait la frappe.

Regex, 34 octets

Je ne pouvais pas trouver de règles sur l'utilisation de Regex en tant que langue. S'il vous plaît laissez-moi savoir si j'ai besoin d'ajuster cela.

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

Essayez-le ici: https://regex101.com/r/s9kyPm/1/tests

APL + WIN, 58 octets

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

Invite à saisir une chaîne, une origine d'index 0 et utilise ~ pour le caractère supérieur

Essayez-le en ligne! Gracieuseté de Dyalog Classic