怪异的评分系统

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的范围内（包括0-365））。

规则：

  • 您可以输入为字符串或数字，但必须输出为字符串/字母（可以选择小写或大写。）
  • 有标准漏洞。
  • 这是代码高尔夫球，所以最短的程序以字节为单位！

测试用例：

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

计分板：

显示代码段

code-golf  number  decision-problem  classification 
— 官方网站
source
— Officialaimm
1
— Xcoder先生，2017年
4
— -H.PWiz
1
@ Mr.Xcoder我记得在沙箱中讨论过它不是一个重复，因为它没有相等大小的范​​围，并且没有后缀，例如+/ -。
— Erik the Outgolfer
1
我们可以记分板吗？
— jrtapsell

Answers:

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)
— 乔纳森·艾伦
source
12

Javascript（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
source
1
总结条件的事情很棒！！！希望我能再次投票！！！：D
— Officialaimm
我可以在一个替代解决方案中保存两个字节：n=>"AFEDCB"[[14,171,181,295,301].findIndex(m=>n<m)+1]
— 尼尔（Neil）2009年
-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
— 添泰
source
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
— 英里
source
我第一次I.在野外见过二元对。整齐。
— 科尔
@cole我相信我过去在代码高尔夫球中使用过几次。
— 英里
6

Python 3，50个字节

感谢@jferard提供-4个字节。

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

在线尝试！

Python 3，54个字节

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

在线尝试！

感谢@mathmandan，节省了2个字节，间接感谢@JonathanFrech。

Python 2，56个字节

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

在线尝试！

— Xcoder先生
source
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上的回答）
— 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);}

在线尝试！

— 稳定箱
source
— 乔纳森·弗雷希
为什么不提交最短版本作为您的主要解决方案？
— 毛茸茸的
@Shaggy需要gcc的应用程序会使用不确定的行为，因此我宁愿将定义良好的应用程序放在最前面，并按从最早到最新的顺序进行排序，同时从最长到最短的顺序对其进行排序。
— Steadybox
3

Kotlin，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
source
+1。我将您的答案编辑为更正式的格式，希望您不要介意。
— Officialaimm
完全没有，我打算修复我的工具以输出正确的标头
— jrtapsell
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，最终不保存任何字节。

— 毛茸茸
source
3

R，50 44字节

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

在线尝试！

与javascript答案相同，但使用R的向量化和内置的LETTERS来缩短一点。

感谢rturnbull删除了最后6个字节。

— 朱塞佩
source
— rturnbull
实际上，仅通过使其成为完整程序而不是函数即可获得44个字节。
— rturnbull
@rturnbull啊，我要说的是“不，您不需要将其包装cat或使用source(program,ec=T)并计ec=T为一个标志（根据R程序的元共识），但是通过另一个较新的元共识，我们不计算任何标志更长的时间，所以我这是一个非常有效的解决方案。
— Giuseppe
2

Recursiva，49 30字节

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

在线尝试！

请允许我用我自己的语言回答我自己的问题。：D

  • 通过使用@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
— 官方网站
source
2

派克（Pyke），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.
— Xcoder先生
source
1

Pyth，30个字节

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

该网站似乎并没有表现出与代码点1的字符，所以你需要前插入的代码点1的字符&，,以及m在结尾

（将所有1s 替换为代码点为1的字符）：

@GtlfgTQmCdc"\r ª ´ 1& 1, 1m"d
— 卡兰（Karan Elangovan）
source
1

Pyth，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.
— Xcoder先生
source
1

Ly，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;

在线尝试！

一种简单的if-chain方法。我怀疑它可以变得更短。

— 歌词
source
那些偏执(...)需要吗？PS nvm，显然是。
— Officialaimm
1

Java 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 。仍在对此进行调查。

— 凯文·克鲁伊森
source
1

PowerShell，59个字节

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

在线尝试！

与乔纳森·艾伦（Jonathan Allen）的果冻（Jelly）答案类似，因为我们要构建一个由所有串联在一起的字母组成的数组，然后使用input索引到该数组中$args。

— AdmBorkBork
source
1

Rabbit〜，50字节

（非竞争性的，关于日期的问题。我刚刚完成了口译员的工作，想尝试解决一些问题。这也是我有史以来第一次编写高尔夫代码）

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

它基本上将一个年级到下一个年级的差异14,157,10,114,6,65（编码为 ỤṅỌrḲA) and subtracts from the input. If a negative number is found it stops progressing along the 'FEDCBA' sequence and outputs the letter.

对这个漂亮的语法的小解释

Rabbit〜使用基于网格的内存，其中可以插入一个或多个插入符；该解决方案使用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
source
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
source
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
source
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
source
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
source
1

Perl 6, 42 39 bytes

{chr(65+[+] "\rª´ĦĬ".ords »>»$_)}
— bb94
source
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
source
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
source
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
By using our site, you acknowledge that you have read and understand our Cookie Policy and Privacy Policy.
Licensed under cc by-sa 3.0 with attribution required.