Я сделал IMC в этом году. Кто-нибудь еще здесь делал это?

В документе UKMT Intermediate Maths Challenge есть двадцать пять вопросов. Первые пятнадцать вопросов дают вам пять баллов, если вы понимаете их правильно. За остальные десять вопросов вы получите шесть баллов за их правильность. В последних десяти вопросах вы теряете оценки, если ошибаетесь! За вопросы с шестнадцатого по двадцать вы теряете одну оценку, а за последние пять вопросов вы теряете две оценки. Если вы оставите вопрос пустым, оценки не начисляются и не вычитаются. За неправильные ответы на первые пятнадцать вопросов баллы не вычитаются. Бумага с множественным выбором; Вы можете выбрать любой ответ из A, B, C, D и E для каждого вопроса. На каждый вопрос всегда есть только один правильный ответ.

Создайте программу / функцию, которая принимает две строки и выводит оценку. Первая строка будет ваши ответы на бумаге. Если вы пропустите вопрос, используйте пробел, нулевой байт или подчеркивание. В противном случае используйте букву A, B, C, D или E для ответа. Вы можете вводить заглавные или строчные буквы. Вторая строка будет правильными ответами на каждый вопрос в статье. Ваша программа / функция выведет результат. Сделайте ваш код коротким.

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

DDDDDDDDDDDDDDDDDDDDDDDDD
ABCDEABCDEABCDEABCDEABCDE
15

BDBEACCECEDDBDABBCBDAEBCD
BDBEACCECEDDBDABBCBDAEBCD
135

DBACBDCDBAEDABCDBEECACDC_
DBADBDCDBAEDABCDBEEDACDCA
117

_________________________
DABDABDABDABDABDABDABDABD
0

DBADBDCDBAEDABCD_E__A__C_
DBADBDCDBAEDABCDBEEDACDCA
99

_______________BBBBBBBBBB
AAAAAAAAAAAAAAAAAAAAAAAAA
-15

C 88 87 86 81 байт

c,d;i(char*a,char*b){for(c=d=0;*b;c++,a++)d+=*a^*b++?*a?-c/15-c/20:0:5+c/15;d=d;}

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

Желе , 26 23 22 байта

=s5ị"“HHHQP‘D¤_2Fæ.n⁶¥

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

Как это работает

=s5ị"“HHHQP‘D¤_2Fæ.n⁶¥  Main link. Argument: t (answer to test), s (answer sheet)

=                       Test the characters of t and s for equality.
 s5                     Split into chunks of length 5.
             ¤          Combine the two preceding links into a niladic chain.
     “HHHQP‘              Yield the code points, i.e., [72, 72, 72, 81, 80].
            D             Decimal; yield [[7, 2], [7, 2], [7, 2], [8, 1], [8, 0]].
   ị"                   Index zipwith; use the Booleans in each chunk to index into
                        the corresponding pair. Indexing is 1-based and modular, so
                        1 gives the first element and 0 the last.
              _2        Subtract 2 from each result.
                F       Flatten the resulting 5x5 matrix.
                     ¥  Combine the two preceding links into a dyadic chain.
                   n⁶     Test the characters of t for inequality with space.
                 æ.     Take the dot product of the integers to the left and the
                        Booleans to the right.

JavaScript (ES6), 70 68 66 байт

Сохранено 2 байта благодаря Neil
Сохранено 2 байта благодаря ETHproductions

Принимает ответы заявителя aи правильные ответы cв синтаксисе карри (a)(c). Ожидает пропущенные вопросы, которые будут отмечены пробелом.

a=>c=>a.replace(/\S/g,(a,i)=>s+=a==c[j=i>14,i]?5+j:-j^i>19,s=0)&&s

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

let f =

a=>c=>a.replace(/\S/g,(a,i)=>s+=a==c[j=i>14,i]?5+j:-j^i>19,s=0)&&s

