Ось простий арт- рубін ASCII :

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

Як ювелір для корпорації ASCII Gemstone, ваша робота - оглянути нещодавно придбані рубіни та залишити записку про будь-які вади, які ви знайдете.

На щастя, можливі лише 12 видів дефектів, і ваш постачальник гарантує, що жоден рубін не матиме більше одного дефекту.

У 12 дефектів відповідають заміні одного з 12 внутрішніх _, /або \персонажів рубіна з символом пробілу ( ). Зовнішній периметр рубіна ніколи не має дефектів.

Дефекти нумеруються, згідно з якими внутрішній персонаж має пробіл на своєму місці:

Отже, рубін з дефектом 1 виглядає так:

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

Рубін з дефектом 11 виглядає приблизно так:

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

Це ж ідея для всіх інших дефектів.

Виклик

Напишіть програму або функцію, яка містить рядки одного, потенційно несправного рубіна. Номер дефекту слід роздрукувати або повернути. Номер дефекту дорівнює 0, якщо дефекту немає.

Візьміть дані з текстового файлу, stdin або аргументу рядкової функції. Поверніть номер дефекту або роздрукуйте його для виведення.

Ви можете припустити, що в рубіні є зворотний новий рядок. Ви можете не припускати, що в ньому є пробіли чи провідні рядки.

Виграє найкоротший код у байтах. ( Зручний лічильник байтів. )

Випробування

13 точних типів рубінів з наступним очікуваним результатом:

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

CJam, 27 23 байт

F7EC5ZV4DI8G6]qBb67%J%#

Перетворити базу 11, взяти mod 67, взяти mod 19 результату, а потім знайти індекс того, що ти маєш у масиві

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

Магія!

Спробуйте в Інтернеті .

Ruby 2.0, 69 байт

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

Hexdump (для вірного відображення бінарних даних у рядку):

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

Пояснення:

1. -KnВаріант читає вихідний файл як ASCII-8BIT(двійковий).
2. -0Опція дозволяє getsчитати весь вхід (а не тільки один рядок).
3. -rdigestВаріант завантажує digestмодуль, який забезпечує Digest::MD5.
4. Потім код робить MD5 вхідного даних, приймає перший байт дайджесту і отримує його індекс у заданому двійковому рядку.

Юлія, 90 59 байт

Однозначно не найкоротша, але прекрасна діва Юлія дуже дбає при огляді королівських рубінів.

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

Це створює лямбда-функцію, яка приймає рядок sі повертає відповідний номер дефекту в рубіні. Щоб зателефонувати, дайте ім’я, наприклад f=s->....

Недоліковані + пояснення:

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

Приклади:

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

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

Зауважте, що у вхідному сигналі слід уникати відхилень від косої риски Я підтвердив, що з @ Calvin'sHobbies це добре.

Повідомте мене, якщо у вас є якісь питання чи пропозиції!

Редагувати: Збережено 31 байт за допомогою Ендрю Пілізера!

> <> (Риба) , 177 байт

Це довге, але унікальне рішення. Програма не містить арифметичних чи розгалужених, крім вставки символів вводу у фіксовані місця в коді.

Зауважте, що всі перевірені символи для створення рубіну ( / \ _) можуть бути "дзеркалами" в коді> <>, які змінюють напрямок вказівника інструкції (IP).

Ми можемо використовувати ці вхідні символи, щоб створити з них лабіринт за допомогою інструкції щодо зміни коду, pі при кожному виході (який створюється відсутнім дзеркалом на вході) ми можемо надрукувати відповідне число.

iiiiiiiii19pi1cpi18piiii2bpi27pii28pi3apiiiii37pi49pi36piiiii00pi45pii46p

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

Ці S B Uлисти є ті , змінені , щоб / \ _відповідно. Якщо вхід є повним рубіном, остаточним кодом стає:

\iiiiiiii19pi1cpi18piiii2bpi27pii28pi3apiiiii37pi49pi36piiiii00pi45pii46p

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

Ви можете спробувати програму з цим чудовим онлайн-візуальним перекладачем . Оскільки ви не можете вводити там нові рядки, вам доведеться використовувати замість них кілька манекенів, щоб ви могли ввести повний рубін, наприклад SS___LS/\_/\L/_/S\_\L\S\_/S/LS\/_\/. (Простори також змінені на S через відмітку.)

CJam, 41 31 29 28 байт

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

Як зазвичай, для символів, які не друкуються, перейдіть за цим посиланням .

Спробуйте його онлайн тут

Пояснення незабаром

Попередній підхід:

Досить впевнений, що це можна зменшити, змінивши логіку цифр / перетворення. Але ось перша спроба:

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

Як завжди, використовуйте це посилання для недрукувальних символів.

Логіка досить проста

• "Hash for each defect":i - Це отримує мені хеш на дефект як індекс
• qN-"/\\_ "4,er - це перетворює символи в числа
• 4b1e3%A/ - це унікальне число в базовому перетвореному номері
• # Тоді я просто знаходжу індекс унікального числа в хеші

