Давайте играть в Мёлкки!

32

Mölkky

Mölkky - финская метательная игра. Игроки используют деревянную булавку (также называемую «mölkky»), чтобы попытаться опрокинуть деревянные булавки почти одинакового размера с помощью метательной булавки, обозначенной цифрами от 1 до 12. Начальная позиция булавок следующая:

   (07)(09)(08)
 (05)(11)(12)(06)
   (03)(10)(04)
     (01)(02)

Это описание и приведенные ниже правила основаны на Википедии .

Упрощенные правила Mölkky

  1. Опрокидывание одного штифта означает количество очков, отмеченных на штифте.

  2. Если выбить 2 или более штифтов, количество выбитых штифтов (например, опрокидывание 3 штифтов набирает 3 балла).

  3. Цель игры - набрать ровно 50 очков. Забив более 50 очков, штрафуется за счет установки 25 очков назад .

  4. Для этой задачи мы сделаем предположение, что контакты всегда находятся в точном порядке, описанном выше. (В реальной игре булавки поднимаются снова после каждого броска в том месте, где они приземлились.)

Все остальные правила Mölkky игнорируются, и рассматривается только один игрок.

вход

Непустой список списков из 12 логических значений. Каждый список логических значений описывает результат броска: 1, если булавка была опрокинута, и 0 в противном случае. Логические значения даны в точном порядке выводов, слева направо и снизу справа: 7 , 9 , 8 , 5 , 11 , 12 , 6 , 3 , 10 , 4 , 1 , 2 .

Выход

Счет после всех бросков, описанных во входных данных, рассчитывается с применением правил 1 , 2 и 3 .

Подробный пример

Давайте рассмотрим следующий вход:

// 07 09 08 05 11 12 06 03 10 04 01 02
[ [ 0, 0, 0, 1, 0, 0, 0, 0, 0, 0, 0, 0 ],  // scores 5 (rule #1)
  [ 1, 0, 0, 1, 0, 0, 0, 0, 0, 0, 0, 0 ],  // scores 2 (rule #2), total: 7
  [ 0, 0, 0, 0, 0, 1, 1, 1, 1, 1, 1, 1 ],  // scores 7, total: 14
  [ 0, 0, 0, 0, 0, 1, 0, 0, 0, 0, 0, 0 ],  // scores 12, total: 26
  [ 0, 0, 0, 0, 0, 1, 0, 0, 0, 0, 0, 0 ],  // scores 12, total: 38
  [ 0, 0, 0, 0, 1, 0, 0, 0, 0, 0, 0, 0 ],  // scores 11, total: 49
  [ 1, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0 ],  // scores 7, total: 56 -> 25 (rule #3)
  [ 1, 1, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0 ] ] // scores 2, total: 27

Ожидаемый результат - 27 .

Правила вызова

  • Вы можете принять участие в любом разумном формате. Вместо списков логических значений вы можете использовать целые числа, где старший бит - это контакт № 7, а младший бит - это контакт № 2. В этом формате приведенный выше пример будет передан как [ 256, 2304, 127, 64, 64, 128, 2048, 3072 ].
  • Входной список может содержать броски, в которых ни один пин вообще не опрокинут, и в этом случае счет пропускается без изменений.
  • У вас нет ничего особенного, когда счет достигает ровно 50 баллов. Но вы можете предположить, что никакой другой бросок не последует, когда это произойдет.
  • Это код-гольф , поэтому выигрывает самый короткий ответ в байтах.

Контрольные примеры

Используя списки целых чисел в качестве входных данных:

