Voici un simple rubis d' art ASCII :

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

En tant que bijoutier pour l'ASCII Gemstone Corporation, votre travail consiste à inspecter les rubis nouvellement acquis et à laisser une note sur les défauts que vous trouvez.

Heureusement, seuls 12 types de défauts sont possibles, et votre fournisseur garantit qu'aucun rubis n'aura plus d'un défaut.

Les 12 défauts correspondent au remplacement de l' un des 12 internes _, /ou des \caractères du rubis avec un caractère d'espace ( ). Le périmètre extérieur d'un rubis n'a jamais de défauts.

Les défauts sont numérotés selon le caractère intérieur qui a une place à sa place:

Donc, un rubis avec défaut 1 ressemble à ceci:

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

Un rubis avec défaut 11 ressemble à ceci:

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

C'est la même idée pour tous les autres défauts.

Défi

Écrivez un programme ou une fonction qui prend la chaîne d'un seul rubis potentiellement défectueux. Le numéro de défaut doit être imprimé ou retourné. Le numéro de défaut est 0 s'il n'y a pas de défaut.

Prenez l'entrée d'un fichier texte, stdin ou un argument de fonction de chaîne. Renvoyez le numéro du défaut ou imprimez-le sur stdout.

Vous pouvez supposer que le rubis a une nouvelle ligne de fin. Vous ne pouvez pas supposer qu'il comporte des espaces de fin ou des nouvelles lignes de début.

Le code le plus court en octets gagne. ( Compteur d'octets pratique. )

Cas de test

Les 13 types exacts de rubis, suivis directement par leur sortie attendue:

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

CJam, 27 23 octets

F7EC5ZV4DI8G6]qBb67%J%#

Convertissez la base 11, prenez le mod 67, prenez le mod 19 du résultat puis trouvez l'index de ce que vous avez dans le tableau

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

La magie!

Essayez-le en ligne .

Ruby 2.0, 69 octets

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

Hexdump (pour afficher fidèlement les données binaires dans la chaîne):

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

Explication:

1. L' -Knoption lit le fichier source comme ASCII-8BIT(binaire).
2. L' -0option permet getsde lire l'intégralité de l'entrée (et pas seulement une ligne).
3. L' -rdigestoption charge le digestmodule, qui fournit Digest::MD5.
4. Le code effectue ensuite un MD5 de l'entrée, prend le premier octet du résumé et obtient son index dans la chaîne binaire donnée.

Julia, 90 59 octets

Certainement pas le plus court, mais la belle demoiselle Julia prend grand soin de l'inspection des rubis royaux.

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

Cela crée une fonction lambda qui accepte une chaîne set renvoie le numéro de défaut rubis correspondant. Pour l'appeler, donnez-lui un nom, par exemple f=s->....

Non golfé + explication:

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

Exemples:

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

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

Notez que les barres obliques inverses doivent être échappées dans l'entrée. J'ai confirmé avec @ Calvin'sHobbies que ça allait.

Faites-moi savoir si vous avez des questions ou des suggestions!

Edit: enregistré 31 octets avec l'aide d'Andrew Piliser!

> <> (Poisson) , 177 octets

Il s'agit d'une solution longue mais unique. Le programme ne contient aucune arithmétique ou ramification à part l'insertion de caractères d'entrée à des endroits fixes dans le code.

Notez que tous les caractères de construction de rubis inspectés ( / \ _) peuvent être des "miroirs" dans le code> <> qui changent la direction du pointeur d'instruction (IP).

Nous pouvons utiliser ces caractères d'entrée pour construire un labyrinthe à partir d'eux avec l'instruction de modification de code pet à chaque sortie (créée par un miroir manquant dans l'entrée), nous pouvons imprimer le numéro correspondant.

iiiiiiiii19pi1cpi18piiii2bpi27pii28pi3apiiiii37pi49pi36piiiii00pi45pii46p

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

Les S B Ulettres sont / \ _respectivement modifiées . Si l'entrée est un rubis complet, le code final devient:

\iiiiiiii19pi1cpi18piiii2bpi27pii28pi3apiiiii37pi49pi36piiiii00pi45pii46p

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

Vous pouvez essayer le programme avec cet excellent interprète visuel en ligne . Comme vous ne pouvez pas y saisir de sauts de ligne, vous devez utiliser des caractères fictifs à la place, vous pouvez donc saisir un rubis complet comme par exemple SS___LS/\_/\L/_/S\_\L\S\_/S/LS\/_\/. (Les espaces ont également changé en S à cause du démarque.)

CJam, 41 31 29 28 octets

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

Comme d'habitude, pour les caractères non imprimables, suivez ce lien .

Essayez-le en ligne ici

Explication bientôt

Approche précédente:

Je suis sûr que cela peut être réduit en changeant la logique des chiffres / conversion. Mais voici la première tentative:

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

Comme d'habitude, utilisez ce lien pour les caractères non imprimables.

La logique est assez simple

• "Hash for each defect":i - Cela me donne le hachage par défaut comme index
• qN-"/\\_ "4,er - cela convertit les caractères en nombres
• 4b1e3%A/ - c'est le nombre unique dans le nombre converti de base
• # Ensuite, je trouve simplement l'index du numéro unique dans le hachage

