Ich nehme gerne an Mathe-Wettbewerben teil, die von Mu Alpha Theta, einer Mathematik-Ehrengesellschaft in den Vereinigten Staaten, veranstaltet werden. Bei Wettbewerben absolviere ich einen Multiple-Choice-Test mit 30 Fragen. Pro Frage stehen fünf Auswahlmöglichkeiten mit den Bezeichnungen A bis E zur Verfügung.

Meine Punktzahl bei einem Test beträgt vier Punkte für jede richtige Antwort, null Punkte für eine leere Frage und ein negativer Punkt für jede falsche Antwort.

Schreiben Sie ein Programm, das einen Test nach dem obigen Bewertungssystem bewertet. Die Eingabe sollte aus zwei Komponenten bestehen: einem Antwortschlüssel, gefolgt von Antworten. Fragen, die leer bleiben, müssen als Leerzeichen eingegeben werden. Die erste Eingabe darf nur die Buchstaben AE (oder ae, Ihre Wahl) enthalten, und es kann davon ausgegangen werden, dass die Eingabe kein Leerzeichen enthält. Die zweite Eingabe darf nur Leerzeichen und die Buchstaben AE (oder ae) enthalten. Eingaben, die keine 30-Fragen-Tests implementieren, müssen Invalid testals Ausgabe gedruckt werden.

Die Ausgabe sollte die Note oder sein Invalid test.

Bonus

Wenn Ihr Programm die Zahl rechts, die Zahl links und die Zahl falsch nach dem Endergebnis als druckt (aR bB cW), entfernen Sie 20 Bytes.

Probeneingabe

CABBDCABECDBACDBEAACADDBBBEDDA    //answer key
CABEDDABDC BACDBBAADE  CBBEDDA    //responses

Beispielausgabe

Kein Bonus

73

Bonus

73 (20R 3B 7W)

Es gelten Standardregeln. Kürzester Code in Bytes gewinnt.

Pyth, 53 51

?&!-sJ.z+d<G5&FqR30lMJ+sm?qFd4_1CJ/eJd"Invalid test

Probieren Sie es online aus

Die Prüfungen werden durchgeführt, indem geprüft wird, ob die gesamte Eingabe Zeichen enthält, wenn alle Leerzeichen und a-eentfernt wurden, und indem geprüft wird, ob beide Zeichenfolgen eine Länge haben 30.

Die Score - Berechnung wird durch die beiden Linien Zipping zusammen gemacht, dann durch Abbilden jedes Paares an: (letters are equal) ? 4 : -1. Summieren Sie dann einfach die Werte und addieren Sie die Anzahl der Leerzeichen in der zweiten Zeile zurück zur Punktzahl.

Im Ernst , 86 Bytes

,`;l5╙¬=);' UΣS" ABCDE"=(**;l`Mi@)=YWé"Invalid test"0WX@Z```i@;(=5*(' =D+`(;l@)5╙¬=IMΣ

Nimmt Eingaben wie "CABBDCABECDBACDBEAACADDBBBEDDA", "CABEDDABDC BACDBBAADE CBBEDDA"

Probieren Sie es online aus (Sie müssen die Eingabe manuell eingeben, da Permalinks keine Anführungszeichen mögen)

Arbeite jetzt am Bonus. Nein, das Hinzufügen des Bonus würde mehr als 20 Bytes kosten.

Ich wusste, dass ich etwas vergessen hatte ... Invalid Testwurde im Fehlerfall nicht gedruckt. Ich hoffe, dass ich Dennis übertreffen kann.

JavaScript (ES6), 134 Byte

Bearbeiten: Die Fragenanforderungen wurden geändert. Diese Antwort stammt von dem Zeitpunkt, zu dem das Programm sicherstellen muss, dass jedes Antwortzeichen AE ist, jedes Antwortzeichen AE oder ein Leerzeichen ist und beide Längen von 30 haben, andernfalls wird zurückgegeben Invalid test.

