Système de classement étrange

14

Weirdo Incorporates a une façon étrange de classer son personnel en fonction du nombre de jours où il était présent au bureau:

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

Objectif:

Écrivez un programme / une fonction qui génère / renvoie la note d'un employé pour le nombre de jours [compris dans la plage comprise entre 0 et 365] suivis par l'employé.

Règles:

  • Vous pouvez prendre les entrées sous forme de chaîne ou de nombre mais vous devez les produire sous forme de chaîne / alphabet (vous pouvez choisir entre minuscules ou majuscules.)
  • Des échappatoires standard s'appliquent.
  • Il s'agit de code-golf , donc le programme le plus court en octets gagne!

Cas de test:

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

Tableau d'affichage:

Afficher l'extrait de code

code-golf  number  decision-problem  classification 
— officialaimm
source
— officialaimm
1
— M. Xcoder
4
— H.PWiz
1
@ Mr.Xcoder Je me souviens qu'il a été discuté dans le bac à sable que ce n'est pas une dupe car cela n'a pas de plages de taille égale et que d'avoir des suffixes tels que +/ -.
— Erik the Outgolfer le
1
Pouvons-nous obtenir un tableau de bord?
— jrtapsell

Réponses:

4

Gelée ,  18 17 15  14 octets

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

Un lien monadique prenant un numéro et renvoyant un personnage.

Essayez-le en ligne! ou voir toutes les paires entrée-sortie .

Comment?

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)
— Jonathan Allan
source
12

Javascript (ES6), 51 octets

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

Solutions alternatives (plus longues):

53 52 octets (-1 octet grâce à @Arnauld)

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

55 53 octets (-2 octets grâce à @Neil)

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

55 octets

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

Exemple d'extrait de code:

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))
Développer l'extrait

— Herman L
source
1
Ce résumé des conditions est super !!! J'aimerais pouvoir voter une fois de plus !!! : D
— officialaimm
Je peux économiser deux octets sur l'une de vos solutions alternatives:n=>"AFEDCB"[[14,171,181,295,301].findIndex(m=>n<m)+1]
— Neil
-1 octet pour votre première solution alternative:n=>'FEDCBA'[n>300?5:n>294?4:n>180?3:n>170?2:+(n>13)]
— Arnauld
7

TI-Basic, 40 octets

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

J , 31 octets

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

Essayez-le en ligne!

Explication

'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
— miles
source
Première fois que j'ai vu dyadique I.à l'état sauvage. Soigné.
— cole
@cole Je crois que je l'ai utilisé plusieurs fois par le passé en code-golf.
— miles
6

Python 3 , 50 octets

Merci à @jferard pour -4 octets.

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

Essayez-le en ligne!

Python 3 , 54 octets

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

Essayez-le en ligne!

Enregistré 2 octets grâce à @mathmandan, et indirectement grâce à @JonathanFrech.

Python 2 , 56 octets

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

Essayez-le en ligne!

— M. Xcoder
source
1
54 octets: lambda n:chr(70-sum(n>x for x in[13,170,180,294,300])). (Voir la réponse de @Jonathan Frech à codegolf.stackexchange.com/a/142244/36885 )
— mathmandan
1
— jferard
port rubis: ->n{(70-"ĬĦ´ª\r".chars.count{|i|n>i.ord}).chr}même taille
— Asone Tuhid
4

C, 62 61 octets

Merci à @Jonathan Frech d'avoir enregistré un octet!

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

Essayez-le en ligne!

C, 57 octets

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

Essayez-le en ligne!

C (gcc), 54 octets

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

Essayez-le en ligne!

C (gcc), 50 octets

Utilisation de la solution de @Herman Lauenstein .

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

Essayez-le en ligne!

— Steadybox
source
— Jonathan Frech
Pourquoi ne pas soumettre la version la plus courte comme solution principale?
— Shaggy
@Shaggy Ceux qui nécessitent que gcc recoure à un comportement indéfini, je préfère donc garder ceux bien définis en haut, et les trier du plus ancien au plus récent et en même temps du plus long au plus court me semble correct.
— Steadybox
3

Kotlin , 56 octets

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

Essayez-le en ligne!

Embellie

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

Tester

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. J'ai édité votre réponse dans un format plus formel, j'espère que cela ne vous dérange pas.
— officialaimm
Pas du tout, je voulais réparer mon outil pour sortir l'en-tête droit
— jrtapsell
3

Japt , 23 21 octets

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

Essayez-le

Explantion

Saisie implicite d'entier U.

'Gc-

Soustraire des points de code de la chaîne (un seul caractère) G...

è<U

Le nombre d'éléments inférieur à U...

