Sistema de clasificación extraño

14

Weirdo Incorporates tiene una forma extraña de calificar a su personal por la cantidad de días que estuvieron presentes en la oficina:

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

Objetivo:

Escriba un programa / función que genere / devuelva la calificación de un empleado por el número de días [dentro del rango inclusivo de 0-365] atendido por el empleado.

Reglas:

  • Puede tomar la entrada como una cadena o un número, pero debe salir como una cadena / alfabeto (puede elegir minúsculas o mayúsculas).
  • Se aplican lagunas estándar.
  • Este es el código de golf , por lo que gana el programa más corto en bytes.

Casos de prueba:

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

Marcador:

Mostrar fragmento de código

code-golf number decision-problem classification officialaimm
fuente
sandbox
officialaimm
1
Muy relacionado
Sr. Xcoder
44
Más relacionado
H.PWiz
1
@ Mr.Xcoder Recuerdo que se discutió en el sandbox que no es una trampa de eso, ya que esto no tiene rangos de igual tamaño y que tiene sufijos como +/ -.
Erik the Outgolfer
1
¿Podemos obtener un marcador?
jrtapsell

Respuestas:

4

Jalea ,  18 17 15  14 bytes

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

Un enlace monádico que toma un número y devuelve un personaje.

Pruébalo en línea! o ver todos los pares de entrada-salida .

¿Cómo?

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
fuente
12

Javascript (ES6), 51 bytes

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

Soluciones alternativas (más largas):

53 52 bytes (-1 byte gracias a @Arnauld)

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

55 53 bytes (-2 bytes gracias a @Neil)

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

55 bytes

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

Fragmento de código de ejemplo:

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

Herman L
fuente
1
Que resumir las condiciones es genial !!! ¡Ojalá pudiera votar de nuevo! : D
officialaimm
Puedo guardar dos bytes en una de sus soluciones alternativas:n=>"AFEDCB"[[14,171,181,295,301].findIndex(m=>n<m)+1]
Neil
-1 byte para su primera solución alternativa:n=>'FEDCBA'[n>300?5:n>294?4:n>180?3:n>170?2:+(n>13)]
Arnauld
7

TI-Basic, 40 bytes

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

J , 31 bytes

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

Pruébalo en línea!

Explicación

'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
millas
fuente
Primera vez que veo diádica I.en la naturaleza. Ordenado.
cole
@cole Creo que lo he usado un par de veces en el pasado en code-golf.
millas
6

Python 3 , 50 bytes

Gracias a @jferard por -4 bytes.

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

Pruébalo en línea!

Python 3 , 54 bytes

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

Pruébalo en línea!

Ahorré 2 bytes gracias a @mathmandan e indirectamente gracias a @JonathanFrech.

Python 2 , 56 bytes

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

Pruébalo en línea!

Sr. Xcoder
fuente
1
54 bytes: lambda n:chr(70-sum(n>x for x in[13,170,180,294,300])). (Ver respuesta de @Jonathan Frech en codegolf.stackexchange.com/a/142244/36885 )
mathmandan
1
50 bytes
jferard
puerto rubí: ->n{(70-"ĬĦ´ª\r".chars.count{|i|n>i.ord}).chr}mismo tamaño
Asone Tuhid
4

C, 62 61 bytes

¡Gracias a @Jonathan Frech por guardar un byte!

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

Pruébalo en línea!

C, 57 bytes

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

Pruébalo en línea!

C (gcc), 54 bytes

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

Pruébalo en línea!

C (gcc), 50 bytes

Usando la solución de @Herman Lauenstein .

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

Pruébalo en línea!

Steadybox
fuente
61 bytes.
Jonathan Frech
¿Por qué no enviar la versión más corta como su solución principal?
Shaggy
@Shaggy Los que requieren gcc recurren a un comportamiento indefinido, por lo que prefiero mantener los bien definidos en la parte superior, y ordenarlos del más antiguo al más nuevo y al mismo tiempo del más largo al más corto me parece bien.
Steadybox
3

Kotlin , 56 bytes

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

Pruébalo en línea!

Embellecido

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

Prueba

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
fuente
+1. Edité tu respuesta a un formato más formal, espero que no te importe.
officialaimm
No, en absoluto, me refería a arreglar mi herramienta para mostrar la cabecera derecha
jrtapsell
3

Japt , 23 21 bytes

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

Intentalo

Explantacion

Entrada implícita de entero U.

'Gc-

Restar de los puntos de código de la cadena (carácter único) G...

è<U

El recuento de elementos menores que U...

