J'ai fait l'IMC cette année. Est-ce que quelqu'un d'autre ici l'a fait?

Dans un article du UKMT Intermediate Maths Challenge, il y a vingt-cinq questions. Les quinze premières questions vous donnent cinq points si vous les obtenez correctement. Pour les dix autres questions, vous obtenez six points pour avoir bien répondu. Dans les dix dernières questions, vous perdez des points si vous vous trompez! Pour les questions seize à vingt, vous perdez un point et pour les cinq dernières questions, vous perdez deux points. Si vous laissez une question en blanc, aucun point n'est attribué ou déduit. Aucun point n'est déduit pour avoir mal répondu aux quinze premières questions. Le papier est à choix multiples; vous pouvez choisir n'importe quelle réponse parmi A, B, C, D et E pour chaque question. Il y a toujours une seule bonne réponse pour chaque question.

Créez un programme / une fonction qui prend deux chaînes et génère une partition. La première chaîne sera vos réponses au papier. Si vous sautez une question, utilisez un espace, un octet nul ou un trait de soulignement. Sinon, utilisez la lettre A, B, C, D ou E pour la réponse. Vous pouvez avoir les entrées en majuscules ou en minuscules. La deuxième chaîne sera les réponses correctes pour chaque question dans le document. Votre programme / fonction affichera alors une partition. Faites votre code court.

Cas de test:

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 octets

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

Essayez-le en ligne!

Gelée , 26 23 22 octets

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

Essayez-le en ligne!

Comment ça marche

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

2 octets enregistrés grâce à Neil
2 octets enregistrés grâce à ETHproductions

Prend les réponses des candidats aet les bonnes réponses cdans la syntaxe de curry (a)(c). Attend que les questions ignorées soient marquées d'un espace.

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

Cas de test

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 octets

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)

Essayez-le en ligne!

Comment ça marche

Ceci définit une fonction récursive f qui prend deux arguments non optimaux: t (les réponses au test) et s (la feuille de réponses). Lorsqu'il est appelé uniquement avec ces deux arguments, f initialise i à 24 , le dernier indice de t et s .

Chaque fois que f est appelé, il vérifie d'abord si ~ i (le NOT binaire de i ) est véridique / non nul. Puisque ~ (-1) = 0 , cela se produit une fois que le i atteint la valeur -1 . Si i = -1 , ~ i = 0 est retourné, mais comme i prend des valeurs de 24 à 0 (tous les indices de t et s ), le code suivant andest exécuté et f renvoie le résultat.

Bien que i ne soit pas négatif, les événements suivants se produisent. Première,

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

crée un tuple de longueur 2 :

• Le quotient i/10est 0 si 0 ≤ i <10 , 1 si 10 ≤ i <20 et 2 si 20 ≤ i <25 . La comparaison chaînée 14<i<t[i]<'_'renvoie Vrai si et seulement si toutes les comparaisons individuelles renvoient Vrai , c'est-à-dire si et seulement si i ≥ 15 (la gamme de questions avec pénalité), i est plus petit que t [i] (toujours vrai car tous les nombres sont plus petits que tous les itérables en Python 2), et t [i] n'est pas un trait de soulignement.

  Si la comparaison renvoie False , l'unaire -renvoie 0 et l'expression entière est évaluée à 0 . Cependant, si la comparaison renvoie Vrai , l'unaire -renvoie -1 , de sorte que l'expression entière est évaluée à 0 si 0 ≤ i <10 , -1 si 10 ≤ i <20 et -2 si 20 ≤ i <25 ; ce sont les résultats nets des réponses erronées ou manquantes pour tous les indices i .

• 5+i/15renvoie 5 + 0 = 5 si 0 ≤ i <15 et 5 + 1 = 6 si 15 ≤ i <25 . Ce sont les résultats nets des réponses correctes pour tous les indices i .

Enfin, [t[i]==s[i]]sélectionne le premier élément du tuple construit si t [i] et s [i] diffèrent (réponse fausse ou manquante) et le second s'ils sont égaux (réponse correcte), puis ajoute la valeur de retour de f appelée avec décrémentée je à ce résultat. Une fois que i atteint -1 , le score final a été calculé et est renvoyé par f .

Mathematica, 114 octets

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

