ग्रेड में पूर्णांक चिह्न

30

एक सकारात्मक पूर्णांक (0 और ऊपर, अधिकतम नहीं) को देखते हुए, इन नियमों का पालन करते हुए इसे एक ग्रेड में परिवर्तित करें:

A = 100+  
B = 90 - 99  
C = 80 - 89  
D = 70 - 79  
E = 60 - 69  
F = 59 and less.

यह थोड़ा उबाऊ लगा, इसलिए ग्रेड को +अगर यह 7,8 या 9 है और -यदि यह 0,1 या 2. है, तो एफ और ए मामलों के लिए इसे अनदेखा करें।

एक उदाहरण:

इनपुट:

65

आउटपुट:

E

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

0  -> F
20 -> F
65 -> E
72 -> D-
75 -> D
80 -> C-
99 -> B+
102 -> A
864 -> A

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

यह कोड गोल्फ है, इसलिए सबसे छोटा कोड जीतता है। यह एक उबंटू प्रश्न से प्रेरित था, संख्यात्मक श्रेणियों को पत्र ग्रेड आवंटित करने के लिए शेल स्क्रिप्ट कैसे लिखें? । जवाब बैश और अजगर में हैं, इसलिए थोड़ा बिगाड़ते हैं।

लीडरबोर्ड:

यहां एक नियमित लीडरबोर्ड और भाषा के अनुसार विजेताओं का अवलोकन करने के लिए एक स्टैक स्निपेट है।

यह सुनिश्चित करने के लिए कि आपका उत्तर दिख रहा है, कृपया अपना उत्तर शीर्षक मार्कडाउन टेम्पलेट का उपयोग करके शीर्षक के साथ शुरू करें:

# Language Name, N bytes

Nआपके सबमिशन का आकार कहां है। यदि आप अपने स्कोर में सुधार करते हैं, तो आप पुराने अंकों को हेडलाइन में रख सकते हैं , उनके माध्यम से स्ट्राइक करके। उदाहरण के लिए:

# Ruby, <s>104</s> <s>101</s> 96 bytes

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

code-golf 
— टिम
स्रोत
1
वहाँ एक नहीं होगा A+और A-? मैं नहीं देखता कि हम उनकी उपेक्षा क्यों कर रहे हैं।
— ASCIIThenANSI
1
@ASCIIThenANSI अपवादों को अधिक दिलचस्प बनाता है, और ए के लिए कोई अधिकतम नहीं है, इसलिए नहीं+
— टिम
1
उस वर्गीकरण बोर्ड में एक बग है: मछली संस्करण पुराना है और मेरा उत्तर इसके पहले है।
— इस्माइल मिगुएल
@IsmaelMiguel यह तब लिखा गया था जब शुरुआती पोस्ट अभी तक डिफ़ॉल्ट टाई ब्रेकर नहीं थी (इसलिए यह संबंधों को आदेश नहीं देती है)। मैं इसे कुछ बिंदु पर ठीक करने की कोशिश करूँगा (शायद इस चुनौती के लिए नहीं, लेकिन कम से कम स्रोत पर मेटा)।
— मार्टिन एंडर
@ मार्टिनबटनर मैं इसे इंगित कर रहा था।
— इस्माइल मिगुएल

जवाबों:

21

पायथन 2, 72 70 62 बाइट्स

lambda n:"FA"[n>59:1+n/100]or chr(75-n/10)+"+-"[(n+3)%10/3::2]

यह एक अनाम फ़ंक्शन है जो एक इंट लेता है और एक स्ट्रिंग के रूप में ग्रेड लौटाता है।

(सुझावों के लिए @ MartinBüttner, @grc और @TheNumberOne का धन्यवाद)

— Sp3000
स्रोत
4
"EDCB"[n/10-6]->chr(75-n/10)
— grc
एक चरित्र का चयन करने के लिए एक चतुर तरीका जो खाली हो सकता है!
— xnor
11

CJam, 34 33 32 बाइट्स

riAmd)4/"- +"=S-\Ae<5e>_~'L+o5%<

