Hice el IMC este año. ¿Alguien más aquí lo hizo?

En un documento del Reto Intermedio de Matemáticas de UKMT, hay veinticinco preguntas. Las primeras quince preguntas le dan cinco puntos si las contesta correctamente. Para las otras diez preguntas, obtienes seis puntos por acertar. ¡En las últimas diez preguntas, pierde puntos si se equivoca! Para las preguntas 16 a 20, pierde una nota y para las últimas cinco preguntas, pierde dos puntos. Si deja una pregunta en blanco, no se otorgan ni se deducen las marcas. No se deducen marcas por haber respondido mal alguna de las primeras quince preguntas. El papel es de opción múltiple; Puede elegir cualquier respuesta de A, B, C, D y E para cada pregunta. Siempre hay una sola respuesta correcta para cada pregunta.

Cree un programa / función que tome dos cadenas y genere una puntuación. La primera cadena serán sus respuestas al documento. Si omite una pregunta, use un espacio, un byte nulo o un guión bajo. De lo contrario, use la letra A, B, C, D o E para la respuesta. Puede tener las entradas en mayúscula o minúscula. La segunda cadena será las respuestas correctas para cada pregunta en el documento. Su programa / función generará una puntuación. Haz tu código corto.

Casos de prueba:

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

Pruébalo en línea!

Jalea , 26 23 22 bytes

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

Pruébalo en línea!

Cómo 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

Guardado 2 bytes gracias a Neil
Guardado 2 bytes gracias a ETHproductions

Toma las respuestas del solicitante ay las respuestas correctas cen la sintaxis curry(a)(c) . Espera que las preguntas omitidas se marquen con un espacio.

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 prueba

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)

Pruébalo en línea!

Cómo funciona

Esto define una función recursiva f que toma dos argumentos no óptimos: t (las respuestas a la prueba) ys (la hoja de respuestas). Cuando se llama solo con estos dos argumentos, f inicializa i a 24 , el último índice de t y s .

Cada vez que se llama f , primero verifica si ~ i (el NO a nivel de bit de i ) es verdadero / no cero. Como ~ (-1) = 0 , esto sucede una vez que i alcanza el valor -1 . Si i = -1 , ~ i = 0 se devuelve, pero como i toma valores desde 24 a 0 (todos los índices de t y s ), el siguiente código andes ejecutado y f devuelve el resultado.

Mientras i es no negativo, ocurre lo siguiente. Primero,

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

crea una tupla de longitud 2 :

• El cociente i/10es 0 si 0 ≤ i <10 , 1 si 10 ≤ i <20 y 2 si 20 ≤ i <25 . La comparación encadenada 14<i<t[i]<'_'devuelve Verdadero si y solo si todas las comparaciones individuales devuelven Verdadero , es decir, si y solo si i ≥ 15 (el rango de preguntas con penalización), i es menor que t [i] (siempre cierto ya que todos los números son menores que todos los iterables en Python 2), y t [i] no es un guión bajo.

  Si la comparación devuelve False , el unario -devuelve 0 y toda la expresión se evalúa a 0 . Sin embargo, si la comparación devuelve Verdadero , el unario -devuelve -1 , por lo que toda la expresión se evalúa a 0 si 0 ≤ i <10 , -1 si 10 ≤ i <20 y -2 si 20 ≤ i <25 ; Estos son los resultados netos de respuestas incorrectas o faltantes para todos los índices i .

• 5+i/15devuelve 5 + 0 = 5 si 0 ≤ i <15 y 5 + 1 = 6 si 15 ≤ i <25 . Estos son los resultados netos para las respuestas correctas para todos los índices i .

Finalmente, [t[i]==s[i]]selecciona el primer elemento de la tupla construido si t [i] y s [i] difieren (mal o respuesta que falta) y el segundo si son iguales (respuesta correcta), luego se agrega el valor de retorno de f llamada con decrementa yo a ese resultado. Una vez i alcanza -1 , la puntuación final se ha calculado y se devuelve 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}}]&

