Aquí hay un simple arte rubí ASCII :
___
/\_/\
/_/ \_\
\ \_/ /
\/_\/
Como joyero de ASCII Gemstone Corporation, su trabajo es inspeccionar los rubíes recién adquiridos y dejar una nota sobre cualquier defecto que encuentre.
Afortunadamente, solo son posibles 12 tipos de defectos, y su proveedor garantiza que ningún rubí tendrá más de un defecto.
Los 12 defectos corresponden a la sustitución de uno de los 12 internos _
, /
o \
personajes de la rubí con un carácter de espacio ( ). El perímetro exterior de un rubí nunca tiene defectos.
Los defectos están numerados de acuerdo con qué carácter interno tiene un espacio en su lugar:
Entonces un rubí con defecto 1 se ve así:
___
/\_/\
/_/ _\
\ \_/ /
\/_\/
Un rubí con defecto 11 se ve así:
___
/\_/\
/_/ \_\
\ \_/ /
\ _\/
Es la misma idea para todos los demás defectos.
Reto
Escriba un programa o función que tome la cadena de un único rubí potencialmente defectuoso. El número de defecto debe imprimirse o devolverse. El número de defecto es 0 si no hay ningún defecto.
Tome la entrada de un archivo de texto, stdin o un argumento de función de cadena. Devuelva el número de defecto o imprímalo en stdout.
Puede suponer que el rubí tiene una nueva línea final. Es posible que no asuma que no tiene ningún saltos de línea finales espacios o líderes.
El código más corto en bytes gana. ( Práctico contador de bytes ) .
Casos de prueba
Los 13 tipos exactos de rubíes, seguidos directamente por su producción esperada:
___
/\_/\
/_/ \_\
\ \_/ /
\/_\/
0
___
/\_/\
/_/ _\
\ \_/ /
\/_\/
1
___
/\ /\
/_/ \_\
\ \_/ /
\/_\/
2
___
/\_/\
/_ \_\
\ \_/ /
\/_\/
3
___
/\_/\
/_/ \_\
\ _/ /
\/_\/
4
___
/\_/\
/_/ \_\
\ \ / /
\/_\/
5
___
/\_/\
/_/ \_\
\ \_ /
\/_\/
6
___
/\_/\
/_/ \ \
\ \_/ /
\/_\/
7
___
/\_ \
/_/ \_\
\ \_/ /
\/_\/
8
___
/ _/\
/_/ \_\
\ \_/ /
\/_\/
9
___
/\_/\
/ / \_\
\ \_/ /
\/_\/
10
___
/\_/\
/_/ \_\
\ \_/ /
\ _\/
11
___
/\_/\
/_/ \_\
\ \_/ /
\/_ /
12
fuente
Respuestas:
CJam,
2723 bytesConvierta la base 11, tome el mod 67, tome el mod 19 del resultado y luego encuentre el índice de lo que tiene en la matriz
¡Mágico!
Pruébalo en línea .
fuente
Ruby 2.0, 69 bytes
Hexdump (para mostrar fielmente los datos binarios en la cadena):
Explicación:
-Kn
opción lee el archivo fuente comoASCII-8BIT
(binario).-0
opción permitegets
leer toda la entrada (y no solo una línea).-rdigest
opción carga eldigest
módulo, que proporcionaDigest::MD5
.fuente
Julia
9059 bytesDefinitivamente no es el más corto, pero la bella doncella Julia se cuida mucho en la inspección de los rubíes reales.
Esto crea una función lambda que acepta una cadena
s
y devuelve el número de defecto ruby correspondiente. Para llamarlo, dale un nombre, por ejemplof=s->...
.Ungolfed + explicación:
Ejemplos:
Tenga en cuenta que las barras invertidas deben escaparse en la entrada. Confirmé con @ Calvin'sHobbies que está bien.
¡Avíseme si tiene alguna pregunta o sugerencia!
Editar: ¡ Guardado 31 bytes con la ayuda de Andrew Piliser!
fuente
search
indexación de matrices.s->(d=reshape([18 10 16 24 25 26 19 11 9 15 32 34],12);search(s[d],' '))
. No me gusta la remodelación, pero no se me ocurrió una forma más corta de obtener una matriz 1d.reshape()
es usarvec()
. :)> <> (Pez) , 177 bytes
Esta es una solución larga pero única. El programa no contiene aritmética ni ramificación, aparte de insertar caracteres de entrada en lugares fijos en el código.
Observe que todos los caracteres de construcción de rubíes inspeccionados (
/ \ _
) pueden ser "espejos" en el código> <> que cambian la dirección del puntero de instrucción (IP).Podemos usar estos caracteres de entrada para construir un laberinto a partir de ellos con la instrucción de modificación del código
p
y en cada salida (que se crea con un espejo faltante en la entrada) podemos imprimir el número correspondiente.Las
S B U
letras son las que se cambiaron/ \ _
respectivamente. Si la entrada es un rubí completo, el código final se convierte en:Puede probar el programa con este excelente intérprete visual en línea . Como no puede ingresar nuevas líneas allí, debe usar algunos caracteres ficticios para poder ingresar un rubí completo como, por ejemplo
SS___LS/\_/\L/_/S\_\L\S\_/S/LS\/_\/
. (Los espacios también cambiaron a S debido a la rebaja).fuente
CJam,
41 31 2928 bytesComo de costumbre, para los caracteres no imprimibles, siga este enlace .
Pruébalo en línea aquí
Explicación pronto
Enfoque previo:
Estoy bastante seguro de que esto se puede reducir cambiando los dígitos / la lógica de conversión. Pero aquí va el primer intento:
Como de costumbre, usa este enlace para caracteres no imprimibles.
La lógica es bastante simple
"Hash for each defect":i
- Esto me da el hash por defecto como índiceqN-"/\\_ "4,er
- esto convierte los caracteres en números4b1e3%A/
- este es el número único en el número convertido base#
Luego, simplemente encuentro el índice del número único en el hashPruébalo en línea aquí
fuente
.h
este momento no sirve para nada porque usa la función no confiable y mala incorporadahash()
), hasta entonces no puedo hacerlo mejor.Slip ,
123108+ 3 = 111 bytesEjecutar con las banderas
n
yo
, es decirAlternativamente, pruébelo en línea .
Slip es un lenguaje tipo regex que se creó como parte del desafío de coincidencia de patrones 2D . Slip puede detectar la ubicación de un defecto con la
p
bandera de posición a través del siguiente programa:que busca uno de los siguientes patrones (aquí
S
denota que comienza el partido):Pruébelo en línea : las coordenadas se generan como un par (x, y). Todo se lee como una expresión regular normal, excepto que:
`
se usa para escapar,<>
gire el puntero del partido hacia la izquierda / derecha respectivamente^6
establece el puntero de coincidencia para mirar hacia la izquierda, y\
desliza el puntero del fósforo ortogonalmente hacia la derecha (por ejemplo, si el puntero está orientado hacia la derecha, entonces baja una fila)Pero desafortunadamente, lo que necesitamos es un solo número del 0 al 12 que indique qué defecto se detectó, no dónde se detectó. El deslizamiento solo tiene un método para generar un solo número: el
n
indicador que genera el número de coincidencias encontradas.Para hacer esto, expandimos la expresión regular anterior para que coincida con el número correcto de veces para cada defecto, con la ayuda del
o
modo de coincidencia superpuesta. Desglosados, los componentes son:Sí, es un uso exagerado de
?
para obtener los números correctos: Pfuente
JavaScript (ES6), 67
72Simplemente busca espacios en blanco en las 12 ubicaciones dadas
Editar guardado 5 bytes, thx @apsillers
Prueba en la consola Firefox / FireBug
Salida
fuente
C,
9884 bytesACTUALIZACIÓN: Un poco más inteligente sobre la cadena y solucionó un problema con los rubíes no defectuosos.
Desenredado:
Muy sencillo y justo menos de 100 bytes.
Para las pruebas:
Entrada a STDIN.
Cómo funciona
Cada defecto en el rubí se encuentra en un carácter diferente. Esta lista muestra dónde se produce cada defecto en la cadena de entrada:
Dado que hacer una matriz de
{17,9,15,23,24,25,18,10,8,14,31,33}
costos cuesta muchos bytes, encontramos una forma más corta de crear esta lista. Observe que agregar 30 a cada número da como resultado una lista de enteros que podrían representarse como caracteres ASCII imprimibles. Esta lista es la siguiente:"/'-5670(&,=?"
. Por lo tanto, podemos establecer una matriz de caracteres (en el códigoc
) en esta cadena, y simplemente restar 30 de cada valor que recuperamos de esta lista para obtener nuestra matriz original de enteros. Definimosa
ser igual ac
para realizar un seguimiento de qué tan lejos hemos llegado a la lista. Lo único que queda en el código es elfor
bucle. Comprueba para asegurarse de que aún no hemos llegado al final dec
, y luego comprueba si el carácter deb
en la actualidadc
es un espacio (ASCII 32). Si es así, establecemos el primer elemento no utilizado deb
al número de defecto y devolverlo.fuente
Python 2,
146888671 bytesLa función
f
prueba la ubicación de cada segmento y devuelve el índice del segmento del defecto. Una prueba en el primer byte en la cadena de entrada asegura que regresemos0
si no se encuentran defectos.Ahora empaquetamos los desplazamientos de segmentos en una cadena compacta y los usamos
ord()
para recuperarlos:Prueba con un rubí perfecto:
Prueba con el segmento 2 reemplazado por un espacio:
EDITAR: Gracias a @xnor por la buena
sum(n*bool for n in...)
técnica.EDIT2: Gracias a @ Sp3000 por consejos de golf adicionales.
fuente
sum(n*(s[...]==' ')for ...)
.<'!'
lugar de==' '
un byte. También puede generar la lista conmap(ord, ...)
, pero no estoy seguro de cómo se siente acerca de los no imprimibles :)Pyth,
353128 bytesRequiere un Pyth parcheado , la última versión actual de Pyth tiene un error
.z
que elimina los caracteres finales.Esta versión no utiliza una función hash, abusa de la función de conversión de base en Pyth para calcular un hash muy estúpido pero funcional. Luego convertimos ese hash en un carácter y buscamos su índice en una cadena.
La respuesta contiene caracteres no imprimibles, use este código Python3 para generar el programa con precisión en su máquina:
fuente
Haskell, 73 bytes
La misma estrategia que muchas otras soluciones: buscar espacios en las ubicaciones dadas. La búsqueda devuelve una lista de índices de los cuales tomo el último elemento, porque siempre hay un hit para el índice 0.
fuente
05AB1E , 16 bytes
Pruébelo en línea o verifique todos los casos de prueba .
Explicación:
Vea esta sugerencia mía 05AB1E (secciones ¿Cómo comprimir enteros grandes? Y ¿Cómo comprimir listas enteras? ) Para comprender por qué
•W)Ì3ô;4(•
es2272064612422082397
y•W)Ì3ô;4(•₆в
es[17,9,15,23,24,25,18,10,8,14,31,33]
.fuente