整数标记成等级

30

给定正整数（0及以上，没有最大值），请遵循以下规则将其转换为等级：

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

这感觉有些无聊，因此+如果成绩为7,8或9，-则为a；如果分数为0,1或2，则为a。对于F和A情况，请忽略此等级。

一个例子：

输入：

65

输出：

E

测试用例：

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

没有尾随空格。输出后使用一个换行符就可以了，但是要保持一致。功能和完整程序都可以。

这是代码高尔夫，所以最短的代码获胜。这是受一个Ask Ubuntu问题的启发，该问题如何编写一个Shell脚本来为数字范围分配字母等级？。答案是在bash和python中，因此会有些破坏。

排行榜：

这是一个堆栈片段，用于按语言生成常规排行榜和获胜者概述。

为确保您的答案显示出来，请使用以下Markdown模板以标题开头。

# Language Name, N bytes

N您提交的文件大小在哪里。如果您提高了分数，则可以将旧分数保留在标题中，方法是将它们打掉。例如：

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

显示代码段

code-golf 
— 提姆
source
1
不会有A+and A-吗？我不明白为什么我们会忽略它们。
— ASCIIThenANSI，2015年
1
@ASCIIThenANSI使具有异常更加有趣，并且A没有最大值，所以没有+
— Tim
1
该分类委员会有一个错误：鱼版本较旧，我的答案还早于此。
— 伊斯梅尔·米格尔
@IsmaelMiguel它是在最早的帖子尚未成为默认的决胜局时编写的（因此它根本不定领结）。我会尝试在某个时候修复它（可能不是针对此挑战，而是至少针对meta的源代码）。
— 马丁·恩德
@MartinBüttner我只是指出来。
— Ismael Miguel

Answers:

21

Python 2，72 70 62字节

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

这是一个匿名函数，它接受一个int并将分数作为字符串返回。

（感谢@MartinBüttner，@ grc和@TheNumberOne提供提示）

— Sp3000
source
4
"EDCB"[n/10-6]->chr(75-n/10)
— grc 2015年
选择一个可能为空的字符的巧妙方法！
— xnor 2015年
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个字节

在这里在线尝试

— 优化器
source
怎么s办？
— 丹尼斯
@Dennis最后将char + /-/空格转换为字符串<
— Optimizer
那没必要。Character String -推一个字符串。
— 丹尼斯
@丹尼斯啊，你是对的。我认为对于某些以前的版本，用法有所不同。
— Optimizer
8

视网膜，43 + 15 = 58字节

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

视网膜是由马丁·布特纳（MartinBüttner）创建的一种正则表达式语言，其中奇数文件是要与之匹配的正则表达式，而偶数文件是要用其替换的正则表达式。每行是一个单独的文件，因此我为每个其他文件添加了15个字节。

说明

