Ich habe den IMC in diesem Jahr gemacht. Hat das noch jemand gemacht?

In einem Artikel der UKMT Intermediate Maths Challenge stehen 25 Fragen. Die ersten fünfzehn Fragen geben Ihnen fünf Punkte, wenn Sie sie richtig verstehen. Für die anderen zehn Fragen erhalten Sie sechs Punkte, um sie richtig zu stellen. In den letzten zehn Fragen verlieren Sie Noten, wenn Sie sie falsch verstehen! Bei den Fragen 16 bis 20 verlieren Sie eine Note und bei den letzten fünf Fragen zwei. Wenn Sie eine Frage leer lassen, werden keine Noten vergeben oder abgezogen. Es werden keine Noten abgezogen, wenn eine der ersten fünfzehn Fragen falsch ist. Das Papier ist Multiple Choice; Sie können für jede Frage eine beliebige Antwort aus A, B, C, D und E auswählen. Zu jeder Frage gibt es immer nur eine richtige Antwort.

Erstellen Sie ein Programm / eine Funktion, die aus zwei Zeichenfolgen besteht und eine Partitur ausgibt. Die erste Zeichenfolge sind Ihre Antworten auf das Papier. Wenn Sie eine Frage überspringen, verwenden Sie ein Leerzeichen, ein Null-Byte oder einen Unterstrich. Verwenden Sie andernfalls die Buchstaben A, B, C, D oder E für die Antwort. Sie können die Eingaben entweder in Groß- oder Kleinbuchstaben eingeben. Die zweite Zeichenfolge enthält die richtigen Antworten für jede Frage im Papier. Ihr Programm / Ihre Funktion gibt dann eine Punktzahl aus. Machen Sie Ihren Code kurz.

Testfälle:

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

Probieren Sie es online!

Jelly , 26 23 22 Bytes

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

Probieren Sie es online!

Wie es funktioniert

=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

2 Bytes dank Neil
gespart 2 Bytes dank ETHproductions gespart

Übernimmt die Antworten des Bewerbers aund korrigiert die Antworten cin der aktuellen Syntax (a)(c). Erwartet, dass übersprungene Fragen mit einem Leerzeichen markiert werden.

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

Testfälle

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)

Probieren Sie es online!

Wie es funktioniert

Dies definiert eine rekursive Funktion f , die zwei nicht optimale Argumente akzeptiert: t (die Antworten auf den Test) und s (das Antwortblatt). Wenn f nur mit diesen beiden Argumenten aufgerufen wird, initialisiert es i mit 24 , dem letzten Index von t und s .

Jedes Mal , wenn f aufgerufen wird, wird zuerst geprüft, ob ~ i (das bitweise NICHT von i ) wahr ist / nicht Null. Da ~ (-1) = 0 ist , geschieht dies, sobald das i den Wert -1 erreicht . Wenn i = -1 ist , wird ~ i = 0 zurückgegeben, aber wenn i Werte von 24 bis 0 annimmt (alle Indizes von t und s ), wird der folgende Code andausgeführt und f gibt das Ergebnis zurück.

Während ich nicht negativ ist, passiert Folgendes. Zuerst,

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

erstellt ein Tupel der Länge 2 :

• Der Quotient i/10ist 0, wenn 0 ≤ i <10 , 1, wenn 10 ≤ i <20 und 2, wenn 20 ≤ i <25 . Die verkettete Vergleich 14<i<t[i]<'_'kehrt wahr , wenn und nur wenn alle einzelnen Vergleiche zurückkehren Wahr ist , dh wenn und nur wenn i ≥ 15 (der Bereich von Fragen mit Strafe), i kleiner als t [i] (immer der Fall , da alle Zahlen sind kleiner als alle Iterables in Python 2), und t [i] ist kein Unterstrich.

  Wenn der Vergleich gibt Falsch , die unäre -kehrt 0 und der gesamte Ausdruck ergibt 0 . Wenn jedoch der Vergleich kehrt Wahr , die unären -kehrt -1 , so dass die gesamten Ausdruck ergibt 0 wenn 0 ≤ i <10 , -1 , wenn 10 ≤ i <20 , und -2 , wenn 20 ≤ i <25 ; Dies sind die Nettoergebnisse für falsche oder fehlende Antworten für alle Indizes i .

• 5+i/15gibt 5 + 0 = 5 zurück, wenn 0 ≤ i <15 und 5 + 1 = 6, wenn 15 ≤ i <25 . Dies sind die Nettoergebnisse für korrekte Antworten für alle Indizes i .

Schließlich [t[i]==s[i]]wählt das erste Element des konstruierten Tupels , wenn t [i] und S [i] unterscheiden (falsche oder fehlende Antwort) und die zweite , wenn sie gleich sind (richtige Antwort), dann fügt der Rückgabewert von f bezeichnet mit dekrementiert Ich zu diesem Ergebnis. Sobald ich -1 erreicht habe , wurde die endgültige Punktzahl berechnet und wird von f zurückgegeben .

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

