Escriba un programa que tome una cadena de línea única que pueda asumir que solo contendrá los caracteres /\_‾. (Eso es barra inclinada hacia adelante y hacia atrás, subrayado y sobrelíneo . Puede usarlo ~en lugar de sobrelíneo si lo necesita, ya que no es conveniente ASCII).

Por ejemplo, una posible entrada es:

__/‾‾\/\_/‾

Su programa necesita generar un valor verdadero o falso dependiendo de si el borde izquierdo de la cadena está "conectado", por así decirlo, al borde derecho de la cadena a través de las líneas de los caracteres. Entonces, si el interletraje fuera un poco menor, habría una línea negra sólida (aunque rizada) desde el borde izquierdo hacia la derecha, como un trozo de hilo o hilo sin romper.

La salida para el ejemplo anterior sería verdadera porque los bordes están conectados:

Para ser claro en las conexiones:

• / se conecta en su parte inferior izquierda y superior derecha
• \ se conecta en su parte superior izquierda e inferior derecha
• _ se conecta en su parte inferior izquierda e inferior derecha
• ‾(o ~) se conecta en su parte superior izquierda y superior derecha

También:

• No importa si los bordes de la cadena comenzaron en la parte superior o inferior, solo importa que se conecten horizontalmente a lo largo de toda la cadena.

• Puede suponer que la cadena de entrada no está vacía y, por supuesto, solo una línea.

Aquí hay algunos ejemplos más seguidos de 1 (verdadero) si están conectados o 0 (falso) si no:

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

El código más corto es el ganador.

Jalea , 9 bytes

-1 byte gracias a @EriktheOutgolfer

Esperar en ~lugar de ‾. Devuelve $0$ o $1$ .

O*Ɲ:⁽8ƇḂẠ

Pruébalo en línea! , Banco de pruebas Truthy , banco de pruebas Falsy

Usando esta fórmula (pero similar a la versión de 11 bytes a continuación):

La transición es válida si $n$ es impar o inválida si $n$ es par.

Comentado

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

Jalea ,  14 12  11 bytes

Admite (y espera) el ‾carácter en la cadena de entrada. Devuelve $0$ o $1$ .

O*Ɲ%276%7ỊẠ

Pruébalo en línea! , Banco de pruebas Truthy , banco de pruebas Falsy

¿Cómo?

Dados dos caracteres consecutivos de los códigos ASCII $x$ e $y$ , queremos una función que verifique si forman una transición válida.

Necesitamos una operación no conmutativa, porque el resultado puede cambiar cuando los caracteres se invierten. Por ejemplo, _/es válido pero /_no lo es.

Usando la exponenciación, una posible fórmula ¹ es:

La transición es válida si , o inválida 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. Encontrado con una búsqueda de fuerza bruta en Node.js (usando BigInts)}

Comentado

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

Pruébalo en línea!

Reduce todas las secuencias de ruptura de cadenas a dos casos usando clases de caracteres Regex.

JavaScript (ES6), 45 bytes

La manera ingenua.

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

Pruébalo en línea!

R , 89 87 81 78 bytes

-2 bytes gracias a @Giuseppe

-6 bytes gracias a @Nick Kennedy

-3 bytes reemplazando 1:length(y)con seq(a=y), donde aes la abreviatura dealong.with

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

usos \ / _ ~. Probablemente no sea tan corto como una solución basada en expresiones regulares, pero me imaginé hacer algo un poco diferente a los demás.

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

Los caracteres menores de 93 cambian el estado de arriba a abajo (o viceversa), y como tal se comportan como -1mientras que los demás no hacen nada y se comportan como 1, cumprod rastrea el estado con respecto al inicio. Los números pares están en el norte del estado (representados con -1), los números impares están en el estado hacia abajo ( 1). Si la cadena no se rompe, el estado rastreado multiplicado por la posición arriba / abajo no debe cambiar, siempre será la condición inicial ( -1, o 1)

Pruébalo en línea

Python , 46 bytes

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

Pruébalo en línea!

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

Intenté otros métodos menos rutinarios para verificar los pares de caracteres, pero todos fueron más largos que codificar todos los pares legales como este.

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

Pruébalo en línea!

Chip -z , 17 bytes

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

Pruébalo en línea! (TIO incluye -vpara facilitar la comprensión de la salida).

Espera el _/~\conjunto. Devuelve \x00(falso) o \x01(verdadero).

La estrategia para mi respuesta utiliza la siguiente información:

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

A: Esta posición de bit es 1cuando el lado izquierdo del símbolo es bajo y 0cuando es alto
F: esta posición de bit es 0cuando el lado derecho del símbolo es bajo y 1cuando es alto
C: esta posición de bit pasa a siempre sé1

