İşte basit bir ASCII sanat yakutu :

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

ASCII Gemstone Corporation için bir kuyumcu olarak, işiniz yeni kazanılan yakutları incelemek ve bulduğunuz kusurlarla ilgili not bırakmak.

Neyse ki, sadece 12 tip hata mümkündür ve tedarikçiniz hiçbir yakutun birden fazla kusura sahip olmayacağını garanti eder.

12 kusurları 12 iç birinin yerine tekabül _, /ya da \bir boşluk karakteri (Ruby karakter ). Bir yakutun dış çevresi asla kusurlu değildir.

Kusurlar, hangi iç karakterin yerinde bir boşluğa sahip olduğuna göre numaralandırılır:

Yani kusur 1 olan bir yakut şöyle görünür:

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

Hatalı bir yakut 11 şöyle görünür:

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

Diğer tüm kusurlar için aynı fikir.

Meydan okuma

Tek, potansiyel olarak arızalı bir yakutun dizesini içine alan bir program veya işlev yazın. Hata numarası yazdırılmalı veya iade edilmelidir. Kusur yoksa, hata numarası 0'dır.

Bir metin dosyasından, stdin veya bir dize işlevi bağımsız değişkeninden girdi alın. Arıza numarasını döndürün veya stdout'a yazdırın.

Yakutun takip eden bir yeni hattı olduğunu varsayabilirsin. Sen olabilir değil herhangi boşluk veya lider yeni satır olduğunu varsayalım.

Bayt cinsinden en kısa kod kazanır. ( Kullanışlı bayt sayacı. )

Test Kılıfları

13 kesin yakut türü, ardından beklenen verim doğrudan geldi:

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

CJam, 27 23 bayt

F7EC5ZV4DI8G6]qBb67%J%#

11 tabanını dönüştürün, mod 67'yi alın, sonucun mod 19'unu alın, sonra dizideki dizininizi bulun

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

Sihirli!

Çevrimiçi deneyin .

Ruby 2.0, 69 bayt

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

Hexdump (dizedeki ikili verileri güvenilir bir şekilde göstermek için):

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

Açıklama:

1. -KnSeçenek olarak kaynak dosyasını okur ASCII-8BIT(ikili).
2. -0Seçenek veriyor getsbütün girişi (sadece bir satır) okumak için.
3. -rdigestSeçenek yükler digestsağlar modülü, Digest::MD5.
4. Kod daha sonra girişin bir MD5'ini yapar, özetin ilk baytını alır ve dizini verilen ikili dizgede alır.

Julia 90 59 bayt

Kesinlikle en kısa değil, fakat adil bir bakire Julia, kraliyet yakutlarının denetiminde büyük özen gösteriyor.

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

Bu, bir dizgeyi kabul eden sve karşılık gelen yakut hata sayısını döndüren bir lambda işlevi yaratır . Aramak için bir isim verin, örneğin f=s->....

Ungolfed + açıklama:

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

Örnekler:

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

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

Girdide ters eğik çizgi çıkması gerektiğini unutmayın. @ Calvin's Hobbies ile bunun doğru olduğunu onayladım.

Herhangi bir sorunuz veya öneriniz varsa bana bildirin!

Düzenleme: Andrew Piliser yardımı ile 31 bayt kaydedildi!

> <> (Balık) , 177 bayt

Bu uzun ama eşsiz bir çözüm. Program, giriş karakterlerini kodun sabit yerlerine eklemekten ayrı bir aritmetik veya dallanma içermez .

Denetlenen tüm yakut oluşturma karakterlerinin ( / \ _), talimat işaretçisinin (IP) yönünü değiştiren> <> kodunda "aynalar" olabileceğine dikkat edin.

Bu girdi karakterlerini, kod değiştirme talimatıyla bir labirent oluşturmak için kullanabiliriz pve her çıkışta (girişte eksik bir ayna tarafından oluşturulan) ilgili sayıyı yazdırabiliriz.

iiiiiiiii19pi1cpi18piiii2bpi27pii28pi3apiiiii37pi49pi36piiiii00pi45pii46p

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

S B UHarfler değiştirildi olanlardır / \ _sırasıyla. Giriş tam bir yakut ise, son kod şöyle olur:

\iiiiiiii19pi1cpi18piiii2bpi27pii28pi3apiiiii37pi49pi36piiiii00pi45pii46p

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

İle programı deneyebilirsiniz Bu harika çevrimiçi görsel tercümanla . Yeni satırları giremediğiniz için, bunun yerine bazı boş karakterler kullanmanız gerekir, böylece tam bir yakutu örneğin olarak girebilirsiniz SS___LS/\_/\L/_/S\_\L\S\_/S/LS\/_\/. (Boşluklar ayrıca işaretleme nedeniyle S olarak değiştirildi.)

CJam, 41 31 29 28 bayt

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

Her zamanki gibi, yazdırılamayan karakterler için bu bağlantıyı .

Burada çevrimiçi deneyin

Yakında açıklama

Önceki yaklaşım:

Rakamlar / dönüşüm mantığını değiştirerek bunun azaltılacağından emin olabilirsiniz. Fakat işte ilk girişim:

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

Her zamanki gibi, bu bağlantıyı kullan yazdırılamayan karakterler için .

Mantık oldukça basittir

• "Hash for each defect":i - Bu bana indeks olarak kusur başına karma alır
• qN-"/\\_ "4,er - bu karakterleri sayılara dönüştürür
• 4b1e3%A/ - Bu, baz dönüşüm sayısındaki benzersiz sayıdır
• # Sonra sadece karma içinde benzersiz sayının indeksini bulmak

Burada çevrimiçi deneyin