Reine Funktion, die ein geordnetes Paar von Zeichenlisten nimmt und eine Ganzzahl zurückgibt. m[Equal,#/."_"->u]Gibt eine Liste von Booleschen Werten zurück, mit Ausnahme von nicht bewerteten Einträgen des Formulars u=="B"an Stellen, an denen die Antwort gleich war "_". u==_->0verwandelt dann sofort diese unbewerteten Einträge in 0s. Tr/@Partition[...,5]addiert diese Einträge zu 5 auf einmal, was zu einer Liste wie {4False+True, 4False+True, 4False+True, 4False+True, 4False+True}für den ersten Testfall oder {5True, 5True, 5True, 2True, 2True}für den letzten Testfall führt. Anschließend werden in jeder Koordinate Trueund Falseden entsprechenden Punktzahlen zugeordnet und die Ergebnisse addiert.

Jelly , 22 21 Bytes

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

Probieren Sie es online!

ich dachte, @ Dennis Antwort war wahrscheinlich schlagbar. Und nachdem ich eine Vielzahl von Möglichkeiten ausprobiert und von einem erstaunlichen Zufall profitiert habe, habe ich es endlich geschafft!

Dieses Programm verwendet ein Paar [Antworten des Schülers, richtige Antworten] als Eingabe und verwendet Leerzeichen, um eine fehlende Antwort anzuzeigen.

Erläuterung

Dieses Programm verwendet einige bizarre interne Eingabeformate, um zu verfolgen, was gerade passiert.

1. Z

   Dadurch wird die Eingabe transponiert. Am Ende erhalten Sie eine Liste mit 25 Elementen, eines für jede Frage. Jedes Element hat die Form [Antwort des Schülers, richtige Antwort]. Wir werden ein Element dieses Formulars mit einem Großbuchstaben kennzeichnen. Afür Frage 1, Bfür Frage 2 und so weiter. Die Antworten werden also aktuell als gespeichert

   ABCDEFGHIJKLMNOPQRSTUVWXY
   

2. m0

   Dies ist eine "größere Palindrom" -Operation; wir hängen die Umkehrung des aktuellen Wertes an den Wert selbst an und ergeben dies:

   ABCDEFGHIJKLMNOPQRSTUVWXYYXWVUTSRQPONMLKJIHGFEDCBA
   

3. ṁ135

   Der ṁ(Form-) Operator führt eine Reihe von Dingen aus, in diesem Kontext werden jedoch die ersten 135 Elemente der unendlichen Liste effektiv verwendet, indem der aktuelle Wert wiederholt an sich selbst angehängt wird. Das gibt uns Folgendes (das ich der Einfachheit halber in Gruppen von 50 Elementen unterteilt habe; dies ist nur eine Liste von 135 Paaren intern):

   ABCDEFGHIJKLMNOPQRSTUVWXYYXWVUTSRQPONMLKJIHGFEDCBA
   ABCDEFGHIJKLMNOPQRSTUVWXYYXWVUTSRQPONMLKJIHGFEDCBA
   ABCDEFGHIJKLMNOPQRSTUVWXYYXWVUTSRQP
   

4. µ;

   µSetzt den aktuellen Wert als neuen Standard für fehlende Operanden. Wir sehen dann sofort ein eingebautes Objekt, dem ein Operand fehlt. ;Anhängen, aber wir haben nicht angegeben, was angehängt werden soll. Infolgedessen wird der aktuelle Wert an den Wert ab dem letzten Wert µ(der auch der aktuelle Wert ist) angehängt. Dies ergibt den folgenden aktuellen Wert von 270 Elementen:

   ABCDEFGHIJKLMNOPQRSTUVWXYYXWVUTSRQPONMLKJIHGFEDCBA
   ABCDEFGHIJKLMNOPQRSTUVWXYYXWVUTSRQPONMLKJIHGFEDCBA
   ABCDEFGHIJKLMNOPQRSTUVWXYYXWVUTSRQPABCDEFGHIJKLMNO
   PQRSTUVWXYYXWVUTSRQPONMLKJIHGFEDCBAABCDEFGHIJKLMNO
   PQRSTUVWXYYXWVUTSRQPONMLKJIHGFEDCBAABCDEFGHIJKLMNO
   PQRSTUVWXYYXWVUTSRQP
   

5. t€⁶

   Denken Sie daran, dass alle Großbuchstaben Paare von [Antwort des Schülers, richtige Antwort] darstellen. Die t€⁶Operation bearbeitet jedes ( €) Paar und löscht ( t) Leerzeichen ( ⁶) von beiden Seiten des Paares (dh alle Leerzeichen, die im Paar erscheinen). Wir haben also immer noch dieselbe gewundene Liste von 270 Fragen mit vielen Wiederholungen, aber sie haben die Form [richtige Antwort] (Schüler hat nicht geantwortet) oder [Schüler hat geantwortet, richtige Antwort] (Schüler hat geantwortet).

6. E€’

   Die E€’Operation wirkt sich auch auf jedes ( €) Element aus und Eersetzt das Element aufgrund der Verwendung von durch 1, wenn alle Elemente gleich sind (dh der Schüler hat die Frage nicht beantwortet oder richtig beantwortet), oder durch 0, wenn nicht alle Elemente sind gleich (dh der Schüler hat geantwortet, aber die Frage falsch gestellt). Die Verwendung von ’hier ändert die Nummerierung, was bedeutet, dass wir jetzt -1 bzw. 0 verwenden. Ich werde für diese neue Art von Element Kleinbuchstaben verwenden, wobei -1 für eine Antwort verwendet wird, die bei einer Frage mit Strafmaß bestraft würde, oder 0 für eine fehlende oder korrekte Antwort:

   abcdefghijklmnopqrstuvwxyyxwvutsrqponmlkjihgfedcba
   abcdefghijklmnopqrstuvwxyyxwvutsrqponmlkjihgfedcba
   abcdefghijklmnopqrstuvwxyyxwvutsrqpabcdefghijklmno
   pqrstuvwxyyxwvutsrqponmlkjihgfedcbaabcdefghijklmno
   pqrstuvwxyyxwvutsrqponmlkjihgfedcbaabcdefghijklmno
   pqrstuvwxyyxwvutsrqp
   

7. ;E€

   Wir haben beide E€und ;vorher gesehen; Wir hängen etwas an den aktuellen Wert an und verwenden das Format 1, wenn alle Elemente gleich sind, oder 0, wenn einige unterschiedlich sind ( ’diesmal nicht!). Da hier ein Operand fehlt, verwenden wir den Wert vom letzten µ(dh die Ausgabe von Schritt 3). Zurück in Schritt 3 hatten wir keine Leerzeichen aus den Elementen gelöscht, daher haben wir 1 für eine korrekte Antwort oder 0 für eine falsche oder fehlende Antwort (da ein Leerzeichen nicht mit der korrekten Antwort übereinstimmt). Von nun an verwende ich Großbuchstaben für dieses 1 = richtige, 0 = falsche / fehlende Format und weiterhin Kleinbuchstaben für 0 = richtige / fehlende, -1 = falsche. Der resultierende Wert hat 405 Elemente und sieht folgendermaßen aus:

   abcdefghijklmnopqrstuvwxyyxwvutsrqponmlkjihgfedcba
   abcdefghijklmnopqrstuvwxyyxwvutsrqponmlkjihgfedcba
   abcdefghijklmnopqrstuvwxyyxwvutsrqpabcdefghijklmno
   pqrstuvwxyyxwvutsrqponmlkjihgfedcbaabcdefghijklmno
   pqrstuvwxyyxwvutsrqponmlkjihgfedcbaabcdefghijklmno
   pqrstuvwxyyxwvutsrqpABCDEFGHIJKLMNOPQRSTUVWXYYXWVU
   TSRQPONMLKJIHGFEDCBAABCDEFGHIJKLMNOPQRSTUVWXYYXWVU
   TSRQPONMLKJIHGFEDCBAABCDEFGHIJKLMNOPQRSTUVWXYYXWVU
   TSRQP
   

8. ṫ⁹

   Hier kommt der erstaunliche Zufall, den ich zuvor erwähnt habe. Bevor ich über diesen Teil des Codes spreche, möchte ich eine Bestandsaufnahme machen, wo wir hin müssen.

   Jeder Großbuchstabe steht für +1 für eine korrekte Antwort. Die ersten 15 Fragen ( Abis O) werden jeweils fünfmal in der Zeichenfolge angezeigt, und die letzten 10 Fragen ( Pbis Y) werden jeweils sechsmal angezeigt. Dieser Teil ist nicht wirklich magisch; Ich habe es so entworfen, als ich die Nummer 135 früher im Programm gewählt habe (das ist 5 × 15 + 6 × 10), und der einzige Glücksfall hier ist, dass 5 zufällig eine ungerade Nummer ist (es sind also die letzten 10) Fragen, die am Ende die zusätzlichen Male erscheinen, anstatt die ersten 10). Die 15 Buchstaben unmittelbar davor enthaltenp durch t(-1 die Strafe Fragen) einmal und udurch y(die Strafe -2 - Fragen) zweimal. Das ist auch kein großer Zufall; weil wir benutzt habenm0Zuvor waren die zusätzlichen Kopien der Fragen in der ReihenfolgePQRSTUVWXYYXWVUTSRQP, und die späteren Fragen werden natürlich in der Mitte dieser Zeichenfolge auftreten (wenn Sie also die letzten 15 der "zusätzlichen" Fragen nehmen, werden die Fragen in der Nähe der Ränder weniger wiederholt; und natürlich ist es keine Überraschung, dass die "zusätzlichen" Fragen kommen zuletzt).

   Da jeder Kleinbuchstabe für eine falsche, nicht fehlende Antwort 1 von der Punktzahl abzieht und jeder Großbuchstabe für eine korrekte Antwort 1 zur Punktzahl hinzufügt, müssen wir einfach die letzten 135 + 15 = 150 Elemente nehmen, um zu erhalten jede Art von Element die richtige Anzahl von Malen. Jellys Befehl zum Abrufen einer Teilzeichenfolge am Ende einer Liste lautetṫ : Es wird jedoch nicht die Anzahl der gewünschten Elemente angegeben, sondern der Index des ersten gewünschten Elements. Wir haben zu diesem Zeitpunkt 405 Elemente und wollen 150, also müssen wir mit dem Index (405 - 150 + 1) oder 256 beginnen. In einem erstaunlichen Zufall ist 256 zufällig die Anzahl der unterschiedlichen Oktette, die existieren, und hat somit eine kurze Darstellung in Jelly (⁹). Ich konnte sehr wenig tun, um dies zu erreichen. Schritt 4 fügte weitere 135 Elemente zum Anfang der Liste hinzu, um die runde Zahl zu treffen, aber die Tatsache, dass es sich um 135 Elemente handelte, die ich hinzufügen musste (ein Wert, der zu diesem Zeitpunkt im Programm leicht verfügbar war), war wirklich praktisch. Im Grunde genommen ist jede andere Nummer in dieser Situation nicht hilfreich.

   So sieht der interne Wert jetzt aus:

   uvwxyyxwvutsrqpABCDEFGHIJKLMNOPQRSTUVWXYYXWVUTSRQP
   ONMLKJIHGFEDCBAABCDEFGHIJKLMNOPQRSTUVWXYYXWVUTSRQP
   ONMLKJIHGFEDCBAABCDEFGHIJKLMNOPQRSTUVWXYYXWVUTSRQP
   

