Eu fiz o IMC este ano. Mais alguém aqui fez isso?

Em um artigo do UKMT Intermediate Maths Challenge, existem 25 perguntas. As primeiras quinze perguntas dão cinco notas, se você as acertar. Nas outras dez perguntas, você recebe seis notas para acertá-las. Nas últimas dez perguntas, você perde notas se errar! Nas perguntas dezesseis a vinte, você perde uma nota e nas últimas cinco perguntas, você perde duas notas. Se você deixar uma pergunta em branco, nenhuma marca será concedida ou deduzida. Nenhuma marca é deduzida por se ter errado uma das primeiras quinze perguntas. O artigo é de múltipla escolha; você pode escolher qualquer resposta entre A, B, C, D e E para cada pergunta. Sempre há apenas uma resposta certa para cada pergunta.

Crie um programa / função que use duas strings e produza uma pontuação. A primeira sequência será sua resposta ao artigo. Se você pular uma pergunta, use um espaço, um byte nulo ou um sublinhado. Caso contrário, use a letra A, B, C, D ou E para a resposta. Você pode ter as entradas em maiúsculas ou minúsculas. A segunda sequência será a resposta correta para cada pergunta do artigo. Seu programa / função produzirá uma pontuação. Faça seu código curto.

Casos de teste:

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 bytes

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

Experimente online!

Geléia , 26 23 22 bytes

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

Experimente online!

Como funciona

=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 bytes

Economizou 2 bytes graças a Neil
Economizou 2 bytes graças a ETHproductions

Leva as respostas do candidato ae as respostas corretas cna sintaxe do curry (a)(c). Espera que as perguntas ignoradas sejam marcadas com um espaço.

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

Casos de teste

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 bytes

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)

Experimente online!

Como funciona

Isso define uma função recursiva f que recebe dois argumentos não ideais: t (as respostas para o teste) es (a folha de respostas). Quando chamado apenas com estes dois argumentos, f inicializa i a 24 , o último índice de ambos t e s .

Toda vez que f é chamado, primeiro verifica se ~ i (o bit a bit NÃO de i ) é verdadeiro / diferente de zero. Como ~ (-1) = 0 , isso acontece quando i atinge o valor -1 . Se i = -1 , ~ i = 0 é retornado, mas como i toma valores de 24 a 0 (todos os índices de t e s ), o código seguinte andé executado e f retorna o resultado.

Enquanto i não é negativo, acontece o seguinte. Primeiro,

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

cria uma tupla de comprimento 2 :

• O quociente i/10é 0 se 0 ≤ i <10 , 1 se 10 ≤ i <20 e 2 se 20 ≤ i <25 . A comparação encadeada 14<i<t[i]<'_'retorna True se e somente se todas as comparações individuais retornarem True , ou seja, se e somente se i ≥ 15 (o intervalo de perguntas com penalidade), i for menor que t [i] (sempre verdadeiro, pois todos os números são menores que todas as iteráveis ​​no Python 2), e t [i] não é um sublinhado.

  Se a comparação retornar Falso , o unário -retornará 0 e a expressão inteira será avaliada como 0 . No entanto, se a comparação retornar True , o unário -retornará -1 , então a expressão inteira será avaliada como 0 se 0 ≤ i <10 , -1 se 10 ≤ i <20 e -2 se 20 ≤ i <25 ; estes são os resultados líquidos de respostas erradas ou ausentes para todos os índices i .

• 5+i/15retorna 5 + 0 = 5 se 0 ≤ i <15 e 5 + 1 = 6 se 15 ≤ i <25 . Estes são os resultados líquidos para respostas corretas para todos os índices i .

Finalmente, [t[i]==s[i]]seleciona o primeiro elemento da tupla construída se t [i] e s [i] diferem (resposta incorreta ou ausente) e o segundo se for igual (resposta correta) e, em seguida, adiciona o valor de retorno de f chamado com decrementado eu para esse resultado. Quando eu atingir -1 , a pontuação final será calculada e retornada por f .

Mathematica, 114 bytes

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

