Ecco un semplice rubino di arte ASCII :

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

Come gioielliere della ASCII Gemstone Corporation, il tuo lavoro è ispezionare i rubini appena acquisiti e lasciare una nota su eventuali difetti che trovi.

Fortunatamente, sono possibili solo 12 tipi di difetti e il vostro fornitore garantisce che nessun rubino avrà più di un difetto.

I 12 difetti corrispondono alla sostituzione di uno dei 12 interne _, /o \caratteri di rubino con uno spazio ( ). Il perimetro esterno di un rubino non presenta mai difetti.

I difetti sono numerati in base al personaggio interno che ha uno spazio al suo posto:

Quindi un rubino con difetto 1 assomiglia a questo:

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

Un rubino con difetto 11 si presenta così:

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

È la stessa idea per tutti gli altri difetti.

Sfida

Scrivi un programma o una funzione che includa la stringa di un singolo rubino potenzialmente difettoso. Il numero del difetto deve essere stampato o restituito. Il numero del difetto è 0 se non ci sono difetti.

Accetta input da un file di testo, stdin o un argomento della funzione stringa. Restituire il numero del difetto o stamparlo su stdout.

Puoi presumere che il rubino abbia una nuova riga finale. Si può non pensare che ci sono delle finali spazi e portano a capo.

Vince il codice più breve in byte. ( Pratico contatore di byte. )

Casi test

I 13 tipi esatti di rubini, seguiti direttamente dalla produzione prevista:

  ___
 /\_/\
/_/ \_\
\ \_/ /
 \/_\/
0
  ___
 /\_/\
/_/  _\
\ \_/ /
 \/_\/
1
  ___
 /\ /\
/_/ \_\
\ \_/ /
 \/_\/
2
  ___
 /\_/\
/_  \_\
\ \_/ /
 \/_\/
3
  ___
 /\_/\
/_/ \_\
\  _/ /
 \/_\/
4
  ___
 /\_/\
/_/ \_\
\ \ / /
 \/_\/
5
  ___
 /\_/\
/_/ \_\
\ \_  /
 \/_\/
6
  ___
 /\_/\
/_/ \ \
\ \_/ /
 \/_\/
7
  ___
 /\_ \
/_/ \_\
\ \_/ /
 \/_\/
8
  ___
 / _/\
/_/ \_\
\ \_/ /
 \/_\/
9
  ___
 /\_/\
/ / \_\
\ \_/ /
 \/_\/
10
  ___
 /\_/\
/_/ \_\
\ \_/ /
 \ _\/
11
  ___
 /\_/\
/_/ \_\
\ \_/ /
 \/_ /
12

CJam, 27 23 byte

F7EC5ZV4DI8G6]qBb67%J%#

Converti la base 11, prendi la mod 67, prendi la mod 19 del risultato, quindi trova l'indice di ciò che hai nell'array

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

Magia!

Provalo online .

Ruby 2.0, 69 byte

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

Hexdump (per mostrare fedelmente i dati binari nella stringa):

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

Spiegazione:

1. L' -Knopzione legge il file sorgente come ASCII-8BIT(binario).
2. L' -0opzione consente getsdi leggere l'intero input (e non solo una riga).
3. L' -rdigestopzione carica il digestmodulo, che fornisce Digest::MD5.
4. Il codice esegue quindi un MD5 dell'input, accetta il primo byte del digest e ottiene il suo indice nella stringa binaria fornita.

Julia, 90 59 byte

Sicuramente non il più breve, ma la bella fanciulla Julia si prende molta cura nell'ispezione dei rubini reali.

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

Questo crea una funzione lambda che accetta una stringa se restituisce il corrispondente numero di difetto rubino. Per chiamarlo, dagli un nome, ad es f=s->....

Ungolfed + spiegazione:

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

Esempi:

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

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

Si noti che le barre rovesciate devono essere salvate nell'input. Ho confermato con @ Calvin'sHobbies che va bene.

Fammi sapere se hai domande o suggerimenti!

Modifica: salvato 31 byte con l'aiuto di Andrew Piliser!

> <> (Pesce) , 177 byte

Questa è una soluzione lunga ma unica. Il programma non contiene aritmetiche o ramificazioni oltre all'inserimento di caratteri di input in punti fissi nel codice.

Si noti che tutti i personaggi ispezionati di costruzione di rubini (/ \ _ ) possono essere "specchi" nel codice> <> che modificano la direzione del puntatore dell'istruzione (IP).

Possiamo usare questi caratteri di input per creare un labirinto da essi con l'istruzione di modifica del codice pe ad ogni uscita (creata da un mirror mancante nell'input) possiamo stampare il numero corrispondente.

iiiiiiiii19pi1cpi18piiii2bpi27pii28pi3apiiiii37pi49pi36piiiii00pi45pii46p

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

Le S B Ulettere sono quelle cambiate / \ _rispettivamente. Se l'input è un rubino pieno, il codice finale diventa:

\iiiiiiii19pi1cpi18piiii2bpi27pii28pi3apiiiii37pi49pi36piiiii00pi45pii46p

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

Puoi provare il programma con questo fantastico interprete visivo online . Dato che non puoi inserire newline lì devi usare alcuni caratteri fittizi in modo da poter inserire un rubino completo come ad es SS___LS/\_/\L/_/S\_\L\S\_/S/LS\/_\/. (Anche gli spazi sono cambiati in S a causa del markdown.)

CJam, 41 31 29 28 byte

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

Come al solito, per i caratteri non stampabili, segui questo link .

Provalo online qui

Spiegazione presto

