Étant donné un entier positif (0 et plus, pas de maximum), convertissez-le en note en suivant ces règles:

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

Cela semblait un peu ennuyeux, alors faites la note a +si c'est 7,8 ou 9 et a -si c'est 0,1 ou 2. Ignorez cela pour les cas F et A.

Un exemple:

Contribution:

65

Sortie:

E

Cas de test:

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

Aucun espace de fuite. Une nouvelle ligne après la sortie est correcte, mais restez cohérente. Les fonctions et les programmes complets conviennent parfaitement.

C'est le golf de code, donc le code le plus court gagne. Cela a été inspiré par une question Ask Ubuntu, Comment écrire un script shell pour attribuer des notes à des plages numériques? . Les réponses sont en bash et en python, donc légèrement spoilers.

Classement:

Voici un extrait de pile pour générer à la fois un classement régulier et un aperçu des gagnants par langue.

Pour vous assurer que votre réponse s'affiche, veuillez commencer votre réponse avec un titre, en utilisant le modèle Markdown suivant:

# Language Name, N bytes

où Nest la taille de votre soumission. Si vous améliorez votre score, vous pouvez conserver les anciens scores dans le titre, en les barrant. Par exemple:

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

var QUESTION_ID=49876;function answersUrl(e){return"http://api.stackexchange.com/2.2/questions/"+QUESTION_ID+"/answers?page="+e+"&pagesize=100&order=desc&sort=creation&site=codegolf&filter="+ANSWER_FILTER}function getAnswers(){jQuery.ajax({url:answersUrl(page++),method:"get",dataType:"jsonp",crossDomain:!0,success:function(e){answers.push.apply(answers,e.items),e.has_more?getAnswers():process()}})}function shouldHaveHeading(e){var a=!1,r=e.body_markdown.split("\n");try{a|=/^#/.test(e.body_markdown),a|=["-","="].indexOf(r[1][0])>-1,a&=LANGUAGE_REG.test(e.body_markdown)}catch(n){}return a}function shouldHaveScore(e){var a=!1;try{a|=SIZE_REG.test(e.body_markdown.split("\n")[0])}catch(r){}return a}function getAuthorName(e){return e.owner.display_name}function process(){answers=answers.filter(shouldHaveScore).filter(shouldHaveHeading),answers.sort(function(e,a){var r=+(e.body_markdown.split("\n")[0].match(SIZE_REG)||[1/0])[0],n=+(a.body_markdown.split("\n")[0].match(SIZE_REG)||[1/0])[0];return r-n});var e={},a=1,r=null,n=1;answers.forEach(function(s){var t=s.body_markdown.split("\n")[0],o=jQuery("#answer-template").html(),l=(t.match(NUMBER_REG)[0],(t.match(SIZE_REG)||[0])[0]),c=t.match(LANGUAGE_REG)[1],i=getAuthorName(s);l!=r&&(n=a),r=l,++a,o=o.replace("{{PLACE}}",n+".").replace("{{NAME}}",i).replace("{{LANGUAGE}}",c).replace("{{SIZE}}",l).replace("{{LINK}}",s.share_link),o=jQuery(o),jQuery("#answers").append(o),e[c]=e[c]||{lang:c,user:i,size:l,link:s.share_link}});var s=[];for(var t in e)e.hasOwnProperty(t)&&s.push(e[t]);s.sort(function(e,a){return e.lang>a.lang?1:e.lang<a.lang?-1:0});for(var o=0;o<s.length;++o){var l=jQuery("#language-template").html(),t=s[o];l=l.replace("{{LANGUAGE}}",t.lang).replace("{{NAME}}",t.user).replace("{{SIZE}}",t.size).replace("{{LINK}}",t.link),l=jQuery(l),jQuery("#languages").append(l)}}var ANSWER_FILTER="!t)IWYnsLAZle2tQ3KqrVveCRJfxcRLe",answers=[],page=1;getAnswers();var SIZE_REG=/\d+(?=[^\d&]*(?:&lt;(?:s&gt;[^&]*&lt;\/s&gt;|[^&]+&gt;)[^\d&]*)*$)/,NUMBER_REG=/\d+/,LANGUAGE_REG=/^#*\s*([^,]+)/;

body{text-align:left!important}#answer-list,#language-list{padding:10px;width:290px;float:left}table thead{font-weight:700}table td{padding:5px}

<script src="https://ajax.googleapis.com/ajax/libs/jquery/2.1.1/jquery.min.js"></script><link rel="stylesheet" type="text/css" href="//cdn.sstatic.net/codegolf/all.css?v=83c949450c8b"><div id="answer-list"> <h2>Leaderboard</h2> <table class="answer-list"> <thead> <tr><td></td><td>Author</td><td>Language</td><td>Size</td></tr></thead> <tbody id="answers"> </tbody> </table></div><div id="language-list"> <h2>Winners by Language</h2> <table class="language-list"> <thead> <tr><td>Language</td><td>User</td><td>Score</td></tr></thead> <tbody id="languages"> </tbody> </table></div><table style="display: none"> <tbody id="answer-template"> <tr><td>{{PLACE}}</td><td>{{NAME}}</td><td>{{LANGUAGE}}</td><td>{{SIZE}}</td><td><a href="{{LINK}}">Link</a></td></tr></tbody></table><table style="display: none"> <tbody id="language-template"> <tr><td>{{LANGUAGE}}</td><td>{{NAME}}</td><td>{{SIZE}}</td><td><a href="{{LINK}}">Link</a></td></tr></tbody></table>

Python 2, 72 70 62 octets

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

Il s'agit d'une fonction anonyme qui prend un entier et renvoie la note sous forme de chaîne.

(merci à @ MartinBüttner, @grc et @TheNumberOne pour les conseils)

CJam, 34 33 32 octets

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

D'accord, j'ai essayé plusieurs approches maintenant et je n'arrive pas à obtenir un résultat inférieur à 33, alors voici l'explication:

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.

MISE À JOUR : 1 octet enregistré grâce à un pointeur de Dennis

Essayez-le en ligne ici

Rétine, 43 + 15 = 58 octets

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

Retina est un langage regex créé par Martin Büttner, où les fichiers impairs sont les regex avec lesquels correspondre, et les fichiers pairs sont ce par quoi le remplacer. Chaque ligne est un fichier distinct, j'ai donc ajouté 15 octets pour chaque fichier supplémentaire.

Explication

Il commence par faire quelque chose avec 3 chiffres ou plus un A. Il ajoute un -s'il s'agit d'un nombre à deux chiffres se terminant par 0, 1 ou 2, et +s'il se termine par 7, 8 ou 9. Les nombres sont ensuite mappés sur leur note (par exemple, un nombre commençant par 9 reçoit un B). Tout nombre restant est automatiquement un F. Malheureusement, il ;`doit être ajouté à tous sauf au dernier regex pour supprimer la sortie intermédiaire. Mise à jour: la version 0.5.0 a une sortie intermédiaire désactivée par défaut, ce qui me permet d'économiser quelques octets.

C, 99 octets

Je suis nouveau ici, j'espère que je suis les règles.

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

Cette fonction prend la marque comme paramètre et renvoie la note sous forme de chaîne terminée par NULL.

Explication

Espaces ajoutés:

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

Les variables globales sont automatiquement initialisées à zéro, donc b est rempli de NULL. Étant donné que seuls les deux premiers caractères sont touchés, nous n'avons à nous soucier de mettre un NULL dans b [1] que si le grade n'a qu'un seul caractère. Ce NULL est inséré au tout début de la fonction. Le paramètre n est implicitement int. Si la note est inférieure à 60, elle est définie sur «F», si elle est supérieure à 99, elle est définie sur «A». Dans les autres cas, la note de base est donnée par 'E' - (n - 60) / 10, ce qui simplifie à 75 - n / 10. n % 10obtient le chiffre des unités de la marque. S'il est inférieur à 3, alors un - est ajouté, s'il est supérieur à 6, un + est ajouté, sinon b [1] est annulé (ce qu'il était déjà).

Cas de test

#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

Pyth, 33 octets

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

Essayez-le en ligne: démonstration ou suite de tests

Explication:

                                     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

> <> (Poisson), 78 71 octets

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

Méthode:

• Nous lisons les points de code des 3 premiers caractères x,y,zde l'entrée. Si un caractère n'est pas présent, la valeur de sa variable sera -1implicitement. ( ord(c)marquera le point de code du personnage c)
• Si z > 0(entrée à 3 chiffres) imprimez Aet quittez.
• Si x < ord('6') or y < 0(entrée <60) imprimez Fet quittez.
• Imprimez le caractère avec le code 123 - x.
• Si y < ord('4') print-` et quittez.
• Si y > ord('6') print+ `et quittez.
• Sortie.

C, 67 65

Étonnamment, c'est assez proche de la solution python.

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

Mais pour que ce programme soit si court, il a fallu faire des sacrifices:

• Si un Fou un Aest imprimé printfne regarde même pas les autres arguments passés. C'est un hack assez méchant.

• Si (i%10+1)/4évalue à 1(non +ou -doit être ajouté à la note), le %sformateur reçoit un pointeur sur un \0octet, donc rien n'est imprimé. Aussi assez drôle, car je ne savais pas que vous pouviez prendre l'adresse d'un littéral de chaîne indexée. (par exemple &"string"[i]) ( modifier : "string"+iest encore plus court ! Merci @nutki)

Voici la sortie du programme pour les nombres 57 à 102. J'en ai fait un vidage hexadécimal, donc nous pouvons être sûrs qu'aucun \0octet bizarre n'a été imprimé.

% 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

La mainméthode utilisée:

main(c,v)char**v;{f(atoi(v[1]));}

CJam, 41 39 37 34 octets

C'est beaucoup trop long, mais je ne pense pas que je vais continuer à jouer au golf pour l'instant.

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

Testez-le ici. Ou exécutez tous les cas de test ici.

Trois octets enregistrés par Optimizer.

Explication

(Légèrement dépassé)

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.

GNU sed, 73 + 1 = 74 octets

Le + 1 correspond au paramètre -r.

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

Python 2, 94 88 84 69 octets

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

JavaScript (ES6), 66 octets

Tout droit.

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

R, 107 105 99 octets

Pas un très bon effort, je le crains, mais je vais essayer de jouer au golf plus tard.

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

Modifier Supprimé quelques ifs. Correction du cas et un résultat incorrect pour 100. Maintenant, pour se débarrasser du ifelses . Je me suis débarrassé de l' ifelseart.

Perl, 66 62 octets

Cela peut probablement être joué plus. Une manière différente pourrait également être meilleure.

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

+1 pour -p

Courir avec:

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

Javascript (ES6), 78 79 octets

Ce n'est vraiment pas l'option la plus intelligente, mais j'ai fait ce que j'ai pu.

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

Passez simplement la note sous forme de chaîne , et elle renverra sa lettre de note.

La partie chaîne est très importante.

Vous pouvez vérifier un cas test ici:

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>

Si l'espace supplémentaire après la lettre n'est pas autorisé, je le retirerai avec plaisir. Ça ne l'était pas! Cela a augmenté mon code d'un octet, mais rien de (trop) grave.

C #, 143 127 112 88 octets

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

J'ai essayé d'être intelligent en faisant des mods de nombres ASCII, mais il semble que je n'étais pas seul!

Merci à Tim pour ses conseils sur les listes plutôt que sur les ifs.

Merci à DarcyThomas d'avoir souligné que je pouvais utiliser des opérateurs ternaires imbriqués.

Haskell, 78 octets

La première ligne semble inutile, coûtant 14 octets, mais je ne pourrais pas trouver une version plus courte sans elle.

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

Explication

L'opérateur #est un raccourci pour créer n copies de son deuxième argument. List aest une liste infinie de chaînes "A". La fonction findexe dans une liste de toutes les notes pour n = 0,1, ... La compréhension de la liste construit la "partie médiane" de cette liste (notes E à B); gest un seul caractère ajouté à la chaînes (qui peut être vide).

Usage

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

C, 102 octets

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

}

Usage

#include <stdio.h>
int f(int );
int main(){
    int c;
    scanf("%d",&c);
    f(c);
}

dc, 52

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

Sortie

$ 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} $ 
$ 

TI-Basic, 79 74 76 octets

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

TI-BASIC, 69 68 66 octets

.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 n'est pas bon pour la manipulation de chaînes.

Saisie sur l'écran d'accueil de la calculatrice, sous la forme de [numéro]: [nom du programme].

Formaté:

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

Cela peut probablement être joué plus loin.

C #, 82 octets

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

Voici un violon avec quelques cas de test.

JavaScript (ES6), 86 83 octets

Ce qui mange vraiment les personnages, c'est la String.fromCharCodecondition +/- ... Je soupçonne fortement qu'il existe un moyen intelligent de raccourcir au moins l'un d'entre eux.

f=n=>n>99?'A':n<60?'F':String.fromCharCode(75.9-n/10|0)+(n%10<3?'-':n%10>6?'+':'');

PHP5,5, 73 octets

Encore une fois, pas le plus court.

Mais ça marche!

<?=($n=$_GET[n])<59?F:($n>99?A:'BCDE'[$n[0]-6].'+-'[$n[1]<3?1:2*$n[1]<5])

Je l'ai classé sous PHP5.5 au lieu de simplement PHP car cela utilise une syntaxe qui n'est valide que pour PHP5.5 et PHP5.6.

Vous pouvez lire sur le déréférencement de chaînes et de tableaux dans le manuel:
http://php.net/manual/en/migration55.new-features.php

Perl, 52

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

Rubis, 58 octets

Je ne pouvais pas croire qu'il n'y en avait pas de Ruby ici. À la réflexion, c'est assez similaire à certains qui sont déjà là, mais de toute façon:

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

Essayez-le ici

Excel, 100 octets

=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,"+",""))))