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.
fuente
Respuestas:
Jalea , 9 bytes
-1 byte gracias a @EriktheOutgolfer
Esperar en0 0 o 1 .
~
lugar de‾
. DevuelvePrué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 sinorte es impar o inválida si norte es par.
Comentado
Jalea ,
14 1211 bytesAdmite (y espera) el0 0 o 1 .
‾
carácter en la cadena de entrada. DevuelvePruébalo en línea! , Banco de pruebas Truthy , banco de pruebas Falsy
¿Cómo?
Dados dos caracteres consecutivos de los códigos ASCIIX 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:
La transición es válida si , o inválida si .n ≤ 1 n > 1
1. Encontrado con una búsqueda de fuerza bruta en Node.js (usando BigInts)
Comentado
fuente
⁽"O
es lo mismo que9580
.Ruby -n , 30 bytes
Pruébalo en línea!
Reduce todas las secuencias de ruptura de cadenas a dos casos usando clases de caracteres Regex.
fuente
~
lugar de‾
. No estoy seguro de si es importante para este desafío, ya que el recuento de caracteres es el mismo./
s aunque estén entre corchetes?JavaScript (ES6), 45 bytes
La manera ingenua.
Pruébalo en línea!
fuente
s=>!/[~\/][\/_]|[_\\][\\~]/.test(s)
. Comprueba si\/
o~
termina en\/
o_
. Y luego, verifica si\\
o_
termina en\\
o~
.R ,
89 87 8178 bytes-2 bytes gracias a @Giuseppe
-6 bytes gracias a @Nick Kennedy
-3 bytes reemplazando
1:length(y)
conseq(a=y)
, dondea
es la abreviatura dealong.with
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.Los caracteres menores de 93 cambian el estado de arriba a abajo (o viceversa), y como tal se comportan como
-1
mientras que los demás no hacen nada y se comportan como1
, 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
, o1
)Pruébalo en línea
fuente
()
entornoy%%2
para ahorrar 2 bytes, ya que los operadores especiales%(any)%
tienen una prioridad bastante alta.!
Python , 46 bytes
Pruébalo en línea!
__/~~\/\_
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.
fuente
C (gcc) , 93 bytes
Pruébalo en línea!
fuente
w,o,r;k
.Chip
-z
, 17 bytesPruébalo en línea! (TIO incluye
-v
para 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:
A
: Esta posición de bit es1
cuando el lado izquierdo del símbolo es bajo y0
cuando es altoF
: esta posición de bit es0
cuando el lado derecho del símbolo es bajo y1
cuando es altoC
: esta posición de bit pasa a siempre sé1
Usando esta información, simplemente necesito verificar que
F
cada personaje coincida con elnot A
del siguiente. Unaxor
puerta es una forma conveniente de lograr esto.El siguiente código hace esto, pero da salida para cada emparejamiento (más un extra
1
al inicio) (7 bytes):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
-z
para darnos un terminador nulo). Podemos usarnot C
para indicar dónde nos detuvimos, y eso nos da este programa (13 bytes):Pero todavía tenemos "ceros iniciales" (por ejemplo,
\_/\
da00 00 00 00 01
), por lo que esto se transforma en la respuesta dada en la parte superior.fuente
05AB1E ,
29149 bytesLa 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 :
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: "
Vea esta sugerencia mía 05AB1E (secciones ¿Cómo agrupar enteros grandes? Y ¿Cómo comprimir listas enteras? ) Para comprender por qué
•6_üê{↕
es1781179816800959
,ƵΔ
es180
y•6_üê{↕ƵΔв
es[52,66,69,100,103,131,179]
.Explicación adicional:
["/_", 52]
["\~", 66]
["_~", 69]
["//", 100]
["\\", 100]
["_\", 103]
["~_", 131]
["~/", 179]
__
~~
//
\\
0
100
~
y_
en la cadena de entrada, antes de calcular y verificar las diferencias de pares.fuente
Python 3 ,
797063 bytesGuardado 16 bytes gracias a Arnauld y Jo King, ¡gracias!
Pruébalo en línea!
Python 3 ,
6760 bytes con ~ en lugar de ‾Pruébalo en línea!
fuente
Python 3, 126 bytes
fuente
Haskell , 70 bytes
Esta variante utiliza en
~
lugar de overlines. Toma los ocho pares válidos y comprueba si la cadena solo contiene esos:Pruébalo en línea!
Sin golf:
fuente
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:
fuente
R , 43 caracteres, 47 bytes
Es la misma expresión regular que usan las otras respuestas, pero adaptada para R.
Pruébalo en línea!
Y obligatorio xkcd .
fuente
~
en lugar de‾
para llegar a 43 bytes, 43 caracteres.Adelante (adelante) ,
10098 bytesPrué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 bajoLa posición de inicio es alta si el carácter es
\
(92) o~
(126). De lo contrario, es bajoExplicación del código
fuente
Pitón 3 ,
8078 bytesRealmente no hago muchos campos de código de Python, pero pensé que podría intentarlo
Pruébalo en línea!
Python 3.8 (prelanzamiento) , 71 bytes
Quería probar la nueva
:=
asignación de expresiónPruébalo en línea!
fuente
Jalea ,
13 1211 bytesUn 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 inaceptablesLos posibles personajes vecinos y sus evaluaciones internas:
Anterior @ 12:
Pruébalo en línea!
Anterior @ 13:
Pruébalo en línea!
fuente
Ị
estaba probando enabs(x)<1
lugar deabs(x)≤1
. Esto ofrece bastantes oportunidades más. :) (Estoy atascado en 11 bytes también por ahora, sin embargo.)Ị
muy útil.perl 5,
2625 bytesutilizando
;
como delimitador, el delimitador final se puede quitarTIO
26 bytes
fuente
Excel, 150 bytes
Elimina cualquier par no válido, luego devuelve
true
si esto da como resultado la cadena original.fuente
Haskell, 42 bytes
esta solución usa
~
, y la función para llamar es h (es decir,h string
da 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.fuente
C (gcc) ,
4136 bytesPruébalo en línea!
-5 eliminó a
&1
partir de una idea de Peter Cordes ; operadores modificados (precedencia) para eliminar paréntesisUtiliza
~
. Comprueba los bits primero y sexto de las representaciones binarias de los dos primeros caracteres:y atraviesa la cadena de forma recursiva.
(*_ / 32) & 1
es cierto solo para los caracteres que terminan alto, mientras que*_ & 1
es 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. La1
proviene delf(_)
valor de retorno, si el resto de la cadena era viscosa.fuente
c&32
Es cierto para los caracteres que terminan en alto, mientras quec&1
es cierto solo para los caracteres que comienzan bajo.)*_ ^ *++_
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 unreturn
, por lo que solo funcionagcc -O0
donde el cuerpo de la función es una expresión de declaración.&1
dos 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&1
2 bytes, porque(x&1) ^ y
no 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 ...Bash, 30 bytes
La entrada es STDIN. El código de salida es 1 si es válido, 0 si no es válido.
fuente
SNOBOL4 (CSNOBOL4) , 58 bytes
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.
fuente
Carbón ,
3218 bytesPruébalo en línea! El enlace es a la versión detallada del código. Explicación:
fuente
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.
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. Nobool
porque 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. Paratransitions == 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.
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).
fuente
Excel, 79 bytes
Celda
A1
como entradafuente
Dart , 94 bytes
Pruébalo en línea!
fuente
C ++,
132110 bytes-22 bytes gracias a ASCII-only
Utiliza una máscara de bits para saber si el inicio y el final están arriba o abajo
fuente
Retina , 26 bytes
Pruébalo en línea!
Utiliza en
~
lugar de‾
, porque eso facilitaba la escritura.fuente
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
fuente
‾
a~
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.
fuente