अजीब ग्रेडिंग सिस्टम


14

वेर्डो निगमित कार्यालय में उपस्थित कर्मचारियों की संख्या के अनुसार उनके कर्मचारियों को ग्रेड देने का एक अजीब तरीका है:

  0 -  13 : F  
 14 - 170 : E
171 - 180 : D
181 - 294 : C
295 - 300 : B
301 - 365 : A

Note: The range is inclusive (i.e. 0-13 means 0 days and 13 days both will evaluate
as grade 'F').

उद्देश्य:

एक प्रोग्राम / फ़ंक्शन लिखें जो कर्मचारी द्वारा किसी कर्मचारी के ग्रेड को उस दिन की संख्या [0-365 की समावेशी सीमा के भीतर] आउटपुट / रिटर्न करता है।

नियम:

  • आप एक स्ट्रिंग या संख्या के रूप में इनपुट ले सकते हैं, लेकिन एक स्ट्रिंग / वर्णमाला के रूप में आउटपुट होना चाहिए (आप कम या ऊपरी केस चुन सकते हैं।)
  • मानक खामियां लागू होती हैं।
  • यह , इसलिए बाइट्स जीत में सबसे छोटा कार्यक्रम है!

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

12  => F
15  => E
301 => A
181 => C

स्कोरबोर्ड:





1
@ Mr.Xcoder मुझे याद है कि यह सैंडबॉक्स में चर्चा की गई थी कि यह इसका कोई कारण नहीं है क्योंकि इसमें समान-आकार की सीमाएं नहीं हैं और जैसे प्रत्यय +/ -
आउटगॉल्फ

1
क्या हमें स्कोरबोर्ड मिल सकता है?
जराटसेपेल

जवाबों:


4

जेली ,  18 17 15  14 बाइट्स

NịØAx“A©r½ɗÇ‘¤

एक मोनडिक लिंक एक नंबर ले रहा है और एक चरित्र वापस कर रहा है।

इसे ऑनलाइन आज़माएं! या सभी इनपुट-आउटपुट जोड़े देखें

कैसे?

NịØAx“A©r½ɗÇ‘¤ - Link: number, d
N              - negate d
             ¤ - nilad followed by link(s) as a nilad:
  ØA           -   uppercase alphabet yield = "ABCDEFGHIJKLMNOPQRSTUVWXYZ"
     “A©r½ɗÇ‘  -   code-page indices = [65,6,114,10,157,14]
    x          -   times = 'A'x65+'B'*6+'C'x114+'D'x10+'E'*157+'F'*14
 ị             - index into (1-indexed & modular - hence the negation to allow all Fs
                                                   to be together at one end)

12

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

n=>"ABCDEF"[(n<14)+(n<171)+(n<181)+(n<295)+(n<301)]

वैकल्पिक समाधान (लंबा):

५३ ५२ बाइट्स (-१ बाइट @ अरनौल को धन्यवाद)

n=>"FEDCBA"[n>300?5:n>294?4:n>180?3:n>170?2:+(n>13)]

55 53 बाइट्स (-2 बाइट्स @ @ नील के लिए धन्यवाद)

n=>"AFEDCB"[[14,171,181,295,301].findIndex(m=>n<m)+1]

55 बाइट्स

n=>"FEDCBA"[[13,170,180,294,300].filter(m=>n>m).length]

उदाहरण कोड स्निपेट:

f=
n=>"ABCDEF"[(n<14)+(n<171)+(n<181)+(n<295)+(n<301)]
console.log(f(12))
console.log(f(15))
console.log(f(301))
console.log(f(181))


1
यह है कि शर्तों के योग बात महान है !!! काश मैं एक बार फिर उत्थान कर पाता !!! : डी
आधिकारिक

मैं आपके एक वैकल्पिक समाधान पर दो बाइट्स बचा सकता हूं:n=>"AFEDCB"[[14,171,181,295,301].findIndex(m=>n<m)+1]
नील