[ 0 ] --> 0
[ 528 ] --> 2
[ 4095 ] --> 12
[ 64, 0, 3208 ] --> 16
[ 16, 1907, 2048 ] --> 18
[ 2023, 2010, 1, 8 ] --> 29
[ 1726, 128, 35, 3136, 1024 ] --> 34
[ 32, 32, 2924, 2, 256, 16 ] --> 28
[ 64, 64, 2434, 1904, 3251, 32, 256 ] --> 25
[ 3659, 2777, 2211, 3957, 64, 2208, 492, 2815 ] --> 25
[ 2047, 1402, 2, 2599, 4, 1024, 2048, 3266 ] --> 50
[ 256, 2304, 127, 64, 64, 128, 2048, 3072 ] --> 27
[ 16, 8, 128, 1, 2048, 1, 2048, 513, 8, 3206 ] --> 30

Вы можете перейти по этой ссылке, чтобы получить эти тестовые примеры в логическом формате.

code-golf  game  binary 
— Arnauld
источник
5
Крутой вызов, а также отличная игра для тех, кто еще не пробовал летом - прекрасно работает вместе с грилем.
— Нить
2
@Nit Спасибо. :) Я должен признаться, что я не знал эту игру до сегодняшнего дня. Я видел, как люди играли в нее во время прогулки в парке этим днем. Теперь я хотел бы попробовать.
— Арно

Ответы:

7

Python 2 , 126 111 108 104 байта

-3 байта благодаря Джонатану Аллану

-4 байта благодаря Kaya!

f=lambda A,t=0:t>50and f(A,25)or A and f(A[1:],t-~(sum(A[0])-1or 762447093078/12**A[0].index(1)%12))or t

Попробуйте онлайн!

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

Объяснение:

f=lambda A,t=0:    #Define the function, initialising t to 0 on the first iteration
               t>50and f(A,25)      #If t>50 then iterate again with t=25
                              or    #Else
               A and                #If A exists
                     f(A[1:],       #Iterate again without the first list of A
                        t-~         #And add to t, either
                           (sum(A[0])-1   #The sum of all elements if that's not 1
                                         or
                           762447093078/12**A[0].index(1)%12   #Else the appropriate pin value (black magic!)
               or t       #Finally, if A is finished, just return t
— Джо Кинг
источник
(0x103925BA4786>>4*A[0].index(1))%16сохраняет 1 персонажа противord('GIHEKLFCJDAB'[A[0].index(1)])-65
— Кая
1
Чуть более оптимально:762447093078/12**A[0].index(1)%12
— Кая
Этот материал выглядит как черная магия для меня! Спасибо @Kaya!
— Джо Кинг
1
Вот только кодировка с базы 12
— enedil
6

Желе , 25 байт

“ñ€bḷ’œ?TLḢṖ?µ€+25¹>?50ɗ/

Монадическая ссылка, принимающая список списков единиц и нулей (каждый длиной 12), который возвращает целое число.

Попробуйте онлайн! Или посмотрите набор тестов (используя целочисленные значения, указанные в OP)

Как?

Это решение использует œ?, для которого задано число n, и список находит n- ю лексикографическую перестановку списка, где список определяет порядок сортировки. Сначала нам нужно решить это n:

 index:  1  2  3  4  5  6  7  8  9 10 11 12
 value:  7  9  8  5 11 12  6  3 10  4  1  2   (as defined by the question)
     P: 11 12  8 10  4  7  1  3  2  9  5  6   (our permutation lookup array)

... то есть, Pв index iустановлен исходный индекс значения i.
Это Pимеет лексикографический индекс 438,337,469 (то есть, если вы возьмете все 12! Перестановок чисел от 1 до 12 и отсортируете их лексикографически, 438,337,469- й будет P).
Это может быть найдено с помощью Œ¿атома желе .
Оба шага могут быть выполнены за один раз с помощью программы JellyĠŒ¿

“ñ€bḷ’œ?TLḢṖ?µ€+25¹>?50ɗ/ - Link: list of lists of zeros and ones
             µ€           - perform the monadic chain to the left for €ach list:
“ñ€bḷ’                    -   base 250 number = 438337469
      œ?                  -   nth permutation (reorder the 1s and 0s to their pin values)
        T                 -   truthy indices (get the pin values of the 1s)
            ?             -   if...
           Ṗ              -   ...condition: pop (length greater than 1 ?)
         L                -   ...then: length (the number of pins)
          Ḣ               -   ...else: head (the first (& only) pin value)
                        / - reduce the resulting list of integers with:
                       ɗ  -   last three links as a dyad:
               +          -     addition (add the two values together)
                     50   -     literal fifty
                    ?     -     if...
                   >      -     ...condition: greater than (sum greater than 50 ?)
                25        -     ...then: literal twenty-five
                  ¹       -     ...else: identity (do nothing - just yield the sum)
— Джонатан Аллан
источник
Я думаю, что ваше объяснение о поиске подходящего лексикографического индекса среди всех перестановок стоило бы добавить в качестве подсказки желе . (Последний раз , когда я должен был сделать это, я сделал ручной дихотомический поиск, который не является , что долго для коротких последовательностей , но ... вроде утомительных ^^.)
— Arnauld
СМЕШНО; У меня было точно такое же решение, за исключением двух разных байтов: Ṗ-> Ḋ, µ-> Ʋ. Jelly действительно выиграл бы от принятия ниладической ссылки в качестве ¡s <link>(первый аргумент), за исключением того, что в случае самого запуска программы следует придерживаться специального режима.
— Эрик Outgolfer
... и я почти использовал оба!
— Джонатан Аллан
4

Pyth, 51 48 38 байт

VQI>=+Z?qJsN1@.PC"îO&"S12xN1J50=Z25;Z

Сохранено 10 байт благодаря Джонатану Аллану. Вводит в виде списка списков логических значений.
Попробуй здесь

объяснение

VQI>=+Z?qJsN1@.PC"îO&"S12xN1J50=Z25;Z
VQ                                  ;     For each input...
    =+Z                                   ... add to the total...
       ?q sN1                             ... if one pin is down...
             @.PC"îO&"S12xN1              ... the score of that pin.
         J                    J           ... otherwise, the count.
  I>                           50         If we pass 50...
                                 =Z25     ... reset to 25.
                                     Z    Output the total.
Не уверен, как точно ввести его в программу, но он должен сохранить 6 или 7 байт, если вы можете ... 7tT8h4hT12h5h2T4h02-> .PC"îO&"S12- использует индексацию лексикографической перестановки, как мой ответ Jelly. (Код содержит непечатаемый байт 0x0F в начале строки.)
— Джонатан Аллан
))может быть;
— Джонатан Аллан
4