Fonction pure prenant une paire ordonnée de listes de caractères et renvoyant un entier. m[Equal,#/."_"->u]renvoie une liste de booléens, sauf pour les entrées non évaluées du formulaire u=="B"aux endroits où la réponse est égale "_"; puis tout de suite, u==_->0transforme ces entrées non évaluées en 0art. Tr/@Partition[...,5]ajoute ces entrées jusqu'à 5 à la fois, résultant en une liste comme {4False+True, 4False+True, 4False+True, 4False+True, 4False+True}pour le premier cas de test ou {5True, 5True, 5True, 2True, 2True}pour le dernier cas de test. Ensuite, dans chaque coordonnée, Trueet Falsesont mappés aux scores appropriés, et les résultats sont additionnés.

Gelée , 22 21 octets

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

Essayez-le en ligne!

Je pensais que la réponse de @ Dennis était probablement battable. Et après avoir essayé un grand nombre de possibilités différentes et bénéficié d'une coïncidence étonnante, je l'ai enfin réussi!

Ce programme prend une paire de [réponses de l'élève, réponses correctes] en entrée et utilise des espaces pour indiquer une réponse manquante.

Explication

Ce programme utilise des formats d'entrée internes bizarres pour garder une trace de ce qui se passe, nous allons donc procéder étape par étape.

1. Z

   Cela transpose l'entrée, nous allons donc nous retrouver avec une liste de 25 éléments, un pour chaque question; chaque élément est de la forme [réponse de l'élève, réponse correcte]. Nous indiquerons un élément de ce formulaire avec une majuscule; Apour la question 1, Bpour la question 2, etc. Donc, les réponses sont actuellement stockées sous

   ABCDEFGHIJKLMNOPQRSTUVWXY
   

2. m0

   Il s'agit d'une opération "grand palindrome"; nous ajoutons l'inverse de la valeur actuelle à la valeur elle-même, ce qui donne:

   ABCDEFGHIJKLMNOPQRSTUVWXYYXWVUTSRQPONMLKJIHGFEDCBA
   

3. ṁ135

   L' ṁopérateur (moule) fait un certain nombre de choses, mais dans ce contexte, il prend effectivement les 135 premiers éléments de la liste infinie produite en s'ajoutant à plusieurs reprises la valeur actuelle. Cela nous donne ce qui suit (que j'ai divisé en groupes de 50 éléments pour plus de commodité; ce n'est qu'une liste de 135 paires en interne):

   ABCDEFGHIJKLMNOPQRSTUVWXYYXWVUTSRQPONMLKJIHGFEDCBA
   ABCDEFGHIJKLMNOPQRSTUVWXYYXWVUTSRQPONMLKJIHGFEDCBA
   ABCDEFGHIJKLMNOPQRSTUVWXYYXWVUTSRQP
   

4. µ;

   µdéfinit la valeur actuelle comme nouvelle valeur par défaut pour les opérandes manquants. Nous voyons alors immédiatement un builtin auquel il manque un opérande; ;ajoute, mais nous n'avons pas spécifié quoi ajouter. Par conséquent, la valeur actuelle est ajoutée à la valeur de la dernière µ(qui est également la valeur actuelle), ce qui nous donne la valeur actuelle de 270 éléments suivante:

   ABCDEFGHIJKLMNOPQRSTUVWXYYXWVUTSRQPONMLKJIHGFEDCBA
   ABCDEFGHIJKLMNOPQRSTUVWXYYXWVUTSRQPONMLKJIHGFEDCBA
   ABCDEFGHIJKLMNOPQRSTUVWXYYXWVUTSRQPABCDEFGHIJKLMNO
   PQRSTUVWXYYXWVUTSRQPONMLKJIHGFEDCBAABCDEFGHIJKLMNO
   PQRSTUVWXYYXWVUTSRQPONMLKJIHGFEDCBAABCDEFGHIJKLMNO
   PQRSTUVWXYYXWVUTSRQP
   

5. t€⁶

   N'oubliez pas que toutes les majuscules ci-dessus représentent des paires de [réponse de l'élève, bonne réponse]. L' t€⁶opération opère sur chaque ( €) paire et supprime ( t) les espaces ( ⁶) de chaque côté de la paire (c'est-à-dire tout espace qui apparaît dans la paire). Nous avons donc toujours la même liste alambiquée de 270 questions avec de nombreuses répétitions, mais elles sont de la forme [bonne réponse] (l'élève n'a pas répondu) ou [l'élève a répondu, la bonne réponse] (l'élève a répondu).

