Hier ist ein einfacher ASCII-Kunst- Rubin :

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

Als Juwelier der ASCII Gemstone Corporation müssen Sie die neu erworbenen Rubine untersuchen und eventuelle Mängel notieren.

Zum Glück sind nur 12 Arten von Fehlern möglich, und Ihr Lieferant garantiert, dass kein Rubin mehr als einen Fehler aufweist.

Die 12 Defekte entsprechen den Ersatz von einem des 12 Innen _, /oder \Zeichen des Rubins mit einem Leerzeichen ( ). Der äußere Umfang eines Rubins weist niemals Mängel auf.

Die Mängel sind nummeriert, je nachdem, in welchem ​​inneren Zeichen ein Leerzeichen steht:

So sieht ein Rubin mit Defekt 1 aus:

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

Ein Rubin mit Defekt 11 sieht folgendermaßen aus:

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

Das ist die gleiche Idee für alle anderen Mängel.

Herausforderung

Schreiben Sie ein Programm oder eine Funktion, die die Zeichenfolge eines einzelnen, möglicherweise defekten Rubins aufnimmt. Die Fehlernummer sollte ausgedruckt oder zurückgesandt werden. Die Fehlernummer ist 0, wenn kein Fehler vorliegt.

Nehmen Sie Eingaben aus einer Textdatei, einem stdin oder einem Zeichenfolgenfunktionsargument entgegen. Senden Sie die Fehlernummer zurück oder drucken Sie sie auf stdout.

Sie können davon ausgehen, dass der Rubin einen nachgestellten Zeilenumbruch hat. Sie können nicht davon ausgehen, dass es Leerzeichen oder führende Zeilenumbrüche enthält.

Der kürzeste Code in Bytes gewinnt. ( Handy-Byte-Zähler. )

Testfälle

Die 13 genauen Rubintypen, gefolgt von der erwarteten Ausgabe:

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

CJam, 27 23 Bytes

F7EC5ZV4DI8G6]qBb67%J%#

Konvertiere Basis 11, nimm Mod 67, nimm Mod 19 des Ergebnisses und finde den Index dessen, was du im Array hast

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

Zauber!

Probieren Sie es online aus .

Ruby 2.0, 69 Bytes

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

Hexdump (um die Binärdaten in der Zeichenkette originalgetreu anzuzeigen):

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

Erläuterung:

1. Die -KnOption liest die Quelldatei als ASCII-8BIT(binär).
2. Die -0Option ermöglicht getsdas Einlesen der gesamten Eingabe (und nicht nur einer Zeile).
3. Die -rdigestOption lädt das digestbereitgestellte Modul Digest::MD5.
4. Der Code führt dann ein MD5 der Eingabe aus, nimmt das erste Byte des Digests und erhält seinen Index in der angegebenen Binärzeichenfolge.

Julia, 90 59 Bytes

Auf jeden Fall nicht die kürzeste, aber das schöne Mädchen Julia achtet sehr auf die Inspektion der königlichen Rubine.

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

Dadurch wird eine Lambda-Funktion erstellt, die eine Zeichenfolge akzeptiert sund die entsprechende Ruby-Fehlernummer zurückgibt. Um es zu nennen, geben Sie ihm einen Namen, z f=s->....

Ungolfed + Erklärung:

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

Beispiele:

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

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

Beachten Sie, dass Backslashes in der Eingabe maskiert werden müssen. Ich habe mit @ Calvin'sHobbies bestätigt, dass es in Ordnung ist.

Lassen Sie mich wissen, wenn Sie Fragen oder Anregungen haben!

Edit: 31 Bytes mit Hilfe von Andrew Piliser gespeichert!

> <> (Fisch) , 177 Bytes

Dies ist eine lange, aber einzigartige Lösung. Das Programm enthält keine Arithmetik oder Verzweigung außer dem Einfügen von Eingabezeichen an festen Stellen im Code.

Beachten Sie, dass alle untersuchten rubinbildenden Charaktere (/ \ _ ) "Spiegel" im Code> <> sein können, die die Richtung des Befehlszeigers (IP) ändern.