Usando esta información, simplemente necesito verificar que Fcada personaje coincida con el not Adel siguiente. Una xorpuerta es una forma conveniente de lograr esto.

El siguiente código hace esto, pero da salida para cada emparejamiento (más un extra 1al inicio) (7 bytes):

FZ!
A}a

Queremos detenernos en el primer fallo, y también imprimir si nos hemos detenido dentro de la cadena o en el terminador nulo (también agregamos -zpara darnos un terminador nulo). Podemos usar not Cpara indicar dónde nos detuvimos, y eso nos da este programa (13 bytes):

FZ!C~a
A}^]~t

Pero todavía tenemos "ceros iniciales" (por ejemplo, \_/\da 00 00 00 00 01), por lo que esto se transforma en la respuesta dada en la parte superior.

05AB1E , 29 14 9 bytes

ÇümŽb‘÷ÈP

La respuesta de Port of @Arnauld 's Jelly , ¡así que asegúrate de votarlo también!

Entrada con ‾.

Pruébelo en línea o verifique todos los casos de prueba .

Respuesta original de 29 bytes :

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

Entrada con en ~lugar de ‾.

Parecía más corto en mi cabeza. Intentaré jugar golf desde aquí.

Pruébelo en línea o verifique todos los casos de prueba .

Explicación: "

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