Función pura que toma un par ordenado de listas de caracteres y devuelve un número entero. m[Equal,#/."_"->u]devuelve una lista de booleanos, excepto las entradas no evaluadas del formulario u=="B"en lugares donde la respuesta es igual "_"; luego, de inmediato, u==_->0convierte esas entradas no evaluadas en 0s. Tr/@Partition[...,5]agrega estas entradas hasta 5 a la vez, dando como resultado una lista como {4False+True, 4False+True, 4False+True, 4False+True, 4False+True}para el primer caso de prueba o {5True, 5True, 5True, 2True, 2True}para el último caso de prueba. Luego, en cada coordenada, Truey Falsese asignan a las puntuaciones apropiadas, y los resultados se suman.

Jalea , 22 21 bytes

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

Pruébalo en línea!

me pensamiento @ respuesta de Dennis fue probablemente puede derrotar. Y después de probar una gran cantidad de posibilidades diferentes y beneficiarme de una sorprendente coincidencia, ¡finalmente lo logré!

Este programa toma un par de [respuestas del estudiante, respuestas correctas] como entrada y usa espacios para indicar una respuesta que falta.

Explicación

Este programa utiliza algunos formatos de entrada internos extraños para realizar un seguimiento de lo que está sucediendo, por lo que lo haremos paso a paso.

1. Z

   Esto transpone la entrada, por lo que terminaremos con una lista de 25 elementos, uno para cada pregunta; cada elemento tiene la forma [respuesta del alumno, respuesta correcta]. Indicaremos un elemento de este formulario con una letra mayúscula; Apara la pregunta 1, Bpara la pregunta 2, y así sucesivamente. Entonces las respuestas se almacenan actualmente como

   ABCDEFGHIJKLMNOPQRSTUVWXY
   

2. m0

   Esta es una operación de "mayor palíndromo"; agregamos el reverso del valor actual al valor en sí mismo, produciendo esto:

   ABCDEFGHIJKLMNOPQRSTUVWXYYXWVUTSRQPONMLKJIHGFEDCBA
   

3. ṁ135

   El ṁoperador (molde) hace una serie de cosas, pero en este contexto, toma efectivamente los primeros 135 elementos de la lista infinita producidos al agregar el valor actual a sí mismo repetidamente. Eso nos da lo siguiente (que he dividido en grupos de 50 elementos por conveniencia; esto es solo una lista de 135 pares internamente):

   ABCDEFGHIJKLMNOPQRSTUVWXYYXWVUTSRQPONMLKJIHGFEDCBA
   ABCDEFGHIJKLMNOPQRSTUVWXYYXWVUTSRQPONMLKJIHGFEDCBA
   ABCDEFGHIJKLMNOPQRSTUVWXYYXWVUTSRQP
   

4. µ;

   µestablece el valor actual como el nuevo valor predeterminado para los operandos faltantes. Entonces vemos de inmediato una construcción que le falta un operando; ;agrega, pero no hemos especificado con qué agregar. Como resultado, el valor actual se agrega al valor del último µ(que también es el valor actual), dándonos el siguiente valor actual de 270 elementos:

   ABCDEFGHIJKLMNOPQRSTUVWXYYXWVUTSRQPONMLKJIHGFEDCBA
   ABCDEFGHIJKLMNOPQRSTUVWXYYXWVUTSRQPONMLKJIHGFEDCBA
   ABCDEFGHIJKLMNOPQRSTUVWXYYXWVUTSRQPABCDEFGHIJKLMNO
   PQRSTUVWXYYXWVUTSRQPONMLKJIHGFEDCBAABCDEFGHIJKLMNO
   PQRSTUVWXYYXWVUTSRQPONMLKJIHGFEDCBAABCDEFGHIJKLMNO
   PQRSTUVWXYYXWVUTSRQP
   

5. t€⁶

   Recuerde que todas las letras mayúsculas arriba representan pares de [respuesta del estudiante, respuesta correcta]. La t€⁶operación opera en cada ( €) par y elimina ( t) espacios ( ⁶) de cualquier lado del par (es decir, cualquier espacio que aparezca en el par). Así que todavía tenemos la misma lista enrevesada de 270 preguntas con muchas repeticiones, pero son de la forma [respuesta correcta] (el estudiante no respondió) o [respuesta del estudiante, respuesta correcta] (el estudiante sí respondió).

6. E€’

   La E€’operación también opera en cada €elemento ( ) y, debido al uso de E, reemplaza el elemento con 1 si todos los elementos son iguales (es decir, el estudiante no respondió o respondió correctamente), o 0 si no todos los elementos son iguales (es decir, el alumno respondió pero se equivocó). El uso de ’aquí cambia la numeración, lo que significa que ahora usamos -1 o 0 respectivamente. Usaré letras minúsculas para este nuevo tipo de elemento, que usa -1 para una respuesta que sería penalizada si se tratara de una pregunta elegible para penalización, o 0 para una respuesta faltante o correcta:

   abcdefghijklmnopqrstuvwxyyxwvutsrqponmlkjihgfedcba
   abcdefghijklmnopqrstuvwxyyxwvutsrqponmlkjihgfedcba
   abcdefghijklmnopqrstuvwxyyxwvutsrqpabcdefghijklmno
   pqrstuvwxyyxwvutsrqponmlkjihgfedcbaabcdefghijklmno
   pqrstuvwxyyxwvutsrqponmlkjihgfedcbaabcdefghijklmno
   pqrstuvwxyyxwvutsrqp
   

7. ;E€

   Hemos visto ambos E€y ;antes; estamos agregando algo al valor actual, y estamos usando un formato de 1 si todos los elementos son iguales, o 0 si algunos son diferentes (¡no ’esta vez!). Aquí falta un operando, por lo que usamos el valor del último µ(es decir, la salida del paso 3). En el paso 3, no habíamos eliminado espacios de los elementos, por lo que tendremos 1 para una respuesta correcta o 0 para una respuesta incorrecta o faltante (porque un espacio no coincidirá con la respuesta correcta). De ahora en adelante, usaré letras mayúsculas para este formato 1 = correcto, 0 = incorrecto / faltante, y continuaré usando letras minúsculas para 0 = correcto / faltante, -1 = incorrecto. El valor resultante tiene 405 elementos, y se ve así:

   abcdefghijklmnopqrstuvwxyyxwvutsrqponmlkjihgfedcba
   abcdefghijklmnopqrstuvwxyyxwvutsrqponmlkjihgfedcba
   abcdefghijklmnopqrstuvwxyyxwvutsrqpabcdefghijklmno
   pqrstuvwxyyxwvutsrqponmlkjihgfedcbaabcdefghijklmno
   pqrstuvwxyyxwvutsrqponmlkjihgfedcbaabcdefghijklmno
   pqrstuvwxyyxwvutsrqpABCDEFGHIJKLMNOPQRSTUVWXYYXWVU
   TSRQPONMLKJIHGFEDCBAABCDEFGHIJKLMNOPQRSTUVWXYYXWVU
   TSRQPONMLKJIHGFEDCBAABCDEFGHIJKLMNOPQRSTUVWXYYXWVU
   TSRQP
   

8. ṫ⁹

   Aquí viene la sorprendente coincidencia que mencioné anteriormente. Antes de hablar sobre este fragmento de código, quiero hacer un balance de dónde tenemos que llegar.

   Cada letra mayúscula representa +1 para una respuesta correcta; las primeras 15 preguntas ( Ahasta O) aparecen 5 veces cada una en la cadena, y las últimas 10 preguntas ( Phasta Y) aparecen 6 veces cada una. Esa parte no es realmente mágica; Lo diseñé de esa manera cuando elegí el número 135 anteriormente en el programa (que es 5 × 15 + 6 × 10), y el único golpe de suerte aquí es que 5 es un número impar (así que son los últimos 10 preguntas que terminan apareciendo los tiempos extra, en lugar de los primeros 10). Las 15 letras inmediatamente anteriores a este contienen pa través de t(las -1 preguntas de penalización) una vez, y ua través de y(preguntas el -2 de penalización) dos veces. Eso tampoco es una gran coincidencia; porque usamosm0anteriormente, las copias adicionales de las preguntas están en el orden PQRSTUVWXYYXWVUTSRQP, y las preguntas posteriores ocurrirán naturalmente cerca del medio de esa cadena (por lo tanto, tomar las últimas 15 preguntas "adicionales" dará menos repeticiones a las que están cerca de los bordes; y por supuesto, no es una sorpresa que las preguntas "adicionales" sean las últimas).

   Debido a que cada letra minúscula resta 1 del puntaje para obtener una respuesta incorrecta y no falta, y cada letra mayúscula agrega 1 al puntaje para obtener una respuesta correcta, por lo tanto, simplemente necesitamos tomar los últimos 135 + 15 = 150 elementos para obtener cada tipo de elemento el número correcto de veces. El comando de Jelly para obtener una subcadena al final de una lista es ṫ; sin embargo, no especifica la cantidad de elementos que desea, sino el índice del primer elemento que desea. Tenemos 405 elementos en este punto, y queremos 150, por lo que necesitamos comenzar en el índice (405 - 150 + 1), o 256. En una sorprendente coincidencia, 256 es el número de octetos distintos que existen, y por lo tanto tiene una breve representación en Jelly (⁹) Había muy poco que pudiera hacer para que esto sucediera; el paso 4 agregó otros 135 elementos al comienzo de la lista para alcanzar el número redondo, pero el hecho de que fueran 135 elementos que tuve que agregar (un valor que estaba fácilmente disponible en ese punto del programa) fue realmente conveniente, básicamente, cualquier otro número es completamente inútil en esta situación.

   Así es como se ve el valor interno ahora:

   uvwxyyxwvutsrqpABCDEFGHIJKLMNOPQRSTUVWXYYXWVUTSRQP
   ONMLKJIHGFEDCBAABCDEFGHIJKLMNOPQRSTUVWXYYXWVUTSRQP
   ONMLKJIHGFEDCBAABCDEFGHIJKLMNOPQRSTUVWXYYXWVUTSRQP
   

9. S

   Finalmente, ahora tenemos una lista de modificaciones al puntaje de las preguntas, todo lo que tenemos que hacer es sumarlas usando S, y hemos terminado.

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)