它以3或3个以上的数字作为A开头。-如果它是以0、1或2结尾的两位数字，以及+以7、8或9 结尾的两位数字，则添加a 。然后将数字映射到他们的成绩（例如，以9开头的数字为B）。剩下的任何数字都将自动为F。不幸的是，;`必须在除最后一个正则表达式之外的所有前缀之前添加所有数字，以禁止中间输出。更新：默认情况下，版本0.5.0的中间输出处于关闭状态，这使我节省了一些字节。

— 忍者熊猴子
source
您确定F情况下不输出+和-吗？
— 蒂姆（Tim）
1
@Tim不应该，因为\d.*匹配并替换了+包括的整个字符串。
— NinjaBearMonkey
啊，好的-我现在可以看到了！:)
— 蒂姆（Tim）
8

C，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;}

此函数将标记作为参数，并将成绩作为以NULL终止的字符串返回。

说明

添加空格：

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，则将其设置为“ F”，如果分数大于99，则将其设置为“ A”。在其他情况下，基本等级由给出'E' - (n - 60) / 10，简化为75 - n / 10。n % 10获取标记的单位数字。如果小于3，则附加--，如果大于6，则附加+，否则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
— 安德里亚·比昂多（Andrea Biondo）
source
完美:)那里没什么问题。
— 蒂姆（Tim）
您的代码和我的代码之间的区别是一个单词“ printf”，如果忽略了它，它应该节省3个以上的字节：）
— Abr001am，2015年
7

Pyth，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
— 雅库比
source
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并退出。
  • 用codepoint打印字符123 - x。
  • 如果为y < ord('4') print-`，然后退出。
  • 如果为y > ord('6') print+`，然后退出。
  • 出口。
— Randomra
source
7

C，67 65

令人惊讶的是，这与python解决方案非常接近。

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

但是为了使该程序变得如此短促，必须做出牺牲：

  • 如果打印出an F或an，A则printf根本不会查看传递的其他参数。这是一个非常讨厌的黑客。

  • 如果(i%10+1)/4计算结果为1（没有，+或者-应该附加到等级上），那么%s格式化程序会收到一个指向\0字节的指针，因此不会输出任何内容。也很有趣，因为我不知道您可以使用索引字符串文字的地址。（例如&"string"[i]）（编辑："string"+i更短！谢谢@nutki）

在这里，该程序的输出为数字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]));}
— 马克·迪芬特
source
1
&"string"[i]不必要，因为它等效于较短的"string"+i字节，可以节省2个字节。
— 2015年
我必须是客观的，并且要做到这一点:)恭喜，您击败了所有C记录
— Abr001am，2015年
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.
— 马丁·恩德
source
6

GNU sed，73 +1 = 74字节

+1用于-r参数。

s/^[1-5]?.$/F/
s/.{3,}/A/
s/[7-9]$/+/
s/[3-6]$//
s/[0-2]$/-/
y/9876/BCDE/
— 数字创伤
source
5

Python 2，94 88 84 69字节

lambda g:g>99and'A'or[chr(75-g/10)+'-+'[g%10>2:1-(g%10>6)],'F'][g<60]
— 头号
source
5

JavaScript（ES6），66个字节

直行。 

F=n=>n<60?'F':n>99?'A':'EDCB'[n/10-6|0]+(n%10>6?'+':n%10<3?'-':'')

// TEST (in Firefox)

for(i=0;i<111;i++)document.write(i+'='+F(i)+' ')
展开摘要

— edc65
source
4

R，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='')

编辑丢了几个ifs。修复了大小写错误和结果不正确的问题，为100。 现在摆脱ifelses。摆脱了ifelse。

— 米奇
source
我想你想要LETTERS而不是letters。
— Alex A.
3

Perl，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
source
为什么不使用-p并丢弃say？
— ThisSuitIsBlackNot 2015年
@ThisSuitIsBlack不，谢谢！更新
— hmatt1 2015年
2

Javascript（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个字节，但没有（太）严重的问题。

— 伊斯梅尔·米格尔（Ismael Miguel）
source
1
@Tim修复它。我希望这足够了。引用自己：“ One newline after output is fine, but keep it consistent.”。我认为这是足够一致的。
— 伊斯梅尔·米格尔
2

C＃，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数字mod来变得更聪明，但是似乎我并不孤单！

感谢Tim为列表提供建议，而不是ifs。

感谢DarcyThomas指出我可以使用嵌套的三元运算符。

— 传输
source
1
您不能减少使用清单的假设吗？
— 蒂姆（Tim）
我不确定使用列表的意思，可以解释一下吗？
— 传输
在python中，我可以这样做：[item1,item2][condition]。如果条件为True，则给出第二项，如果为False，则给出第二项。
— 2015年
好主意！补充说。
— 传输
我想你可以使用三元if语句例如，return <condition> ? <true result> : <false result>请注意，您还可以嵌套他们，让return <condition> ? <true result> : <condition> ? <2nd true result> : < 2nd false result>
— DarcyThomas
1

Haskell，78个字节

第一行感觉很浪费，占用了14个字节，但是没有它，我找不到更短的版本。

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

说明

运算符#是创建第二个参数的n个副本的简写。List a是字符串“ A”的无限列表。函数f索引到n = 0,1，...的所有等级的列表中。g是在字符串前面添加的单个Char s（可以为空）。

用法

ghci> map f [0,20,65,72,75,80,99,102,864]
["F","F","E","D-","D","C-","B+","A","A"]
— 用户名
source
1

C，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
source
您缺少+和-部分。
— Optimizer
啊，好吧……。想念
— Abr001am
太长：( ..
— Abr001am，2015年
1

直流，52

[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} $ 
$
— 数字创伤
source
1

TI-Basic，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
— 添泰
source
这不适用于小于10的数字
— 。– lirtosiast
很好，汤姆，它不见了1+
— Timtech
每当没有+或-时，它也具有（不可见的）尾随空格。
— lirtosiast 2015年
1

TI-BASIC，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)

这可能会打得更远。

— 小鱼
source
0

C＃，82个字节

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

这是一些测试用例的小提琴。

— 圆胡子
source
0

JavaScript（ES6），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
source
如果您需要短代码，则String.fromCharCode几乎总是无用的。使用字符串索引（请参阅其他javascript答案）
— edc65 2015年
无论如何，~~(.1*-n+75.9)->75.9-n/10|0
— edc65
@ edc65感谢您的高尔夫建议！下一次我将牢记字符串索引。
— vvye
0

Perl，52岁

#!perl -p
$_=$_>99?A:$_<60?F:"$_"^"s";y/JK7890-6/BC+++\-\--/d
— 坚果
source
0

Ruby，58字节

无法相信这里没有Ruby。经过反思，它与已经存在但仍在这里的一些相似：

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

在这里尝试

— 里奇AHB
source
0

Excel，100字节

=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,"+",""))))
— 韦尼施
source
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.