ठीक है, मैंने अब कई दृष्टिकोण आजमाए हैं और इसे 33 से नीचे लाने में असमर्थ हूं, इसलिए यहां स्पष्टीकरण दिया गया है:

ri                                 e# Read the input and convert to integer
  Amd                              e# Take divmod of the input with 10. This leaves the
                                   e# number/10 and number%10 on stack
     )4/                           e# Increment the mod by 1 and integer divide by 4.
        "- +"=S-                   e# This converts 0,1,2 to 0 and 7,8,9 to 2. Pick - or +
                                   e# respectively and remove space in case of 3,4,5 and 6
                \Ae<5e>            e# To the divisor by 10 scope it to range of [5,10]
                       _~          e# Take a copy and do number * -1 - 1
                         'L+       e# Add it to char L. This gets us the required grade
                            o      e# Output the grade. This removes it from stack
                             5%    e# We now have scoped divisor on stack. Do mod with 5
                               <   e# Both 5 and 10 will return 0, in which case, we don't
                                   e# want the + or -. So we do a substr(0, 0).
                                   e# 5 represents F and 10, A. For others, it will do
                                   e# substr(0,X) where X > 0. Since the string is only
                                   e# 1 char long, it doesn't affect at all.

अद्यतन : 1 बाइट डेनिस द्वारा एक सूचक के लिए धन्यवाद बचाया

इसे यहाँ ऑनलाइन आज़माएँ

— अनुकूलक
स्रोत
क्या करता sहै?
— डेनिस
@ डेनिस आखिरी के लिए स्ट्रिंग + / - / स्पेस को स्ट्रिंग में बदल देता है<
— ऑप्टिमाइज़र
यह आवश्यक नहीं होना चाहिए। Character String -एक तार को धकेलता है।
— डेनिस
@ डेनिस आह, आप सही कह रहे हैं। मुझे लगता है कि कुछ पिछले संस्करण के लिए, उपयोग अलग था।
— ऑप्टिमाइज़र
8

रेटिना, 43 + 15 = 58 बाइट्स

...+
A
.[012]
$&-
.[789]
$&+
^9.
B
^8.
C
^7.
D
6.
E
\d.*
F

रेटिना मार्टिन बुर्टनर द्वारा बनाई गई एक रेगेक्स भाषा है, जहां विषम संख्या वाली फाइलें मेल खाने वाली रेक्स हैं, और सम-संख्या वाली फाइलें हैं जो इसे बदलने के लिए हैं। प्रत्येक पंक्ति एक अलग फ़ाइल है, इसलिए मैंने प्रत्येक अतिरिक्त फ़ाइल के लिए 15 बाइट्स जोड़े हैं।

व्याख्या