Função pura pegando um par ordenado de listas de caracteres e retornando um número inteiro. m[Equal,#/."_"->u]retorna uma lista de booleanos, exceto para entradas não avaliadas do formulário u=="B"em locais onde a resposta foi igual "_"; então, imediatamente, u==_->0transforma essas entradas não avaliadas em 0s. Tr/@Partition[...,5]adiciona essas entradas 5 por vez, resultando em uma lista como {4False+True, 4False+True, 4False+True, 4False+True, 4False+True}para o primeiro caso de teste ou {5True, 5True, 5True, 2True, 2True}o último caso de teste. Em seguida, em cada coordenada, Truee Falsesão mapeados para as contagens apropriadas, e os resultados são adicionados juntos.

Geléia , 22 21 bytes

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

Experimente online!

Eu pensei que a resposta de @ Dennis provavelmente era superável. E depois de experimentar um grande número de possibilidades diferentes e me beneficiar de uma incrível coincidência, finalmente consegui!

Este programa usa um par de [respostas dos alunos, respostas corretas] como entrada e usa espaços para indicar uma resposta ausente.

Explicação

Este programa usa alguns formatos de entrada internos bizarros para acompanhar o que está acontecendo, por isso daremos um passo de cada vez.

1. Z

   Isso transpõe a entrada; portanto, terminaremos com uma lista de 25 elementos, um para cada pergunta; cada elemento tem a forma [resposta do aluno, resposta correta]. Indicaremos um elemento deste formulário com uma letra maiúscula; Apara a pergunta 1, Bpara a pergunta 2 e assim por diante. Portanto, as respostas estão atualmente sendo armazenadas como

   ABCDEFGHIJKLMNOPQRSTUVWXY
   

2. m0

   Esta é uma operação "maior palíndromo"; anexamos o reverso do valor atual ao próprio valor, produzindo o seguinte:

   ABCDEFGHIJKLMNOPQRSTUVWXYYXWVUTSRQPONMLKJIHGFEDCBA
   

3. ṁ135

   O ṁoperador (molde) faz várias coisas, mas, nesse contexto, efetivamente pega os primeiros 135 elementos da lista infinita produzidos, acrescentando o valor atual a si mesmo repetidamente. Isso nos dá o seguinte (que dividimos em grupos de 50 elementos por conveniência; esta é apenas uma lista de 135 pares internamente):

   ABCDEFGHIJKLMNOPQRSTUVWXYYXWVUTSRQPONMLKJIHGFEDCBA
   ABCDEFGHIJKLMNOPQRSTUVWXYYXWVUTSRQPONMLKJIHGFEDCBA
   ABCDEFGHIJKLMNOPQRSTUVWXYYXWVUTSRQP
   

4. µ;

   µdefine o valor atual como o novo padrão para os operandos ausentes. Em seguida, vemos imediatamente um componente que está faltando um operando; ;acrescenta, mas não especificamos com o que anexar. Como resultado, o valor atual é anexado ao valor do último µ(que também é o valor atual), fornecendo o seguinte valor atual de 270 elementos:

   ABCDEFGHIJKLMNOPQRSTUVWXYYXWVUTSRQPONMLKJIHGFEDCBA
   ABCDEFGHIJKLMNOPQRSTUVWXYYXWVUTSRQPONMLKJIHGFEDCBA
   ABCDEFGHIJKLMNOPQRSTUVWXYYXWVUTSRQPABCDEFGHIJKLMNO
   PQRSTUVWXYYXWVUTSRQPONMLKJIHGFEDCBAABCDEFGHIJKLMNO
   PQRSTUVWXYYXWVUTSRQPONMLKJIHGFEDCBAABCDEFGHIJKLMNO
   PQRSTUVWXYYXWVUTSRQP
   

5. t€⁶

   Lembre-se de que todas as letras maiúsculas acima representam pares de [resposta do aluno, resposta correta]. A t€⁶operação opera em cada ( €) par e exclui ( t) espaços ( ⁶) de ambos os lados do par (ou seja, qualquer espaço que apareça no par). Portanto, ainda temos a mesma lista complicada de 270 perguntas com muitas repetições, mas elas têm a forma [resposta correta] (o aluno não respondeu) ou [resposta do aluno, resposta correta] (o aluno respondeu).

6. E€’

   A E€’operação também opera em cada €elemento ( ) e, devido ao uso de E, substitui o elemento por 1 se todos os elementos forem iguais (ou seja, o aluno não respondeu ou acertou a pergunta) ou 0, se não todos. os elementos são iguais (ou seja, o aluno respondeu, mas errou a pergunta). O uso de ’aqui altera a numeração, o que significa que agora usamos -1 ou 0, respectivamente. Usarei letras minúsculas para esse novo tipo de elemento, que usa -1 para uma resposta que seria penalizada se estivesse em uma pergunta elegível à penalidade ou 0 para uma resposta correta ou ausente:

   abcdefghijklmnopqrstuvwxyyxwvutsrqponmlkjihgfedcba
   abcdefghijklmnopqrstuvwxyyxwvutsrqponmlkjihgfedcba
   abcdefghijklmnopqrstuvwxyyxwvutsrqpabcdefghijklmno
   pqrstuvwxyyxwvutsrqponmlkjihgfedcbaabcdefghijklmno
   pqrstuvwxyyxwvutsrqponmlkjihgfedcbaabcdefghijklmno
   pqrstuvwxyyxwvutsrqp
   

7. ;E€

   Já vimos tanto E€e ;antes; estamos acrescentando algo ao valor atual e usando o formato 1 se todos os elementos forem iguais ou 0 se alguns forem diferentes (não ’desta vez!). Há um operando ausente aqui, então usamos o valor do último µ(ou seja, a saída da etapa 3). Na etapa 3, não havíamos excluído espaços dos elementos, portanto, teremos 1 para uma resposta correta ou 0 para uma resposta incorreta ou ausente (porque um espaço não corresponde à resposta correta). A partir de agora, usarei letras maiúsculas para este formato 1 = correto, 0 = incorreto / ausente e continuarei a usar letras minúsculas para 0 = correto / ausente, -1 = incorreto. O valor resultante possui 405 elementos e se parece com isso:

   abcdefghijklmnopqrstuvwxyyxwvutsrqponmlkjihgfedcba
   abcdefghijklmnopqrstuvwxyyxwvutsrqponmlkjihgfedcba
   abcdefghijklmnopqrstuvwxyyxwvutsrqpabcdefghijklmno
   pqrstuvwxyyxwvutsrqponmlkjihgfedcbaabcdefghijklmno
   pqrstuvwxyyxwvutsrqponmlkjihgfedcbaabcdefghijklmno
   pqrstuvwxyyxwvutsrqpABCDEFGHIJKLMNOPQRSTUVWXYYXWVU
   TSRQPONMLKJIHGFEDCBAABCDEFGHIJKLMNOPQRSTUVWXYYXWVU
   TSRQPONMLKJIHGFEDCBAABCDEFGHIJKLMNOPQRSTUVWXYYXWVU
   TSRQP
   

8. ṫ⁹

   Aí vem a incrível coincidência que mencionei anteriormente. Antes de falar sobre esse trecho do código, quero fazer um balanço de onde devemos chegar.

   Cada letra maiúscula representa +1 para uma resposta correta; as 15 primeiras perguntas ( Aa O) aparecem 5 vezes cada na string e as últimas 10 perguntas ( Pa Y) aparecem 6 vezes cada. Essa parte não é realmente mágica; Eu o projetei dessa maneira quando escolhi o número 135 no início do programa (que é 5 × 15 + 6 × 10), e o único golpe de sorte aqui é que 5 passa a ser um número ímpar (então são os últimos 10 perguntas que acabam aparecendo nos horários extras, em vez dos 10 primeiros). As 15 letras imediatamente anteriores a isso contêm patravés t(as questões de penalidade -1) uma vez e uatravés y(as questões de penalidade -2) duas vezes. Isso também não é muita coincidência; porque nós usamosm0anteriormente, as cópias extras das perguntas estão na ordem PQRSTUVWXYYXWVUTSRQPe as perguntas posteriores ocorrerão naturalmente perto do meio dessa sequência (portanto, fazer as últimas 15 perguntas "extras" fornecerá menos repetições para as próximas às bordas; e é claro que não é surpresa que as perguntas "extras" venham por último).

   Como cada letra minúscula subtrai 1 da pontuação para uma resposta incorreta e ausente, e cada letra maiúscula adiciona 1 à pontuação para uma resposta correta, portanto, precisamos simplesmente usar os últimos 135 + 15 = 150 elementos para obter cada tipo de elemento o número correto de vezes. O comando de Jelly para obter uma substring no final de uma lista é ṫ; no entanto, não especifica o número de elementos que você deseja, mas o índice do primeiro elemento que você deseja. Temos 405 elementos neste momento e queremos 150, portanto, precisamos começar no índice (405 - 150 + 1) ou 256. Em uma incrível coincidência, 256 passa a ser o número de octetos distintos que existem e, portanto, tem uma breve representação em Jelly (⁹) Havia muito pouco que eu pudesse fazer para que isso acontecesse; a etapa 4 adicionou outros 135 elementos ao início da lista para atingir o número da rodada, mas o fato de serem 135 elementos que eu tinha que adicionar (um valor que estava prontamente disponível naquele ponto do programa) era realmente conveniente, com basicamente qualquer outro número sendo completamente inútil nessa situação.

   Aqui está como o valor interno parece agora:

   uvwxyyxwvutsrqpABCDEFGHIJKLMNOPQRSTUVWXYYXWVUTSRQP
   ONMLKJIHGFEDCBAABCDEFGHIJKLMNOPQRSTUVWXYYXWVUTSRQP
   ONMLKJIHGFEDCBAABCDEFGHIJKLMNOPQRSTUVWXYYXWVUTSRQP
   

9. S

   Por fim, agora temos uma lista de modificações na pontuação das perguntas, tudo o que precisamos fazer é somar e usar S.

Python 2 , 93 91 bytes

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)