Спробуйте його онлайн тут

Ковзання , 123 108 + 3 = 111 байт

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

Бігайте зі значками nта oпрапорами, тобто

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

Крім того, спробуйте його в Інтернеті .

Slip - це мова, що нагадує виразки, яка була створена як частина 2D виклику відповідності шаблону . Slip може виявити місце дефекту за допомогою pпрапора позиції за допомогою наступної програми:

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

який шукає один із наступних шаблонів (тут Sпозначається тут збіг):

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

Спробуйте в Інтернеті - координати виводяться у вигляді пари (x, y). Все читається як звичайний регулярний вираз, за ​​винятком того, що:

• ` використовується для втечі,
• <> поверніть відповідник вліво / вправо відповідно,
• ^6 встановлює вказівник відповідності обличчям ліворуч та
• \ просуває вказівник відповідності ортогонально праворуч (наприклад, якщо вказівник спрямований праворуч, то він знижується рядок)

Але, на жаль, нам потрібно одне число від 0 до 12, яке говорить про те, який дефект виявлено, а не там, де його було виявлено. У ковзанні є лише один метод виведення єдиного числа - nпрапор, який видає кількість знайдених відповідностей.

Тому для цього ми розширюємо вищевказаний вираз, щоб відповідати правильній кількості разів для кожного дефекту, за допомогою режиму oзбігу, що перекривається. Розбиті, компоненти:

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

Так, це надмірне використання, ?щоб правильно визначити числа: P

JavaScript (ES6), 67 72

Просто шукає заготовки в заданих 12 місцях

Редагувати Збережені 5 байт, thx @apsillers

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

Тест у консолі 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
})

Вихідні дані

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

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

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

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

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

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

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

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

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

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

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

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

C, 98 84 байт

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

ОНОВЛЕННЯ: Театр трохи розумніший щодо струни і виправив проблему з руйнованими рубінами.

Розгадали:

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

Досить прямо, і трохи менше 100 байт.

Для тестування:

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

Вхід до STDIN.

Як це працює

Кожен дефект в рубіні розташований на різному характері. У цьому списку показано, де у вхідному рядку виникає кожен дефект:

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

Оскільки створення масиву {17,9,15,23,24,25,18,10,8,14,31,33}коштує багато байтів, ми знаходимо коротший спосіб створення цього списку. Зауважте, що додавання 30 до кожного числа призводить до переліку цілих чисел, які можуть бути представлені як друковані символи ASCII. Цей список виглядає наступним чином : "/'-5670(&,=?". Таким чином, ми можемо встановити символьний масив (у коді, c) до цього рядка і просто відняти 30 з кожного значення, яке ми отримуємо з цього списку, щоб отримати наш вихідний масив цілих чисел. Ми визначаємо aрівне значення cдля відстеження того, наскільки далеко ми потрапили до списку. Єдине, що залишилося в коді - це forцикл. Він перевіряє, щоб переконатися, що ми ще не потрапили до кінця c, а потім перевіряє, чи є символb в потоці cє пробіл (ASCII 32). Якщо це так, ми встановлюємо перший, невикористаний елементb на номер дефекту і повернути його.

Python 2, 146 88 86 71 байт

Функція fперевіряє розташування кожного сегмента і повертає індекс дефектного сегмента. Тест на перший байт у рядку введення гарантує, що ми повернемось, 0якщо не знайдені дефекти.

Тепер ми пакуємо зсуви сегмента в компактний рядок і використовуємо ord()для їх відновлення:

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

Тестування з ідеальним рубіном:

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

Тестування з сегментом 2 замінено пробілом:

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

EDIT: Дякую @xnor за гарну sum(n*bool for n in...)техніку.

EDIT2: Завдяки @ Sp3000 за додаткові поради щодо гольфу.

Pyth, 35 31 28 байт

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

Потрібен виправлений Pyth , остання остання версія Pyth має помилку, .zяка позбавляє символів, що тривають .

Ця версія не використовує хеш-функцію, вона зловживає базовою функцією перетворення в Pyth для обчислення дуже дурного, але працюючого хеша. Потім ми перетворюємо цей хеш у персонаж і переглядаємо його індекс в рядку.

Відповідь містить недруковані символи, використовуйте цей код Python3, щоб точно створити програму на вашому комп'ютері:

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 байти

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

Ця ж стратегія, як і багато інших рішень: пошук місця в заданих місцях. Пошук повертає список індексів, з яких я беру останній елемент, оскільки завжди є звернення до індексу 0.

05AB1E , 16 байт

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

Спробуйте в Інтернеті або перевірте всі тестові випадки .

Пояснення:

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

Ознайомтеся з цією підказкою 05AB1E (розділи Як стиснути великі цілі числа? І як стиснути цілі списки? ), Щоб зрозуміти, чому •W)Ì3ô;4(•це так 2272064612422082397і •W)Ì3ô;4(•₆вє [17,9,15,23,24,25,18,10,8,14,31,33].