console.log(f
  ("DDDDDDDDDDDDDDDDDDDDDDDDD")
  ("ABCDEABCDEABCDEABCDEABCDE")
);
console.log(f
  ("BDBEACCECEDDBDABBCBDAEBCD")
  ("BDBEACCECEDDBDABBCBDAEBCD")
);
console.log(f
  ("DBACBDCDBAEDABCDBEECACDC ")
  ("DBADBDCDBAEDABCDBEEDACDCA")
);
console.log(f
  ("                         ")
  ("DABDABDABDABDABDABDABDABD")
);
console.log(f
  ("DBADBDCDBAEDABCD E  A  C ")
  ("DBADBDCDBAEDABCDBEEDACDCA")
);
console.log(f
  ("               BBBBBBBBBB")
  ("AAAAAAAAAAAAAAAAAAAAAAAAA")
);

Python 2 , 86 85 83 77 байт

f=lambda t,s,i=24:~i and(i/10*-(14<i<t[i]<'_'),5+i/15)[t[i]==s[i]]+f(t,s,i-1)

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

Как это работает

Это определяет рекурсивную функцию f, которая принимает два неоптимальных аргумента: t (ответы на тест) и s (лист ответов). Когда вызывается только с этими двумя аргументами, f инициализирует i в 24 , последний индекс как t, так и s .

Каждый раз, когда вызывается f , он сначала проверяет, является ли ~ i (побитовое НЕ для i ) истинным / ненулевым. Поскольку ~ (-1) = 0 , это происходит, когда i достигает значения -1 . Если i = -1 , ~ i = 0 возвращается, но, поскольку i принимает значения от 24 до 0 (все индексы t и s ), выполняется следующий код andи f возвращает результат.

Пока я неотрицательный, происходит следующее. Первый,

(i/10*-(14<i<t[i]<'_'),5+i/15)

создает кортеж длины 2 :

• Коэффициент i/10равен 0, если 0 ≤ i <10 , 1, если 10 ≤ i <20 , и 2, если 20 ≤ i <25 . Связанное сравнение 14<i<t[i]<'_'возвращает True, если и только если все отдельные сравнения возвращают True , то есть, если и только если i ≥ 15 (диапазон вопросов с штрафом), i меньше, чем t [i] (всегда верно, поскольку все числа меньше, чем все итерируемые в Python 2), и t [i] не является подчеркиванием.

  Если сравнение возвращает False , унарный код -возвращает 0, а все выражение оценивается как 0 . Однако, если сравнение возвращает True , унарное значение -возвращает -1 , поэтому все выражение оценивается в 0, если 0 ≤ i <10 , -1, если 10 ≤ i <20 , и -2, если 20 ≤ i <25 ; это чистые результаты для неправильных или пропущенных ответов для всех индексов i .

• 5+i/15возвращает 5 + 0 = 5, если 0 ≤ i <15, и 5 + 1 = 6, если 15 ≤ i <25 . Это чистые результаты для правильных ответов по всем показателям i .

Наконец, [t[i]==s[i]]выбирает первый элемент составного кортежа, если t [i] и s [i] различаются (неправильный или отсутствующий ответ), и второй, если они равны (правильный ответ), затем добавляет возвращаемое значение f, вызванное с уменьшением я к этому результату. Как только я достигну -1 , окончательный счет был вычислен и возвращен f .

Mathematica, 114 байт

