जीपीए कैलकुलेटर

(GPA = ग्रेड प्वाइंट औसत)

आप फाइनल वीक के दौरान एक तनावग्रस्त कॉलेज छात्र हैं। अपनी परीक्षा के लिए अध्ययन करने के बजाय, आप तय करते हैं कि यह निर्धारित करना सबसे अच्छा है कि सेमेस्टर के अंत में आपके पास GPA क्या होगा। इस तरह आपके पास डीन की सूची में बने रहने के लिए बी के बजाय ए में कैलकुलस में ए पाने के लिए रात भर रहने के अपने निर्णय का समर्थन करने के लिए डेटा है!

कंप्यूटर विज्ञान प्रमुख होने के नाते आप इस GPA को निर्धारित करने का सबसे अच्छा तरीका खोजना चाहते हैं। बेशक सबसे छोटा तरीका सबसे छोटे कोड के साथ है! यह कोड-गोल्फ है , इसलिए बाइट्स जीत में सबसे छोटा कोड है!

विवरण

कॉलेज जो आप क्रेडिट घंटे के साथ-साथ एक बुनियादी जीपीए स्केल का उपयोग करने के लिए जाते हैं।
A का एक अक्षर ग्रेड 4.0 है, B 3.0 है, C 2.0 है, D 1.0 है और F 0.0 है
आपका GPA एक भारित GPA है, इसलिए A एक 4 क्रेडिट घंटे वर्ग में 4 बार गिना जाता है, जबकि A एक 1 क्रेडिट घंटे वर्ग में A (अधिक वजन व्याख्या के लिए नीचे उदाहरण देखें)
क्रेडिट घंटे 1-4 से लेकर हैं
आपके प्रोग्राम के लिए दो कमांड लाइन इनपुट, ग्रेड और क्रेडिट ऑवर की सूची होनी चाहिए। आप कमांड लाइन के माध्यम से इन्हें अपने प्रोग्राम में इनपुट करने का सबसे अच्छा तरीका निर्धारित कर सकते हैं। आपको बहुत अधिक इनपुट के बारे में चिंता करने की आवश्यकता नहीं है, लेकिन यह सुनिश्चित करें कि आपका कोड 19 क्रेडिट घंटे सेमेस्टर को संभाल सकता है।
- यानी इनपुट: एक 1 बी 4 सी 2 ...
आपके कार्यक्रम को 3 अंकों (अर्थात X.XX) का उपयोग करके GPA का उत्पादन करना चाहिए
आपके GPA को दो दशमलव स्थानों पर गोल करना होगा। जो भी आपको पसंद हो (जैसे, मंजिल, छत, आधार, आदि…) में गोल

इनपुट उदाहरण (जो भी आपके डिजाइन के लिए सबसे अच्छा काम करता है उसे चुनें)

A1B3C2F3B4
ए 1 बी 3 सी 2 एफ 3 बी 4
ए 1 बी 3 सी 2 एफ 3 बी 4
ए, 1, बी, 3, सी, 2, एफ, 3, बी, 4
ए 1, बी 3, सी 2, F3, बी 4

या इनमें से कोई भी संयोजन जहां आप सभी ग्रेड को सूचीबद्ध करने के प्रारूप का उपयोग करते हैं, तो उनके क्रेडिट घंटे:

यानी एबीएए 3 4 1 1

उदाहरण

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

code-golf

— DevelopingDeveloper
स्रोत

2

@DevelopingDeveloper कृपया बोझिल I / O स्वरूपों से बचने का प्रयास करें ।

— जुंगवान मिन

1

@JungHwanMin कृपया मुझे बताएं कि मैं कौन सा / ओ विकल्प चाहता था जो मैंने निर्दिष्ट नहीं किया था? मैंने लगभग 6 अलग-अलग लचीले विकल्प दिए, लेकिन इसे वास्तव में इस परिदृश्य में फिट होने के लिए निर्दिष्ट करने की आवश्यकता है।

— DevelopingDeveloper

3

