Escreva um programa que utilize uma única linha que você possa assumir que conterá apenas os caracteres /\_‾. (Isso é barra invertida e traseira, sublinhado e overline . Você pode usá-lo ~no lugar de overline, se necessário, pois o overline não é conveniente ASCII.)

Por exemplo, uma entrada possível é:

__/‾‾\/\_/‾

Seu programa precisa gerar um valor verdadeiro ou falso, dependendo de a borda esquerda da string estar "conectada", por assim dizer, à borda direita da string através das linhas dos caracteres. Portanto, se o kerning fosse um pouco menor, haveria uma linha preta sólida (embora retorcida) todo o caminho da borda esquerda para a direita, como um pedaço ininterrupto de barbante ou barbante.

A saída para o exemplo acima seria verdadeira porque as bordas estão conectadas:

Para ser claro sobre as conexões:

• / conecta no canto inferior esquerdo e superior direito
• \ conecta no canto superior esquerdo e no canto inferior direito
• _ conecta no canto inferior esquerdo e inferior direito
• ‾(ou ~) se conecta no canto superior esquerdo e no canto superior direito

Além disso:

• Não importa se as arestas da string começaram na parte superior ou inferior, é importante que elas se conectem horizontalmente por todo o comprimento da string.

• Você pode assumir que a sequência de entrada não está vazia e, é claro, apenas uma linha.

Aqui estão mais alguns exemplos seguidos por 1 (verdade) se eles estiverem conectados ou 0 (falso) se não:

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

O código mais curto é o vencedor.

Geléia , 9 bytes

-1 byte graças a @EriktheOutgolfer

Espere em ~vez de ‾. Retorna ou 1 .$0$$1$

O*Ɲ:⁽8ƇḂẠ

Experimente online! , Conjunto de testes Truthy , conjunto de testes Falsas

Usando esta fórmula (mas semelhante à versão de 11 bytes abaixo):

A transição é válida se $n$ for ímpar ou inválida se $n$ for 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

Geléia ,  14 12  11 bytes

Suporta (e espera) o ‾caractere na sequência de entrada. Retorna $0$ ou $1$ .

O*Ɲ%276%7ỊẠ

Experimente online! , Conjunto de testes Truthy , conjunto de testes Falsas

Quão?

Dados dois caracteres consecutivos dos códigos ASCII $x$ e $y$ , queremos uma função que verifique se eles formam uma transição válida.

Precisamos de uma operação não comutativa, porque o resultado pode mudar quando os caracteres são revertidos. Por exemplo, _/é válido, mas /_não é.

Usando exponenciação, uma possível fórmula ¹ é:

A transição é válida se ou inválida 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. Encontrado com uma pesquisa de força bruta no 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 !/[_\\][\\‾]|[\/‾][_\/]/

Experimente online!

Reduz todas as sequências de quebra de cadeia para dois casos usando classes de caracteres Regex.

JavaScript (ES6), 45 bytes

O caminho ingênuo.

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

Experimente online!

R , 89 87 81 78 bytes

-2 bytes graças a @ Giuseppe

-6 bytes graças a @Nick Kennedy

-3 bytes substituindo 1:length(y)por seq(a=y), onde aé a abreviação dealong.with

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

usos \ / _ ~. Provavelmente isso não é tão curto quanto uma solução baseada em regex, mas imaginei fazer algo um pouco diferente para todos os outros.

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

Os caracteres menores que 93 alternam o estado de cima para baixo (ou vice-versa) e, como tal, se comportam como -1enquanto os outros não fazem nada e se comportam como 1, cumprod rastreia o estado com relação ao início. Os números pares estão em um estado norte (representado por -1), os números ímpares estão em um estado inativo ( 1). Se a sequência não for quebrada, o estado rastreado multiplicado pela posição cima / baixo não deve mudar, sempre será a condição inicial ( -1ou 1)

Experimente online

Python , 46 bytes

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

Experimente online!

Confirma que cada par adjacente de caracteres se conecta, verificando se eles aparecem consecutivamente __/~~\/\_. Essa sequência pode ser vista como uma sequência De_Bruijn nos triplos das posições alta / baixa.$2^3=8$

Tentei outros métodos menos monótonos para verificar pares de caracteres, mas eles eram todos mais longos que codificavam todos os pares legais como esse.

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

Experimente online!

Chip -z , 17 bytes

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

Experimente online! (O TIO inclui -vpara facilitar a compreensão da saída.)