(a,r)=>[...a].map((q,i)=>q>"E"|q<"A"?x=1:(c=r[l=i])==" "?0:c>"E"|c<"A"?x=1:c==q?s+=4:s--,s=x=0)&&x|l!=29|r.length!=30?"Invalid test":s

Erläuterung

(a,r)=>                   // a = answer string, r = responses string
  [...a].map((q,i)=>      // iterate over answers, q = answer, i = question number
    q>"E"|q<"A"?x=1:      // x = 1 if answer is invalid
    (c=r[l=i])==" "?0:    // c = question response, l = answer length, add 0 for space
    c>"E"|c<"A"?x=1:      // x = 1 if response is invalid
    c==q?s+=4:s--,        // add 4 if correct, subtract 1 if incorrect
    s=x=0                 // s = total score, x = is invalid
  )&&
    x|l!=29|r.length!=30? // check input lengths for validity
      "Invalid test":
      s                   // return the score

Prüfung

<input type="text" id="answers" value="CABBDCABECDBACDBEAACADDBBBEDDA" /><br />
<input type="text" id="responses" value="CABEDDABDC BACDBBAADE  CBBEDDA" /><br />
<button onclick='result.innerHTML=(

(a,r)=>[...a].map((q,i)=>q>"E"|q<"A"?x=1:(c=r[l=i])==" "?0:c>"E"|c<"A"?x=1:c==q?s+=4:s--,s=x=0)&&x|l!=29|r.length!=30?"Invalid test":s

)(answers.value,responses.value)'>Go</button><pre id="result"></pre>

CJam, 60 Bytes

2{l_,30=\N?}*_2$|S'F,65>+-!@2$.{=4W?}@' f=+:+"Invalid test"?

Probieren Sie es online im CJam-Interpreter aus .

JavaScript (Firefox 31+), 86 Byte

(x,y)=>(r=i=0,[for(l of y)x[i++]==l?r+=4:r-=l!=' '],i!=30|i-x.length?'Invalid test':r)

Verwendet das für ES7 vorgeschlagene Array-Verständnis. Daher ist die Unterstützung momentan auf Firefox beschränkt.

Mit Bonus 106 Bytes (126 - 20)

(x,y)=>[r=w=i=0,[for(l of y)x[i++]==l?r++:w+=l!=' '],`${r*4-w} (${r}R ${i-r-w}B ${w}W)`,'Invalid test'][i!=30||i-x.length?3:2]

Bearbeiten: Früher hat meine Lösung nur die Antwort- oder Fragenlänge überprüft, jetzt überprüft sie beide.

F=(x,y)=>(r=i=0,[for(l of y)x[i++]==l?r+=4:r-=l!=' '],i!=30|i-x.length?'Invalid test':r)
G=(x,y)=>[r=w=i=0,[for(l of y)x[i++]==l?r++:w+=l!=' '],`${r*4-w} (${r}R ${i-r-w}B ${w}W)`,'Invalid test'][i!=30||i-x.length?3:2]

var score = () => result.innerHTML = (bonus.checked ? G:F)(questions.value, answers.value);

questions.oninput = answers.oninput = bonus.onchange = score;
score();

* {
    box-sizing: border-box;
}

label {
  float: left;
  clear: left;
  vertical-align: middle;
  line-height: 2;
  padding-right: 0.5em;
}

input[type="text"] {
  width: 100%;
  vertical-align: middle;
  line-height: 2;
  font-family: monospace;
  padding: 0 0.5em;
}

input[type="checkbox"] {
  vertical-align: middle;
  line-height: 2;
  margin: 0.5em;
}

hr {
  clear: both;
}

.input-wrapper {
  overflow: hidden;
  width: auto;
}

#result, #error {
  font-weight: bold;
}

#error {
  display: none;
}

<script  type="text/javascript">
  window.onerror = () => {
    var inputEls = document.getElementsByTagName('input');
    for (var i = 0; i < inputEls.length; i++) {
      inputEls[i].disabled = true;
    }
    error.style.display = 'block';
    output.style.display = 'none';
  }
</script>
<label for="questions">Q:</label>
<div class="input-wrapper">
  <input id="questions" type="text" value="CABBDCABECDBACDBEAACADDBBBEDDA"/>