Vea esta sugerencia mía 05AB1E (secciones ¿Cómo agrupar enteros grandes? Y ¿Cómo comprimir listas enteras? ) Para comprender por qué •6_üê{↕es 1781179816800959, ƵΔes 180y •6_üê{↕ƵΔвes [52,66,69,100,103,131,179].

Explicación adicional:

$2^4$["/_", 52]["\~", 66]["_~", 69]["//", 100]["\\", 100]["_\", 103]["~_", 131]["~/", 179]
__~~//\\0100~y _ en la cadena de entrada, antes de calcular y verificar las diferencias de pares.

Python 3 , 79 70 63 bytes

Guardado 16 bytes gracias a Arnauld y Jo King, ¡gracias!

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

Pruébalo en línea!

Python 3 , 67 60 bytes con ~ en lugar de ‾

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

Pruébalo en línea!

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

Esta variante utiliza en ~lugar de overlines. Toma los ocho pares válidos y comprueba si la cadena solo contiene esos:

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

Pruébalo en línea!

Sin golf:

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

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

Pruébalo en línea!

Una solución de expresiones regulares que simplemente comprueba que la cadena no contiene secuencias no válidas.

Explicación:

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

R , 43 caracteres, 47 bytes

Es la misma expresión regular que usan las otras respuestas, pero adaptada para R.

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

Pruébalo en línea!

Y obligatorio xkcd .

Adelante (adelante) , 100 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> ;

Pruébalo en línea!

Explicación

Ir a través de la cadena y determinar si cada personaje comienza en la misma posición (superior o inferior) que la anterior antes de finalizar. Resta 1 de un contador si no coinciden. Al final, si el contador ha cambiado, entonces la cadena no es una cadena.

La posición final es alta si char es / (47) o ~(126). De lo contrario, es bajo

La posición de inicio es alta si el carácter es \ (92) o ~(126). De lo contrario, es bajo

Explicación del código

\ 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

Pitón 3 , 80 78 bytes

Realmente no hago muchos campos de código de Python, pero pensé que podría intentarlo

• -2 bytes: realizado not (any ()) es lo mismo que all (not ()) y podría mover el not al r-string

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

Pruébalo en línea!

Python 3.8 (prelanzamiento) , 71 bytes

Quería probar la nueva :=asignación de expresión

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

Pruébalo en línea!

Jalea ,  13 12  11 bytes

O*Ɲ%⁽wḃ%5ỊẠ

Un enlace monádico que acepta una lista de caracteres, utiliza el ~en lugar de‾ opción .

Pruébalo en línea! O ver un conjunto de pruebas (... donde he reordenado para colocar los 8 falsey al final)

Esta fórmula fue encontrada jugando a mano: p (como fueron los siguientes)

Para este también yo, los 16 pares de ordinales de caracteres tratados como una exponenciación y busqué un módulo grande que se ajuste a tres bytes seguido de un módulo de un byte (1,2,3,4,5,6,7,8 , 9,10,16,256) que dividieron los 16 de manera que todos los resultados aceptables fueron 1 o 0 ("insignificante") ya que sé que Ịes más corto que <5, en mi solución anterior, que buscaba que todos los resultados aceptables fueran menores que todos inaceptables

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?

Los posibles personajes vecinos y sus evaluaciones internas:

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

Anterior @ 12:

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

Pruébalo en línea!

Anterior @ 13:

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

Pruébalo en línea!

perl 5, 26 25 bytes

utilizando ;como delimitador, el delimitador final se puede quitar

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

TIO

26 bytes

Excel, 150 bytes

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

Elimina cualquier par no válido, luego devuelve truesi esto da como resultado la cadena original.

Haskell, 42 bytes

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

esta solución usa ~, y la función para llamar es h (es decir, h stringda la respuesta)

La solución utiliza una función g que, dada una lista, devuelve todas las tuplas de valores adyacentes en la lista.

Luego usamos g para generar la lista de vecinos permitidos (in g"__/~~\\/\\_") y también la lista de todos los pares vecinos en la lista de entrada. Luego verificamos que cada par vecino sea un par permitido.

C (gcc) , 41 36 bytes

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

Pruébalo en línea!

-5 eliminó a &1partir de una idea de Peter Cordes ; operadores modificados (precedencia) para eliminar paréntesis

Utiliza ~. Comprueba los bits primero y sexto de las representaciones binarias de los dos primeros caracteres:

_ 1011111
\ 1011100
/  101111
~ 1111110
   ^    ^

y atraviesa la cadena de forma recursiva.

(*_ / 32) & 1es cierto solo para los caracteres que terminan alto, mientras que *_ & 1es cierto solo para los caracteres que comienzan bajo. (x&1) ^ (y&1) == (x+y)&1. XOR es add-without-carry, y el carry no perturba el bit más bajo. La 1proviene del f(_)valor de retorno, si el resto de la cadena era viscosa.

Bash, 30 bytes

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

La entrada es STDIN. El código de salida es 1 si es válido, 0 si no es válido.

SNOBOL4 (CSNOBOL4) , 58 bytes

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

Pruébalo en línea!

No genera nada para la verdad y un entero positivo (que indica la posición del primer salto en la cadena) para la falsedad.

Carbón , 32 18 bytes

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

Pruébalo en línea! El enlace es a la versión detallada del código. Explicación:

  θ                 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

Código de máquina x86, 13 bytes.

(O 11 bytes sin manejar cadenas de un solo carácter que son trivialmente fibrosas).

Utiliza la comprobación de posición de bit de la respuesta C de @ attinat

El mismo código de máquina funciona en modos de 16, 32 y 64 bits. La fuente es NASM para el modo de 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

Se puede llamar desde C como unsigned char string_connected(int dummy_rdi, const char *s, int dummy_rdx, size_t transitions);con la convención de llamadas del sistema V x86-64. No boolporque el caso transitions = 0 devuelva un código ASCII, no 1.

RCX = len = strlen(s) - 1. es decir, el número de límites de caracteres = transiciones para verificar en la cadena de longitud explícita.

Para transitions > 0, devuelve 0 (falta de coincidencia) o 1 (conectado) y deja ZF configurado en consecuencia. Para transitions == 0, devuelve el byte único de la cadena (que no es cero y, por lo tanto, también es verdadero). Si no fuera por ese caso especial, podríamos abandonar el JRCXZ de salida anticipada. Está dentro del bucle solo porque AL no es cero allí.

La lógica de posición de bit se basa en la observación de que el bit 0 del código ASCII le indica la altura inicial, y el bit 5 le indica la altura final.

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

Arnés de prueba (modificado del enlace TIO de attinat, tenga cuidado con el punto de secuencia C UB en esa función de referencia C). Pruébalo en línea! . Esta función es correcta para los 30 casos. (Incluyendo los casos de un solo carácter donde el valor de retorno no coincide: ambos son verdaderos con diferentes valores distintos de cero en ese caso).

Excel, 79 bytes

Celda A1como entrada

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

Dart , 94 bytes

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

Pruébalo en línea!

C ++, 132 110 bytes

-22 bytes gracias a ASCII-only

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

Utiliza una máscara de bits para saber si el inicio y el final están arriba o abajo

Retina , 26 bytes

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

Pruébalo en línea!

Utiliza en ~lugar de ‾, porque eso facilitaba la escritura.

Regex, 34 bytes

No pude encontrar reglas sobre el uso de Regex como idioma. Avíseme si necesito ajustar esto.

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

Pruébelo aquí: https://regex101.com/r/s9kyPm/1/tests

APL + WIN, 58 bytes

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

Solicita la entrada de la cadena, el origen del índice 0 y usa ~ para el carácter superior

Pruébalo en línea! Cortesía de Dyalog Classic.