6. E€’

   L' E€’opération opère également sur chaque €élément ( ) et, en raison de l'utilisation de E, remplace l'élément par 1 si tous les éléments sont égaux (c'est-à-dire que l'étudiant n'a pas répondu ou a bien répondu à la question), ou 0 si ce n'est pas tous les les éléments sont égaux (c.-à-d. que l'élève a répondu mais a mal répondu à la question). L'utilisation d' ’ici modifie la numérotation, ce qui signifie que nous utilisons désormais respectivement -1 ou 0. Je vais utiliser des lettres minuscules pour ce nouveau type d'élément, qui utilise -1 pour une réponse qui serait pénalisée s'il s'agissait d'une question éligible à une pénalité, ou 0 pour une réponse manquante ou correcte:

   abcdefghijklmnopqrstuvwxyyxwvutsrqponmlkjihgfedcba
   abcdefghijklmnopqrstuvwxyyxwvutsrqponmlkjihgfedcba
   abcdefghijklmnopqrstuvwxyyxwvutsrqpabcdefghijklmno
   pqrstuvwxyyxwvutsrqponmlkjihgfedcbaabcdefghijklmno
   pqrstuvwxyyxwvutsrqponmlkjihgfedcbaabcdefghijklmno
   pqrstuvwxyyxwvutsrqp
   

7. ;E€

   Nous avons vu les deux E€et ;avant; nous ajoutons quelque chose à la valeur actuelle, et nous utilisons un format de 1 si tous les éléments sont égaux, ou de 0 si certains sont différents (non ’cette fois!). Il y a un opérande manquant ici, nous utilisons donc la valeur en date du dernier µ(c'est-à-dire la sortie de l'étape 3). À l'étape 3, nous n'avions pas supprimé les espaces des éléments, nous aurons donc 1 pour une réponse correcte ou 0 pour une réponse incorrecte ou manquante (car un espace ne correspondra pas à la bonne réponse). À partir de maintenant, je vais utiliser des majuscules pour ce 1 = correct, 0 = format incorrect / manquant, et continuer à utiliser des lettres minuscules pour 0 = correct / manquant, -1 = incorrect. La valeur résultante a 405 éléments et ressemble à ceci:

   abcdefghijklmnopqrstuvwxyyxwvutsrqponmlkjihgfedcba
   abcdefghijklmnopqrstuvwxyyxwvutsrqponmlkjihgfedcba
   abcdefghijklmnopqrstuvwxyyxwvutsrqpabcdefghijklmno
   pqrstuvwxyyxwvutsrqponmlkjihgfedcbaabcdefghijklmno
   pqrstuvwxyyxwvutsrqponmlkjihgfedcbaabcdefghijklmno
   pqrstuvwxyyxwvutsrqpABCDEFGHIJKLMNOPQRSTUVWXYYXWVU
   TSRQPONMLKJIHGFEDCBAABCDEFGHIJKLMNOPQRSTUVWXYYXWVU
   TSRQPONMLKJIHGFEDCBAABCDEFGHIJKLMNOPQRSTUVWXYYXWVU
   TSRQP
   

