GPA Calculator

(GPA = Moyenne pondérée cumulative)

Vous êtes un étudiant stressé pendant la semaine des finales. Au lieu d'étudier pour vos examens à venir, vous décidez qu'il est préférable de déterminer quel GPA vous aurez à la fin du semestre. De cette façon, vous avez des données pour confirmer votre décision de rester éveillé toute la nuit pour obtenir ce A en calcul au lieu d'un B pour rester sur la liste du doyen!

Étant un majeur en informatique, vous voulez trouver le moyen le plus cool de déterminer ce GPA. Bien sûr, le moyen le plus cool est avec le code le plus court! C'est le code-golf , donc le code le plus court en octets gagne!

Détails

• Le collège que vous fréquentez utilise un GPA de base échelonné avec des heures de crédit.
• Une note de lettre A est un 4,0, B est 3,0, C est 2,0, D est 1,0 et F est 0,0
• Votre GPA est un GPA pondéré, donc un A dans une classe de 4 heures compte 4 fois plus qu'un A dans une classe de 1 heure (voir les exemples ci-dessous pour plus d'explications sur le poids)
• Les heures de crédit vont de 1 à 4

• Votre programme devra avoir une liste de deux entrées de ligne de commande, Grade et Credit Hour. Vous pouvez déterminer la meilleure façon de les saisir dans votre programme via la ligne de commande. Vous n'avez pas à vous soucier de trop d'entrées, mais assurez-vous que votre code peut gérer un semestre de 19 crédits.

  • ie Entrée: A 1 B 4 C 2…

• Votre programme doit sortir le GPA, en utilisant 3 chiffres (c'est-à-dire X.XX)

• Votre GPA doit être arrondi à deux décimales. Arrondissez comme bon vous semble (sol, plafond, base, etc…)

Exemples d'entrée (choisissez celui qui convient le mieux à votre conception)

• 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

Ou l'une des combinaisons ci-dessus où vous utilisez le format de liste de toutes les notes, puis leurs heures de crédit:

• c'est-à-dire ABAA 3 4 1 1

Exemples

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

Gelée ,  15  21 octets (12 sans arrondi)

+6 octets pour le formatage strict (presque certainement possible en moins mais c'est l'heure du coucher)

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

Un programme complet prenant les notes et les heures de crédit respectives qui imprime le GPA calculé (Remarque: la méthode d'arrondi est au plancher, comme le permet le PO).

Essayez-le en ligne!

Sans arrondi pour 12 octets :

Oạ69.Ḟ×S÷⁹S¤

Comment?

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 octets

-5 octets grâce à Rod.

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

Essayez-le en ligne!

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

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

Essayez-le en ligne!

Modifier: permuté l'entrée pour économiser 4 octets

Format d'entrée: ligne séparée, crédits suivis de la note:

grade credits

Exemple:

A 3
B 4
A 1
A 1

Python 2 , 69 octets

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

Essayez-le en ligne!

Wolfram Language (Mathematica) , 39 octets

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

Prend une liste d'heures de crédit, puis une chaîne de notes.

Ne fonctionne pas sur TIO car TIO utilise le noyau Mathematica (qui ne veut pas imprimer de nombres de précision arbitraires)

JavaScript (ES6), 72 octets

Format d'entrée: A1B3C2F3B4

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

Cas de test

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 octets

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

Essayez-le en ligne!

merci à user2390246 pour corriger un bug!

Java, 211 octets

Format d'entrée: A1B3C2F3B4

Golfé

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

Unglofed

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*/
}

Autre version

Mon intuition m'a dit que l'utilisation d'un format d'entrée différent (ABCF1324) rendrait le code plus court. Il semble que non. La version ci-dessous est longue de 234 octets.

Golfé

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

Non golfé

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 octets

-38 octets grâce à Bumptious

Golfé

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

Non golfé

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 octets

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

Essayez-le en ligne!

Explication

Format d'entrée g:: vecteur de notes; h: vecteur d'heures de crédit

• g%h: Redéfinir % opérateur.
• 69-Int.(g): Convertir 'F','D','C','B','A'en -1,1,2,3,4respectivement pour chaque élément de g.
• max.( ,0): Plage de serrage à 0:4 (par élément).
• Le reste est de simples mathématiques vectorielles.
• L'arrondi coûte 9 octets.