[#ªT#´D294L*3]

Dans le tableau de 170 ( #ª), 0 ( T), 180 ( #´), 13 ( D), 294 (littéral) et 300 (L*3 ), donc formatés et ordonnés pour éviter l'utilisation de virgules de délimitation. 0pourrait être supprimé (en soustrayant du point de code de la Fplace) mais alors une virgule devrait être ajoutée ou C*F(12 * 15) utilisée pour 180, en fin de compte, aucun octet.

— Hirsute
source
3

R , 50 44 octets

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

Essayez-le en ligne!

identique à la réponse javascript, mais utilise la vectorisation de R et le LETTERS intégré pour venir un tout petit peu plus court.

Merci à rturnbull d' avoir rasé ces 6 derniers octets.

— Giuseppe
source
— rturnbull
En fait, 44 octets en faisant simplement un programme complet au lieu d'une fonction.
— rturnbull
@rturnbull ah, j'étais sur le point de dire "non, vous devez en tenir compte, catsinon l'utiliser source(program,ec=T)et compter ec=Tcomme indicateur (selon le méta-consensus sur les programmes R), mais par un autre méta-consensus plus récent, nous ne comptons aucun indicateur" plus longtemps, donc c'est une solution parfaitement valable.
— Giuseppe
2

Recursiva , 49 30 octets

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

Essayez-le en ligne!

Permettez-moi de répondre à ma propre question dans ma propre langue. :RÉ

  • économisé 19 octets en utilisant la technique de la réponse JS étonnante de @Herman Lauenstein

Explication:

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
source
2

Pyke , 28 octets

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

Essayez-le ici!

Explication

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.
— M. Xcoder
source
1

Pyth, 30 octets

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

Le site ne semble pas montrer le caractère avec le point de code 1, vous devez donc insérer un caractère avec le point de code 1 avant &, ,etm à la fin

(Remplacez tous les 1s par un caractère avec le point de code 1):

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

Pyth , 25  26  octets

@<G6sgRQ[13*17T180*30T294

Vérifiez tous les cas de test.

Explication

@<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.
— M. Xcoder
source
1

Ly , 74 octets

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;

Essayez-le en ligne!

Une approche simple si-chaîne. Je doute que cela puisse être beaucoup plus court.

— LyricLy
source
Ces parenthèses sont-elles (...)nécessaires? PS nvm, apparemment ils le sont.
— officialaimm
1

Java 8, 55 octets

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

Essayez-le ici.

Alternative 57 octets :

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

Essayez-le ici.

Alternative 60 octets :

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

Essayez-le ici.

Peut-être qu'une sorte de formule peut être trouvée pour obtenir 0-5 d'une manière plus courte que l' n<14?0:n<171?1:n<181?2:n<295?3:n<301?4:5utilisation de la dernière approche. Toujours en train d'enquêter.

— Kevin Cruijssen
source
1

PowerShell , 59 octets

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

Essayez-le en ligne!

Similaire à la réponse Jelly de Jonathan Allen, en ce sens que nous construisons un tableau de toutes les lettres concaténées ensemble, puis indexons dans ce tableau avec l'entrée $args.

— AdmBorkBork
source
1

Lapin ~ , 50 octets

(Question non concurrente, postdate. Je viens de terminer l'interprète (yay) et je voulais essayer de résoudre quelque chose. C'est aussi ma première chose de golf de code jamais)

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

Il prend essentiellement les différences d'une année à l'autre 14,157,10,114,6,65 (codé comme ỤṅỌrḲA ) et soustrait de l'entrée. Si un nombre négatif est trouvé, il cesse de progresser le long de la séquence «FEDCBA» et sort la lettre.

Petite explication de ce beau morceau de syntaxe

Rabbit ~ utilise une mémoire basée sur une grille avec un ou plusieurs carets que vous pouvez déplacer; cette solution utilise 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
Agréable. Existe-t-il un moyen de l'essayer en ligne?
— officialaimm
Pas pour le moment ^^
— Adam
1

Excel, 53 octets

Somme des conditions, puis retourne le caractère ASCII requis:

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

Solutions alternatives:

Conditions de sommation, retourne l'index de chaîne (63 octets):

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

K (oK) , 30 octets

Solution:

"FEDCBA"@0 14 171 181 295 301'

Essayez-le en ligne!

Explication:

Index dans le bon compartiment:

"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 octets

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

Programme complet:

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

Porté ma précédente réponse Kotlin ici .

— jrtapsell
source
1

V , 37 34 octets

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

Essayez-le en ligne!

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

Idée basique:

  • Imprimez FEDCBA, créez 5 copies de B, 113 copies de C etc. résultant en la chaîne FFFFFFFFFFFFFEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEDDDDDDDDDCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCBBBBBA(Il existe probablement un moyen plus efficace de le faire)
  • Accédez à nla colonne ( nc'est le premier argument), copiez un seul caractère et remplacez-y la chaîne entière.
— oktupol
source
1

Perl 6, 42 39 octets

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

Stax , 18 octets

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

Exécutez et déboguez en ligne!

Explication

Octets comptés dans 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 octets

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

Essayez-le en ligne

— ronflement
source
2
Vous pouvez raccourcir considérablement votre lambda en utilisant l'opérateur trinaire ?:commex<14?"F":x<170?"E":x<180?"D":x<294?"C":x<300?"B":"A"
— Bradley Uffner
En utilisant notre site, vous reconnaissez avoir lu et compris notre politique liée aux cookies et notre politique de confidentialité.
Licensed under cc by-sa 3.0 with attribution required.