¿Funcionaría esta cadena como cadena?


92

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:

ruta de ejemplo

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.


37
Bienvenido a PPCG! Bonito primer desafío.
AdmBorkBork

1
¿Son los personajes especificados en su desafío los únicos que aparecerán en la cadena?
Encarnación de la ignorancia

@EmbodimentofIgnorance Sí, solo el 4.
Juegos discretos

30
Espera, puedes hacer un lenguaje de esto
Delioth

2
@Arnauld No, realmente creo que solo es verdad para los conectados y falso para los que no están conectados. (¿A menos que permitir un intercambio sea normal para este tipo de preguntas?)
Juegos discretos

Respuestas:


34

Jalea , 9 bytes

-1 byte gracias a @EriktheOutgolfer

Esperar en ~lugar de . Devuelve 0 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):

norte=Xy15145

La transición es válida si norte es impar o inválida si norte 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 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 1 es:

norte=(Xymod276)mod7 7

La transición es válida si , o inválida si .norte1norte>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

2
método de tabla de búsqueda ha ganado muchos problemas
qwr

9 bytes : ⁽"Oes lo mismo que 9580.
Erik el Outgolfer

@EriktheOutgolfer Gracias. :) Tal vez el script proporcionado en este consejo debería actualizarse para admitir este formato (cuando sea relevante).
Arnauld

1
@Arnauld En realidad, Jonathan Allan ha hecho esto .
Erik el Outgolfer

16

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.


55
Puede guardar 4 bytes utilizando en ~lugar de . No estoy seguro de si es importante para este desafío, ya que el recuento de caracteres es el mismo.
iamnotmaynard

¿Necesitas escapar de los /s aunque estén entre corchetes?
Solomon Ucko

14

JavaScript (ES6), 45 bytes

La manera ingenua.

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

Pruébalo en línea!


1
Entonces, ¿esto está verificando todos los emparejamientos no válidos, asegurándose de que no existan en la cadena? Inteligente.
Juegos discretos

@DiscreteGames Sí, exactamente. (Excepto que olvidé 2 de ellos. Ahora arreglado.)
Arnauld

35: bytes s=>!/[~\/][\/_]|[_\\][\\~]/.test(s). Comprueba si \/o ~termina en \/o _. Y luego, verifica si \\o _termina en \\o ~.
Ismael Miguel

@IsmaelMiguel Esto podría publicarse como una respuesta por separado, pero será mejor que deje esta sin cambios como referencia, ya que muestra la expresión regular más simple (como 'menos complicada') para resolver el problema.
Arnauld

Puede publicarlo como una alternativa, pero no como respuesta definitiva.
Ismael Miguel

10

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


2
¡Esto es bastante inteligente y una forma única de hacer las cosas! Creo que puede eliminar el ()entorno y%%2para ahorrar 2 bytes, ya que los operadores especiales %(any)%tienen una prioridad bastante alta.
Giuseppe

3
¿Qué tal tio para 83 bytes? Aprovecha la coerción implícita a lógica por!
Nick Kennedy

9

Python , 46 bytes

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

Pruébalo en línea!

__/~~\/\_23=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.



6

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.


Agradable, noté este patrón pero no sabía un buen lenguaje para explotarlo.
histocrat

6

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:

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


1
Ahora 9 bytes .
Arnauld

@Arnauld ¡Qué bien!
Kevin Cruijssen

Esa explicación funcionaría como una cadena.
connectyourcharger

@connectyourcharger ¿Qué quieres decir?
Kevin Cruijssen

6

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!


2
Buena primera respuesta! Puede guardar 6 bytes eliminando algunos espacios en blanco. (Es posible que desee agregar un enlace TIO, por cierto).
Arnauld

1
¡Gracias! Estoy disfrutando aprender todos estos trucos
Joachim Worthington

4

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])

4

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

4

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

4

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 .


1
puede usar ~en lugar de para llegar a 43 bytes, 43 caracteres.
Giuseppe

2
Es cierto, pero es más divertido con el overbar. :)
CT Hall

4

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

3

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!


3

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!


Por alguna razón, pensé que estaba probando en abs(x)<1lugar de abs(x)≤1. Esto ofrece bastantes oportunidades más. :) (Estoy atascado en 11 bytes también por ahora, sin embargo.)
Arnauld

Me parece muy útil.
Jonathan Allan


3

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.


3

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.


3

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.


El desplazamiento a la derecha en 5 deja el sexto bit en la parte inferior. Entonces estás revisando los bits 0 y 5, o los bits primero y sexto. (Este es un truco realmente agradable, por cierto, bien hecho. c&32Es cierto para los caracteres que terminan en alto, mientras que c&1es cierto solo para los caracteres que comienzan bajo.)
Peter Cordes

Sé que las reglas solo requieren que funcione en al menos una implementación, pero aún vale la pena señalar que *_ ^ *++_es un comportamiento indefinido: ^no es un punto de secuencia, por lo que no hay una relación secuenciada antes que garantice que obtengan diferentes caracteres. Por supuesto, también le falta un return, por lo que solo funciona gcc -O0donde el cuerpo de la función es una expresión de declaración.
Peter Cordes

Vaya, tienes razón sobre los bits. Gracias por atrapar eso
attinat

1
Hacer &1dos veces es redundante. (x^y)&1 == (x&1) ^ (y&1). Pero dada la precedencia del operador C donde &tiene mayor prioridad que ^(a diferencia de los operadores aritméticos donde + y - tienen la misma prioridad), necesitaríamos agregar ()2 bytes para eliminar &12 bytes, porque (x&1) ^ yno es equivalente. Pero tal vez el uso de parens abre oportunidades para otros ahorros. Afortunadamente no es un problema para una versión de código máquina x86 de esto, donde la manipulación de bits es muy compacta ...
Peter Cordes

Terminé mi respuesta de código de máquina x86 , 13 bytes usando este algoritmo.
Peter Cordes

2

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.



1

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

1

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


1

Excel, 79 bytes

Celda A1como entrada

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


0

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


hmm no portaría la versión C sería más golfista: P
solo ASCII





Al usar nuestro sitio, usted reconoce que ha leído y comprende nuestra Política de Cookies y Política de Privacidad.
Licensed under cc by-sa 3.0 with attribution required.