Pruébalo en línea!

-2 bytes gracias a @KritixiLithos

Entrada:

• a: Respuestas del alumno como una cadena, _para la pregunta omitida
• b : respuestas correctas
• n: el número de la pregunta actual 0basada en valores predeterminados0

k, 52 bytes

La función toma 2 cadenas, formato según los casos de prueba

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

Ejemplo:

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

Ejemplo de uso: ((sum.).zipWith3 i(w=<<[0..2])) "DBADBDCDBAEDABCD_E__A__C_" "DBADBDCDBAEDABCDBEEDACDCA"-> 99. Pruébalo en línea! .

Cómo funciona: i x a bcalcula el puntaje de una sola respuesta acon el resultado correcto by la penalización xpor una respuesta incorrecta (un valor no negativo). Si omite ( a>'Z'), la puntuación es 0, si la respuesta es correcta ( a==b), la puntuación es 6-0^x, de lo contrario, la puntuación es -x.

w=<<[0..2]hace una lista de todas las sanciones por 25 preguntas mediante la aplicación wa 0, 1y 2, es decir, hacer 5*3^0^xcopias de cada número (-> 15 veces 0, 5 veces 1y 5 veces 2).

zipWith3se aplica ia la lista de penalizaciones, lista de respuestas y lista de resultados correctos. Finalmente se suman todos los puntajes ( sum).

Octava, 61 54 bytes

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

Pruébalo en línea!

Respuesta 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

Mi primera solución en ES6, tal vez incluso primero 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 es la solución presentada y a es la solución correcta. Ambos serán tomados como cadenas.

Aquí hay una solución no recursiva de 78 bytes:

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

Toma información a través de la sintaxis de curry.

¡Gracias a @ETHproductions por guardar 9 bytes! s[i]a cy (-1-(i>19|0))a ~(i>19).

¡Gracias a @Kritixi Lithos por guardar un byte! c=='_'a c>'Z'.

Pruébalo en línea!