05AB1E , 29 28 байт

v•CÞŸαLć•13вyOΘmyÏOO25‚¬50›è

Попробуйте онлайн!

объяснение

v                              # for each boolean list in input
 •CÞŸαLć•                      # push 13875514324986
         13в                   # convert to a list of base-13 numbers
            yO                 # push the sum of y
              Θm               # truthify and raise the pin-list to this number (0 or 1)
                yÏ             # keep those which are true in the current list
                  OO           # sum the list and the stack
                    25‚        # pair with 25
                       ¬50›    # check if the first number is larger than 50
                           è   # index into the pair with this result
— Emigna
источник
3

Haskell , 96 байт

foldl(\s a->([s..50]++e)!!sum(last$zipWith(*)[7,9,8,5,11,12,6,3,10,4,1,2]a:[a|sum a>1]))0
e=25:e

Попробуйте онлайн!

Обертка умная: я, по сути, индексирую позицию s+sum(…)в списке ([0..50]++cycle[25]). Тем не менее, более короткий способ записи - индексирование в позиции sum(…)и начало списка в s.

— Линн
источник
3

Java 10, 131 130 129 байт

m->{int r=0,i,s,t;for(var a:m){for(i=s=t=0;i<12;s+=a[i++])t=a[i]>0?"    \n".charAt(i):t;r+=s<2?t:s;r=r>50?25:r;}return r;}

Содержит 10 непечатных.
Ввод в виде целочисленной матрицы нулей и единиц.

