Come posso utilizzare un'istruzione switch() per convertire da una valutazione numerica a una lettera?

Question

Questo NON è compito a casa, ma è una pratica che l'insegnante ci ha dato per aiutare a studiare per un test. Ma non lo trasformerò nell'insegnante. (spero che sia permesso)

Vuole che un utente inserisca un voto e gli abbia assegnato un voto di lettera. Sarebbe facile con le dichiarazioni if, ma non posso usare ANY! Devo usare il metodo switch.

Qui è la mia classe funzionale:

public class Grade { 

public double getGrade(int input) 
{ 
    double inputGrade; 
    switch(input) 
    { 
    case 1: inputGrade >= 90; 
     break; 
    case 2: inputGrade >= 80; 
     break; 
    case 3: inputGrade >= 70; 
     break; 
    default: 
     grade = 60; 
    } 
    return grade; 

} 

} 

Qui è la mia classe di test:

import java.util.*; 
public class TestGrade 
{ 
public static void main(String[] args) 
{ 
    Scanner scan = new Scanner(System.in); 
    int input = scan.nextInt(); 
    Grade lGrade = new Grade(); 
    double finalGrade = lGrade.getGradeSwitch(input); 
    System.out.println("Your toll is $" + finalGrade); 
} 

} 

io non ho stato di programmazione sufficiente per avere questa mente analitica. Ho provato a completarlo, non ho trovato un modo per nascondere l'input dell'utente (int) in una lettera di grado (stringa) senza istruzioni.

So che questo è incompleto, ma questo è il più lontano possibile senza fare errori.

MODIFICA: WOW! Grazie ragazzi, odio scegliere una sola risposta corretta, perché molti di voi mi hanno aiutato!

Questo è ciò che ho finito con (che ha lavorato: D)

public String getGrade(int input) 
{ 
    String letterGrade; 
    switch(input/10) 
    { 
     case 9: letterGrade = "A"; 
        break; 
     case 8: letterGrade = "B"; 
        break; 
     case 7: letterGrade = "C"; 
        break; 
     case 6: letterGrade = "D"; 
     default: 
        letterGrade = "F"; 
    } 
    return letterGrade; 

} 

Answer 1

OK, la mia ipotesi è che inserirai un voto numerico 0-100, e che i voti delle lettere che vuoi siano come "90-100: A; 80 -89: B; ...; 60-69: D; 0-59: F ".

Se questo non è il caso, la vostra prima lezione da imparare sulla programmazione è: la parte più importante della codifica è chiaramente scrivendo le specifiche ei requisiti

Detto questo, ci sono approcci intelligenti e stupidi .

• approccio Dumb:

  • utilizzare un interruttore sul "ingresso", come si fa ora

  • Poiché i valori 90, 91 ... 100 sono tutti suppone di essere trattati alla stesso, inserirli tutti come casi di switch separati ma esegui solo il lavoro nell'ultimo (noto come fall-through; see SwitchDemo2 on this page for how that works)

  • Per l'ultimo valore (ad esempio, 90 se si inizia da 100 e si scende), l'istruzione switch sarebbe letterGrade = "A"; rompere;

  • una volta raggiunto caso di 89, si ripete la stessa logica come avete fatto per il 100 di 90

  • Lather, risciacquo, ripetizione, sino 60

  • Handle Fs come un caso di default.

Questo sarà molto lunga, abbastanza muto (come in, forza bruta) e molto fastidioso per scrivere, e uno strumento didattico brillante per il motivo per cui non si vuole scrivere il codice muto di nuovo se si può aiutare esso.

• soluzione più elegante (inserto appropriato Star Wars citazione qui)

  • Cosa vedi in comune tra tutti i # che corrisponde allo "A"?

  destro, è il fatto che, a parte 100, sono tutti #s 2-DIIT iniziano con 9.

  Quindi, per gestire tutti in 1 caso un'affermazione, non sarebbe meraviglioso per attivare un valore che ti dà "9" per tutti i # tra 90 e 99?

  spero che si conosce la risposta subito ... suggerimento di seguito ...

  Sì, basta dividere insieme con 10!

  Quindi, è necessario disporre di un interruttore sul vostro grado numerica diveded da 10, con casi di 10, 9, 8, 7, 6 e mappatura predefinita per F.

