Calcolatore GPA

(GPA = media dei voti)

Sei uno studente universitario stressato durante la settimana delle finali. Invece di studiare per i tuoi esami in arrivo, decidi che è meglio determinare quale GPA avrai alla fine del semestre. In questo modo hai i dati per sostenere la tua decisione di rimanere sveglio tutta la notte per ottenere quella A in Calcolo invece di una B per rimanere nella lista del Decano!

Essendo un grande esperto di informatica, vuoi trovare il modo migliore per determinare questo GPA. Ovviamente il modo migliore è con il codice più corto! Questo è code-golf , quindi vince il codice più breve in byte!

Dettagli

• Il college in cui vai utilizza un GPA di base ridimensionato insieme alle ore di credito.
• Una lettera di grado A è 4,0, B è 3,0, C è 2,0, D è 1,0 e F è 0,0
• Il tuo GPA è un GPA ponderato, quindi una A in una classe di 4 ore di credito conta 4 volte tanto quanto una A in una classe di 1 ora di credito (vedi gli esempi di seguito per una spiegazione più ponderata)
• Le ore di credito vanno da 1 a 4

• Il tuo programma dovrà avere un elenco di due input da riga di comando, Grado e Ora credito. Puoi determinare il modo migliore per inserirli nel tuo programma attraverso la riga di comando. Non devi preoccuparti di troppi input, ma assicurati che il tuo codice sia in grado di gestire un semestre di 19 ore di credito.

  • cioè Ingresso: A 1 B 4 C 2 ...

• Il tuo programma deve emettere GPA, usando 3 cifre (es. X.XX)

• Il GPA deve essere arrotondato al secondo decimale. Rotonda come preferisci (pavimento, soffitto, base, ecc ...)

Esempi di input (Scegli quello che funziona meglio per il tuo design)

• 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

O una qualsiasi delle combinazioni di cui sopra in cui si utilizza il formato di elencazione di tutti i voti, quindi le loro ore di credito:

• cioè ABAA 3 4 1 1

Esempi

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

Gelatina ,  15  21 byte (12 senza arrotondamento)

+6 byte per la formattazione rigorosa (quasi certamente possibile in meno ma è ora di andare a letto)

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

Un programma completo che prende in considerazione i voti e le rispettive ore di credito che stampa il GPA calcolato (Nota: il metodo di arrotondamento è a terra, come consentito nel PO).

Provalo online!

Con alcun arrotondamento per 12 byte :

Oạ69.Ḟ×S÷⁹S¤

Come?

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 byte

-5 byte grazie a Rod.

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

Provalo online!

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

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

Provalo online!

Modifica: scambiato l'input per salvare 4 byte

Formato di input: linea separata, crediti seguiti dal voto:

grade credits

Esempio:

A 3
B 4
A 1
A 1

Python 2 , 69 byte

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

Provalo online!

Wolfram Language (Mathematica) , 39 byte

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

Prende un elenco di ore di credito, quindi una serie di voti.

Non funziona su TIO perché TIO utilizza il kernel Mathematica (che non vuole stampare numeri di precisione arbitrari)

JavaScript (ES6), 72 byte

Formato di input: A1B3C2F3B4

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

Casi 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 byte

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

Provalo online!

grazie a user2390246 per aver corretto un bug!

Java, 211 byte

Formato di input: A1B3C2F3B4

golfed

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

Altra versione

Il mio istinto mi ha detto che l'uso di un formato di input diverso (ABCF1324) renderebbe il codice più breve. Sembra di no. La versione seguente è lunga 234 byte.

golfed

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 byte

-38 byte grazie a Bumptious

golfed

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 byte

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

Provalo online!

Spiegazione

Formato di input g: vettore dei voti; h: vettore delle ore di credito

• g%h: Ridefinisci % operatore.
• 69-Int.(g): Conversione 'F','D','C','B','A'di -1,1,2,3,4rispettivamente per ogni elemento g.
• max.( ,0): Imposta la gamma su 0:4(in base all'elemento).
• Il resto è semplice matematica vettoriale.
• L'arrotondamento costa 9 byte.