यह 3 या अधिक अंकों के साथ कुछ भी बनाने से शुरू होता है। ए यह जोड़ता है -यदि यह 0, 1, या 2 के साथ समाप्त होने वाला दो अंकों की संख्या है, और +यदि यह 7, 8 या 9 के साथ समाप्त होता है, तो संख्याओं को मैप किया जाता है। उनकी ग्रेड (उदाहरण के लिए 9 से शुरू होने वाली संख्या को बी दिया जाता है)। कोई भी संख्या शेष है, स्वचालित रूप से एक एफ है। दुर्भाग्य से, ;`मध्यवर्ती उत्पादन को दबाने के लिए सभी को अंतिम रेगेक्स के लिए तैयार किया जाना चाहिए। अपडेट: संस्करण 0.5.0 में डिफ़ॉल्ट रूप से इंटरमीडिएट आउटपुट है, जिससे मुझे कुछ बाइट्स बचाने की अनुमति मिलती है।

— NinjaBearMonkey
स्रोत
क्या आप सुनिश्चित हैं कि यह F केस के लिए + और - आउटपुट नहीं देता है?
— टिम
1
@ यह नहीं होना चाहिए, क्योंकि \d.*मैच और पूरे स्ट्रिंग की जगह +शामिल है।
— निन्जाबियरमॉन्की
आह ठीक है - अब मैं देख सकता हूँ! :)
— टिम
8

सी, 99 बाइट्स

मैं यहाँ नया हूँ, मुझे आशा है कि मैं नियमों का पालन कर रहा हूँ।

char b[3];char*f(n){b[1]=0;n<60?*b=70:n>99?*b=65:(*b=75-n/10,b[1]=n%10<3?45:n%10>6?43:0);return b;}

यह फ़ंक्शन चिह्न को एक पैरामीटर के रूप में लेता है और ग्रेड को एक पूर्ण-समाप्त स्ट्रिंग के रूप में वापस करता है।

व्याख्या

जोड़ा गया व्हाट्सएप:

char b[3];

char *f(n) {
    b[1] = 0;
    n<60 ? *b = 70 :
    n>99 ? *b = 65 :
    (
        *b = 75 - n / 10,
        b[1] = n % 10 < 3 ? 45 : n % 10 > 6 ? 43 : 0
    );

    return b;
}

वैश्विक चर स्वचालित रूप से शून्य से आरंभिक होते हैं, इसलिए b को NULL से भरा जाता है। चूंकि केवल पहले दो वर्णों को कभी भी छुआ जाता है, इसलिए हमें केवल B [1] में NULL डालने की चिंता करनी होगी यदि ग्रेड में केवल एक ही वर्ण है। इस NULL को फंक्शन की शुरुआत में डाला जाता है। N पैरामीटर स्पष्ट रूप से int है। यदि ग्रेड 60 से कम है, तो यह 'एफ' पर सेट है, यदि यह 99 से बड़ा है तो यह 'ए' पर सेट है। अन्य मामलों में, बेस ग्रेड द्वारा दिया जाता है 'E' - (n - 60) / 10, जो सरल करता है 75 - n / 10। n % 10निशान की इकाइयों अंक प्राप्त करता है। यदि यह 3 से कम है, तो a - को जोड़ दिया जाता है, यदि यह 6 से बड़ा है a + को जोड़ दिया जाता है, अन्यथा b [1] को शून्य कर दिया जाता है (जो कि यह पहले से था)।

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

#include <stdio.h>

char b[3];char*f(n){b[1]=0;n<60?*b=70:n>99?*b=65:(*b=75-n/10,b[1]=n%10<3?45:n%10>6?43:0);return b;}

int main() {
    printf("  0 -> %s\n", f(0));
    printf(" 20 -> %s\n", f(20));
    printf(" 65 -> %s\n", f(65));
    printf(" 72 -> %s\n", f(72));
    printf(" 75 -> %s\n", f(75));
    printf(" 80 -> %s\n", f(80));
    printf(" 99 -> %s\n", f(99));
    printf("102 -> %s\n", f(102));
    printf("864 -> %s\n", f(864));

    return 0;
}

Output:
  0 -> F
 20 -> F
 65 -> E
 72 -> D-
 75 -> D
 80 -> C-
 99 -> B+
102 -> A
864 -> A
— एंड्रिया बियोन्डो
स्रोत
परफेक्ट :) कुछ भी गलत नहीं है।
— टिम
उर कोड और मेरा के बीच अंतर एक शब्द "प्रिंटफ" है जिसे अनदेखा करने पर 3 से अधिक बाइट बचाना चाहिए :)
— अब्राहम
7

पायथ, 33 बाइट्स

+C-75K@S[/QTT5)1<-@"- +"/heQ4d%K5

इसे ऑनलाइन आज़माएँ: प्रदर्शन या टेस्ट सूट

स्पष्टीकरण:

                                     implicit: Q = input
        [/QTT5)                      create the list [Q/10, 10, 5]
       S                             sort
      @        1                     take the element in the middle
     K                               store in K (this results in a number between 5 and 10)
  -75K                               75 - K
 C                                   char with ASCII-value ...
                  @"- +"/heQ4        "- +"[(Q%10 + 1) / 4]
                 -           d       remove spaces
                <             %K5    slice [:K%5]
+                                    add these two chars and print
— Jakube
स्रोत
7

> <> (मछली), 78 71 बाइट्स

iii0)?/:0({:'6'(@@+?/'{'01.
;$-o:'4'(?\'7'(?;'+'o
 ;o'A'\   \'-'o;o'F'\

तरीका:

  • हम x,y,zइनपुट से पहले 3 वर्णों के कोडपॉइंट पढ़ते हैं । यदि कोई वर्ण अपने चर के मान को प्रस्तुत नहीं करता है, तो वह -1निहित होगा । ( ord(c)चरित्र के कोड बिंदु को चिह्नित करेगा c)
  • यदि z > 0(3 अंक इनपुट) प्रिंट Aऔर बाहर निकलें।
  • यदि x < ord('6') or y < 0(इनपुट <60) प्रिंट Fऔर बाहर निकलें।
  • कोडपॉइंट के साथ वर्ण प्रिंट करें 123 - x।
  • अगर- y < ord('4') print`और बाहर निकलें।
  • यदि y > ord('6') print+ `और बाहर निकलें।
  • बाहर जाएं।
— randomra
स्रोत
7

सी, ६ ६५

हैरानी की बात है, यह अजगर समाधान के काफी करीब है।

f(i){printf(i<60?"F":i>99?"A":"%c%s",75-i/10,"-\0+"+(i%10+1)/4);}

लेकिन इस कार्यक्रम के लिए, इतनी बड़ी कमी के लिए, बलिदान करना पड़ा:

  • यदि एक Fया एक Aमुद्रित किया जाता है तो पास किए printfगए अन्य तर्कों को भी नहीं देखता है। यह काफी नॉटी हैक है।

  • यदि (i%10+1)/4मूल्यांकन करने के लिए 1(कोई +या -ग्रेड के साथ जोड़ दिया जाना चाहिए), %sफ़ॉर्मेटर एक करने के लिए एक सूचक प्राप्त करता है \0तो कुछ भी नहीं छपा है, बाइट। यह भी काफी हास्यास्पद है, क्योंकि मुझे नहीं पता था कि आप एक अनुक्रमित स्ट्रिंग शाब्दिक का पता ले सकते हैं। (उदाहरण &"string"[i]) ( संपादित करें : "string"+iऔर भी छोटा है ! धन्यवाद @ कुटकी)

यहां 57 से 102 की संख्या के लिए कार्यक्रम का आउटपुट। मैंने इसे एक हेक्सडंप बनाया है, इसलिए हम सुनिश्चित कर सकते हैं कि कोई अजीब \0बाइट नहीं छपी है।

% seq 44 115 | xargs -n1 ./grade | xxd
0000000: 4646 4646 4646 4646 4646 4646 4646 4646  FFFFFFFFFFFFFFFF
0000010: 452d 452d 452d 4545 4545 452b 452b 452b  E-E-E-EEEEE+E+E+
0000020: 442d 442d 442d 4444 4444 442b 442b 442b  D-D-D-DDDDD+D+D+
0000030: 432d 432d 432d 4343 4343 432b 432b 432b  C-C-C-CCCCC+C+C+
0000040: 422d 422d 422d 4242 4242 422b 422b 422b  B-B-B-BBBBB+B+B+
0000050: 4141 4141 4141 4141 4141 4141 4141 4141  AAAAAAAAAAAAAAAA

mainउपयोग की गई विधि:

main(c,v)char**v;{f(atoi(v[1]));}
— MarcDefiant
स्रोत
1
&"string"[i]यह अनावश्यक है क्योंकि यह "string"+i2 बाइट्स बचा सकता है।
— नटकी
मुझे इसका उद्देश्य और सुधार करना चाहिए :) बधाई हो, यू ने सभी C रिकॉर्ड को
— हरा दिया
6

CJam, 41 39 37 34 बाइट्स

यह बहुत लंबा रास्ता है, लेकिन मुझे नहीं लगता कि मैं इसे अभी के लिए आगे बढ़ाऊंगा।

qiAmd'K@Ae<5e>:X-X5%g@)4/"- +"=*S-

इसका परीक्षण यहां करें। या यहां सभी परीक्षण मामलों को चलाएं।

ऑप्टिमाइज़र द्वारा सहेजे गए तीन बाइट्स।

व्याख्या

(थोड़ा पुराना)

qi                                    e# Read input and convert to integer.
  'K1$                                e# Push the character K, then copy the input.
      A/                              e# Divide by 10.
        Ae<5e>                        e# Clamp the result to the range 5..10.";
              -                       e# Subtract from K to get the grade.
               _'Am                   e# Duplicate get difference to A.
                   5%g                e# Check that its neither 0 (A) nor 5 (F).
                      @               e# Pull up the other copy of the input.
                       A%)4/          e# ((i % 10) + 1) / 4
                            "- +"=    e# Use that to select -, space, or +.
                                  *   e# Multiply it with the earlier boolean so that
                                      e# it vanishes for A and F.
                                   S- e# Remove the space if there is one.
— मार्टिन एंडर
स्रोत
4

आर, 107 105 99 बाइट्स

बहुत अच्छा प्रयास नहीं, मैं डरता हूं, लेकिन मैं कोशिश करूंगा और इसे बाद में गोल्फ दूंगा।

cat(LETTERS[11-(r=min(max(scan(),59),100))%/%10],if(r>59&r<100)c('-','','+')[(r%%10+1)/4+1],sep='')

संपादित करेंif एस के एक जोड़े को गिरा दिया । मामले और 100 के लिए कोई गलत परिणाम फिक्स्ड अब से छुटकारा पाने के ifelseरों । ifelseएस से छुटकारा मिल गया ।

— MickyT
स्रोत
मुझे लगता है कि आप के LETTERSबजाय चाहते हैं letters।
— एलेक्स ए
3

पर्ल, 66 62 बाइट्स

यह शायद अधिक गोल्फ हो सकता है। इसके अलावा एक अलग तरीका बेहतर हो सकता है।

$_=$_>99?A:$_<60?F:s/\d$/$&>6?"+":$&<3?"-":""/re;y/9876/BCDE/

के लिए +1 -p

साथ दौड़ो:

echo 72 | perl -pE'$_=$_>99?A:$_<60?F:s/\d$/$&>6?"+":$&<3?"-":""/re;y/9876/BCDE/'
— hmatt1
स्रोत
क्यों नहीं उपयोग -pऔर ड्रॉप say?
— ThisSuitIsBlackNot
@ThisSuitIsBlackNot धन्यवाद! अपडेट किया गया
— hmatt1
2

जावास्क्रिप्ट (ES6), 78 79 बाइट्स

यह वास्तव में सबसे अच्छा विकल्प नहीं है, लेकिन मैंने वह किया जो मैं कर सकता था।

F=n=>'FEDCBA'[n[2]?5:n<60?0:n[0]-5]+(n[2]||n<60?'':'-+\n'[n[1]<3?0:n[1]>6?1:2])

बस एक स्ट्रिंग के रूप में ग्रेड पास करें , और यह ग्रेड पत्र को वापस कर देगा।

बहुत में स्ट्रिंग भाग महत्वपूर्ण ।

आप यहां एक टेस्टकेस देख सकते हैं:

console._RELAY_TO_DOC=true;

//non-es6 version:

function F(n){return 'FEDCBA'[n[2]?5:n<60?0:n[0]-5]+(n[2]||n<60?'':'-+\n'[n[1]<3?0:n[1]>6?1:2])}



var testcases=[0,20,65,72,75,77,80,90,99,100,102,180,1000],
    results={};

for(var i in testcases)
{
  results[testcases[i]]=F(testcases[i]+'');
}

console.log(results);
<script src="http://ismael-miguel.github.io/console-log-to-document/files/console.log.min.js"></script>
स्निपेट का विस्तार करें

यदि अक्षर के बाद की अनुमति नहीं है, तो मैं ख़ुशी से इसे हटा दूंगा। यह नहीं था! इससे मेरा कोड 1 बाइट बढ़ गया, लेकिन कुछ भी (गंभीर) नहीं।

— इस्माइल मिगुएल
स्रोत
1
@ यह तय किया। मुझे उम्मीद है कि यह पर्याप्त है। अपने आप को उद्धृत करते हुए: " One newline after output is fine, but keep it consistent."। मुझे लगता है कि यह लगातार पर्याप्त है।
— इस्माइल मिगुएल
2

सी #, 143 127 112 88 बाइट्स

string g(int n){return n>=100?"A":n<=59?"F":(char)(75-n/10)+(n%10>6?"+":n%10<3?"-":"");}

मैंने ASCII नंबर मॉड्स करके चालाक बनने की कोशिश की, लेकिन ऐसा लगता है कि मैं अकेला नहीं था!

इफ के बजाय सूचियों पर सलाह के लिए टिम का धन्यवाद।

डार्सीटॉमास को धन्यवाद देने के लिए कि मैं नेस्टेड टर्नरी ऑपरेटरों का उपयोग कर सकता हूं।

— हस्तांतरण
स्रोत
1
क्या आप सूचियों का उपयोग करके आईएफ पर कटौती नहीं कर सकते हैं?
— टिम
मुझे यकीन नहीं है कि सूचियों का उपयोग करने से आपका क्या मतलब है, क्या आप थोड़ा समझा सकते हैं?
— ट्रांसमिशन
अजगर में मैं यह कर सकता हूँ [item1,item2][condition]:। यदि स्थिति सही है तो यह दूसरा आइटम देता है, यदि पहला गलत है।
— टिम
अच्छा विचार! उसको जोड़ा।
— संचरण
मुझे लगता है कि आप बयानों का उपयोग कर सकते हैं यदि उदाहरण के लिए, return <condition> ? <true result> : <false result>ध्यान दें कि आप उन्हें घोंसला भी दे सकते हैंreturn <condition> ? <true result> : <condition> ? <2nd true result> : < 2nd false result>
— डार्सी टॉमस
1

हास्केल, 78 बाइट्स

पहली पंक्ति बेकार लगती है, जिसकी लागत 14 बाइट होती है, लेकिन मुझे इसके बिना एक छोटा संस्करण नहीं मिल सकता है।

(#)=replicate
a="A":a
f=(!!)$60#"F"++[g:s|g<-"EDCB",s<-3#"-"++4#""++3#"+"]++a

व्याख्या

ऑपरेटर #अपने दूसरे तर्क की एन प्रतियां बनाने के लिए एक आशुलिपि है। सूची aस्ट्रिंग्स "ए" की एक अनंत सूची है। fN = 0,1 के लिए सभी ग्रेड की सूची में फ़ंक्शन इंडेक्स, ... सूची की समझ इस सूची के "मध्य भाग" (ग्रेड ई से बी) का निर्माण करती है; gएक एकल चार है sजो स्ट्रिंग के लिए पूर्व निर्धारित है (जो खाली हो सकता है)।

प्रयोग

ghci> map f [0,20,65,72,75,80,99,102,864]
["F","F","E","D-","D","C-","B+","A","A"]
— user40671
स्रोत
1

सी, 102 बाइट्स

int f(int h){int b,c;printf("%c%c",b?65:!c?70:75-h/10,!(b=h>99)*(c=h>59)*(((h%10<3)*45+(h%10>6)*43)));

}

प्रयोग

#include <stdio.h>
int f(int );
int main(){
    int c;
    scanf("%d",&c);
    f(c);
}
— Abr001am
स्रोत
आप + और - भाग को याद कर रहे हैं।
— ऑप्टिमाइज़र
आह ठीक है .... याद है कि
— Abr001am
बहुत लंबा :( ....
— अब्राहम
1

डीसी, ५२

[Anq]sa[Fnq]sf[q]sn16o?A~rd9<ad6>f20r-n1+4/d1=n45r-P

उत्पादन

$ for i in {0,20,65,72,75,80,99,102,864}; do printf "{%s -> %s} " $i $(dc -e '[Anq]sa[Fnq]sf[q]sn16o?A~rd9<ad6>f20r-n1+4/d1=n45r-P' <<< $i); done
{0 -> F} {20 -> F} {65 -> E} {72 -> D-} {75 -> D} {80 -> C-} {99 -> B+} {102 -> A} {864 -> A} $ 
$
— डिजिटल आघात
स्रोत
1

टीआई-बेसिक, 79 74 76 बाइट्स

Input N
If N>99
105->N
sub("FFFFFFEDCBA",1+int(N.1),1
If Ans!="F
Ans+sub("---    +++",1+fPart(N.1),1
Ans
— Timtech
स्रोत
10 से कम संख्या के लिए काम नहीं करता है
— 20
अच्छा कैच, टॉम, यह गायब था1+
— टिमटेक
यह भी (अदृश्य) अनुगामी रिक्त स्थान है जब भी कोई + या - नहीं होता है।
— lirtosiast
1

टीआई-बेसिक, 69 68 66 बाइट्स

.1Ans
sub("F?E-E+D-D+C-C+B-B+A",1+2max(0,min(9,int(2Ans)-11)),int(e^(Ans<10 and Ans≥6 and iPart(2.2-5fPart(Ans

TI-BASIC स्ट्रिंग हेरफेर के लिए अच्छा नहीं है।

कैलकुलेटर होमस्क्रीन पर इनपुट [संख्या] के रूप में: [कार्यक्रम का नाम]।

प्रारूपित:

.1Ans
sub(                      //Syntax for the substring command is sub(string, index, length)

    "F?E-E+D-D+C-C+B-B+A"                  //String that encodes possible grades

    ,1+2max(0,min(9,            ))         //Starts at "F" if input <60, "A" if >=100
                   int(2Ans)-11           //(Input-55)/5, so starts at "E" from 60 to 64,
                                          //second E from 65-69, D from 70 to 74, &c.

    ,int(e^(                                   //length 1 if false, 2 (includes +/-) if true
            Ans<10 and Ans≥6 and               //grade between 60 and 100        
                                 iPart(               //1 if abs. val. of below >= 0.2
                                       2.2-5fPart(Ans  //2.2-.5(last digit)

यह शायद आगे गोल्फ हो सकता है।

— lirtosiast
स्रोत
0

सी #, 82 बाइट्स

Func<int,string>g=s=>s>99?"A":s<60?"F":(char)(75-s/10)+(s%10<3?"-":s%10>6?"+":"");

यहाँ कुछ परीक्षण मामलों के साथ एक बेला है ।

— Blorgbeard
स्रोत
0

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

वास्तव में खाने वाले पात्र क्या हैं String.fromCharCodeऔर +/- स्थिति ... मुझे दृढ़ता से संदेह है कि उनमें से कम से कम एक को छोटा करने का एक चतुर तरीका है।

f=n=>n>99?'A':n<60?'F':String.fromCharCode(75.9-n/10|0)+(n%10<3?'-':n%10>6?'+':'');
— vvye
स्रोत
If you want short code, String.fromCharCode is almost always useless. Use string indexing (see the other javascript answers)
— edc65
Anyway, ~~(.1*-n+75.9) --> 75.9-n/10|0
— edc65
@edc65 Thanks for the golfing advice! I'll keep string indexing in mind for the next occasion.
— vvye
0

Ruby, 58 Bytes

Couldn't believe that there are no Ruby ones here. On reflection it's fairly similar to some that are here already but anyway:

->x{x<60?'F':x>99?'A':(75-x/10).chr+'+-'[(x+3)%10/3].to_s}

Try it here

— RichieAHB
स्रोत
0

Excel, 100 bytes

=IF(A1<60,"F",IF(A1>99,"A",MID("EDCB",INT(A1/10)-5,1)&IF(MOD(A1,10)<3,"-",IF(MOD(A1,10)>6,"+",""))))
— Wernisch
स्रोत
हमारी साइट का प्रयोग करके, आप स्वीकार करते हैं कि आपने हमारी Cookie Policy और निजता नीति को पढ़ और समझा लिया है।
Licensed under cc by-sa 3.0 with attribution required.