Spero che questo copre abbastanza motivo per voi di venire con soluzione di lavoro, pur mostrando come l'analisi potrebbe funzionare pure.

Answer 2

Ecco un punto di partenza: La 'A' personaggio, come un intero, ha il valore di 65. Cosa credi succede se tu converti il ​​valore 66 in un personaggio?

Answer 3

L'istruzione switch non prende valori condizionali, cioè doesnt cercare un true o false risposta come inputGrade >= 70;, invece sembra per se l'elemento n in switch(n) è pari a x del casex:.

Inoltre, i casi di commutazione terminano con i due punti (:), non i semi.

Vedere this link per una spiegazione generica dell'istruzione switch con uno specifico esempio Java.

Answer 4

effettuare questa correzione

double grade; // i think you mispelled it inputGrade 

e

case 1: grade = 90; // inputGrade >= 90 is an expression and is not valid 
     break; 

Answer 5

abbiamo coperto Enums ancora? Il mio suggerimento sarebbe di pensare a come un'enumerazione potrebbe aiutarti a ottenere la tua risposta. Scusa, non posso darti più aiuto di quello senza rovinare il tuo momento aha.

Answer 6

Non vedo da nessuna parte nel codice in cui restituirai una lettera.

Si consiglia di scriverlo in inglese, un po ', e vedere cosa ti manca.

Ad esempio: Ingressi utente grade numerica grado numerico viene convertito in un grado di lettera Stampa fuori grade numerica e lettera.

Quindi, scrivere la parte preponderante duro, parte 2. possibili gradi sono ... possibili campi di ingresso sono ... ritorno grado di lettera

Se scrivere è il nostro più chiaramente, molto passo- passo dopo passo, dato che è così che il computer lo elabora, dovresti vedere come farlo.

Fai finta che stai spiegando a un secondo anno come fare questo, deve essere istruzioni di base.

Answer 7

Ecco un altro suggerimento su come farlo.

Cosa succederebbe se il numero intero fosse diviso per 10?

Answer 8

Prima di tutto, se la funzione è di prendere un voto come numero intero e restituire un voto in lettere, perché ha un tipo di ritorno double?

Dopo aver affrontato con questo, ecco un suggerimento:

Il grado potrebbe variare da 0 a 100, in modo che sia 101 casi per gestire nell'istruzione switch. Quindi potresti scrivere tutti i 101 casi se lo volessi. Ma, puoi pensare a un modo per ridurre il numero di casi? (grande suggerimento: tutti i limiti di classe sono multipli di 10)

Answer 9

Le istruzioni di commutazione funzionano solo con valori corrispondenti ai casi specificati (insieme a un valore predefinito). L'unico modo per scrivere questo utilizzando un'istruzione switch è di avere un caso per ogni punteggio possibile.

si dovrebbe fare questo tipo:

switch (score) 
{ 
    case 0: 
    case 1: 
    ... 
    case 80: 
    case 81:   
    ... 
    case 89: 
     return "B"; 
    case 90: 
    ... 
    case 100: 
     return "A"; 
     break; 
} 

O

si può tagliare fino a un un elenco di 11 possibili casi dividendo per 10 prima.

Che si lascerebbe con:

switch (score/10) 
{ 
    case 0: 
    case 1: 
    case 2: 
    case 3: 
    case 4: 
     return "F"; 
    case 5: 
     return "E"; 
    case 6: 
     return "D"; 
    case 7: 
     return "C"; 
    case 8: 
     return "B"; 
    case 9: 
    case 10: 
     return "A"; 
} 