8. ṫ⁹

   Voici la coïncidence étonnante que j'ai mentionnée plus tôt. Avant de parler de cette partie du code, je veux faire le point où nous en sommes.

   Chaque lettre majuscule représente +1 pour une réponse correcte; les 15 premières questions (à Atravers O) apparaissent 5 fois chacune dans la chaîne, et les 10 dernières questions (à Ptravers Y) apparaissent 6 fois chacune. Ce morceau n'est pas vraiment magique; Je l'ai conçu de cette façon quand j'ai choisi le nombre 135 plus tôt dans le programme (qui est 5 × 15 + 6 × 10), et le seul coup de chance ici est que 5 se trouve être un nombre impair (c'est donc le dernier 10 questions qui finissent par apparaître les heures supplémentaires, plutôt que les 10 premières). Les 15 lettres précédant immédiatement cette contiennent ppar t(-1 des questions de pénalité) une fois, et à utravers y(la question de pénalité -2) deux fois. Ce n'est pas non plus une coïncidence; parce que nous avons utilisém0plus tôt, les copies supplémentaires des questions sont dans l'ordre PQRSTUVWXYYXWVUTSRQP, et les questions ultérieures se poseront naturellement près du milieu de cette chaîne (donc prendre les 15 dernières questions "supplémentaires" donnera moins de répétitions à celles près des bords; et bien sûr, il n'est pas surprenant que les questions "supplémentaires" viennent en dernier).

   Parce que chaque lettre minuscule soustrait 1 du score pour une réponse incorrecte et non manquante, et chaque lettre majuscule ajoute 1 au score pour une réponse correcte, nous devons donc simplement prendre les 135 + 15 = 150 derniers éléments afin d'obtenir chaque type d'élément le nombre correct de fois. La commande de Jelly pour obtenir une sous-chaîne à la fin d'une liste est ṫ; cependant, il ne spécifie pas le nombre d'éléments que vous voulez, mais plutôt l'index du premier élément que vous voulez. Nous avons 405 éléments à ce stade et voulons 150, nous devons donc commencer à l'index (405 - 150 + 1), ou 256. Dans une étonnante coïncidence, 256 se trouve être le nombre d'octets distincts qui existent, et a donc une courte représentation dans Jelly (⁹). Il y avait très peu que je pouvais faire pour y arriver; l'étape 4 a ajouté 135 autres éléments au début de la liste afin de frapper le numéro du tour, mais le fait qu'il s'agissait de 135 éléments que j'ai dû ajouter (une valeur qui était facilement disponible à ce stade du programme) était vraiment pratique, avec pratiquement tout autre numéro étant complètement inutile dans cette situation.

   Voici à quoi ressemble maintenant la valeur interne:

   uvwxyyxwvutsrqpABCDEFGHIJKLMNOPQRSTUVWXYYXWVUTSRQP
   ONMLKJIHGFEDCBAABCDEFGHIJKLMNOPQRSTUVWXYYXWVUTSRQP
   ONMLKJIHGFEDCBAABCDEFGHIJKLMNOPQRSTUVWXYYXWVUTSRQP
   

9. S

   Enfin, nous avons maintenant une liste de modifications du score des questions, tout ce que nous devons faire est de les additionner en utilisant S, et nous avons terminé.

Python 2 , 93 91 octets

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)

Essayez-le en ligne!

-2 octets grâce à @KritixiLithos

Contribution:

• a: Réponses de l'élève sous forme de chaîne, _pour une question ignorée
• b : réponses correctes
• n: le numéro de la question actuelle 0, par défaut à0

k, 52 octets

La fonction prend 2 chaînes, format selon les cas de test

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

Exemple:

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

Haskell, 84 octets

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

Exemple d'utilisation: ((sum.).zipWith3 i(w=<<[0..2])) "DBADBDCDBAEDABCD_E__A__C_" "DBADBDCDBAEDABCDBEEDACDCA"-> 99. Essayez-le en ligne! .

Comment ça marche: i x a bcalcule le score pour une seule réponse aavec un résultat correct bet la pénalité xpour une mauvaise réponse (une valeur non négative). Si vous sautez ( a>'Z'), le score est 0, si la réponse est correcte (a==b ), le score est 6-0^x, sinon le score est -x.

w=<<[0..2]établit une liste de sanctions pour les 25 questions en postulant wà 0, 1et 2, c'est-à-dire en faisant des 5*3^0^xcopies de chaque numéro (-> 15 fois 0, 5 fois1 et 5 fois 2).

zipWith3s'applique ià la liste des sanctions, à la liste des réponses et à la liste des résultats corrects. Enfin, tous les scores sont ajoutés ( sum).

Octave, 61 54 octets

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

Essayez-le en ligne!

Réponse précédente:

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

Ma première solution en ES6, peut-être même la première en 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 est la solution soumise et un est la bonne solution. Les deux seront considérés comme des chaînes.

Voici une solution non récursive à 78 octets:

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

Prend des entrées via la syntaxe de curry.

Merci à @ETHproductions pour avoir économisé 9 octets! s[i]vers cet (-1-(i>19|0))vers~(i>19) .

Merci à @Kritixi Lithos d' avoir enregistré un octet! c=='_'à c>'Z'.

Essayez-le en ligne!