Wir können diese Eingabezeichen verwenden, um mit der Code-Änderungsanweisung ein Labyrinth daraus zu erstellen, pund bei jedem Exit (der durch einen fehlenden Spiegel in der Eingabe erzeugt wird) können wir die entsprechende Zahl drucken.

iiiiiiiii19pi1cpi18piiii2bpi27pii28pi3apiiiii37pi49pi36piiiii00pi45pii46p

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

Die S B UBuchstaben sind diejenigen, die / \ _jeweils geändert wurden. Wenn die Eingabe ein voller Rubin ist, lautet der endgültige Code:

\iiiiiiii19pi1cpi18piiii2bpi27pii28pi3apiiiii37pi49pi36piiiii00pi45pii46p

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

Sie können das Programm mit diesem großartigen visuellen Online-Dolmetscher ausprobieren . Da Sie dort keine Zeilenumbrüche eingeben können, müssen Sie stattdessen einige Dummy-Zeichen verwenden, damit Sie einen vollständigen Ruby eingeben können, wie z SS___LS/\_/\L/_/S\_\L\S\_/S/LS\/_\/. (Die Leerzeichen wurden aufgrund von Abschriften ebenfalls in S geändert.)

CJam, 41 31 29 28 Bytes

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

Folgen Sie für nicht druckbare Zeichen wie gewohnt diesem Link .

Probieren Sie es hier online aus

Erklärung bald

Bisheriger Ansatz:

Ziemlich sicher, dass dies durch Ändern der Ziffern- / Konvertierungslogik reduziert werden kann. Aber hier ist der erste Versuch:

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

Verwenden Sie wie gewohnt diesen Link für nicht druckbare Zeichen.

Die Logik ist ziemlich einfach

• "Hash for each defect":i - Dadurch erhalte ich den Hash pro Defekt als Index
• qN-"/\\_ "4,er - Hiermit werden die Zeichen in Zahlen umgewandelt
• 4b1e3%A/ - Dies ist die eindeutige Nummer in der umgerechneten Basisnummer
• # Dann finde ich einfach den Index der eindeutigen Nummer im Hash

Probieren Sie es hier online aus

Beleg , 123 108 + 3 = 111 Bytes

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

Laufen Sie mit den nund oFlags, dh

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

Alternativ können Sie es auch online versuchen .

Slip ist eine Regex-ähnliche Sprache, die im Rahmen der 2D-Pattern-Matching- Herausforderung erstellt wurde. Mit dem pPositions-Flag kann Slip die Position eines Defekts über folgendes Programm erkennen:

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

das nach einem der folgenden Muster sucht (hier Sbedeutet dies, dass die Übereinstimmung beginnt):

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

Probieren Sie es online aus - Koordinaten werden als (x, y) Paar ausgegeben. Alles liest sich wie ein normaler Regex, außer dass:

• ` wird für die Flucht verwendet,
• <> drehen Sie den Match-Zeiger nach links / rechts,
• ^6 Setzt den Übereinstimmungszeiger nach links und
• \ Bewegt den Übereinstimmungszeiger orthogonal nach rechts (z. B. wenn der Zeiger nach rechts zeigt, wird eine Zeile nach unten verschoben)

Was wir jedoch brauchen, ist eine einzelne Zahl von 0 bis 12, die angibt , welcher Fehler festgestellt wurde, und nicht, wo er festgestellt wurde. Slip bietet nur eine Methode zur Ausgabe einer einzelnen Nummer - das nFlag, das die Anzahl der gefundenen Übereinstimmungen ausgibt.

Zu diesem Zweck erweitern wir den obigen regulären Ausdruck mithilfe des oüberlappenden Übereinstimmungsmodus so, dass er für jeden Fehler die richtige Anzahl von Übereinstimmungen aufweist. Aufgeschlüsselt sind die Komponenten:

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

Ja, das ist eine exzessive Verwendung von ?, um die Zahlen richtig zu machen: P

JavaScript (ES6), 67, 72

Sucht einfach nach Leerzeichen an den angegebenen 12 Stellen

Bearbeite gespeicherte 5 Bytes, danke @apsillers

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

Test In der Firefox / FireBug-Konsole

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

Ausgabe

  ___
 / _/\
/_/ \_\
\ \_/ /
 \/_\/
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;}

UPDATE: Ein bisschen cleverer in Bezug auf die Saite und ein Problem mit nicht defekten Rubinen wurde behoben.

Entwirrt:

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

Ganz einfach und gerecht 100 Bytes.

Zum Prüfen:

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

Eingabe in STDIN.

Wie es funktioniert

Jeder Fehler im Rubin liegt bei einem anderen Charakter. Diese Liste zeigt, wo jeder Fehler in der Eingabezeichenfolge auftritt:

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

Da das {17,9,15,23,24,25,18,10,8,14,31,33}Erstellen eines Arrays viele Bytes kostet, finden wir einen kürzeren Weg, um diese Liste zu erstellen. Beachten Sie, dass durch Hinzufügen von 30 zu jeder Zahl eine Liste von Ganzzahlen erstellt wird, die als druckbare ASCII-Zeichen dargestellt werden können. Diese Liste ist wie folgt: "/'-5670(&,=?". Daher können wir ein Zeichenarray (im Code c) auf diese Zeichenfolge setzen und einfach 30 von jedem Wert abziehen, den wir aus dieser Liste abrufen, um unser ursprüngliches Array von Ganzzahlen zu erhalten. Wir definieren a, gleich zu sein, cum zu verfolgen, wie weit wir auf der Liste sind. Das einzige, was im Code übrig bleibt, ist die forSchleife. Es prüft, ob wir das Ende cnoch nicht erreicht haben, und prüft dann, ob das Zeichen bder aktuellenc ein Leerzeichen ist (ASCII 32). Wenn ja, setzen wir das erste, nicht verwendete Element vonb an die Fehlernummer und senden Sie diese zurück.

Python 2, 146 88 86 71 Bytes

Die Funktion ftestet jede Segmentposition und gibt den Index des defekten Segments zurück. Ein Test des ersten Bytes in der Eingabezeichenfolge stellt sicher, dass wir zurückgeben, 0wenn keine Fehler gefunden werden.

Wir packen jetzt die Segmentversätze in eine kompakte Zeichenfolge und verwenden sie ord(), um sie wiederherzustellen:

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

Testen mit einem perfekten Rubin:

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

Testen mit Segment 2, das durch ein Leerzeichen ersetzt wurde:

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

EDIT: Danke an @xnor für die nette sum(n*bool for n in...)Technik.

EDIT2: Danke an @ Sp3000 für zusätzliche Golftipps.

Pyth, 35 31 28 Bytes

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

Benötigt einen gepatchten Pyth , die aktuellste Version von Pyth hat einen Fehler .z, der abschließende Zeichen beseitigt .

Diese Version verwendet keine Hash-Funktion, sondern verwendet die Basis-Konvertierungsfunktion in Pyth, um einen sehr dummen, aber funktionierenden Hash zu berechnen. Dann konvertieren wir diesen Hash in ein Zeichen und schlagen seinen Index in einer Zeichenkette nach.

Die Antwort enthält nicht druckbare Zeichen. Verwenden Sie diesen Python3-Code, um das Programm genau auf Ihrem Computer zu generieren:

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)==' ']

Gleiche Strategie wie bei vielen anderen Lösungen: Suche nach Räumen an den angegebenen Standorten. Das Nachschlagen gibt eine Liste von Indizes zurück, von denen ich das letzte Element nehme, weil es immer einen Treffer für den Index 0 gibt.

05AB1E , 16 Bytes

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

Probieren Sie es online aus oder überprüfen Sie alle Testfälle .

Erläuterung:

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

Sehen Sie sich meinen Tipp 05AB1E an (Abschnitte Wie komprimiere ich große Ganzzahlen? Und Wie komprimiere ich Ganzzahlenlisten? ) , Um zu verstehen, warum das so •W)Ì3ô;4(•ist 2272064612422082397und •W)Ì3ô;4(•₆вist [17,9,15,23,24,25,18,10,8,14,31,33].