Tr@(m=MapThread)[#/.True->#2/.False->-#3&,{Tr/@Partition[m[Equal,#/."_"->u]/.u==_->0,5],{5,5,5,6,6},{0,0,0,1,2}}]&

Чистая функция, берущая упорядоченную пару списков символов и возвращающую целое число. m[Equal,#/."_"->u]возвращает список логических значений, за исключением недооцененных записей формы u=="B"в местах, где равнялся ответ "_"; затем сразу же u==_->0превращает эти неоцененные записи в 0s. Tr/@Partition[...,5]добавляет эти записи до 5 за раз, в результате получается список, как {4False+True, 4False+True, 4False+True, 4False+True, 4False+True}для первого теста или {5True, 5True, 5True, 2True, 2True}для последнего теста. Затем в каждой координате Trueи Falseсопоставляются соответствующие баллы, и результаты складываются вместе.

Желе , 22 21 байт

Zm0ṁ135µ;t€⁶E€’;E€ṫ⁹S

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

Я думал, что ответ @ Денниса, вероятно, можно победить. И после того, как опробовал огромное количество различных возможностей и извлек выгоду из удивительного совпадения, я наконец справился с этим!

Эта программа принимает в качестве входных данных пару [ответы ученика, правильные ответы] и использует пробелы для обозначения пропущенного ответа.

объяснение

Эта программа использует несколько причудливых внутренних форматов ввода для отслеживания происходящего, поэтому мы будем делать это шаг за шагом.

1. Z

   Это транспонирует входные данные, поэтому мы получим список из 25 элементов, по одному на каждый вопрос; каждый элемент имеет форму [ответ ученика, правильный ответ]. Мы укажем элемент этой формы заглавной буквой; Aдля вопроса 1, Bдля вопроса 2 и так далее. Таким образом, ответы в настоящее время хранятся как

   ABCDEFGHIJKLMNOPQRSTUVWXY
   

2. m0

   Это операция "большего палиндрома"; мы добавляем обратное значение текущего значения к самому значению, получая это:

   ABCDEFGHIJKLMNOPQRSTUVWXYYXWVUTSRQPONMLKJIHGFEDCBA
   

3. ṁ135

   Оператор ṁ(mold) делает несколько вещей, но в этом контексте он эффективно берет первые 135 элементов бесконечного списка, созданного путем многократного добавления текущего значения к себе. Это дает нам следующее (который я разбил на группы по 50 элементов для удобства; это всего лишь список из 135 пар внутри):

   ABCDEFGHIJKLMNOPQRSTUVWXYYXWVUTSRQPONMLKJIHGFEDCBA
   ABCDEFGHIJKLMNOPQRSTUVWXYYXWVUTSRQPONMLKJIHGFEDCBA
   ABCDEFGHIJKLMNOPQRSTUVWXYYXWVUTSRQP
   

4. µ;

   µустанавливает текущее значение как новое значение по умолчанию для пропущенных операндов. Затем мы сразу видим встроенный объект, в котором отсутствует операнд; ;добавляется, но мы не указали, что добавить. В результате текущее значение добавляется к последнему значению µ(которое также является текущим значением), давая нам следующее текущее значение из 270 элементов:

   ABCDEFGHIJKLMNOPQRSTUVWXYYXWVUTSRQPONMLKJIHGFEDCBA
   ABCDEFGHIJKLMNOPQRSTUVWXYYXWVUTSRQPONMLKJIHGFEDCBA
   ABCDEFGHIJKLMNOPQRSTUVWXYYXWVUTSRQPABCDEFGHIJKLMNO
   PQRSTUVWXYYXWVUTSRQPONMLKJIHGFEDCBAABCDEFGHIJKLMNO
   PQRSTUVWXYYXWVUTSRQPONMLKJIHGFEDCBAABCDEFGHIJKLMNO
   PQRSTUVWXYYXWVUTSRQP
   

5. t€⁶

   Помните, что все заглавные буквы выше представляют пары [ответ учащегося, правильный ответ]. t€⁶Операция действует на каждой ( €пары), и удаляет ( t) пространств ( ⁶) с обеих сторон пары (т.е. любое пространство , которое появляется в паре). Таким образом, у нас все еще есть тот же запутанный список из 270 вопросов со многими повторениями, но они имеют форму [правильный ответ] (студент не ответил) или [ответ студента, правильный ответ] (студент ответил).

6. E€’

   E€’Операция также действует на каждом ( €элементе), и, в связи с использованием E, заменяет элемент с 1 , если все элементы равны (т.е. ученик не ответил или получил право вопроса), или 0 , если не все элементы равны (то есть студент ответил, но неправильно понял вопрос). Использование ’здесь меняет нумерацию, что означает, что теперь мы используем -1 или 0 соответственно. Я буду использовать строчные буквы для этого нового вида элемента, который использует -1 для ответа, который был бы оштрафован, если бы он был на отвечающем штрафу вопросе, или 0 для пропущенного или правильного ответа:

   abcdefghijklmnopqrstuvwxyyxwvutsrqponmlkjihgfedcba
   abcdefghijklmnopqrstuvwxyyxwvutsrqponmlkjihgfedcba
   abcdefghijklmnopqrstuvwxyyxwvutsrqpabcdefghijklmno
   pqrstuvwxyyxwvutsrqponmlkjihgfedcbaabcdefghijklmno
   pqrstuvwxyyxwvutsrqponmlkjihgfedcbaabcdefghijklmno
   pqrstuvwxyyxwvutsrqp
   

7. ;E€

   Мы видели как E€и ;раньше; мы добавляем что-то к текущему значению и используем формат 1, если все элементы равны, или 0, если некоторые отличаются (нет, на ’этот раз!). Здесь пропущен операнд, поэтому мы используем значение как последнее µ(т.е. вывод шага 3). Вернувшись к шагу 3, мы не удалили пробелы из элементов, поэтому у нас будет 1 для правильного ответа или 0 для неправильного или пропущенного ответа (поскольку пробел не будет соответствовать правильному ответу). С этого момента я буду использовать заглавные буквы для этого 1 = правильный, 0 = неправильный / отсутствующий формат и продолжу использовать строчные буквы для 0 = правильный / отсутствующий, -1 = неправильный. Результирующее значение имеет 405 элементов и выглядит следующим образом:

   abcdefghijklmnopqrstuvwxyyxwvutsrqponmlkjihgfedcba
   abcdefghijklmnopqrstuvwxyyxwvutsrqponmlkjihgfedcba
   abcdefghijklmnopqrstuvwxyyxwvutsrqpabcdefghijklmno
   pqrstuvwxyyxwvutsrqponmlkjihgfedcbaabcdefghijklmno
   pqrstuvwxyyxwvutsrqponmlkjihgfedcbaabcdefghijklmno
   pqrstuvwxyyxwvutsrqpABCDEFGHIJKLMNOPQRSTUVWXYYXWVU
   TSRQPONMLKJIHGFEDCBAABCDEFGHIJKLMNOPQRSTUVWXYYXWVU
   TSRQPONMLKJIHGFEDCBAABCDEFGHIJKLMNOPQRSTUVWXYYXWVU
   TSRQP
   

8. ṫ⁹

   Здесь происходит удивительное совпадение, о котором я упоминал ранее. Прежде чем говорить об этом фрагменте кода, я хочу подвести итоги того, к чему мы пришли.

   Каждая заглавная буква представляет +1 для правильного ответа; первые 15 вопросов (до Aконца O) появляются 5 раз каждый в строке, а последние 10 вопросов (до Pконца Y) появляются 6 раз каждый. Это немного не волшебно; Я разработал его таким образом, когда я выбрал число 135 ранее в программе (это 5 × 15 + 6 × 10), и единственная удача здесь в том, что 5 оказывается нечетным числом (так что это последние 10 вопросы, которые заканчиваются тем, что появляются дополнительные времена, а не первые 10). 15 букв, непосредственно предшествующих этому, содержат pдо t(-1 штрафные вопросы) один раз и uдо y(-2 штрафных вопроса) дважды. Это также не так много совпадений; потому что мы использовалиm0ранее дополнительные копии вопросов располагались по порядку PQRSTUVWXYYXWVUTSRQP, а более поздние вопросы, естественно, будут располагаться ближе к середине этой строки (таким образом, если взять последние 15 «дополнительных» вопросов, будет меньше повторений тем, которые расположены ближе к краям; и конечно, не удивительно, что «лишние» вопросы приходят последними).

   Поскольку каждая строчная буква вычитает 1 из оценки за неправильный, не пропущенный ответ, а каждая заглавная буква добавляет 1 к оценке для правильного ответа, нам просто нужно взять последние 135 + 15 = 150 элементов, чтобы получить каждый вид элемента правильное количество раз. Команда Jelly для получения подстроки в конце списка есть ṫ; тем не менее, он не указывает количество элементов, которые вы хотите, а скорее индекс первого элемента, который вы хотите. У нас есть 405 элементов на данный момент, и мы хотим 150, поэтому нам нужно начать с индекса (405 - 150 + 1) или 256. При удивительном совпадении 256 оказывается числом существующих октетов, и поэтому имеет короткое представление в желе (⁹). Я мало что мог сделать, чтобы это произошло; шаг 4 добавил еще 135 элементов в начало списка, чтобы попасть в круглое число, но тот факт, что мне нужно было добавить 135 элементов (значение, которое было легко доступно в тот момент в программе), было действительно удобным, в основном любое другое число совершенно бесполезно в этой ситуации.

   Вот как теперь выглядит внутреннее значение:

   uvwxyyxwvutsrqpABCDEFGHIJKLMNOPQRSTUVWXYYXWVUTSRQP
   ONMLKJIHGFEDCBAABCDEFGHIJKLMNOPQRSTUVWXYYXWVUTSRQP
   ONMLKJIHGFEDCBAABCDEFGHIJKLMNOPQRSTUVWXYYXWVUTSRQP
   

9. S

   Наконец, теперь у нас есть список изменений в оценке из вопросов, все, что нам нужно сделать, это суммировать их S, и мы сделали.

Python 2 , 93 91 байт

f=lambda a,b,n=0:a>""and((a[0]==b[0])*(5+n/15)or-(n/15*n/10)*(a[0]<"^"))+f(a[1:],b[1:],n+1)

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

-2 байта благодаря @KritixiLithos

Входные данные:

• a: Ответы ученика в виде строки, _для пропущенного вопроса
• b : правильные ответы
• n: номер текущего вопроса на 0основе, по умолчанию0

к, 52 байта

Функция принимает 2 строки, формат для тестовых случаев

{+/(~x="_")*(+,/'(15 5 5#'0 -1 -2;15 10#'5 6))@'x=y}

Пример:

k){+/(~x="_")*(+,/'(15 5 5#'0 -1 -2;15 10#'5 6))@'x=y}["DBADBDCDBAEDABCD_E__A__C_";"DBADBDCDBAEDABCDBEEDACDCA"]
99

Haskell, 84 байта

i x a b|a>'Z'=0|a==b=6-0^x|1<2= -x
w x=x<$[1..5*3^0^x]
(sum.).zipWith3 i(w=<<[0..2])

Пример использования: ((sum.).zipWith3 i(w=<<[0..2])) "DBADBDCDBAEDABCD_E__A__C_" "DBADBDCDBAEDABCDBEEDACDCA"-> 99. Попробуйте онлайн! ,

Как это работает: i x a bрассчитывает балл за один ответ aс правильным результатом bи штраф xза неправильный ответ (неотрицательное значение). Если вы пропустите ( a>'Z'), оценка будет 0, если ответ правильный ( a==b), оценка будет 6-0^x, в противном случае оценка -x.

w=<<[0..2]составляет список штрафов за все 25 вопросов, обращаясь wк 0, 1и 2, т.е. делая 5*3^0^xкопии каждого номера (-> 15 раз 0, 5 раз 1и 5 раз 2).

zipWith3относится iк списку штрафов, списку ответов и списку правильных результатов. Наконец все оценки добавляются ( sum).

Октава, 61 54 байта

@(a,b)[a==b,-(a<95&a~=b)]*[(x=1:25>15)+5,(1:25>20)+x]'

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

Предыдущий ответ:

@(a,b)(m=a==b)*(((f=kron(z=[0 0 0:2],z|1)')&1)+5)-(a<95&~m)*f

JavaScript (ES6), 105 103 101 94 89 88 85 84 78 77 байт

Мое первое решение в ES6, может быть, даже первое в Javascript Oo

f=(s,a,i=24)=>i+1&&(s[i]>'Z'?0:s[i]==a[i]?5+(i>14):~(i>19)*(i>14))+f(s,a,i-1)

s - представленное решение и a - правильное решение. Оба будут приняты в качестве строк.

Вот нерекурсивное решение на 78 байтов:

s=>a=>eval([...s].map((c,i)=>c>'Z'?0:c==a[i]?5+(i>14):~(i>19)*(i>14)).join`+`)

Принимает ввод через синтаксис карри.

Спасибо @ETHproductions за сохранение 9 байтов! s[i]к cи(-1-(i>19|0)) к ~(i>19).

Спасибо @Kritixi Lithos за сохранение байта! c=='_'вc>'Z' .

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