Espera o _/~\conjunto. Retorna \x00(falsy) ou \x01(truthy).

A estratégia para minha resposta usa as seguintes informações:

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

A: Esta posição de bit ocorre 1quando o lado esquerdo do símbolo está baixo e 0quando está alto
F: Esta posição de bit ocorre 0quando o lado direito do símbolo está baixo e 1quando está alto
C: Esta posição de bit ocorre com sempre seja1

Usando essas informações, basta verificar se o Fde cada caractere corresponde ao not Ado próximo. Um xorportão é uma maneira conveniente de conseguir isso.

O código a seguir faz isso, mas fornece saída para cada emparelhamento (mais um extra 1no início) (7 bytes):

FZ!
A}a

Queremos interromper na primeira falha e também imprimir se paramos dentro da string ou no terminador nulo (também adicionamos -zpara nos dar um terminador nulo). Podemos usar not Cpara indicar onde paramos, e isso nos dá este programa (13 bytes):

FZ!C~a
A}^]~t

Mas ainda temos "zeros à esquerda" (por exemplo, \_/\dá 00 00 00 00 01), então isso é transformado na resposta dada no topo.

05AB1E , 29 14 9 bytes

ÇümŽb‘÷ÈP

Porto de @Arnauld resposta Jelly 's , por isso, certifique-se de upvote-lo bem!

Entrada com ‾.

Experimente online ou verifique todos os casos de teste .

Resposta original de 29 bytes :

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

Insira com em ~vez de ‾.

Soou mais curto na minha cabeça .. Vai tentar jogar golfe daqui.

Experimente online ou verifique todos os casos de teste .

Explicação: "

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