Approccio precedente:

Abbastanza sicuro questo può essere ridotto cambiando le cifre / la logica di conversione. Ma ecco il primo tentativo:

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

Come al solito, utilizzare questo collegamento per caratteri non stampabili.

La logica è piuttosto semplice

• "Hash for each defect":i - Questo mi dà l'hash per difetto come indice
• qN-"/\\_ "4,er - questo converte i caratteri in numeri
• 4b1e3%A/ - questo è il numero univoco nel numero convertito di base
• # Quindi trovo semplicemente l'indice del numero univoco nell'hash

Provalo online qui

Scivolare , 123 108 + 3 = 111 byte

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

Esegui con i flag ne o, ad es

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

In alternativa, provalo online .

Slip è un linguaggio simile alla regex che è stato creato come parte della sfida della corrispondenza del modello 2D . Lo slip può rilevare la posizione di un difetto con l'indicatore di pposizione tramite il seguente programma:

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

che cerca uno dei seguenti schemi (qui Sindica la partita inizia):

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

Provalo online : le coordinate vengono emesse come una coppia (x, y). Tutto si legge come una normale regex, tranne che:

• ` è usato per fuggire,
• <> gira il puntatore della partita rispettivamente a sinistra / a destra,
• ^6 imposta il puntatore della corrispondenza rivolto verso sinistra e
• \ fa scivolare il puntatore della corrispondenza ortogonalmente a destra (ad es. se il puntatore è rivolto verso destra, scende di una riga)

Ma sfortunatamente, ciò di cui abbiamo bisogno è un singolo numero compreso tra 0 e 12 che indichi quale difetto è stato rilevato, non dove è stato rilevato. Slip ha un solo metodo per emettere un singolo numero: il nflag che mostra il numero di corrispondenze trovate.

Per fare ciò, espandiamo la regex sopra per far corrispondere il numero corretto di volte per ogni difetto, con l'aiuto della omodalità di corrispondenza sovrapposta. Ripartiti, i componenti sono:

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

Sì, è un uso eccezionale di ?ottenere i numeri giusti: P

JavaScript (ES6), 67 72

Cerca semplicemente gli spazi vuoti nelle 12 posizioni indicate

Modifica 5 byte salvati, grazie a @apsillers

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

Test nella console di 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
})

Produzione

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

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

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

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

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

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

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

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

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

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

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

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

C, 98 84 byte

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

AGGIORNAMENTO: Un po 'più intelligente sulla stringa e risolto un problema con rubini non difettosi.

svelato:

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

Abbastanza semplice e giusto meno di 100 byte.

Per i test:

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

Ingresso in STDIN.

Come funziona

Ogni difetto nel rubino si trova con un carattere diverso. Questo elenco mostra dove si trova ciascun difetto nella stringa di input:

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

Dato che fare una serie di {17,9,15,23,24,25,18,10,8,14,31,33}costi costa molti byte, troviamo un modo più breve per creare questo elenco. Si noti che l'aggiunta di 30 a ciascun numero comporta un elenco di numeri interi che possono essere rappresentati come caratteri ASCII stampabili. Questo elenco è il seguente: "/'-5670(&,=?". Pertanto, possiamo impostare un array di caratteri (nel codice c) su questa stringa e sottrarre semplicemente 30 da ogni valore che recuperiamo da questo elenco per ottenere il nostro array originale di numeri interi. Definiamo aessere uguale cper tenere traccia di quanto lungo la lista siamo arrivati. L'unica cosa rimasta nel codice è il forloop. Controlla per assicurarsi che non abbiamo ancora raggiunto la fine c, quindi verifica se il carattere della bcorrente corrisponde al numero del difetto e lo restituisce.c è uno spazio (ASCII 32). In tal caso, impostiamo il primo elemento inutilizzato dib

Python 2, 146 88 86 71 byte

La funzione fverifica ogni posizione del segmento e restituisce l'indice del segmento difettoso. Un test sul primo byte nella stringa di input assicura che ritorniamo 0se non vengono rilevati difetti.

Ora comprimiamo gli offset di segmento in una stringa compatta e li usiamo ord()per recuperarli:

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

Test con un rubino perfetto:

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

Test con il segmento 2 sostituito da uno spazio:

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

EDIT: Grazie a @xnor per la bella sum(n*bool for n in...)tecnica.

EDIT2: Grazie a @ Sp3000 per suggerimenti extra sul golf.

Pyth, 35 31 28 byte

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

Richiede un Pyth patchato , l'attuale versione più recente di Pyth ha un bug .zche rimuove i caratteri finali.

Questa versione non usa una funzione hash, abusa della funzione di conversione di base in Pyth per calcolare un hash molto stupido, ma funzionante. Quindi convertiamo quell'hash in un carattere e ne cerchiamo l'indice in una stringa.

La risposta contiene caratteri non stampabili, usa questo codice Python3 per generare il programma con precisione sul tuo computer:

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 byte

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

Stessa strategia di molte altre soluzioni: cercare spazi nei luoghi indicati. La ricerca restituisce un elenco di indici da cui prendo l'ultimo elemento, perché c'è sempre un successo per l'indice 0.

05AB1E , 16 byte

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

Provalo online o verifica tutti i casi di test .

Spiegazione:

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

Vedi questo mio suggerimento 05AB1E (sezioni Come comprimere numeri interi grandi? E Come comprimere gli elenchi numeri interi? ) Per capire perché •W)Ì3ô;4(•è 2272064612422082397ed •W)Ì3ô;4(•₆вè [17,9,15,23,24,25,18,10,8,14,31,33].