GPA-Rechner

(GPA = Notendurchschnitt)

Sie sind ein gestresster Student während der Abschlusswoche. Anstatt für die bevorstehenden Prüfungen zu studieren, ist es am besten zu bestimmen, welche GPA Sie am Ende des Semesters haben werden. Auf diese Weise haben Sie Daten, um Ihre Entscheidung zu bestätigen, die ganze Nacht wach zu bleiben, damit dieses A in Calculus anstelle eines B auf der Liste des Dekans bleibt!

Als Informatik-Hauptfach möchten Sie den coolsten Weg finden, um diesen GPA zu bestimmen. Am coolsten ist natürlich der kürzeste Code! Das ist Code-Golf , also gewinnt der kürzeste Code in Bytes!

Einzelheiten

• Das College, an das Sie gehen, verwendet einen Basis-GPA, der zusammen mit den Kreditstunden skaliert wird.
• Ein Buchstabengrad von A ist 4,0, B ist 3,0, C ist 2,0, D ist 1,0 und F ist 0,0
• Ihr GPA ist ein gewichteter GPA. Ein A in einer 4-Kredit-Stunden-Klasse zählt also viermal so viel wie ein A in einer 1-Kredit-Stunden-Klasse.
• Kredit-Stunden reichen von 1-4

• Ihr Programm muss eine Liste mit zwei Befehlszeilen-Eingaben haben, Grade und Credit Hour. Sie können über die Befehlszeile bestimmen, wie Sie diese am besten in Ihr Programm eingeben können. Sie müssen sich nicht um zu viele Eingaben kümmern, sondern müssen sicherstellen, dass Ihr Code ein Semester mit 19 Kreditstunden bewältigen kann.

  • dh Eingang: A 1 B 4 C 2…

• Ihr Programm muss die GPA mit 3 Ziffern ausgeben (dh X.XX)

• Ihr GPA muss auf zwei Dezimalstellen gerundet werden. Rund nach Belieben (Boden, Decke, Sockel usw.)

Eingabebeispiele (Wählen Sie das für Ihr Design am besten geeignete aus)

• A1B3C2F3B4
• A1 B3 C2 F3 B4
• A 1 B 3 C 2 F 3 B 4
• A, 1, B, 3, C, 2, F, 3, B, 4
• A1, B3, C2, F3, B4

Oder eine der oben genannten Kombinationen, bei denen Sie das Format der Auflistung aller Noten und ihrer Kreditstunden verwenden:

• dh ABAA 3 4 1 1

Beispiele

Input - A 3 B 4 A 1 A 1
Output - 3.56
Explanation: (4.0 * 3 + 3.0 * 4 + 4.0 * 1 + 4.0 * 1)/(3+4+1+1) = 3.555556 rounded off to 3.56 

Input - A 4 F 2 C 3 D 4
Output - 2.00
Explanation: (4.0 * 4 + 0.0 * 2 + 2.0 * 3 + 1.0 * 4)/(4+2+3+4) = 2 rounded off to 2.00

Jelly ,  15  21 Bytes (12 ohne Rundung)

+6 Bytes für die strikte Formatierung (mit ziemlicher Sicherheit in kürzerer Zeit, aber es ist Schlafenszeit)

Oạ69.Ḟ×S×ȷ2÷⁹S¤RLDż”.

Ein vollständiges Programm, das die Noten und die jeweiligen Kreditstunden aufnimmt und den berechneten GPA druckt (Hinweis: Die Rundungsmethode ist, wie im OP zulässig, auf den Mindestbetrag zu runden).

Probieren Sie es online!

Mit keiner Rundung für 12 Bytes :

Oạ69.Ḟ×S÷⁹S¤

Wie?

Oạ69.Ḟ×S×ȷ2÷⁹S¤RLDż”. - Link: list of characters, grades; list of number, creditHours
                      -                                   e.g. "AFBDC", [5, 2, 4, 1, 2]
O                     - cast to ordinals (vectorises)          [65,70,66,68,67]
  69.                 - literal 69.5
 ạ                    - absolute difference (vectorises)       [4.5,0.5,3.5,1.5,2.5]
     Ḟ                - floor (vectorises)                     [4,0,3,1,2]
      ×               - multiply by creditHours (vectorises)   [20,0,12,1,4]
       S              - sum                                    37
         ȷ2           - literal 100
        ×             - multiply                               3700
              ¤       - nilad followed by link(s) as a nilad:
            ⁹         -   chain's right argument, creditHours  [5, 2, 4, 1, 2]
             S        -   sum                                  14
           ÷          - division                               264.2857142857143
               R      - range                                  [1,2,3,...,264]
                L     - length                                 264
                 D    - digits                                 [2,6,4]
                   ”. - literal '.'
                  ż   - zip together                           [[2,'.'],6,4]
                      - implicit print (smashing)              2.64

Python 3 , 66 Bytes

-5 Bytes dank Rod.

lambda g,c:'%.2f'%sum('FDCBA'.find(i)*j/sum(c)for i,j in zip(g,c))

Probieren Sie es online!

Perl 5 , 57 53 + 2 ( -an) = 59 55 Bytes

