Calculadora de GPA

(GPA = promedio de calificaciones)

Eres un estudiante universitario estresado durante la semana final. En lugar de estudiar para los próximos exámenes, decide que es mejor determinar qué GPA tendrá al final del semestre. ¡De esta manera tiene datos para respaldar su decisión de quedarse despierto toda la noche para obtener esa A en el cálculo en lugar de una B para permanecer en la lista del decano!

Al ser un experto en informática, desea encontrar la mejor manera de determinar este GPA. ¡Por supuesto, la mejor manera es con el código más corto! Este es el código de golf , por lo que gana el código más corto en bytes.

Detalles

• La universidad a la que asiste utiliza un GPA básico escalado junto con horas de crédito.
• Una calificación de letra de A es 4.0, B es 3.0, C es 2.0, D es 1.0 y F es 0.0
• Su GPA es un GPA ponderado, por lo que una A en una clase de 4 horas de crédito cuenta 4 veces más que una A en una clase de 1 hora de crédito (consulte los ejemplos a continuación para obtener más explicaciones de peso)
• Las horas de crédito varían de 1-4

• Su programa necesitará tener una lista de dos entradas de línea de comando, Calificación y Hora de crédito. Puede determinar la mejor manera de ingresarlos en su programa a través de la línea de comandos. No necesita preocuparse por demasiadas entradas, pero asegúrese de que su código pueda manejar un semestre de 19 horas de crédito.

  • es decir, entrada: A 1 B 4 C 2 ...

• Su programa debe generar el GPA, utilizando 3 dígitos (es decir, X.XX)

• Su promedio de calificaciones debe redondearse a dos decimales. Redondee de la forma que desee (piso, techo, base, etc.)

Ejemplos de entrada (Elija el que mejor funcione para su diseño)

• 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 cualquiera de las combinaciones anteriores donde usa el formato de listar todas las calificaciones, luego sus horas de crédito:

• es decir, ABAA 3 4 1 1

Ejemplos

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 sin redondeo)

+6 bytes para el formato estricto (casi seguro posible en menos pero es hora de dormir)

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

Un programa completo que toma las calificaciones y las horas de crédito respectivas que imprime el GPA calculado (Nota: el método de redondeo es al piso, según lo permitido en el OP).

Pruébalo en línea!

Sin redondeo para 12 bytes :

Oạ69.Ḟ×S÷⁹S¤

¿Cómo?

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 gracias a Rod.

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

Pruébalo en línea!

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

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

Pruébalo en línea!

Editar: intercambió la entrada para guardar 4 bytes

Formato de entrada: línea separada, créditos seguidos de calificación:

grade credits

Ejemplo:

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)

Pruébalo en línea!

Wolfram Language (Mathematica) , 39 bytes

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

Toma una lista de horas de crédito y luego una serie de calificaciones.

No funciona en TIO porque TIO usa el núcleo de Mathematica (que no quiere imprimir números arbitrarios de precisión)

JavaScript (ES6), 72 bytes

Formato de entrada: A1B3C2F3B4

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

Casos de prueba

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

Pruébalo en línea!

¡Gracias a user2390246 por corregir un error!

Java, 211 bytes

Formato de entrada: 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);}}

Sin pelar

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

Otra versión

Mi instinto me dijo que usar un formato de entrada diferente (ABCF1324) acortaría el código. Parece que no lo hizo. La siguiente versión tiene 234 bytes de longitud.

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

Sin 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 bytes

-38 bytes gracias 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));}

Sin 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 bytes

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

Pruébalo en línea!

Explicación

Formato de entrada g: vector de calificaciones; h: vector de horas de crédito

• g%h: Redefinir % operador.
• 69-Int.(g): Convertir 'F','D','C','B','A'a -1,1,2,3,4respectivamente para cada elemento de g.
• max.( ,0): Rango de sujeción a 0:4(elemento inteligente).
• El resto es simple matemática vectorial.
• El redondeo cuesta 9 bytes.