-1 байт благодаря @JonathanFrech , меняется\t в реальную вкладку (работает в TIO, не работает в моей локальной IDE).

Попробуйте онлайн.

Объяснение:

m->{                // Method with integer-matrix parameter and integer return-type
  int r=0,          //  Result-integer, starting at 0
      i,s,t;        //  Temp integers
  for(var a:m){     //  Loop over the integer-arrays of the input
    for(i=s=t=0;    //   Reset `i`, `s` and `t` to 0
        i<12;       //   Loop `i` in the range [0,12)
        s+=a[i++])  //    Increase `s` by the current value (0 or 1)
      t=a[i]>0?     //    If the current value is 1:
         "  \n".charAt(i)
                    //     Set `t` to the score at this position
        :t;         //    Else: Leave `t` the same
    r+=s<2?         //   If only a single pin was hit:
        t           //    Add its score `t` to the result
       :            //   Else:
        s;          //    Add the amount of pins `s` to the result
    r=r>50?         //   If the result is now above 50
       25           //    Penalize it back to 25
      :r;}          //   If not, it stays the same
  return r;}        //  Return the result
— Кевин Круйссен
источник
Я думаю, что вы можете сохранить один байт, используя фактический символ табуляции в "\t\n".
— Джонатан Фрех
@JonathanFrech Хм, похоже, действительно работает в TIO. Не работает локально в моей IDE, но кого это волнует, я думаю ...;)
— Кевин Круйссен
Когда где-то есть рабочая реализация, это разрешено. : @
— Джонатан Фрех
2

Древесный уголь , 43 байта

≔⁰ηＦθ«≧⁺⎇⊖ΣιΣι⌕᧔$｜#z⁸Ｕg⊗”⌕ι¹η¿›η⁵⁰≔²⁵η»Ｉη

Попробуйте онлайн! Ссылка на подробную версию кода. Принимает ввод как логический массив. Объяснение:

≔⁰η

Установите счет на 0.

Ｆθ«

Зацикливайтесь на бросках.

⎇⊖Σι

Количество контактов 1?

Σι

Если нет, то возьмите количество пинов.

⌕᧔$｜#z⁸Ｕg⊗”⌕ι¹

В противном случае переведите положение штифта в значение.

≧⁺...η

Добавьте это к счету.

¿›η⁵⁰≔²⁵η

Если счет превышает 50, тогда установите его обратно на 25.

»Ｉη

Напечатайте окончательный результат после всех бросков.

— Нил
источник
2

Haskell , 110 байт

m s|sum s==1=sum$zipWith(*)[7,9,8,5,11,12,6,3,10,4,1,2]s|1>0=sum s
f l=foldl(\b->c.(b+).m)0l
c a|a>50=25|1>0=a

Та же длина: f l=foldl(\b a->last$b+m a:[25|b+m a>50])0lвместо fиc

Попробуйте онлайн!

— Angs
источник
Оставьте аргумент l в f на 3 байта. f=foldl(\b->c.(b+).m)0
— Aoemica
2

Шелуха , 47 35 байт

-12 байт благодаря H.PWiz (лучший способ создания точек кодирования списка)!

F₅0
S?25>50+?←Lε`f`+Nm+3d4652893071

Попробуйте онлайн!

объяснение

F₅0  -- input is a list of boolean lists
F    -- left fold by
 ₅   -- | the function flipped (overflowing label) on line 1
  0  -- | with initial value 0

S?25>50+?←Lε`f`+Nm+3d4652893071  -- example inputs: [0,0,0,1,0,0,0,0,0,0,0,0] 0
                     4652893071  -- integer literal: 4652893071
                    d            -- digits: [4,6,5,2,8,9,3,0,7,1]
                 m+3             -- map (+3): [7,9,8,5,11,12,6,3,10,4]
              `+N                -- append natural numbers: [7,9,8,5,11,12,6,3,10,4,1,2,3,...
            `f                   -- filter this list by argument: [5]
        ?  ε                     -- if it's of length 1
         ←                       -- | take first
          L                      -- | else the length
                                 -- : 5
       +                         -- add to argument: 5
 ?  >50                          -- if the value is > 50
  25                             -- | then 25