9. S

   Endlich haben wir eine Liste mit Änderungen an der Punktzahl von Fragen. Alles, was wir tun müssen, ist, sie mit zu summieren S, und fertig.

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)

Probieren Sie es online!

-2 Bytes dank @KritixiLithos

Eingang:

• a: Antworten des Schülers als Zeichenfolge _für übersprungene Frage
• b : korrekte Antworten
• n: Die Nummer der aktuellen Frage 0, standardmäßig0

k, 52 Bytes

Funktion benötigt 2 Zeichenketten, Format je nach Testfall

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

Beispiel:

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

Anwendungsbeispiel: ((sum.).zipWith3 i(w=<<[0..2])) "DBADBDCDBAEDABCD_E__A__C_" "DBADBDCDBAEDABCDBEEDACDCA"-> 99. Probieren Sie es online!.

So funktioniert es: i x a bBerechnet die Punktzahl für eine einzelne Antwort amit korrektem Ergebnis bund die Strafe xfür eine falsche Antwort (ein nicht negativer Wert). Wenn Sie überspringen (a>'Z' ), ist die Punktzahl 0, wenn die Antwort richtig ist ( a==b), ist die Punktzahl 6-0^x, sonst ist die Punktzahl-x .

w=<<[0..2]macht eine Liste der Strafen für alle 25 Fragen durch die Anwendung wzu 0, 1und 2, also machen5*3^0^x Kopien jede Nummer (-> 15 Mal 0, 5 Mal 1und 5 - mal 2).

zipWith3gilt ifür die Liste der Strafen, die Liste der Antworten und die Liste der korrekten Ergebnisse. Schließlich werden alle Punkte hinzugefügt ( sum).

Oktave, 61 54 Bytes

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

Probieren Sie es online!

Vorherige Antwort:

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

Meine erste Lösung in ES6, vielleicht sogar zuerst in 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 ist die eingereichte Lösung und a ist die richtige Lösung. Beide werden als Zeichenfolgen verwendet.

Hier ist eine nicht rekursive Lösung mit 78 Bytes:

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

Übernimmt die Eingabe über die Currying-Syntax.

Vielen Dank an @ETHproductions für die Einsparung von 9 Bytes! s[i]zu cund (-1-(i>19|0))zu~(i>19) .

Vielen Dank an @Kritixi Lithos für das Speichern eines Bytes! c=='_'zu c>'Z'.

Probieren Sie es online!