</div>
<label for="answers">A:</label>
<div class="input-wrapper">
  <input id="answers" type="text" value="CABEDDABDC BACDBBAADE  CBBEDDA"/>
</div>
<label for="bonus">Bonus:</label>
<div class="input-wrapper">
  <input id="bonus" type="checkbox" checked/>
</div>
<hr/>
<div id="output">
  Result: <span id="result"></span>
</div>
<div id="error">
  ERROR: Unsupported browser! Try Firefox 31+
</div>

Japt , 71 Bytes

Japt ist eine verkürzte Version von Ja vaScri pt . Dolmetscher

Ul ¥30©Vl ¥30«(U+V k"[A-E ]+" ?U¬r@VgZ ¥Y?X+4:VgZ ¥S?X:X-1,0 :`InvÃ. È.

Die beiden .Zeichen am Ende sollten die nicht druckbaren Unicode-Zeichen U + 0017 bzw. U + 0099 sein.

Wie es funktioniert

Ul ==30&&Vl ==30&&!(U+V k"[A-E ]+" ?Uq r@VgZ ==Y?X+4:VgZ ==S?X:X-1,0 :"Invalid test
                    // Implicit: U = first input, V = second input
Ul ==30&&Vl ==30&&  // If both input lengths are 30, and
!(U+V k"[A-E ]+"?   // removing all ABCDE and spaces from (U+V) results in an empty string:
Uq r@            ,0 //  Reduce U with this function, starting with a value of 0:
VgZ ==Y?            //   If the matching char in V is equal to this char, 
X+4                 //    return previous value + 4.
:VgZ ==S?X          //   Else if the matching char in V is a space, return previous value.
:X-1                //   Else (if it's wrong), return previous value - 1.
:"Invalid test      // Else, return "Invalid test".
                    // Implicit: output last expression

Ich hoffe, es gibt einen kürzeren Weg, um sicherzustellen, dass beide Längen gleich 30 sind. Vorschläge sind willkommen!

Haskell, 144 138 Bytes

a%b|map length[a,b]==[30,30]&&"ABCDE"!a&&"ABCDE "!b=show$sum$zipWith(?)a b|0<1="Invalid test"
l!s=all(`elem`l)
_?' '=0
x?y|x==y=4|0<1=0-1

Wäre etwa 50 ohne die Validierung. schnüffeln .

Verwendung: "ABCDEABCDEABCDEABCDEABCDEABCDE" % "AAAAABBBBBCCCCCDDDDDEEEEEAAAAA"

C #, 162 154 148 134 Bytes

string g(string k,string a)=>k.Length!=30||a.Length!=30?"Invalid Test!":Enumerable.Range(0,30).Sum(e=>a[e]==' '?0:k[e]==a[e]?4:-1)+"";

Verwendung

g("CABBDCABECDBACDBEAACADDBBBEDDA", "CABEDDABDC BACDBBAADE  CBBEDDA")

Prüfung

http://csharppad.com/gist/15f7c9c3c8cfce471ff2

Ruby, 81 Zeichen

->t,s{r=0;30.times{|i|r+=t[i]==s[i]?4:s[i]>' '?-1:0};t.size==30?r:'Invalid test'}

Probelauf:

2.1.5 :001 > ->t,s{r=0;30.times{|i|r+=t[i]==s[i]?4:s[i]>' '?-1:0};t.size==30?r:'Invalid test'}['CABBDCABECDBACDBEAACADDBBBEDDA','CABEDDABDC BACDBBAADE  CBBEDDA']
 => 73 

2.1.5 :002 > ->t,s{r=0;30.times{|i|r+=t[i]==s[i]?4:s[i]>' '?-1:0};t.size==30?r:'Invalid test'}['CCCATCH','CABEDDABDC BACDBBAADE  CBBEDDA']
 => "Invalid test" 

Java, 183 169 Bytes

Dies war ein schönes Stück Java 8-Übung:

String f(String a,String r){return a.length()==30&r.length()==30?""+IntStream.range(0,30).map(i->a.charAt(i)==r.charAt(i)?4:r.charAt(i)!=' '?-1:0).sum():"Invalid test";}

Brainfuck, 354 Bytes

+[--[>]<<+>-],----------[[<<<]>>->[>>>],----------]<<<[<<<]>>+[<-[-------<+>]<.+[---<+>]<.++++++++.[-<+++>]<-.+++++++++++.---.-----.-[---<+>]<-.---[-<++++>]<.+++[-<+++>]<.[---<+>]<----.+.>]>[[>,----------->+++++++[<---<<+++>>>-]<[<<+[>>+<<-]]>[>]<<<[>[>+>+<<-]>>[<<+>>-]>[>>>]>----<<<<[<<<]>>[-]]>[>-<-]>[>>[>>>]>-----<<<<[<<<]>[-]]>>]----[>+++<--]>--.<]

Benötigt einen Interpreter, mit dem Sie von Zelle 0 nach links gehen können. Die Ausgabe ist ein Byte mit Vorzeichen. Beispielsweise wird das Byte 0x49für die Beispieleingabe 0xFFgedruckt und für die Eingabe mit derselben ersten Zeile gedruckt, wobei jedoch die zweite Zeile durch "C" und 29 Leerzeichen ersetzt wird.

Die Punktzahl beginnt bei 0, und wenn die zweite Eingabezeile gelesen wird, werden die folgenden Änderungen daran vorgenommen:

• Eingabe ist korrekt: Nichts tun
• Eingabe ist falsch: 5 abziehen
• Eingabe ist ein Leerzeichen: Subtrahiere 4

Schließlich wird 120 hinzugefügt. Dies ist funktional dasselbe wie die Annahme einer perfekten Punktzahl und das Anwenden von Strafen, anstatt bei 0 zu beginnen.

Mit Kommentaren:

+[--[>]<<+>-]                          Get 29

,----------[[<<<]>>->[>>>],----------] Get first line of input; for each char sub one
                                       from the 29

<<<[<<<]>>+                            Add one to the cell that originally held 29

[                                      If the cell that originally held 29 is nonzero:

  Write "Invalid test"
  <-[-------<+>]<.+[---<+>]<.++++++++.[-<+++>]<-.+++++++++++.---.-----.-[---<+>]<-.---[-<++++>]<.+++[-<+++>]<.[---<+>]<----.+.

>]

>[                                     If the cell to the right is nonzero:

  This block is only ever entered if "Invalid test" isn't written!

  [                                      For all 30 characters of the first input:

    >,                                     Get char from second input to the right

    ----------                             Subtract 10 for consistency

    -                                      Subtract one more

    >+++++++[<---<<+++>>>-]                Subtract 21 (plus above lines = 32)

    <[                                     If it's nonzero:

      <<+[>>+<<-]                            Add 22 to the character

    ]

    >[>]<<<[                                 If the above block wasn't entered:

      >[>+>+<<-]>>[<<+>>-]                   Make a copy of the character from input 1

      >[>>>]>----                            Subtract 4 from the score

      <<<<[<<<]>>[-]                         Go to the cell just before first character

    ]

    >[>-<-]                                Subtract input 1 char from input 2 char

    >[                                     If the result is nonzero:

      >>[>>>]>-----                          Subtract 5 from the score

      <<<<[<<<]>[-]                          Go back to the result and set it to 0

    ]

    >>                                     Move on to next character

  ]

  ----[>+++<--]>--                       Add 120 to score (perfect score)

  .                                      Print score

  <                                      Go to an empty cell to kill loop

]

Python 3, 187 179 175 165 155 151

lambda a,b:(['Invalid test',sum([-1,4][i==j]for i,j in zip(a,b))+b.count(' ')][len(a)==len(b)==30and set(a)^set('ABCDE')==set(b)^set('ABCDE ')==set()])

JavaScript ES7, 102

Wie immer ist der Bonus die Mühe nicht wert.

(k,h,t=i=0)=>[for(x of h)t+=k[i++]==x?4:1-x?0:-1]|/[^ A-E]/.test(k+h)|i-30|k.length-i?"Invalid test":t

Überprüfen auf ungültige Leerzeichen in der ersten Eingabe (da dies für mich sinnvoll ist) 112

(k,h,t=i=0)=>[for(x of h)(y=k[i++])>' '?t+=y==x?4:1-x?0:-1:k=h+h]|/[^ A-E]/.test(k+h)|i-30|k[i]?"Invalid test":t

Python 2.7, 131, 116, 109 , 139

Ich habe versucht, eine "kurze" Python-Lösung zu erstellen ... Nun, hier sind Vorschläge mehr als willkommen

lambda c,d:d.count(' ')+sum([-1,4][a==b]for a,b in zip(c,d)if b!=' ')if not set('ABCDE ')^set(c+d)and len(c)==len(d)==30 else'Test Invalid'

Das Hinzufügen einiger weiterer Zeichen macht es weitaus lesbarer ...

def m(c, d):
    if len(c)==len(d)==30:return d.count(' ')+sum((a==b)*4+(a!=b)*-1 for a,b in zip(c,d)if b!=' ')
    return'Test Invalid'

Prolog, 165 Bytes

Mehr als die Hälfte der Bytes ist für die Überprüfung ungültiger Tests bestimmt.

Code:

p(X,X,4).
p(_,32,0).
p(_,_,-1).
A*B:-length(A,30),length(B,30),subset(A,`ABCDE`),subset(B,`ABCDE `),maplist(p,A,B,L),sum_list(L,S),write(S);write('Invalid Test').

Erklärt:

p(X,X,4).                                       % If corresponding elements are equal, 4p
p(_,32,0).                                      % If answer is 'space', 0p
p(_,_,-1).                                      % Else, -1p
A*B:-length(A,30),length(B,30),                 % Check that input is of correct length
     subset(A,`ABCDE`),subset(B,`ABCDE `),      % Check that input has correct characters
     maplist(p,A,B,L),sum_list(L,S),write(S);   % Create a list of scores (L) and print sum
     write('Invalid Test').                     % If anything failed, write Invalid Test

Beispiel:

`CABBDCABECDBACDBEAACADDBBBEDDA`*`CABEDDABDC BACDBBAADE  CBBEDDA`.
73

Probieren Sie es hier online aus

MATLAB, 92 90 Bytes

Vielen Dank an Tom Carpenter, der mir geholfen hat, meine Antwort um 2 Byte zu reduzieren!

function c(q,a),if nnz(q)~=30,t='Invalid test';else s=q-a;t=5*nnz(~s)-sum(s<9);end,disp(t)

Die Funktion kann durch Zuweisen des Antwortbogens zu q und der übermittelten Antworten zu a aufgerufen werden . z.B:

c('CABBDCABECDBACDBEAACADDBBBEDDA','CABEDDABDC BACDBBAADE  CBBEDDA')

Die Antwort wird einfach auf den Bildschirm gedruckt. 8 Bytes könnten gespeichert werden, wenn es erlaubt ist, ans = 73 zu drucken

C # 6.0 -> (270-20 = 250) 246-20 = 226 Bytes

void m(string b,string c){if((b+c).Length==60){var a=new int[3];int s=0;for(int i=0;i<30;i++){if(b[i]==c[i]){a[0]++;s+=4;}else if(c[i]==' ')a[2]++;else{a[1]++;s--;}}Console.Write(s+$" ({a[0]} {a[2]} {a[1]})");}else Console.Write("Invalid test");}

Lesbare & ungolfed Version:

    void m(string b, string c)
    {
        if ((b+c).Length==60)
        {
            var a = new int[3];
            int s = 0;
            for (int i = 0; i < 30; i++)
            {
                if (b[i]==c[i])
                {
                    a[0]++;
                    s+=4;
                }
                else if (c[i] == ' ')a[2]++;
                else
                {
                    a[1]++;
                    s--;
                }
            }
            Console.Write(s+$" ({a[0]} {a[2]} {a[1]})");
        }
        else Console.Write("Invalid test");
    }

Wollte eigentlich den Bonus bekommen: D

Groovy 2.4.5, 107 Bytes

Nur eine einfache Übersetzung der früheren Java-Antwort .

f={a,b->a.length()==30&b.length()==30?(0..29).collect{a[it]==b[it]?4:b[it]!=' '?-1:0}.sum():'Invalid test'}

C, 273-20 = 253 Bytes

#include<stdio.h>
#include<string.h>
int main(int c,char**v){char*p=v[1],*q=v[2],*s=" ABCDE",r[]={0,0,0};if(strspn(p,s+1)!=30||p[30]||strspn(q,s)!=30||q[30])puts("Invalid test");else{for(;*p;++q)++r[(*p++!=*q)+(*q==' ')];printf("%d (%dR %dB %dW)",4**r-r[1],*r,r[2],r[1]);}}

Ich habe den Bonus genommen, obwohl es mich 23 Bytes gekostet hat, ihn nur auszudrucken. :-(

Erläuterung

#include <stdio.h>
#include <string.h>
int main(int c,char**v)
{
    char *p=v[1], *q=v[2],      /* arguments */
        *s=" ABCDE",            /* valid chars */
        r[]={0,0,0};            /* results - right, wrong, blank */

    if (strspn(p,s+1) != 30     /* validity check - answer key begins with [A-E]{30} */
        || p[30]                /* and ends there */
        || strspn(q,s) != 30    /* same for answers, but allow space, too */
        || q[30])
    {
        puts("Invalid test");
    } else {
        for ( ;  *p;  ++q)      /* for each answer */
            ++r[(*p++!=*q)+(*q==' ')]; /* increment the appropriate counter */
        printf("%d (%dR %dB %dW)",4**r-r[1],*r,r[2],r[1]); /* print result */
    }
}

Es gibt doppelt so viel Code, der auf ungültige Eingaben überprüft werden muss, wie zum Zählen der Antworten - das wahre Fleisch der Herausforderung befindet sich forkurz vor dem Ende in der Schleife. In der Tat ist hier eine Version, die annimmt, dass die Eingabe immer gültig ist, in 163-20 = 143 Bytes:

#include<stdio.h>
int main(int c,char**v){char*p=v[1],*q=v[2],r[]={0,0,0};for(;*p;++q)++r[(*p++!=*q)+(*q==' ')];printf("%d (%dR %dB %dW)",4**r-r[1],*r,r[2],r[1]);}

Und eine, die die gleiche Annahme macht und nur die Punktzahl in 133 Bytes ausgibt:

#include<stdio.h>
int main(int c,char**v){char*p=v[1],*q=v[2],r[]={4,-1,0};for(c=0;*p;++q)c+=r[(*p++!=*q)+(*q==' ')];printf("%d",c);}

SAS 9.4, 291-20 = 271 Bytes (mit Bonus) oder 231 Bytes (ohne Bonus)

Mit Bonus:

data a;k='CABBDCABECDBACDBEAACADDBBBEDDA';r='CABEDDABDC BACDBBAADE  CBBEDDA';c=0;b=0;w=0;if length(k) ne 30 then put "Invalid test";do i=1 to 30;if substr(k,i,1)=substr(r,i,1) then c=c+1;else if substr(r,i,1) =' ' then b=b+1;else w=w+1;end;a=cat(c*4-w,' (',c,'R ',b,'B ',w,'W)');put a;run;

Ohne Bonus:

data a;k='CABBDCABECDBACDBEAACADDBBBEDDA';r='CABEDDABDC BACDBBAADE  CBBEDDA';c=0;if length(k) ne 30 then put "Invalid test";do i=1 to 30;if substr(k,i,1)=substr(r,i,1) then c=c+4;else if substr(r,i,1)ne' ' then c=c-1;end;put c;run;

Sas hat nicht wirklich einen Ein- / Ausgang, daher müssten Sie k = '..' durch den Schlüssel und r = '..' durch die Antwort ersetzen. Die Ausgabe wird im Protokoll ausgedruckt.