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

CJam, 27 23 bytes

F7EC5ZV4DI8G6]qBb67%J%#

Convierta 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

[15, 7, 14, 12, 5, 3, 0, 4, 13, 18, 8, 16, 6]

¡Mágico!

Pruébalo en línea .

Ruby 2.0, 69 bytes

#!ruby -Kn0rdigest
p'×ñF<ìX‚ɲŸ_'.index Digest::MD5.digest(gets)[0]

Hexdump (para mostrar fielmente los datos binarios en la cadena):

00000000  23 21 72 75 62 79 20 2d  4b 6e 30 72 64 69 67 65  |#!ruby -Kn0rdige|
00000010  73 74 0a 70 27 d7 f1 46  3c 1f ec 58 82 c9 b2 9f  |st.p'..F<..X....|
00000020  5f 02 27 2e 69 6e 64 65  78 20 44 69 67 65 73 74  |_.'.index Digest|
00000030  3a 3a 4d 44 35 2e 64 69  67 65 73 74 28 67 65 74  |::MD5.digest(get|
00000040  73 29 5b 30 5d                                    |s)[0]|

Explicación:

1. La -Knopción lee el archivo fuente como ASCII-8BIT(binario).
2. La -0opción permite getsleer toda la entrada (y no solo una línea).
3. La -rdigestopción carga el digestmódulo, que proporciona Digest::MD5.
4. Luego, el código realiza un MD5 de la entrada, toma el primer byte del resumen y obtiene su índice en la cadena binaria dada.

Julia 90 59 bytes

Definitivamente no es el más corto, pero la bella doncella Julia se cuida mucho en la inspección de los rubíes reales.

s->search(s[vec([18 10 16 24 25 26 19 11 9 15 32 34])],' ')

Esto crea una función lambda que acepta una cadena sy devuelve el número de defecto ruby ​​correspondiente. Para llamarlo, dale un nombre, por ejemplo f=s->....

Ungolfed + explicación:

function f(s)
    # Strings can be indexed like arrays, so we can define d to
    # be a vector of indices corresponding to potential defect
    # locations

    d = vec([18 10 16 24 25 26 19 11 9 15 32 34])

    # Check the specified locations for defects, returning the
    # defect number as the index where a space was found and
    # was not expected. If no spaces are found, 0 is returned.

    search(s[d], ' ')
end

Ejemplos:

