Sistema de classificação estranho

14

A Weirdo Incorporates tem uma maneira estranha de classificar suas equipes pelo número de dias em que estiveram presentes no escritório:

  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:

Escreva um programa / função que produza / retorne a nota de um funcionário pelo número de dias [dentro do intervalo inclusivo de 0 a 365] frequentado pelo funcionário.

Regras:

  • Você pode receber a entrada como uma sequência ou número, mas deve gerar como sequência / alfabeto (você pode escolher entre minúsculas ou maiúsculas).
  • Aplicam-se brechas padrão.
  • Isso é código-golfe , então o programa mais curto em bytes vence!

Casos de teste:

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

Placar:

Mostrar snippet de código

code-golf  number  decision-problem  classification 
— officialaimm
fonte
— officialaimm
1
— Mr. Xcoder 9/09/17
4
— H.PWiz
1
@ Mr.Xcoder Lembro-me de que foi discutido na sandbox que não é um engano disso, já que isso não possui intervalos de tamanho igual e possui sufixos como +/ -.
— Erik the Outgolfer
1
Podemos obter um placar?
— jrtapsell

Respostas:

4

Geléia ,  18 17 15  14 bytes

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

Um link monádico que pega um número e retorna um caractere.

Experimente online! ou veja todos os pares de entrada e saída .

Quão?

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

Javascript (ES6), 51 bytes

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

Soluções alternativas (mais longas):

53 52 bytes (-1 byte graças a @Arnauld)

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

55 53 bytes (-2 bytes graças 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]

Exemplo de trecho de código:

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 snippet

— Herman L
fonte
1
Que somar as condições é ótimo !!! Gostaria de poder votar novamente mais uma vez !!! : D
— officialaimm
I pode salvar dois bytes em uma de suas soluções alternativas:n=>"AFEDCB"[[14,171,181,295,301].findIndex(m=>n<m)+1]
— Neil
-1 byte para sua primeira solução 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
fonte
6

J , 31 bytes

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

Experimente online!

Explicação

'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
— milhas
fonte
Primeira vez que vi diádico I.na natureza. Arrumado.
— cole
@cole Creio que já o usei algumas vezes no code-golf.
— miles
6

Python 3 , 50 bytes

Graças a @jferard por -4 bytes.

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

Experimente online!

Python 3 , 54 bytes

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

Experimente online!

Economizou 2 bytes graças a @mathmandan e indiretamente graças a @JonathanFrech.

Python 2 , 56 bytes

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

Experimente online!

— Mr. Xcoder
fonte
1
54 bytes: lambda n:chr(70-sum(n>x for x in[13,170,180,294,300])). (Veja a resposta de @Jonathan Frech em codegolf.stackexchange.com/a/142244/36885 )
— mathmandan
1
— jferard 11/11/17
porta rubi: ->n{(70-"ĬĦ´ª\r".chars.count{|i|n>i.ord}).chr}mesmo tamanho
— Asone Tuhid 28/02
4

C, 62 bytes

Agradecemos a Jonathan Frech por salvar um byte!

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

Experimente online!

C, 57 bytes

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

Experimente online!

C (gcc), 54 bytes

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

Experimente online!

C (gcc), 50 bytes

Usando a solução de Herman Lauenstein .

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

Experimente online!

— Steadybox
fonte
— 9137 Jonathan Frech
Por que não enviar a versão mais curta como sua solução principal?
— Shaggy
@ Shaggy Os que exigem que o gcc recorram a um comportamento indefinido, então prefiro manter os bem definidos no topo e classificá-los do mais antigo para o mais novo e, ao mesmo tempo, do mais longo para o mais curto, me parece bom.
— Steadybox 11/11
3

Kotlin , 56 bytes

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

Experimente online!

Embelezado

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

Teste

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
fonte
+1. Editei sua resposta para um formato mais formal, espero que você não se importe.
— officialaimm
Nem por isso, eu quis corrigir a minha ferramenta para a saída do cabeçalho direita
— jrtapsell
3

Japonês , 23 21 bytes

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

Tente

Explicação

Entrada implícita de número inteiro U.

'Gc-

Subtrair dos pontos de código da string (único caractere) G...

è<U

A contagem de elementos menor que U...