Essayez-le en ligne ici

Slip , 123108 + 3 = 111 octets

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

Exécutez avec les drapeaux net o, c.-à-d.

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

Vous pouvez également l' essayer en ligne .

Slip est un langage de type regex qui a été créé dans le cadre du défi de correspondance de motifs 2D . Slip peut détecter l'emplacement d'un défaut avec le pdrapeau de position via le programme suivant:

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

qui recherche l'un des modèles suivants (ici Sindique ici que le match commence):

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

Essayez-le en ligne - les coordonnées sont sorties sous forme de paire (x, y). Tout se lit comme une expression régulière, sauf que:

• ` est utilisé pour s'échapper,
• <> tourner le pointeur de match respectivement vers la gauche / droite,
• ^6 place le pointeur de correspondance face à gauche, et
• \ fait glisser le pointeur de correspondance orthogonalement vers la droite (par exemple, si le pointeur est orienté vers la droite, il descend d'une ligne)

Mais malheureusement, nous avons besoin d'un numéro unique de 0 à 12 indiquant quel défaut a été détecté, pas où il a été détecté. Slip n'a qu'une seule méthode pour sortir un seul numéro - le ndrapeau qui sort le nombre de correspondances trouvées.

Donc, pour ce faire, nous développons l'expression régulière ci-dessus pour correspondre au nombre correct de fois pour chaque défaut, à l'aide du omode de correspondance qui se chevauchent. Décomposés, les composants sont:

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

Oui, c'est une utilisation excessive de ?pour obtenir les bons chiffres: P

JavaScript (ES6), 67 72

Recherche simplement les blancs dans les 12 emplacements donnés

Modifier 5 octets enregistrés, thx @apsillers

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

Tester dans la console 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
})

Sortie

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

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

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

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

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

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

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

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

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

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

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

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

C, 98 84 octets

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

MISE À JOUR: Un peu plus intelligent sur la chaîne et correction d'un problème avec les rubis non défectueux.

Démêlé:

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

Assez simple et un peu moins de 100 octets.

Pour tester:

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

Entrée dans STDIN.

Comment ça marche

Chaque défaut dans le rubis est situé à un caractère différent. Cette liste montre où chaque défaut se produit dans la chaîne d'entrée:

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

Comme créer un tableau de {17,9,15,23,24,25,18,10,8,14,31,33}coûts coûte beaucoup d'octets, nous trouvons un moyen plus court de créer cette liste. Notez que l'ajout de 30 à chaque numéro donne une liste d'entiers pouvant être représentés sous forme de caractères ASCII imprimables. Cette liste est la suivante: "/'-5670(&,=?". Ainsi, nous pouvons définir un tableau de caractères (dans le code, c) pour cette chaîne, et simplement soustraire 30 de chaque valeur que nous récupérons de cette liste pour obtenir notre tableau d'origine d'entiers. Nous définissons aêtre égal à cpour garder une trace de la longueur de la liste que nous avons obtenue. La seule chose qui reste dans le code est la forboucle. Il vérifie que nous n'avons pas encore touché la fin c, puis vérifie si le caractère de bat the current cest un espace (ASCII 32). Si tel est le cas, nous définissons le premier élément inutilisé deb au numéro de défaut et le renvoyer.

Python 2, 146 88 86 71 octets

La fonction fteste chaque emplacement de segment et renvoie l'index du segment défectueux. Un test sur le premier octet de la chaîne d'entrée garantit que nous retournons 0si aucun défaut n'est trouvé.

Nous regroupons maintenant les décalages de segments dans une chaîne compacte et les utilisons ord()pour les récupérer:

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

Test avec un rubis parfait:

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

Test avec le segment 2 remplacé par un espace:

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

EDIT: Merci à @xnor pour la belle sum(n*bool for n in...)technique.

EDIT2: Merci à @ Sp3000 pour des conseils de golf supplémentaires.

Pyth, 35 31 28 octets

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

Nécessite un Pyth corrigé , la dernière version actuelle de Pyth a un bug .zqui supprime les caractères de fin.

Cette version n'utilise pas de fonction de hachage, elle abuse de la fonction de conversion de base en Pyth pour calculer un hachage très stupide mais fonctionnel. Ensuite, nous convertissons ce hachage en caractère et recherchons son index dans une chaîne.

La réponse contient des caractères non imprimables, utilisez ce code Python3 pour générer le programme avec précision sur votre machine:

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 octets

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

Même stratégie que de nombreuses autres solutions: rechercher des espaces aux emplacements donnés. La recherche renvoie une liste d'index dont je prends le dernier élément, car il y a toujours un hit pour l'index 0.

05AB1E , 16 octets

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

Essayez-le en ligne ou vérifiez tous les cas de test .

Explication:

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

Voir cette astuce 05AB1E (sections Comment compresser les grands entiers? Et Comment compresser les listes d'entiers? ) Pour comprendre pourquoi •W)Ì3ô;4(•est 2272064612422082397et •W)Ì3ô;4(•₆вest [17,9,15,23,24,25,18,10,8,14,31,33].