Veja esta minha dica do 05AB1E (seções Como aceitar números inteiros grandes? E Como comprimir listas inteiras? ) Para entender por que •6_üê{↕é 1781179816800959, ƵΔé 180e •6_üê{↕ƵΔвé [52,66,69,100,103,131,179].

Explicação adicional:

$2^4$["/_", 52]["\~", 66]["_~", 69]["//", 100]["\\", 100]["_\", 103]["~_", 131]["~/", 179]
__~~//\\0100~e _ na sequência de entrada, antes de calcular e verificar as diferenças de pares.

Python 3 , 79 70 63 bytes

Economizou 16 bytes graças a Arnauld e Jo King, obrigado!

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

Experimente online!

Python 3 , 67 60 bytes com ~ em vez de ‾

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

Experimente 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

Essa variante usa em ~vez de overlines. Ele pega todos os oito pares válidos e verifica se a sequência contém apenas aqueles:

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

Experimente 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

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

Experimente online!

Uma solução regex que simplesmente verifica se a sequência não contém sequências inválidas.

Explicação:

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

R , 43 caracteres, 47 bytes

É o mesmo regex que as outras respostas usam, mas adaptado para R.

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

Experimente online!

E xkcd obrigatório .

Quarto (gforth) , 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> ;

Experimente online!

Explicação

Percorra a sequência e determine se cada caractere começa na mesma posição (superior ou inferior) que a anterior antes de terminar. Subtraia 1 de um contador se não corresponderem. No final, se o contador mudou, a sequência não é uma sequência.

A posição final é alta se char for /(47) ou ~(126). Caso contrário, está baixo

A posição inicial é alta se char for \(92) ou ~(126). Caso contrário, está baixo

Código Explicação

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

Eu realmente não faço muitos campos de código python, mas achei que poderia tentar

• -2 bytes: realizado not (any ()) é o mesmo que all (not ()) e pode mover o not para a string r

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

Experimente online!

Python 3.8 (pré-lançamento) , 71 bytes

Eu queria experimentar a nova :=atribuição de expressão

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

Experimente online!

Geléia ,  13 12  11 bytes

O*Ɲ%⁽wḃ%5ỊẠ

Um link monádico que aceita uma lista de caracteres usa o ~lugar da ‾opção

Experimente online! Ou veja uma suíte de testes (... onde eu reordenei para colocar as 8 falsey no final)

Essa fórmula foi encontrada mexendo à mão: p (como as que estão abaixo)

Para este, eu também todos os 16 pares de ordinais de caracteres tratados como exponenciação e procuramos um módulo grande que caiba em três bytes, seguido por um módulo de um byte (1,2,3,4,5,6,7,8 9,10,16,256) que particionaram os 16 de modo que todos os resultados aceitáveis ​​fossem 1 ou 0 ("insignificantes"), pois sei que Ịé mais curto do que <5na minha solução anterior, que procurava todos os resultados aceitáveis ​​inferiores a todos inaceitáveis.

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?

Os possíveis personagens vizinhos e suas avaliações 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Ạ

Experimente online!

Anterior @ 13:

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

Experimente online!

perl 5, 26 25 bytes

usando ;como delimitador, o delimitador final pode ser removido

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

TIO

26 bytes

Excel, 150 bytes

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

Remove quaisquer pares inválidos e, em seguida, retorna truese isso resultar na string original.

Haskell, 42 bytes

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

essa solução usa ~e a função a ser chamada é h (ou seja, h stringfornece a resposta)

A solução usa uma função g que, dada uma lista, retorna todas as tuplas de valores adjacentes na lista.

Em seguida, usamos g para gerar a lista de vizinhos permitidos (in g"__/~~\\/\\_") e também a lista de todos os pares vizinhos na lista de entrada. Em seguida, verificamos que cada par vizinho é um par permitido.

C (gcc) , 41 36 bytes

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

Experimente online!

-5 eliminado &1partindo de uma idéia de Peter Cordes ; operadores alterados (precedência) para remover parênteses

Usos ~. Verifica o primeiro e o sexto bits das representações binárias dos dois primeiros caracteres:

_ 1011111
\ 1011100
/  101111
~ 1111110
   ^    ^

e atravessa a string recursivamente.

(*_ / 32) & 1é verdadeiro apenas para caracteres que terminam altos, enquanto *_ & 1é válido apenas para caracteres que começam baixos. (x&1) ^ (y&1) == (x+y)&1. XOR é adicionar sem transportar, e transportar não perturba o bit mais baixo. O valor 1vem do f(_)valor de retorno, se o restante da string for pegajoso.

Bash, 30 bytes

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

A entrada é STDIN. O código de saída é 1 se válido, 0 se inválido.

SNOBOL4 (CSNOBOL4) , 58 bytes

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

Experimente online!

Não produz nada para verdade e um número inteiro positivo (indicando a posição da primeira quebra na cadeia) para falsidade.

Carvão , 32 18 bytes

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

Experimente online! Link é a versão detalhada do código. Explicação:

  θ                 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.

(Ou 11 bytes sem manipular cadeias de caracteres simples trivialmente.)

Usa a verificação de posição de bit da resposta C de @ attinat

O mesmo código de máquina funciona nos modos de 16, 32 e 64 bits. A fonte é NASM para o 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

É possível chamar de C como unsigned char string_connected(int dummy_rdi, const char *s, int dummy_rdx, size_t transitions);na convenção de chamada do System V x86-64. Não boolporque o caso transitions = 0 retorne um código ASCII, não 1.

RCX = len = strlen(s) - 1. ou seja, o número de limites de caracteres = transições para verificar a cadeia de comprimento explícito.

Para transitions > 0, retorna 0 (incompatibilidade) ou 1 (conectado) e deixa ZF definido de acordo. Para transitions == 0, retorna o byte único da sequência (que é diferente de zero e, portanto, também é verdade). Se não fosse nesse caso especial, poderíamos descartar o JRCXZ de saída antecipada. Ele está dentro do loop apenas porque AL não é zero lá.

A lógica da posição do bit é baseada na observação de que o bit 0 do código ASCII indica a altura inicial e o bit 5 indica a 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 teste (modificado a partir do link TIO da attinat, cuidado com o ponto de sequência C UB nessa função de referência C). Experimente online! . Esta função está correta para todos os 30 casos. (Incluindo os casos de caractere único em que o valor de retorno não corresponde: ambos são verdadeiros com valores diferentes de zero nesse caso.)

Excel, 79 bytes

Célula A1como entrada

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

Dardo , 94 bytes

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

Experimente online!

C ++, 132 110 bytes

-22 bytes graças ao 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;}

Usa uma máscara de bits para saber se o início e o fim estão ativos ou inativos

Retina , 26 bytes

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

Experimente online!

Usa em ~vez de ‾, porque isso facilitou a digitação.

Regex, 34 bytes

Não consegui encontrar regras sobre o uso do Regex como idioma. Entre em contato se precisar ajustar isso.

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

Experimente aqui: 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 a entrada da string, origem do índice 0 e usa ~ para o caractere superior

Experimente online! Cortesia de Dyalog Classic