Segno intero in grado

30

Dato un numero intero positivo (0 e superiore, nessun massimo), convertilo in un voto seguendo queste regole:

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

Sembrava un po 'noioso, quindi fai un voto a +se è 7,8 o 9 e a -se è 0,1 o 2. Ignoralo per i casi F e A.

Un esempio:

Ingresso:

65

Produzione:

E

Casi test:

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

Nessuno spazio finale. Una nuova riga dopo l'output va bene, ma mantienila coerente. Funzioni e programmi completi vanno entrambi bene.

Questo è il codice golf, quindi vince il codice più breve. Questo è stato ispirato da una domanda di Ubuntu, Come scrivere uno script di shell per assegnare i voti in lettere a intervalli numerici? . Le risposte sono in bash e python, quindi leggermente spoiler.

Classifica:

Ecco uno snippet di stack per generare sia una classifica regolare che una panoramica dei vincitori per lingua.

Per assicurarti che la tua risposta venga visualizzata, ti preghiamo di iniziare la risposta con un titolo, utilizzando il seguente modello Markdown:

# Language Name, N bytes

dov'è Nla dimensione del tuo invio. Se si migliora il punteggio, è possibile mantenere i vecchi punteggi nel titolo, colpendoli. Per esempio:

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

Mostra snippet di codice

code-golf 
— Tim
fonte
1
Non ci sarebbe un A+e A-? Non vedo perché li stiamo ignorando.
— ASCIIThenANSI
1
@ASCIIThenANSI rende più interessante avere delle eccezioni e non esiste un massimo per la A, quindi no+
— Tim
1
Quella classifica ha un bug: la versione fish è più vecchia e la mia risposta è prima.
— Ismael Miguel,
@IsmaelMiguel È stato scritto quando il primo post non era ancora il tie breaker predefinito (quindi non ordina affatto i legami). Cercherò di risolverlo ad un certo punto (probabilmente non per questa sfida, ma almeno la fonte su meta).
— Martin Ender,
@ MartinBüttner lo stavo solo sottolineando.
— Ismael Miguel,

Risposte:

21

Python 2, 72 70 62 byte

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

Questa è una funzione anonima che accetta un int e restituisce il voto come stringa.

(grazie a @ MartinBüttner, @grc e @TheNumberOne per i suggerimenti)

— SP3000
fonte
4
"EDCB"[n/10-6]->chr(75-n/10)
— grc
Che modo intelligente di selezionare un personaggio che potrebbe essere vuoto!
— xnor
11

CJam, 34 33 32 byte

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

Ok, ho provato diversi approcci ora e non riesco a ottenere questo sotto 33, quindi ecco la spiegazione:

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.

AGGIORNAMENTO : 1 byte salvato grazie a un puntatore di Dennis

Provalo online qui

— Optimizer
fonte
Che cosa sfa?
— Dennis,
@Dennis converte char + / - / space in stringa per l'ultimo<
— Optimizer
Non dovrebbe essere necessario. Character String -spinge una stringa.
— Dennis,
@Dennis Ah, hai ragione. Penso che per alcune versioni precedenti, l'uso fosse diverso.
— Ottimizzatore,
8

Retina, 43 + 15 = 58 byte

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

Retina è un linguaggio regex creato da Martin Büttner, in cui i file con numero dispari sono la regex con cui abbinare, e i file con numero pari sono con cui sostituirlo. Ogni riga è un file separato, quindi ho aggiunto 15 byte per ogni file aggiuntivo.

Spiegazione