-1 अपने पहले वैकल्पिक समाधान के लिए बाइट:n=>'FEDCBA'[n>300?5:n>294?4:n>180?3:n>170?2:+(n>13)]
अरनौल्ड

7

टीआई-बेसिक, 40 बाइट्स

sub("FEDCBA",sum(Ans≥{0,14,171,181,295,301}),1

6

जे , 31 बाइट्स

'FEDCBA'{~13 170 180 294 300&I.

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

व्याख्या

'FEDCBA'{~13 170 180 294 300&I.  Input: n
          13 170 180 294 300     Constant array [13, 170, 180, 294, 300]
                            &I.  Use it with interval index to find which of
                                 the intervals (-∞, 13], (13, 170], (170, 180],
                                 (180, 294], (294, 300], (300, ∞) n can be inserted at
        {~                       Index into
'FEDCBA'                         This string and return that char

पहली बार मैंने I.जंगल में डाईएडिक देखा है । साफ।
कोल

@ मुझे विश्वास है कि मैंने इसे कोड-गोल्फ में अतीत में दो बार इस्तेमाल किया है।
मील

6

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

-4 बाइट्स के लिए @jferard को धन्यवाद।

lambda n:chr(70-sum(n>ord(x)for x in"\rª´ĦĬ"))

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

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

lambda n:chr(70-sum(n>x for x in[13,170,180,294,300]))

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

2 बाइट्स @mathmandan की बदौलत, और परोक्ष रूप से @JonathanFrech को धन्यवाद।

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

lambda n:"ABCDEF"[sum(n<x for x in[14,171,181,295,301])]

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


1
54 बाइट्स lambda n:chr(70-sum(n>x for x in[13,170,180,294,300])):। (देखें @Jonathan Frech द्वारा codegolf.stackexchange.com/a/142244/36885 पर देखें )
मैथमैडान


माणिक पोर्ट: ->n{(70-"ĬĦ´ª\r".chars.count{|i|n>i.ord}).chr}समान आकार
असोन तुहिद

4

सी, 62 61 बाइट्स

एक बाइट को बचाने के लिए @ जोनाथन फ्रीच को धन्यवाद!

f(n){putchar(70-(n<14?0:n<171?1:n<181?2:n<295?3:n<301?4:5));}

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

सी, 57 बाइट्स

#define f(n)70-(n<14?0:n<171?1:n<181?2:n<295?3:n<301?4:5)

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

सी (जीसीसी), 54 बाइट्स

f(n){n=70-(n<14?0:n<171?1:n<181?2:n<295?3:n<301?4:5);}

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

सी (जीसीसी), 50 बाइट्स

@ हर्मन लॉस्टीन के समाधान का उपयोग करना ।

f(n){n=65+(n<14)+(n<171)+(n<181)+(n<295)+(n<301);}

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



अपने मुख्य समाधान के रूप में सबसे छोटा संस्करण क्यों नहीं प्रस्तुत करें?
झबरा

@ शागिर्दी जिनके लिए अपरिभाषित व्यवहार के लिए जीसीसी रिसोर्ट की आवश्यकता होती है, इसलिए मैं अच्छी तरह से परिभाषित लोगों को शीर्ष पर रखूंगा, और उन्हें सबसे पुराने से सबसे नए और एक ही समय में सबसे लंबे समय तक छांटने से मुझे ठीक लगता है।
15

3

कोटलीन , 56 बाइट्स

{v->'F'-listOf(13,170,180,294,300).filter{it<v}.count()}

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

सजा हुआ

{ v->
    // Count the grades passed, then subtract that from F
    'F' - listOf(13,170,180,294,300)
            .filter { it < v }
            .count()
}

परीक्षा

var x:(Int)->Char =
{v->'F'-listOf(13,170,180,294,300).filter{it<v}.count()}

fun main(args: Array<String>) {
    println(x(12))
    println(x(15))
    println(x(301))
    println(x(181))
}

+1। मैंने आपके उत्तर को एक अधिक औपचारिक प्रारूप में संपादित किया, आशा है कि आप बुरा नहीं मानेंगे।
आधिकारिक

बिल्कुल नहीं, मेरा मतलब सही हेडर को आउटपुट करने के लिए मेरे टूल को ठीक करना था
१ell:५२ पर १ell

3

जाप , 23 21 बाइट्स

'Gc-[#ªT#´D294L*3]è<U

कोशिश करो


Explantion

पूर्णांक का निहित इनपुट U

'Gc-

(एकल वर्ण) स्ट्रिंग के कोडपाइंट से घटाएँ G...

è<U

से कम तत्वों की गिनती U...

[#ªT#´D294L*3]

१ In० ( ), ० ( ), १ (० ( T), १३ ( D), २ ९ ४ (शाब्दिक) और ३०० ( L*3) के सरणी में , इसलिए प्रारूपित और अल्पविराम अल्पविराम के उपयोग से बचने का आदेश दिया। 0हटाया जा सकता है ( Fइसके बजाय कोडपॉइंट से घटाना ) लेकिन फिर एक अल्पविराम को जोड़ने की आवश्यकता होगी या C*F(12 * 15) के लिए इस्तेमाल किया जाएगा 180, अंततः कोई बाइट नहीं बचाएगी।


3

आर , 50 44 बाइट्स

LETTERS[6-sum(scan()>c(13,170,180,294,300))]

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

जावास्क्रिप्ट उत्तर के समान है, लेकिन एक छोटे से छोटे में आने के लिए R के वैश्वीकरण और LETTERS बिलिन का उपयोग करता है।

उन आखिरी 6 बाइट्स को शेविंग करने के लिए rturnbull को धन्यवाद ।



वास्तव में, 44 बाइट्स केवल एक फ़ंक्शन के बजाय इसे एक पूर्ण कार्यक्रम बनाते हैं।
rturnbull

@ आर्टर्नबुल आह, मैं कहने वाला था "नहीं, आपको इसे लपेटने की ज़रूरत है catया फिर एक ध्वज के रूप में उपयोग करें source(program,ec=T)और गिनें ec=T(आर कार्यक्रमों पर मेटा सर्वसम्मति के अनुसार), लेकिन दूसरे, नए मेटा सर्वसम्मति से हम किसी भी झंडे की गिनती नहीं करते हैं लंबे समय तक, इसलिए मैं एक पूरी तरह से वैध समाधान हूं।
Giuseppe


2

रिकर्सिवा , 49 30 बाइट्स

Y(++++<a301<a295<a181<a171<a14

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

मुझे अपनी भाषा में अपने प्रश्न का उत्तर देने की अनुमति दें। : डी

  • @Herman Lauenstein के अद्भुत JS उत्तर से तकनीक का उपयोग करके 19 बाइट्स को बचाया

स्पष्टीकरण:

Y(++++<a301<a295<a181<a171<a14
      <a301<a295<a181<a171<a14 calculate true/false for all the conditions
  ++++                         sum up all the conditions to obtain n which can be either 0,1,2,3,4 or 5
 (                             yield upper-case Alphabet
Y                              Get n-th element   


2

पाइके , 28 बाइट्स

G6<13T17*180T30*294]5FhQ>)s@

यहाँ यह कोशिश करो!

व्याख्या

G6<13T17*180T30*294]5FhQ>)s@ - Full program. T is the constant for 10.

G                            - The lowercase alphabet.
 6<                          - With the letters after the index 6 trimmed.
   13                        - The literal 13.
     T17*                    - The integer 170, composed by 17 * 10, to save whitespace.
         180                 - The literal 180.
            T30*             - The integer 300, composed by 30 * 10. 
                294          - The literal 294.
                   ]5        - Create a list of 5 elements.
                     FhQ>)   - For each element in the list.
                      h      - Increment.
                       Q     - The input.
                        >    - Is smaller ^^ than ^? Yields 1 for truthy and 0 for falsy.
                         )s  - Close loop and sum.
                           @ - Get the index in the alphabet substring explained above.


1

अजगर, 30 बाइट्स

@GtlfgTQmCdc"\r ª ´ & , m"d

तो इससे पहले कि आप कोड बिंदु 1 के साथ एक चरित्र डालने की आवश्यकता साइट, कोड बिंदु 1 के साथ चरित्र को दिखाने के लिए प्रतीत नहीं होता है &, ,और mअंत में

(सभी 1बिंदुओं को कोड बिंदु 1 के साथ बदलें ):

@GtlfgTQmCdc"\r ª ´ 1& 1, 1m"d

1

पायथ , 25  26  बाइट्स

@<G6sgRQ[13*17T180*30T294

सभी परीक्षण मामलों की जाँच करें।

व्याख्या

@<G6sgRQ[13*17T180*30T294 - Full program.

  G                       - The lowercase alphabet.
 < 6                      - With the letters after the index 6 trimmed. We will call "S".
        [                 - Initialise a list literal.
         13               - The literal 13.
           *17T           - The integer 170, composed by 17 * 10, so save whitespace.
               180        - The literal 180.
                      294 - The literal 294.
                  *30T    - The integer 300, composed by 30 * 10.
     gRQ                  - For each element, return 1 if is is ≥ the input. 0 otherwise.
    s                     - Sum.
@                         - Get the index into S of ^.
                          - Output implicitly.         

1

लाइ , 74 बाइट्स

n(14)L["F"o;]p(171)L["E"o;]p(181)L["D"o;]p(195)L["C"o;]p(301)L["B"o;]"A"o;

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

एक सरल अगर चेन दृष्टिकोण। मुझे संदेह है कि इसे बहुत कम किया जा सकता है।


क्या उन परोपकार की (...)आवश्यकता है? PS nvm, जाहिर है वे हैं।
आधिकारिक


1

जावा 8, 55 बाइट्स

n->n<14?'F':n<171?'E':n<181?'D':n<295?'C':n<301?'B':'A'

इसे यहाँ आज़माएँ।

वैकल्पिक 57 बाइट्स :

n->(char)(n<14?70:n<171?69:n<181?68:n<295?67:n<301?66:65)

इसे यहाँ आज़माएँ।

वैकल्पिक 60 बाइट्स :

n->"FEDCBA".charAt(n<14?0:n<171?1:n<181?2:n<295?3:n<301?4:5)

इसे यहाँ आज़माएँ।

हो सकता है n<14?0:n<171?1:n<181?2:n<295?3:n<301?4:5कि अंतिम दृष्टिकोण का उपयोग करने की तुलना में किसी तरह का सूत्र 0-5 रूप में प्राप्त किया जा सके । अभी भी इसकी जांच चल रही है।


1

पावरशेल , 59 बाइट्स

(,'F'*14+,'E'*157+,'D'*10+,'C'*114+,'B'*6+,'A'*65)["$args"]

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

जोनाथन एलेन के जेली उत्तर के समान, इसमें हम सभी अक्षरों की एक सरणी का निर्माण एक साथ कर रहे हैं, फिर इनपुट के साथ उस सरणी में अनुक्रमण कर रहे हैं $args


1

खरगोश ~ , 50 बाइट्स

(नॉनकोम्पेटिंग, प्रश्न पोस्टड। मैं सिर्फ दुभाषिया (याय) समाप्त कर कुछ हल करने की कोशिश करना चाहता था। यह मेरी पहली कोड गोल्फ चीज़ भी है)

=>FEDCBA$<({.0-\_-^\-&^?n&&}_}\>\{{\>:.¤})Ð"ỤṅỌrḲA

यह मूल रूप से एक ग्रेड से अगले 14,157,10,114,6,65 तक के अंतर को लेता है ỤṅỌrḲA ) और इनपुट से घटाता है। यदि कोई ऋणात्मक संख्या पाई जाती है तो वह 'FEDCBA' अनुक्रम के साथ आगे बढ़ना बंद कर देती है और पत्र को आउटपुट करती है।

सिंटैक्स के इस खूबसूरत टुकड़े की छोटी व्याख्या

खरगोश ~ एक ग्रिड आधारित मेमोरी का उपयोग करता है जिसके साथ आप एक या कई देखभाल कर सकते हैं; यह समाधान 2 का उपयोग करता है।

=>FEDCBA$<({.0-\_-^\-&^?n&&}_}\>\{{\>:.¤})Ð"ỤṅỌrḲA - Full program.

  FEDCBA                                           - Load bytes into grid
                                          Ð"ỤṅỌrḲA - Load bytes 14,157,10,114,6,65 into second line of data grid
=                                                  - Read input
 >       <      _ ^   ^     _  >   >               - Move caret (most instructions read from the grid below the active caret)
        $                                          - Create a new caret
          (                              )         - Loop
           {.0             } }   {{     }          - Conditional statement checking if value at caret == 0 then move active caret to next grade else print and quit
              -  -  -                              - Subtract 
               \   \          \ \                  - Cycle active caret
                     &   &&                        - Bitwise and to see if number is negative
                       ?n                          - Get negative sign bit
                                    :.             - Print value at caret as character
                                      ¤            - Terminate program

अच्छा लगा। क्या ऑनलाइन इसे आज़माने का कोई तरीका है?
आधिकारिक

फिलहाल नहीं ^ ^
एडम

1

एक्सेल, 53 बाइट्स

शर्तों का योग, फिर आवश्यक ASCII वर्ण लौटाता है:

=CHAR((A1<14)+(A1<171)+(A1<181)+(A1<295)+(A1<301)+65)

वैकल्पिक समाधान:

सुमिंग की स्थिति, वापसी स्ट्रिंग सूचकांक (63 बाइट्स):

=MID("ABCDEF",(A1<14)+(A1<171)+(A1<181)+(A1<295)+(A1<301)+1,1)


1

जोटलिन , 48 41 बाइट्स

{v->'F'-l(13,170,180,294,300).f{a<v}.l()}

पूरा कार्यक्रम:

var x:(Int)->Char =
{v->'F'-l(13,170,180,294,300).f{a<v}.l()}

println(x(12))
println(x(15))
println(x(301))
println(x(181))

मेरे पिछले कोटलिन उत्तर को यहाँ पोर्ट किया ।


1

वी , 37 34 बाइट्स

aFEDCBA5äh113äh9äh156äh13ähÀ|vyVp

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

Hexdump:

00000000: 3133 4146 1b31 3536 4145 1b39 4144 1b31  13AF.156AE.9AD.1
00000010: 3133 4143 1b35 4142 1b36 3441 411b eec0  13AC.5AB.64AA...
00000020: 7c76 7956 70                             |vyVp

मूल विचार:

  • प्रिंट FEDCBA, बी के 5 प्रतियां, सी आदि की 113 प्रतियां स्ट्रिंग में जिसके परिणामस्वरूप बनानेFFFFFFFFFFFFFEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEDDDDDDDDDCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCBBBBBA (ऐसा करने के लिए संभवतः एक अधिक कुशल तरीका है)
  • nवें कॉलम पर जाएँ ( nपहला तर्क है), किसी एक वर्ण की प्रतिलिपि बनाएँ और पूरे स्ट्रिंग को इसके साथ बदलें।


1

पर्ल 6, 42 39 बाइट्स

{chr(65+[+] "\rª´ĦĬ".ords »>»$_)}


हमारी साइट का प्रयोग करके, आप स्वीकार करते हैं कि आपने हमारी Cookie Policy और निजता नीति को पढ़ और समझा लिया है।
Licensed under cc by-sa 3.0 with attribution required.