julia> f("  ___
 /\\ /\\
/_/ \\_\\
\\ \\_/ \/
 \\/_\\/")
2

julia> f("  ___
 /\\_/\\
/_/ \\_\\
\\ \\_/ \/
 \\/_\\/")
0

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!

> <> (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 py en cada salida (que se crea con un espejo faltante en la entrada) podemos imprimir el número correspondiente.

iiiiiiiii19pi1cpi18piiii2bpi27pii28pi3apiiiii37pi49pi36piiiii00pi45pii46p

    ;
   ;n
  ;nb
 ;n6S    0n;
 n3SB   cn;
 8SB!  4n;
 SB!  1n;
>B! U9n;
 ! U5
  U7n
 Uan;
 2n;
 n;
 ;

Las S B Uletras son las que se cambiaron / \ _respectivamente. Si la entrada es un rubí completo, el código final se convierte en:

\iiiiiiii19pi1cpi18piiii2bpi27pii28pi3apiiiii37pi49pi36piiiii00pi45pii46p

    ;
   ;n
  ;nb
 ;n6/    0n;
 n3/\   cn;
 8/\!  4n;
 /\!  1n;
>\! _9n;
 ! _5
  _7n
 _an;
 2n;
 n;
 ;

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

CJam, 41 31 29 28 bytes

"-RI)11a!"q103b1e3%A/c#

Como 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:

"<KJ[]\"O=":iqN-"/\\_ "4,er4b1e3%A/#

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 índice
• qN-"/\\_ "4,er - esto convierte los caracteres en números
• 4b1e3%A/ - este es el número único en el número convertido base
• # Luego, simplemente encuentro el índice del número único en el hash

Pruébalo en línea aquí

Slip , 123108 + 3 = 111 bytes

^6 (`\\`_.?<?.?[ _]?|`_(`\.?(<.?|>)|`/.?.?>.?.?).?)| `_(`\.?<.?>?.?.?|`/(.?>.?.?.?|<`_))| `/\`_.?(.<.?>?.?)?

Ejecutar con las banderas ny o, es decir

py -3 slip.py regex.txt input.txt no

Alternativamente, 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 pbandera de posición a través del siguiente programa:

^6? `_[/\]|( `/|^6 `\)\`_

que busca uno de los siguientes patrones (aquí Sdenota que comienza el partido):

S_/    S_\    /_S    \_S    S/      _
                              _      \S

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 nindicador 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 omodo de coincidencia superpuesta. Desglosados, los componentes son:

1 11:    `_`\.?<.?>?.?.?
2 10:    `/\`_.?(.<.?>?.?)?
4 9:     `_`/(.?>.?.?.?|<`_)
3 12:   ^6 `_`/.?.?>.?.?.?
5 7:    ^6 `\\`_.?<?.?[ _]?
6 8:    ^6 `_`\.?(<.?|>).?

Sí, es un uso exagerado de ?para obtener los números correctos: P

JavaScript (ES6), 67 72

Simplemente busca espacios en blanco en las 12 ubicaciones dadas

Editar guardado 5 bytes, thx @apsillers

F=b=>[..."0h9fnopia8evx"].map((v,i)=>b[parseInt(v,34)]>' '?0:d=i)|d

Prueba en la consola Firefox / FireBug

x='  ___\n /\\_/\\\n/_/ \\_\\\n\\ \\_/ /\n \\/_\\/' // no defects
;[...x].forEach((c,p,a)=>{
  a[p]=' ' // put a blank
  y=a.join('') // rebuild a string
  d=F(y) // check
  if (d) console.log('\n'+y+'\n'+d) // if defect, output
  a[p]=c // remove the blamk
})

Salida

  ___
 / _/\
/_/ \_\
\ \_/ /
 \/_\/
9

  ___
 /\ /\
/_/ \_\
\ \_/ /
 \/_\/
2

  ___
 /\_ \
/_/ \_\
\ \_/ /
 \/_\/
8

  ___
 /\_/\
/ / \_\
\ \_/ /
 \/_\/
10

  ___
 /\_/\
/_  \_\
\ \_/ /
 \/_\/
3

  ___
 /\_/\
/_/  _\
\ \_/ /
 \/_\/
1

  ___
 /\_/\
/_/ \ \
\ \_/ /
 \/_\/
7

  ___
 /\_/\
/_/ \_\
\  _/ /
 \/_\/
4

  ___
 /\_/\
/_/ \_\
\ \ / /
 \/_\/
5

  ___
 /\_/\
/_/ \_\
\ \_  /
 \/_\/
6

  ___
 /\_/\
/_/ \_\
\ \_/ /
 \ _\/
11

  ___
 /\_/\
/_/ \_\
\ \_/ /
 \/_ /
12

C, 98 84 bytes

g(char*b){char*c="/'-5670(&,=?",*a=c;for(;*c&&!(*b=b[*c++-30]-32?0:c-a););return*b;}

ACTUALIZACIÓN: Un poco más inteligente sobre la cadena y solucionó un problema con los rubíes no defectuosos.

Desenredado:

g(char*b){
    char*c="/'-5670(&,=?",*a=c;
    for(;*c&&!(*b=b[*c++-30]-32?0:c-a);)
        ;
    return*b;
}

Muy sencillo y justo menos de 100 bytes.

Para las pruebas:

#include "stdio.h"
int main() {
    char b[100];
    scanf("%35c", b);
    printf("%d\n", g(b));
    return 0;
}

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:

Defect 1: 17
Defect 2: 9
Defect 3: 15
Defect 4: 23
Defect 5: 24
Defect 6: 25
Defect 7: 18
Defect 8: 10
Defect 9: 8
Defect 10: 14
Defect 11: 31
Defect 12: 33

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ódigo c) en esta cadena, y simplemente restar 30 de cada valor que recuperamos de esta lista para obtener nuestra matriz original de enteros. Definimos aser igual a cpara realizar un seguimiento de qué tan lejos hemos llegado a la lista. Lo único que queda en el código es el forbucle. Comprueba para asegurarse de que aún no hemos llegado al final de c, y luego comprueba si el carácter de ben la actualidad ces un espacio (ASCII 32). Si es así, establecemos el primer elemento no utilizado deb al número de defecto y devolverlo.

Python 2, 146 88 86 71 bytes

La función fprueba 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 regresemos 0si no se encuentran defectos.

Ahora empaquetamos los desplazamientos de segmentos en una cadena compacta y los usamos ord()para recuperarlos:

f=lambda s:sum(n*(s[ord('ARJPXYZSKIO`b'[n])-65]<'!')for n in range(13))

Prueba con un rubí perfecto:

f('  ___\n /\\_/\\\n/_/ \\_\\\n\\ \\_/ /\n \\/_\\/')
0

Prueba con el segmento 2 reemplazado por un espacio:

f('  ___\n /\\ /\\\n/_/ \\_\\\n\\ \\_/ /\n \\/_\\/')
2

EDITAR: Gracias a @xnor por la buena sum(n*bool for n in...)técnica.

EDIT2: Gracias a @ Sp3000 por consejos de golf adicionales.

Pyth, 35 31 28 bytes

hx"*6#,54@"C%imCds.zT67

Requiere un Pyth parcheado , la última versión actual de Pyth tiene un error .zque 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:

garbage = [42, 22, 54, 35, 44, 28, 31, 53, 52, 64, 16, 11]
prg = 'hx"' + "".join(chr(c) for c in garbage) +'"C%imCds.zT67'
open("golf_gen.pyth", "w").write(prg)
print(len(prg))

Haskell, 73 bytes

f l=last[x|x<-[0..12],l!!([0,17,9,15,23,24,25,18,10,8,14,31,33]!!x)==' ']

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.

05AB1E , 16 bytes

•W)Ì3ô;4(•₆вèðk>

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

Explicación:

•W)Ì3ô;4(•        # Push compressed integer 2272064612422082397
          ₆в      # Converted to Base-36 as list: [17,9,15,23,24,25,18,10,8,14,31,33]
            è     # Index each into the (implicit) input-string
             ðk   # Get the 0-based index of the first space in the indexed characters
                  # (-1 if not found, which means the ruby had no defects)
               >  # And increase it by 1 (which is output implicitly as result)

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(•es 2272064612422082397y •W)Ì3ô;4(•₆вes [17,9,15,23,24,25,18,10,8,14,31,33].