이상한 등급 시스템

14

Weirdo Incorporates는 직원들이 사무실에 있었던 일 수만큼 등급을 매기는 이상한 방법을 가지고 있습니다.

  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 범위 이내) 동안 직원의 등급을 출력 / 반환하는 프로그램 / 기능을 작성하십시오.

규칙 :

  • 문자열 또는 숫자로 입력 할 수 있지만 문자열 / 알파벳으로 출력해야합니다 (소문자 또는 대문자를 선택할 수 있음).
  • 표준 허점이 적용됩니다.
  • 이것은 code-golf 이므로 바이트 단위의 가장 짧은 프로그램이 승리합니다!

테스트 사례 :

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

스코어 보드 :

코드 스 니펫 표시

code-golf  number  decision-problem  classification 
— 공무원
소스
— officialaimm
1
— Mr. Xcoder
4
— H.PWiz
1
@ Mr.Xcoder 필자는 샌드 박스에서 동일한 크기의 범위를 가지고 있지 않고 +/ 와 같은 접미사를 가지고 있기 때문에 그 속임수가 아니라는 것을 기억합니다 -.
— Outgolfer Erik
1
스코어 보드를 얻을 수 있습니까?
— jrtapsell

답변:

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

자바 스크립트 (ES6), 51 바이트

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

대체 솔루션 (더 이상) :

53 52 바이트 (@Arnauld 덕분에 1 바이트)

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

55 53 바이트 (@Neil 덕분에 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))
스 니펫 확장

— 허먼 L
소스
1
그 조건을 요약하는 것은 훌륭합니다 !!! 다시 한번 공감할 수 있으면 좋겠다 !!! : D
— officialaimm
대체 솔루션 중 하나에 2 바이트를 절약 할 수 있습니다.n=>"AFEDCB"[[14,171,181,295,301].findIndex(m=>n<m)+1]
— Neil
첫 번째 대체 솔루션의 경우 -1 바이트 :n=>'FEDCBA'[n>300?5:n>294?4:n>180?3:n>170?2:+(n>13)]
— Arnauld
7

TI 기본, 40 바이트

sub("FEDCBA",sum(Ans≥{0,14,171,181,295,301}),1
— 팀텍
소스
6

J , 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.에는 야생에서 이색적인 모습을 보았습니다 . 산뜻한.
— cole
@cole 나는 코드 골프에서 과거에 두 번 사용했다고 생각합니다.
— 마일
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]))

온라인으로 사용해보십시오!

@mathmandan 덕분에 2 바이트를 절약했으며 @JonathanFrech 덕분에 간접적으로 감사했습니다.

파이썬 2 , 56 바이트

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

온라인으로 사용해보십시오!

— 미스터 Xcoder
소스
1
54 바이트 : lambda n:chr(70-sum(n>x for x in[13,170,180,294,300])). ( @gonathan Frech의 답변 참조 : codegolf.stackexchange.com/a/142244/36885 )
— mathmandan
1
— jferard
루비 포트 : ->n{(70-"ĬĦ´ª\r".chars.count{|i|n>i.ord}).chr}같은 크기
— Asone Tuhid
4

C, 62 61 바이트

바이트를 저장해 준 @Jonathan Frech에게 감사합니다!

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

온라인으로 사용해보십시오!

C, 57 바이트

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

온라인으로 사용해보십시오!

C (gcc), 54 바이트

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

온라인으로 사용해보십시오!

C (gcc), 50 바이트

사용 @Herman Lauenstein의 솔루션을 .

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

온라인으로 사용해보십시오!

— 스테디 박스
소스
— Jonathan Frech
가장 짧은 버전을 기본 솔루션으로 제출하지 않으시겠습니까?
— 얽히고 설킨
@Shaggy gcc가 정의되지 않은 동작에 의존 해야하는 사람들은 잘 정의 된 것을 맨 위에 유지하고 가장 오래된 것부터 가장 최신 것까지 동시에 정렬하는 것이 좋습니다.
— Steadybox
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))
}
— jrtapsell
소스
+1. 더 공식적인 형식으로 답변을 편집했습니다. 걱정하지 않기를 바랍니다.
— officialaimm
전혀, 나는 올바른 헤더를 출력하기 위해 도구를
— 고치려고했다
3

JAPT , 23 21 바이트

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

시도 해봐

외식

정수의 묵시적 입력 U.

'Gc-

(단일 문자) 문자열의 코드 포인트에서 빼기 G...

è<U

보다 적은 요소의 수 U...