@DevelopingDeveloper Your GPA needs to be rounded to two decimal places: इसे प्राप्त करने के लिए, लोगों को अतिरिक्त कोड जोड़ने की आवश्यकता है जिसका GPA गणना से कोई लेना-देना नहीं है।

— जंगहवान मिन

2

PPCG में आपका स्वागत है। मेरी विनम्र राय में पहला सवाल अच्छा लगा।

— एलपीड्रो

5

यह एक काफी दिलचस्प सवाल होने के बावजूद, मैं निराश हो गया, क्योंकि, जैसा कि मैंने पहले कहा था, अनुगामी 0s के साथ राउंडिंग और आउटपुट करने के लिए यह एक मल्टीपार्ट चुनौती है; उत्तर अनावश्यक रूप से बाइट्स जोड़ने के लिए हैं, बस आउटपुट स्पेक्स के अनुरूप, जो एक चुनौती को उबाऊ और समग्र आईएमओ को बदतर बनाते हैं।

— caird coinheringaahing

5

जैली , 15 21 बाइट्स (12 राउंड नहीं)

सख्त स्वरूपण के लिए +6 बाइट्स (लगभग निश्चित रूप से कम में संभव है लेकिन यह बिस्तर का समय है)

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

ग्रेड और संबंधित क्रेडिट घंटे लेने वाला एक पूरा कार्यक्रम जो गणना किए गए जीपीए को नोट करता है (नोट: राउंडिंग विधि फर्श पर है, जैसा कि ओपी में अनुमति दी गई है)।

इसे ऑनलाइन आज़माएं!

साथ के लिए कोई राउंडिंग 12 बाइट्स :

Oạ69.Ḟ×S÷⁹S¤

कैसे?

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

— जोनाथन एलन
स्रोत

@nimi - अच्छी बात है, मैं उस बिट याद किया। फिक्स्ड।

— जोनाथन एलन

4

पायथन 3 , 66 बाइट्स

-5 बाइट्स रॉड के लिए धन्यवाद।

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

इसे ऑनलाइन आज़माएं!

— totallyhuman
स्रोत

69-ord(i)काम नहीं करता है

— रॉड

1

आपके पास एक अतिरिक्त है (), आप 66 बाइट्स/sum(c) तक पहुंचने वाले 3 बाइट्स को बचाने के लिए भी आगे बढ़ सकते हैं

— रॉड

4

पर्ल 5 , 57 53 + 2 ( `-an`) = 59 55 बाइट्स

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

इसे ऑनलाइन आज़माएं!

संपादित करें: 4 बाइट्स को बचाने के लिए इनपुट को चारों ओर स्वैप किया

इनपुट प्रारूप: लाइन अलग, क्रेडिट ग्रेड के बाद:

grade credits

उदाहरण:

A 3
B 4
A 1
A 1

— Xcali
स्रोत

3

पायथन 2 , 69 बाइट्स

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

इसे ऑनलाइन आज़माएं!

— छड़ी
स्रोत

3

वोल्फ्राम भाषा (गणितज्ञ) , 39 बाइट्स

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

क्रेडिट घंटे की एक सूची लेता है, और फिर ग्रेड की एक स्ट्रिंग।

TIO पर काम नहीं करता है क्योंकि TIO गणितज्ञ कर्नेल का उपयोग करता है (जो मनमाने ढंग से सटीक संख्या को प्रिंट नहीं करना चाहता है)

— जंगहवान मिन
स्रोत

2

-3 बाइट्स यदि आप उपयोग करते हैंTr

3

यह दूसरे परीक्षण के मामले में विफल रहता है। यह 1.85 देता है क्योंकि आप F = -1 की गिनती करते हैं

— J42161217

2