Kayma , 123 108 + 3 = 111 bayt

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

nVe obayraklarıyla koşmak , yani

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

Alternatif olarak, çevrimiçi deneyin .

Kayma, 2D desen eşleştirme zorluğunun bir parçası olarak yapılan regex benzeri bir dildir . Kayma p, aşağıdaki program aracılığıyla bir konumun konumunu bayrakla tespit edebilir :

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

Bu, aşağıdaki kalıplardan birini arar (burada Smaç başlar):

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

Çevrimiçi deneyin - koordinatlar (x, y) çifti olarak verilir. Her şey normal bir regex gibi görünüyor, bunun dışında:

• ` kaçmak için kullanılır,
• <> eşleşme işaretçisini sırasıyla sola / sağa çevirin,
• ^6 eşleşme işaretçisini sola dönük olarak ayarlar ve
• \ eşleşme işaretçisini ortogonal olarak sağa kaydırır (örneğin işaretçi sağa bakarsa bir satır aşağıya doğru gider)

Fakat ne yazık ki, ihtiyacımız olan , tespit edildiği yerde değil, hangi arızanın tespit edildiğini söyleyen tek bir sayıdır . Kayma sadece tek bir sayı çıktısı alma yöntemine sahiptir - bulunan neşleşme sayısını veren bayrak.

Bunu yapmak için, oüst üste binen eşleştirme modunun yardımıyla her bir kusur için doğru sayıda eşleşecek şekilde yukarıdaki regex'i genişletiriz . Bozuldu, bileşenler:

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

Evet, bu ?rakamları doğru almak için aşırı bir kullanım : P

JavaScript (ES6), 67 72

Sadece verilen 12 konumdaki boşlukları arar.

Düzenle Kaydet 5 bayt, thx @apsillers

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

Firefox / FireBug konsolunda test edin

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

Çıktı

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

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

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

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

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

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

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

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

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

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

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

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

C, 98 84 bayt

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

GÜNCELLEME: İp hakkında biraz daha zeki ve hatalı olmayan yakutlarla ilgili bir sorunu çözdüm.

sökülmüş:

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

Oldukça basit ve sadece 100 bayt.

Test için:

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

STDIN’e giriş yapın.

Nasıl çalışır

Yakuttaki her kusur farklı bir karakterde bulunur. Bu liste giriş dizisinde her bir hatanın nerede oluştuğunu gösterir:

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

Bir dizi yapım yana {17,9,15,23,24,25,18,10,8,14,31,33}maliyetlerin bayt bir sürü, bu liste oluşturmak için daha kısa bir yol bulmak. Her numaraya 30 eklemenin, yazdırılabilir ASCII karakterleri olarak temsil edilebilecek bir tam sayı listesiyle sonuçlandığını gözlemleyin. Aşağıdaki gibi listesi: "/'-5670(&,=?". Böylece, bir karakter dizisini (kodda c) bu dizgiye ayarlayabilir ve orijinal tamsayı dizimizi elde etmek için bu listeden aldığımız her değerden 30 çıkartabiliriz. Aldığımız listenin ne kadar uzun sürdüğünü takip aetmek ciçin eşit olmayı tanımlarız . Kodda kalan tek şey fordöngüdür. cHenüz sonuna kadar varamadığımızdan emin olmak için kontrol eder ve ardından bşu andaki karakterin gelip gelmediğini kontrol ederc bir boşluk (ASCII 32). Öyleyse, kullanılmayan ilk öğeyi biz belirleriz.b Arıza numarasına gidin ve geri gönderin.

Python 2, 146 88 86 71 bayt

İşlev f her bölüm konumunu test eder ve hata bölümünün dizinini döndürür. Giriş dizesindeki ilk bayt üzerinde yapılan bir test, 0eğer hiçbir hata bulunmazsa geri dönmemizi sağlar .

Şimdi segment ofsetlerini kompakt bir dizeye paketliyoruz ve kullanıyoruz ord() bunları kurtarmak için kullanıyoruz:

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

Mükemmel bir yakutla test:

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

Boşluk ile değiştirilen segment 2 ile test etme:

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

EDIT: Güzeller için @ xnor'a teşekkürler sum(n*bool for n in...) teknik .

EDIT2: Ekstra golf oyunları için @ Sp3000'e teşekkürler.

Pyth, 35 31 28 bayt

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

Yamalı bir Pyth gerektirir en son sürümünde .zsondaki karakterleri yok eden bir hata var .

Bu sürüm bir karma işlevi kullanmaz, çok aptalca, ancak çalışan bir karmaşayı hesaplamak için Pyth'deki temel dönüştürme işlevini kötüye kullanır. Sonra bu karışı bir karaktere çeviririz ve dizini dizgede ararız.

Cevap, yazdırılamayan karakterler içeriyor, programı makinenizde doğru bir şekilde oluşturmak için bu Python3 kodunu kullanın:

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 bayt

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

Diğer birçok çözümde olduğu gibi aynı strateji: verilen yerlerde yer aramak. Arama, son öğeyi aldığım dizinlerin listesini döndürür, çünkü her zaman dizin 0 için bir isabet vardır.

05AB1E , 16 bayt

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

Çevrimiçi deneyin veya tüm test durumlarını doğrulayın .

Açıklama:

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

Benim bu 05AB1E ucu bakın (bölümler ne kadar büyük tamsayılar sıkıştırmak? Etmek ve nasıl kompres tamsayı listelerine? ) Anlamak için •W)Ì3ô;4(•ise 2272064612422082397ve •W)Ì3ô;4(•₆вolup [17,9,15,23,24,25,18,10,8,14,31,33].