[#ªT#´D294L*3]

170 ( #ª), 0 ( T), 180 ( #´), 13 ( D), 294 (리터럴) & 300 ( L*3)의 배열에서 구분 쉼표를 사용하지 않도록 형식화되고 정렬됩니다. 0코드 코드에서 빼는 F대신 제거 할 수 있지만 쉼표를 추가하거나 C*F(12 * 15)를 사용하여 180바이트를 절약해야합니다.

— 얽히고 설킨
소스
3

R , 50 44 바이트

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

온라인으로 사용해보십시오!

자바 스크립트 답변과 동일하지만 R의 벡터화 및 LETTERS 내장 기능을 사용하여 조금 더 짧습니다.

마지막 6 바이트를 면도 해주신 rturnbull 에게 감사드립니다 .

— 주세페
소스
— rturnbull
실제로 함수 대신 전체 프로그램으로 만들어서 44 바이트 입니다.
— rturnbull
아 @rturnbull, 나는 더 당신이 것을 포장 할 필요가 "말할하고 있었다 cat그렇지 않으면 사용 source(program,ec=T)및 계산 ec=T새로운 메타 합의는 우리가 플래그를 포함되지 않습니다 (R 프로그램에 대한 메타 합의에 따라) 플래그로, 그러나 다른에 의해 더 이상, 저는 이것이 완벽하게 유효한 솔루션입니다
— 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
— officialaimm
소스
2

Pyke, 28 bytes

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

Try it here!

Explanation

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.
— Mr. Xcoder
소스
1

Pyth, 30 bytes

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

The site doesn't seem to show the character with code point 1, so you need to insert a character with code point 1 before the &, ,, and m at the end

(Replace all 1s with character with code point 1):

@GtlfgTQmCdc"\r ª ´ 1& 1, 1m"d
— Karan Elangovan
소스
1

Pyth, 25  26  bytes

@<G6sgRQ[13*17T180*30T294

Verify all the test cases.

Explanation

@<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.
— Mr. Xcoder
소스
1

Ly, 74 bytes

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;

Try it online!

A simple if-chain approach. I doubt it can be made much shorter.

— LyricLy
소스
Are those paranthesis (...) required? P.S. nvm, Apparently they are.
— officialaimm
1

Java 8, 55 bytes

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

Try it here.

Alternative 57 bytes:

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

Try it here.

Alternative 60 bytes:

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

Try it here.

Maybe some kind of formula can be find to get 0-5 in a shorter way than n<14?0:n<171?1:n<181?2:n<295?3:n<301?4:5 using the last approach. Still investigating this.

— Kevin Cruijssen
소스
1

PowerShell, 59 bytes

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

Try it online!

Similar-ish to Jonathan Allen's Jelly answer, in that we're constructing an array of all the letters concatenated together, then indexing into that array with the input $args.

— AdmBorkBork
소스
1

Rabbit~, 50 bytes

(Noncompeting, postdates question. I just finished the interpreter(yay) and wanted to try and solve something. This is also my first code golf thing ever)

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

It basically takes the differences from one grade to the next 14,157,10,114,6,65 (encoded as ỤṅỌrḲA) and subtracts from the input. If a negative number is found it stops progressing along the 'FEDCBA' sequence and outputs the letter.

Small explanation of this beautiful piece of syntax

Rabbit~ uses a grid based memory with one or several carets you can move around; this solution uses 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
— Adam
소스
Nice. Is there a way to try it online?
— officialaimm
Not at the moment ^^
— Adam
1

Excel, 53 bytes

Sum of conditions, then returns the required ASCII character:

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

Alternative solutions:

Summing conditions, return string index (63 bytes):

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

K (oK), 30 bytes

Solution:

"FEDCBA"@0 14 171 181 295 301'

Try it online!

Explanation:

Index into the correct bucket:

"FEDCBA"@0 14 171 181 295 301' / the solution
         0 14 171 181 295 301' / bin (') input in a bucket
"FEDCBA"@                      / index (@) into "FEDCBA"
— streetster
소스
1

Jotlin, 48 41 bytes

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

Whole program:

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

Ported my previous Kotlin answer here.

— jrtapsell
소스
1

V, 37 34 bytes

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

Try it online!

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

Basic idea:

  • Print FEDCBA, create 5 copies of B, 113 copies of C etc. resulting in the string FFFFFFFFFFFFFEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEDDDDDDDDDCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCBBBBBA (There is probably a more efficient way to do this)
  • Go to nth column (n is the first argument), copy a single character and replace the entire string with it.
— oktupol
소스
1

Perl 6, 42 39 bytes

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

Stax, 18 bytes

5"«µħĭ",+|oH-VA@]

Run and debug online!

Explanation

Bytes counted in CP437.

5"«µħĭ",+|oH-VA@]
5            -        5 minus the result of the following
 "«µħĭ"                   [14, 171, 181, 295, 301]
        ,+                Append input
          |oH             Index of last element if the array were to be sorted
              VA@]    Letter in the alphabet with the given index
— Weijun Zhou
소스
0

C#, 110 bytes

x=>{if(x<14)return"F";if(x<171)return"E";if(x<181)return"D";if(x<295)return"C";if(x<301)return"B";return"A";};

Try it online

— snorepion
소스
2
You can shorten your lambda significantly using the trinary operator ?: as x<14?"F":x<170?"E":x<180?"D":x<294?"C":x<300?"B":"A"
— Bradley Uffner
당사 사이트를 사용함과 동시에 당사의 쿠키 정책과 개인정보 보호정책을 읽고 이해하였음을 인정하는 것으로 간주합니다.
Licensed under cc by-sa 3.0 with attribution required.