S                                -- | else the value
                                 -- : 5
— ბიმო
источник
Как насчет m+3d4652893071?
— H.PWiz
1

Красный , 189 172 байта

func[b][s: 0 foreach c b[d: 0 foreach e c[if e = 1[d: d + 1]]i: find c 1
n: either i[pick[7 9 8 5 11 12 6 3 10 4 1 2]index? i][0]if 50 < s: s + either 1 < d[d][n][s: 25]]s]

Попробуйте онлайн!

Объяснение негольфированного кода:

f: func[b][                                            ; a block of blocks of booleans
    s: 0                                               ; sets sum to 0
    foreach c b[                                       ; for each row of booleans 
        d: 0 foreach e c[if e = 1[d: d + 1]            ; count the number of 1s         
        i: find c 1                                    ; the index of the first 1
        n: either i[pick [7 9 8 5 11 12 6 3 10 4 1 2]  ; if there is 1, pick the number
                    index? i][0]                       ; at the index of 1
                                                       ; otherwise 0  
        if 50 < s: s + either 1 < d[d][n][s: 25]       ; if there is only one 1, add 
                                                       ; the number to the sum, otherwise
                                                       ; the number of 1s 
                                                       ; if the sum > 50, reset it to 25 
    ]
    s                                                  ; return the sum 
]
— Гален Иванов
источник
1

JavaScript (ES6), 98 байт

a=>a.map(b=>b.map((m,i)=>(c+=m,d+=m*('0x'+'7985bc63a412'[i])),c=d=0)|(t+=c>1?c:d)>50?t=25:0,t=0)|t

Тестовые случаи:

Показать фрагмент кода

— Рик Хичкок
источник
Тот же размер, что и (и очень похож на) моя эталонная реализация . :)
— Арно
Ах, круто. Я счастлив, когда я могу соответствовать вашему размеру кода. Только один раз в голубой луне я могу победить его :)
— Рик Хичкок
0

Stax , 37 байт

├T<↓"♥←~;▌6»≥øF←î5░U╚_π○Q▒<│∟└ù║pε♀▀æ

Запустите и отладьте его

Попробуйте онлайн!

объяснение

F:1"=EA5MQ9-I1%)"!s@c%1={h+}{%+}?c50>{d25}{}?    # Full program, unpacked

F                                                # Loop through every element
 :1                                              # Get indices of truthy elements
   "=EA5MQ9-I1%)"!                               # Push encoded [7,9,8,5,11,12,6,3,10,4,1,2]
                 s@                              # Swap the top 2 elements of stack and get elements at indexes
                   c%1=                          # Copy the top element, get length of array, compare to length of 1
                       {h+}{%+}?                 # If it has length of 1, add the element, otherwise add the length of the array to total
                                 c50>            # Compare total to 50, 
                                     {d25}{}?    # If it is greater, pop it off and push 25 to reset counter, otherwise do nothing

Не самая лучшая моя работа, но она работает. Я уверен, что есть кое-что, что я скучаю, чтобы сделать это немного короче.

— много
источник
0

Python 2 , 109 105 103 байтов

c=0
for l in input():a=sum(l);c+=int('7985bc63a412'[l.index(1)],16)if a==1else a;c=(25,c)[c<51]
print c

Попробуйте онлайн!

Альтернатива без рекурсивной функции.

-2 благодаря @Jo King

— ElPedro
источник
Вы можете убрать скобки вокруг строкового литерала
— Джо Кинг,
Используя наш сайт, вы подтверждаете, что прочитали и поняли нашу Политику в отношении файлов cookie и Политику конфиденциальности.
Licensed under cc by-sa 3.0 with attribution required.