Inizia facendo qualsiasi cosa con 3 o più cifre un A. Aggiunge un -se è un numero di due cifre che termina con 0, 1 o 2 e +se termina con 7, 8 o 9. I numeri vengono quindi mappati su il loro voto (ad es. un numero che inizia con 9 è indicato con una B). Qualsiasi numero lasciato è automaticamente un F. Sfortunatamente, ;`deve essere anteposto a tutti tranne all'ultima regex per sopprimere l'output intermedio. Aggiornamento: la versione 0.5.0 ha un output intermedio disattivato per impostazione predefinita, permettendomi di salvare qualche byte.

— NinjaBearMonkey
fonte
Sei sicuro che non genera + e - per il caso F?
— Tim
1
@Tim Non dovrebbe, perché \d.*corrisponde e sostituisce l'intera stringa, +inclusa.
— NinjaBearMonkey
Ah, okay, adesso posso vederlo! :)
— Tim
8

C, 99 byte

Sono nuovo qui, spero di seguire le regole.

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

Questa funzione accetta il segno come parametro e restituisce il voto come stringa terminata NULL.

Spiegazione

Spazio bianco aggiunto:

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

Le variabili globali vengono inizializzate automaticamente su zero, quindi b viene riempito con NULL. Dato che solo i primi due personaggi sono mai stati toccati, dobbiamo solo preoccuparci di mettere un NULL in b [1] se il voto ha solo un personaggio. Questo NULL viene inserito all'inizio della funzione. Il parametro n è implicitamente int. Se il voto è inferiore a 60, allora è impostato su 'F', se è maggiore di 99 è impostato su 'A'. Negli altri casi, viene dato il voto base 'E' - (n - 60) / 10, che semplifica 75 - n / 10. n % 10ottiene la cifra delle unità del segno. Se è inferiore a 3, allora viene aggiunto a -, se è maggiore di 6, viene aggiunto a +, altrimenti b [1] viene annullato (cosa che era già).

Casi 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
— Andrea Biondo
fonte
Perfetto :) Niente di male lì.
— Tim
la differenza tra il tuo codice e il mio è una parola "printf" che dovrebbe salvare più di 3 byte nel caso in cui venga ignorato :)
— Abr001am
7

Pyth, 33 byte

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

Provalo online: Dimostrazione o Test Suite

Spiegazione:

                                     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
— Jakube
fonte
7

> <> (Pesce), 78 71 byte

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

Metodo:

  • Leggiamo i punti di codice dei primi 3 caratteri x,y,zdall'input. Se un personaggio non è presente, il valore della sua variabile sarà -1implicitamente. ( ord(c)segnerà il punto di codice del personaggio c)
  • Se z > 0(immissione a 3 cifre) stampa Aed esce.
  • Se x < ord('6') or y < 0(input <60) stampa Fed esce.
  • Stampa il personaggio con punto di codice 123 - x.
  • If y < ord('4') print-` ed esci.
  • Se y > ord('6') print+ `ed esci.
  • Uscita.
— randomra
fonte
7

C, 67 65

Sorprendentemente, questo è abbastanza vicino alla soluzione Python.

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

Ma per far sì che questo programma arrivasse a una tale mancanza, bisognava fare dei sacrifici:

  • Se viene stampato an Fo an, non si guardano nemmeno gli altri argomenti passati. Questo è un trucco piuttosto brutto.Aprintf

  • Se viene (i%10+1)/4valutato 1(no +o -deve essere aggiunto al voto), il %sformattatore riceve un puntatore a un \0byte, quindi non viene stampato nulla. Anche abbastanza divertente, perché non sapevo che potresti prendere letteralmente l'indirizzo di una stringa indicizzata. (es. &"string"[i]) ( modifica : "string"+iè ancora più breve ! Grazie @nutki)

Qui l'output del programma per i numeri da 57 a 102. L'ho trasformato in un hexdump, quindi possiamo essere certi che nessun \0byte strano sia stato stampato.

% 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

Il mainmetodo utilizzato:

main(c,v)char**v;{f(atoi(v[1]));}
— MarcDefiant
fonte
1
&"string"[i]non è necessario in quanto equivale a più breve "string"+icon il quale è possibile salvare 2 byte.
— Nutki,
devo essere obiettivo e valorizzare questo :) complimenti, hai battuto tutti i record C
— Abr001,
6

CJam, 41 39 37 34 byte

È troppo lungo, ma per ora non credo che continuerò a giocare a golf.

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

Provalo qui. Oppure esegui tutti i casi di test qui.

Tre byte salvati da Optimizer.

Spiegazione

(Leggermente obsoleto)

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.
— Martin Ender
fonte
6

GNU sed, 73 + 1 = 74 byte

+ 1 è per il parametro -r.

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

Python 2, 94 88 84 69 byte

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

JavaScript (ES6), 66 byte

Dritto. 

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

— edc65
fonte
4

R, 107 105 99 byte

Temo che non sia un grande sforzo, ma proverò a giocarlo più tardi.

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

Modifica Hai lasciato cadere un paio di ifsecondi. Risolto il caso e un risultato errato per 100. Ora per sbarazzarsi della ifelses . Mi sono liberato di ifelses.

— MickyT
fonte
Penso che tu voglia LETTERSpiuttosto che letters.
— Alex A.
3

Perl, 66 62 byte

Questo probabilmente può essere giocato a golf di più. Anche un modo diverso potrebbe essere migliore.

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

+1 per -p

Corri con:

echo 72 | perl -pE'$_=$_>99?A:$_<60?F:s/\d$/$&>6?"+":$&<3?"-":""/re;y/9876/BCDE/'
— hmatt1
fonte
Perché non usare -pe rilasciare il say?
— ThisSuitIsBlackNon
@ThisSuitIsBlackNot thanks! Aggiornato
— hmatt1,
2

Javascript (ES6), 78 79 byte

Questa non è davvero l'opzione più intelligente, ma ho fatto quello che potevo.

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

Basta passare il voto come una stringa e restituirà la lettera del voto.

La parte di stringa è molto importante.

Puoi controllare una testcase qui:

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>
Espandi frammento

Se lo spazio aggiuntivo dopo la lettera non è consentito, lo rimuoverò felicemente. Non lo era! Questo ha aumentato il mio codice di 1 byte, ma nulla (troppo) serio.

— Ismael Miguel
fonte
1
@Tim risolto. Spero sia abbastanza Citando te stesso: " One newline after output is fine, but keep it consistent.". Penso che sia abbastanza coerente.
— Ismael Miguel,
2

C #, 143 127 112 88 byte

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

Ho provato ad essere intelligente facendo mod di numeri ASCII, ma sembra che non ero solo!

Grazie a Tim per i consigli sugli elenchi anziché gli if.

Grazie a DarcyThomas per la segnalazione, ho potuto usare operatori ternari nidificati.

— Trasmissione
fonte
1
Non puoi ridurre gli if usando gli elenchi?
— Tim
Non sono sicuro di cosa intendi usando gli elenchi, potresti spiegarci un po '?
— Trasmissione
In Python posso fare questo: [item1,item2][condition]. Se la condizione è True, viene visualizzato il secondo elemento, se False il primo.
— Tim
Buona idea! Aggiunto quello.
— Trasmissione
Penso che potresti usare ternary se ad esempio affermazioni, return <condition> ? <true result> : <false result>nota che puoi anche nidificarle cosìreturn <condition> ? <true result> : <condition> ? <2nd true result> : < 2nd false result>
— DarcyThomas
1

Haskell, 78 byte

La prima riga sembra dispendiosa, costa 14 byte, ma senza di essa non troverei una versione più corta.

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

Spiegazione

L'operatore #è una scorciatoia per creare n copie del suo secondo argomento. Elenco aè un elenco infinito di stringhe "A". La funzione si findicizza in un elenco di tutti i gradi per n = 0,1, ... La comprensione dell'elenco costruisce la "parte centrale" di questo elenco (gradi da E a B); gè un singolo carattere anteposto alla stringa s(che può essere vuoto).

uso

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

C, 102 byte

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

}

uso

#include <stdio.h>
int f(int );
int main(){
    int c;
    scanf("%d",&c);
    f(c);
}
— Abr001am
fonte
Manca la parte + e -.
— Ottimizzatore
ah ok .... manca quello
— Abr001am
troppo a lungo :( ....
— Abr001am
1

dc, 52

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

Produzione

$ 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} $ 
$
— Trauma digitale
fonte
1

TI-Basic, 79 74 76 byte

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
— Timtech
fonte
Questo non funziona per numeri inferiori a 10.
— lirtosiast
Bella cattura, Tom, mancava1+
— Timtech,
Questo ha anche spazi finali (invisibili) ogni volta che non c'è + o -.
— lirtosiast
1

TI-BASIC, 69 68 66 byte

.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 non è buono per la manipolazione delle stringhe.

Inserire nella schermata iniziale della calcolatrice, sotto forma di [numero]: [nome programma].

formattato:

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

Questo può probabilmente essere ulteriormente giocato a golf.

— lirtosiast
fonte
0

C #, 82 byte

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

Ecco un violino con alcuni casi di test.

— Blorgbeard
fonte
0

JavaScript (ES6), 86 83 byte

Ciò che sta davvero mangiando i personaggi è la String.fromCharCodecondizione +/- e ... Sospetto fortemente che ci sia un modo intelligente per accorciarne almeno uno.

f=n=>n>99?'A':n<60?'F':String.fromCharCode(75.9-n/10|0)+(n%10<3?'-':n%10>6?'+':'');
— vvye
fonte
Se si desidera un codice breve, String.fromCharCode è quasi sempre inutile. Usa l'indicizzazione delle stringhe (vedi le altre risposte javascript)
— edc65,
Comunque, ~~(.1*-n+75.9)->75.9-n/10|0
— edc65,
@ edc65 Grazie per i consigli sul golf! Terrò presente l'indicizzazione delle stringhe per la prossima occasione.
— vvye,
0

PHP5.5, 73 byte

Ancora una volta, non il più breve.

Ma funziona!

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

L'ho classificato in PHP5.5 anziché in PHP poiché utilizza una sintassi valida solo per PHP5.5 e PHP5.6.

Puoi leggere informazioni sulla dereferenziazione di stringhe e array nel manuale:
http://php.net/manual/en/migration55.new-features.php

— Ismael Miguel
fonte
0

Perl, 52

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

Rubino, 58 byte

Non riuscivo a credere che non ci siano Ruby qui. Sulla riflessione è abbastanza simile ad alcuni che sono già qui ma comunque:

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

Provalo qui

— RichieAHB
fonte
0

Excel, 100 byte

=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,"+",""))))
— Wernisch
fonte
Utilizzando il nostro sito, riconosci di aver letto e compreso le nostre Informativa sui cookie e Informativa sulla privacy.
Licensed under cc by-sa 3.0 with attribution required.