[#ªT#´D294L*3]

En el conjunto de 170 ( #ª), 0 ( T), 180 ( #´), 13 ( D), 294 (literal) y 300 ( L*3), formateados y ordenados para evitar el uso de delimitación de comas. 0podría eliminarse (restando del punto de código de en su Flugar), pero luego sería necesario agregar una coma o utilizar C*F(12 * 15) 180, en última instancia, no guardar bytes.

Lanudo
fuente
3

R , 50 44 bytes

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

Pruébalo en línea!

igual que la respuesta de JavaScript, pero usa la vectorización de R y las LETRAS incorporadas para ser un poco más cortas.

Gracias a rturnbull por eliminar esos últimos 6 bytes.

Giuseppe
fuente
49 bytes
rturnbull
De hecho, 44 bytes simplemente convirtiéndolo en un programa completo en lugar de una función.
rturnbull
@rturnbull ah, estaba a punto de decir "no, necesitas envolver eso cato usarlo source(program,ec=T)y contarlo ec=Tcomo una bandera (según el meta consenso sobre los programas R), pero por otro consenso más nuevo no contamos banderas. más tiempo, así que esa es una solución perfectamente válida.
Giuseppe
2

Recursiva , 49 30 bytes

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

Pruébalo en línea!

Permítame responder mi propia pregunta en mi propio idioma. :RE

  • ahorró 19 bytes utilizando la técnica de la sorprendente respuesta JS de @Herman Lauenstein

Explicación:

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

Pyke , 28 bytes

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

Pruébalo aquí!

Explicación

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.
Sr. Xcoder
fuente
1

Jalea , 19 bytes

“n-'‘+⁹;“ỌẠÇ‘ð>SịØA

Pruébalo en línea!

El pie de página ejecuta todos los casos de prueba y formatea la salida.

fireflame241
fuente
1

Pyth, 30 bytes

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

El sitio no parecen mostrar el carácter con el punto 1 del código, por lo que necesita para insertar un carácter con el punto 1 antes del código &, ,ym al final

(Reemplace todas las 1s con caracteres con el punto de código 1):

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

Pyth , 25  26  bytes

@<G6sgRQ[13*17T180*30T294

Verifique todos los casos de prueba.

Explicación

@<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.
Sr. Xcoder
fuente
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;

Pruébalo en línea!

Un enfoque simple de cadena if. Dudo que pueda hacerse mucho más corto.

LyricLy
fuente
¿Se (...)requieren esas parálisis ? PD nvm, aparentemente lo son.
officialaimm
1

Java 8, 55 bytes

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

Pruébalo aquí.

Alternativa 57 bytes :

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

Pruébalo aquí.

Alternativa de 60 bytes :

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

Pruébalo aquí.

Tal vez se pueda encontrar algún tipo de fórmula para obtener 0-5 de una manera más corta que n<14?0:n<171?1:n<181?2:n<295?3:n<301?4:5usar el último enfoque. Aún investigando esto.

Kevin Cruijssen
fuente
1

PowerShell , 59 bytes

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

Pruébalo en línea!

Similar a la respuesta Jelly de Jonathan Allen, en que estamos construyendo una matriz de todas las letras concatenadas juntas, luego indexando en esa matriz con la entrada $args.

AdmBorkBork
fuente
1

Conejo ~ , 50 bytes

(Pregunta no competitiva, posterior a la fecha. Acabo de terminar el intérprete (yay) y quería intentar resolver algo. Este es también mi primer código de golf)

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

Básicamente toma las diferencias de un grado al siguiente 14,157,10,114,6,65 (codificado como ỤṅỌrḲA ) y resta de la entrada. Si se encuentra un número negativo, deja de avanzar a lo largo de la secuencia 'FEDCBA' y genera la letra.

Pequeña explicación de esta hermosa sintaxis

Rabbit ~ utiliza una memoria basada en cuadrícula con uno o varios cuidados que puede mover; Esta solución utiliza 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
Adán
fuente
Agradable. ¿Hay alguna forma de probarlo en línea?
officialaimm
No en este momento ^^
Adam
1

Excel, 53 bytes

Suma de condiciones, luego devuelve el carácter ASCII requerido:

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

Soluciones alternativas:

Condiciones de suma, índice de cadena de retorno (63 bytes):

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

K (oK) , 30 bytes

Solución:

"FEDCBA"@0 14 171 181 295 301'

Pruébalo en línea!

Explicación:

Indice en el cubo correcto:

"FEDCBA"@0 14 171 181 295 301' / the solution
         0 14 171 181 295 301' / bin (') input in a bucket
"FEDCBA"@                      / index (@) into "FEDCBA"
callejero
fuente
1

Jotlin , 48 41 bytes

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

Programa completo:

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é mi respuesta anterior de Kotlin aquí .

jrtapsell
fuente
1

V , 37 34 bytes

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

Pruébalo en línea!

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

Idea básica:

  • Imprima FEDCBA, cree 5 copias de B, 113 copias de C, etc. resultando en la cadena FFFFFFFFFFFFFEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEDDDDDDDDDCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCBBBBBA(Probablemente haya una manera más eficiente de hacer esto)
  • Vaya a nla columna th ( nes el primer argumento), copie un solo carácter y reemplace la cadena completa con él.
oktupol
fuente
1

Perl 6, 42 39 bytes

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

Stax , 18 bytes

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

¡Ejecute y depure en línea!

Explicación

Bytes contados en 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
fuente
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";};

Pruébalo en línea

ronquido
fuente
2
Puede acortar su lambda significativamente utilizando el operador trinario ?:comox<14?"F":x<170?"E":x<180?"D":x<294?"C":x<300?"B":"A"
Bradley Uffner,