Experimente online!

-2 bytes graças a @KritixiLithos

Entrada:

• a : Respostas do aluno como uma string, _ para a pergunta ignorada
• b : respostas corretas
• n: o número do atual 0baseado em perguntas , o padrão é0

k, 52 bytes

A função usa 2 strings, formato de acordo com os casos de teste

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

Exemplo:

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

Haskell, 84 bytes

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

Exemplo de uso: ((sum.).zipWith3 i(w=<<[0..2])) "DBADBDCDBAEDABCD_E__A__C_" "DBADBDCDBAEDABCDBEEDACDCA"-> 99. Experimente online! .

Como funciona: i x a bcalcula a pontuação para uma única resposta acom resultado correto be a penalidade xpor uma resposta errada (um valor não negativo). Se você pular ( a>'Z'), a pontuação será 0, se a resposta estiver correta ( a==b), a pontuação será 6-0^x, caso contrário, a pontuação será -x.

w=<<[0..2]faz uma lista de penalidades para todas as 25 perguntas aplicando wa 0, 1e 2, ou seja, fazendo 5*3^0^xcópias de cada número (-> 15 vezes 0, 5 vezes 1e 5 vezes 2).

zipWith3aplica i- se à lista de penalidades, lista de respostas e lista de resultados corretos. Finalmente, todas as pontuações são adicionadas ( sum).

Oitava, 61 54 bytes

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

Experimente online!

Resposta anterior:

@(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 bytes

Minha primeira solução no ES6, talvez até a primeira no 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 solução enviada e um é a solução correta. Ambos serão tomados como seqüências de caracteres.

Aqui está uma solução não recursiva em 78 bytes:

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

Recebe entrada através da sintaxe de currying.

Obrigado a @ETHproductions por salvar 9 bytes! s[i]para ce (-1-(i>19|0))para~(i>19) .

Agradecemos ao @Kritixi Lithos por salvar um byte! c=='_'para c>'Z'.

Experimente online!