यहाँ एक 41bytes fix है:N[(5-(LetterNumber@#2/. 6->5)).#/Tr@#,3]&

— J42161217

@ जेनी_मथी अच्छी पकड़। मुझे पता नहीं है कि मैं कैसे चूक गया ... अतिरिक्त कोष्ठक को नीचे ले जाकर गला दिया जा सकता है /., हालाँकि।

— जुन्गवान मिन

2

जावास्क्रिप्ट (ईएस 6), 72 बाइट्स

इनपुट प्रारूप: A1B3C2F3B4

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

परीक्षण के मामलों

कोड स्निपेट दिखाएं

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

स्निपेट का विस्तार करें

— Arnauld
स्रोत

किस बिंदु पर searchगोल्फर बन जाता है parseInt?

— नील

@ नील parseIntशायद कुछ और समर्थित ग्रेड के साथ गोल्फर बन जाएगा। एक समस्या एफ = 0 और डी = 1 के बीच की खाई है, हालांकि।

— अरनौलड

हुह, मैंने यह भी नहीं देखा था कि कोई ई ...

— नील

2

आर , 64 बाइट्स

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

इसे ऑनलाइन आज़माएं!

बग को ठीक करने के लिए user2390246 का धन्यवाद!

— ग्यूसेप
स्रोत

मुझे लगता है कि आपका मतलब हैLETTERS[-5]

— user2390246

@ user2390246 हां, बिल्कुल। वह मेरे लिए मूर्ख था।

— ग्यूसेप

2

जावा, 211 बाइट्स

इनपुट प्रारूप: 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*/
}

अन्य संस्करण

मेरे पेट खराब होने ने मुझे बताया कि एक अलग इनपुट प्रारूप (ABCF1324) का उपयोग करने से कोड कम हो जाएगा। ऐसा लगता है जैसे यह नहीं था। नीचे दिया गया संस्करण 234 बाइट्स लंबा है।

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

— PStigerID
स्रोत

नमस्ते और आपका स्वागत है! आपको पूर्ण कार्यक्रमों के साथ उत्तर देने की आवश्यकता नहीं है, इसलिए आप उस तरह के बहुत सारे बाइट्स को निकाल सकते हैं।

— निसा

2

जावा 1.8 , 287 249 बाइट्स

-38 बाइट्स ब्यूमप्टियस के लिए धन्यवाद

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

— DevelopingDeveloper
स्रोत

1

इसका उपयोग करके लंबाई कम करें? स्टेटिक फ्लोट एम (स्ट्रिंग एल) {रिटर्न एल.इन्सलल्स ("एफ")? 0 :( 'ई'-एल.कहरअट (0));}

— बुमपटियस क्यू बैंगविस्टल डे

1

जूलिया 0.6 , 46 43 42 बाइट्स

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

इसे ऑनलाइन आज़माएं!

व्याख्या

इनपुट प्रारूप: gग्रेड के वेक्टर; h: क्रेडिट घंटे के वेक्टर

g%h: रिडिफाइन %ऑपरेटर।
69-Int.(g): जी के प्रत्येक तत्व के 'F','D','C','B','A'लिए -1,1,2,3,4क्रमशः रूपांतरित करें ।
max.( ,0): क्लैंप रेंज से 0:4(तत्व-वार)।
बाकी सरल वेक्टर गणित है।
गोलाई में 9 बाइट का खर्च आता है।

— Lukes
स्रोत

संघर्षरत कॉलेज के छात्र का जीपीए कैलकुलेटर

जीपीए कैलकुलेटर

विवरण

इनपुट उदाहरण (जो भी आपके डिजाइन के लिए सबसे अच्छा काम करता है उसे चुनें)

उदाहरण

जैली , 15 21 बाइट्स (12 राउंड नहीं)

कैसे?

पायथन 3 , 66 बाइट्स

पर्ल 5 , 57 53 + 2 ( -an) = 59 55 बाइट्स

पायथन 2 , 69 बाइट्स

वोल्फ्राम भाषा (गणितज्ञ) , 39 बाइट्स

जावास्क्रिप्ट (ईएस 6), 72 बाइट्स

परीक्षण के मामलों

आर , 64 बाइट्स

जावा, 211 बाइट्स

golfed

Unglofed

अन्य संस्करण

golfed

Ungolfed

जावा 1.8 , 287 249 बाइट्स

golfed

Ungolfed

जूलिया 0.6 , 46 43 42 बाइट्स

पर्ल 5 , 57 53 + 2 ( `-an`) = 59 55 बाइट्स