o qualcosa di simile (naturalmente questo si presuppone gradi corrispondenti a 50+ = E, 90+ = A e così via).

Answer 10

ne dite di questo:

static int[]  SCORES = 
    { 90, 80, 70, 60, 0 }; 

static String[] GRADES = 
    { "A", "B", "C", "D", "F" }; 

String letterGrade(int pct) 
{ 
    for (int i = 0; i < SCORES.length; i++) 
     if (pct >= SCORES[i]) 
      return GRADES[i]; 
} 

Questo presuppone che pct è positivo. Utilizza una singola dichiarazione if, quindi non sono sicuro se questo si qualifica come soluzione valida o meno.

Answer 11

Ho commentato il più accuratamente possibile. Spero che sarai in grado di seguire. Poiché non si tratta di una domanda a casa, non ho problemi a pubblicare una soluzione. A volte hai solo bisogno di vedere il codice per "farlo", quindi eccolo qui. Se hai domande su ciò che ho scritto, lascia un commento e io chiarirò la risposta.

public static String getGrade(int numberGrade) { 
    // There are two parts of the number grade that you really 
    // care about. The first is the quotient after division 
    // by 10. The second is the remainder after division by 
    // 10. The quotient will tell you where it is an A, B, C 
    // D, or F. The remainder will tell you whether it should 
    // have a +, -, or nothing following the letter. 
    // 
    // Let's take the grade 73 as an example. The quotient would 
    // be 7, with a remainder of 3. Because it has a quotient of 
    // 7, you know it's a C. Because of the 3, you know it should 
    // have a minus sign (-) after it. 
    // 
    // Once you know the pattern, you can pretty easily apply 
    // a switch statement to it and produce a letter grade. 

    // Variables for the quotient and remainder, described above 
    int quotient = numberGrade/10; 
    int remainder = numberGrade % 10; 

    // This will hold the final letter grade 
    String letterGrade; 

    switch (quotient) { 
     case 10: 
      // The student got a 100%, so just return A+ 
      return "A+"; 
     case 9: 
      // 90-99 is an A 
      letterGrade = "A"; break; 
     case 8: 
      // 80-89 is a B 
      letterGrade = "B"; break; 
     case 7: 
      // 70-79 is a C 
      letterGrade = "C"; break; 
     case 6: 
      // 60-69 is a D 
      letterGrade = "D"; break; 
     default: 
      // Anything 59 or below is an F 
      return "F"; 
    } 

    switch (remainder) { 
     // For example, 70-73 are C- 
     case 0: case 1: case 2: case 3: 
      letterGrade += "-"; break; 
     // Likewise, 77-79 are C+ 
     case 7: case 8: case 9: 
      letterGrade += "+"; break; 
     // Everything else just falls through, no + or - needed 
    } 

    // You are left with a letter grade consisting of 
    // an A, B, C, D or F, and a plus or minus where 
    // it is appropriate. 
    return letterGrade; 
} 

E qui è davvero un semplice dimostrazione di questo metodo:

for (int i = 100; i >= 0; i--) { 
    System.out.println(i + " = " + getGrade(i)); 
} 

Si stamperà la seguente:

100 = A+ 
99 = A+ 
98 = A+ 
97 = A+ 
96 = A 
95 = A 
94 = A 
93 = A- 
92 = A- 
91 = A- 
90 = A- 
89 = B+ 
88 = B+ 
87 = B+ 
86 = B 

Answer 12

mi annoiavo e si avvicinò con questo. Lo so che non fa uso di istruzioni switch sia, ma anywho:

private string GetGrade(int grade) 
    { 
     return ((char)((int)(Math.Max((Math.Min(10 - (grade/10) + 64, 69)), 65)))) 
       .ToString().Replace("E", "F"); 
    } 

Volevo solo vedere se riuscivo a farlo utilizzando codici di carattere. Probabilmente c'è un modo ancora più breve, ma vabbè :) Oh, e mi dispiace, è C#.