$c+=$F[1];$\+=$F[1]*=!/F/&&69-ord}{printf'%.2f',$\/$c

Probieren Sie es online!

Bearbeiten: vertauscht die Eingabe, um 4 Bytes zu sparen

Eingabeformat: zeilenweise getrennt, Credits gefolgt von der Note:

grade credits

Beispiel:

A 3
B 4
A 1
A 1

Python 2 , 69 Bytes

lambda x:'%.2f'%sum('FDCBA'.find(a)*b*1./sum(zip(*x)[1])for a,b in x)

Probieren Sie es online!

Wolfram Language (Mathematica) , 39 Byte

N[(5-LetterNumber@#2/.-1->0).#/Tr@#,3]&

Nimmt eine Liste von Kreditstunden und dann eine Reihe von Noten.

Funktioniert nicht mit TIO, da TIO den Mathematica-Kernel verwendet (der keine Zahlen mit willkürlicher Genauigkeit drucken möchte)

JavaScript (ES6), 72 Byte

Eingabeformat: A1B3C2F3B4

f=([c,d,...s],a=b=0)=>c?f(s,a+~'DCBA'.search(c,b-=d)*d):(a/b).toFixed(2)

Testfälle

f=([c,d,...s],a=b=0)=>c?f(s,a+~'DCBA'.search(c,b-=d)*d):(a/b).toFixed(2)

console.log(f('A3B4A1A1')) // 3.56
console.log(f('A4F2C3D4')) // 2.00

R , 64 Bytes

function(G,H)sprintf("%.2f",(5-match(G,LETTERS[-5]))%*%H/sum(H))

Probieren Sie es online!

danke an user2390246 für die behebung eines fehlers!

Java, 211 Bytes

Eingabeformat: A1B3C2F3B4

Golf gespielt

interface A{static void main(String[] a){int p=0,t=0,h=0,s=0;for(int c:a[0].toCharArray())if(p++%2==0)t=c=='A'?4:c=='B'?3:c=='C'?2:c=='D'?1:0;else{s+=(c-=48)*t;h+=c;}System.out.print(Math.ceil(100d*s/h)/100);}}

Ungeplündert

static void main(String[] a) {
    int p=0, //position in string
    t=0, //temp var, used to store the grade between iterations
    h=0, //credit sum
    s=0; //sum of weighted grade

    for(int c:a[0].toCharArray())
        if(p++%2==0)
            //map c to grade value, assign to temp variable t
            t=c=='A'?4:c=='B'?3:c=='C'?2:c=='D'?1:0;
        else{
            //map c to credit value, add temp variable (grade from previous char) * value of this char (credit) to sum
            s+=(c-=48)*t;
            //also, add credit to credit sum
            h+=c;
        }
    System.out.print(Math.ceil(100d*s/h)/100); //grade sum / credit hours sum, to 2dp*/
}

Andere Version

Mein Bauchweh sagte mir, dass die Verwendung eines anderen Eingabeformats (ABCF1324) den Code kürzer machen würde. Es scheint so, als ob es nicht so wäre. Die folgende Version ist 234 Byte lang.

Golf gespielt

interface A{static void main(String[] b){char[] a=b[0].toCharArray();int l=a.length/2,h=0,s=0,g,c,i;for(i=0;i<l;i++){g=a[i];g=g=='A'?4:g=='B'?3:g=='C'?2:g=='D'?1:0;c=a[i+l]-48;s+=g*c;h+=c;}System.out.print(Math.ceil(100d*s/h)/100);}}a

Ungolfed

static void main(String[] b) {
    char[] a=b[0].toCharArray(); //char array
    int l=a.length/2, //first grade char
    h=0, //credit sum
    s=0, //sum of weighted grade
    g,c, //avoid declaration in for loop. grade and credit being iterated
    i; //avoid declaration in for loop
    for(i=0;i<l;i++) {
        g=a[i];//get char representing grade from array
        g=g=='A'?4:g=='B'?3:g=='C'?2:g=='D'?1:0; //convert to grade
        c=a[i+l]-48;//get char representing grade from array and convert to credit (48 is value of '0')
        s+=g*c; //add weighted grade to sum
        h+=c; //add credit to sum
    }
    System.out.print(Math.ceil(100d*s/h)/100); //grade sum / credit hours sum, to 2dp*/
}

Java 1.8 , 287 249 Bytes

-38 Bytes dank Bumptious

Golf gespielt

static String N(String[]j){float g=0;float b=0;for(int i=0;i<j.length;i+=2){g=((m(j[i])*Float.parseFloat(j[i+1])+g));b+=Double.parseDouble(j[i+1]);}return String.format("%.2f",g/b);}static float m(String l){return l.equals("F")?0:('E'-l.charAt(0));}

Ungolfed

interface C {
static void main(String[] z) throws Exception {
    String[] j = {"A", "4", "B", "3", "C", "2", "D", "1", "F", "1"};
    System.out.println(N(j));
}

static String N(String[] j) {
    float g = 0;
    float b = 0;
    for (int i = 0; i < j.length; i += 2) {
        g = ((m(j[i]) * Float.parseFloat(j[i + 1]) + g));
        b += Double.parseDouble(j[i + 1]);
    }
    return String.format("%.2f", g / b);
}

static float m(String l) {
    return l.equals("F") ? 0 : ('E' - l.charAt(0));
}
}

Julia 0,6 , 46 43 42 Bytes

g%h=round(max.(69-Int.(g),0)⋅h/sum(h),2)

Probieren Sie es online!

Erläuterung

Eingabeformat:: gVektor der Noten; h: Vektor der Kreditstunden

• g%h: %Operator neu definieren.
• 69-Int.(g): Konvertieren 'F','D','C','B','A'zu -1,1,2,3,4für jedes Element von G ist.
• max.( ,0): Klemmbereich bis 0:4(elementweise).
• Der Rest ist einfache Vektormathematik.
• Die Rundung kostet 9 Byte.