[#ªT#´D294L*3]

Na matriz de 170 ( #ª), 0 ( T), 180 ( #´), 13 ( D), 294 (literal) e 300 ( L*3), então formatado e ordenado para evitar o uso de vírgulas delimitadoras. 0pode ser removido (subtraindo do ponto de código deF vez disso), mas uma vírgula precisaria ser adicionada ou C*F(12 * 15) usada para 180, em última análise, não salvar bytes.

— Shaggy
fonte
3

R , 50 44 bytes

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

Experimente online!

o mesmo que a resposta javascript, mas usa a vetorização de R e as LETRAS incorporadas para ficar um pouco mais curta.

Obrigado ao rturnbull por eliminar esses últimos 6 bytes.

— Giuseppe
fonte
— rturnbull 01/03
De fato, 44 bytes apenas tornando-o um programa completo em vez de uma função.
— #
@rturnbull ah, eu estava prestes a dizer "não, você precisa agrupar isso catou usar source(program,ec=T)e contar ec=Tcomo uma bandeira (conforme o meta consenso nos programas R), mas por outro, mais recente, não temos bandeiras mais tempo, então eu que é uma solução perfeitamente válido.
— Giuseppe
2

Recursiva , 49 30 bytes

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

Experimente online!

Permita-me responder minha própria pergunta no meu próprio idioma. : D

  • salvou 19 bytes usando a técnica da incrível resposta JS de @Herman Lauenstein

Explicação:

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

Pyke , 28 bytes

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

Experimente aqui!

Explicação

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.
— Mr. Xcoder
fonte
1

Pitão, 30 bytes

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

O site não parecem mostrar o personagem com o ponto 1 do código, então você precisa inserir um caractere com o ponto 1 do código antes da &, ,em no final

(Substitua todos os 1s pelo caractere pelo ponto de código 1):

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

Pitão , 25  26  bytes

@<G6sgRQ[13*17T180*30T294

Verifique todos os casos de teste.

Explicação

@<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.
— Mr. Xcoder
fonte
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;

Experimente online!

Uma abordagem simples se-cadeia. Duvido que possa ser muito mais curto.

— LyricLy
fonte
Essas parênteses são (...)necessárias? PS nvm, aparentemente eles são.
— officialaimm
1

Java 8, 55 bytes

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

Experimente aqui.

57 bytes alternativos :

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

Experimente aqui.

Alternativa 60 bytes :

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

Experimente aqui.

Talvez seja possível encontrar algum tipo de fórmula para obter 0-5 de maneira mais curta do que n<14?0:n<171?1:n<181?2:n<295?3:n<301?4:5usar a última abordagem. Ainda estou investigando isso.

— Kevin Cruijssen
fonte
1

PowerShell , 59 bytes

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

Experimente online!

Semelhante à resposta de Jelly Allen, de Jonathan Allen, na medida em que estamos construindo uma matriz de todas as letras concatenadas juntas, depois indexando essa matriz com a entrada $args.

— AdmBorkBork
fonte
1

Coelho ~ , 50 bytes

(Pergunta não competitiva e pós-datas. Acabei de terminar o intérprete (yay) e queria tentar resolver alguma coisa. Essa também é a minha primeira coisa com código de golfe)

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

Basicamente, leva as diferenças de uma série para a seguinte 14.157,10.114,6,65 (codificada como ỤṅỌrḲA ) e subtrai da entrada. Se um número negativo for encontrado, ele pára de progredir na sequência 'FEDCBA' e gera a letra.

Pequena explicação para este belo pedaço de sintaxe

Rabbit ~ usa uma memória baseada em grade com um ou vários pontos de intercalação nos quais você pode se mover; esta solução usa 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ão
fonte
Agradável. Existe uma maneira de experimentá-lo online?
— officialaimm
Não no momento ^^ #
— Adam
1

Excel, 53 bytes

Soma das condições, em seguida, retorna o caractere ASCII necessário:

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

Soluções alternativas:

Condições de soma, índice de string de retorno (63 bytes):

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

K (oK) , 30 bytes

Solução:

"FEDCBA"@0 14 171 181 295 301'

Experimente online!

Explicação:

Índice no intervalo correto:

"FEDCBA"@0 14 171 181 295 301' / the solution
         0 14 171 181 295 301' / bin (') input in a bucket
"FEDCBA"@                      / index (@) into "FEDCBA"
— rua
fonte
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))

Portou minha resposta anterior do Kotlin aqui .

— jrtapsell
fonte
1

V , 37 34 bytes

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

Experimente 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

Ideia básica:

  • Imprima FEDCBA, crie 5 cópias de B, 113 cópias de C etc., resultando na sequênciaFFFFFFFFFFFFFEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEDDDDDDDDDCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCBBBBBA (provavelmente existe uma maneira mais eficiente de fazer isso)
  • Vá para na coluna ( né o primeiro argumento), copie um único caractere e substitua a string inteira por ele.
— oktupol
fonte
1

Perl 6, 42 39 bytes

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

Stax , 18 bytes

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

Execute e depure online!

Explicação

Bytes contados no 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
fonte
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";};

Experimente online

— snorepion
fonte
2
Você pode encurtar sua lambda usando significativamente o operador trinário ?:comox<14?"F":x<170?"E":x<180?"D":x<294?"C":x<300?"B":"A"
— Bradley Uffner
Ao utilizar nosso site, você reconhece que leu e compreendeu nossa Política de Cookies e nossa Política de Privacidade.
Licensed under cc by-sa 3.0 with attribution required.