Olá, sou nova em programação e estou a horas tentando resolver essa questão e não consigo.
"Escreva um programa que converta uma avaliação escolar baseada em letras para uma nota numérica.
As letras sao A,B,C,D e F, possivelmente seguidas por + ou -.
Seus valores numericos sao 4,3,2,1 e 0. Não existe F+ ou F-.
Um + aumenta o valor numérico em 0.3, um - diminui o valor em 0.3.
Mas um A+ tem o valor de 4.0."
thimor
#2
public double converteNova(String nota) {
switch(nota) {
case "A+":
return 4.3;
case "A":
return 4;
case "A-":
return 3.7;
....
default:
0.00
}
}
ai voce faz um case para cada leta com e com o + e -
Estava tentando fazer também, mas a nota A+ representa 4. Acredito q seja assim
private static String mostra_letra() {
String letra_coisada = "";
if (nota == 4) {
letra_coisada = "A+";
} else if (nota <= 3.7 && nota >= 3.5) {
letra_coisada = "A";
} else if (nota <= 3.4 && nota >= 3) {
letra_coisada = "A-";
}
return letra_coisada;
}
exercício legal até
Fiz de uma jeito aqui para estimular uma outra forma de fazer (a lógica na classe Nota
pode ser melhorada):
Nota
import java.util.Arrays;
import java.util.stream.Stream;
public class Nota {
private static final double VALOR_SINAL = 0.3;
private final Letra letra;
private final Sinal sinal;
private Nota(Letra letra, Sinal sinal) {
this.letra = letra;
this.sinal = sinal;
}
public static Nota of(String nota) {
if (nota == null || nota.isEmpty()) {
throw new IllegalArgumentException("Nota inválida");
}
String[] partes = nota.split("");
Letra letra = Letra.of(partes[0]);
Sinal sinal = null;
if (partes.length > 1) {
sinal = Sinal.of(partes[1]);
}
return new Nota(letra, sinal);
}
private enum Letra {
A(4.0), B(3.0), C(2.0), D(1.0), F(0.0);
private Double valor;
private Letra(Double valor) {
this.valor = valor;
}
private static Letra of(String valor) {
return Stream.of(values()).filter(i -> i.name().equals(valor.toUpperCase())).findFirst()
.orElseThrow(() -> new IllegalArgumentException("Letra inválida. Valores válidos: " + Arrays.toString(values())));
}
public Double getValor() {
return valor;
}
}
private enum Sinal {
PLUS("+"), MINUS("-");
private String sinal;
private Sinal(String sinal) {
this.sinal = sinal;
}
private static Sinal of(String valor) {
return Stream.of(values()).filter(i -> i.sinal.equals(valor)).findFirst()
.orElseThrow(() -> new IllegalArgumentException("Sinal inválido. Valores válidos: [+, -]"));
}
}
public Double getValor() {
if (sinal == null) {
return getValorSemSinal();
}
return getValorComSinal();
}
private Double getValorSemSinal() {
return letra.getValor();
}
private Double getValorComSinal() {
if (letra == Letra.A && sinal == Sinal.PLUS || letra == Letra.F) {
return letra.getValor();
}
if (Sinal.PLUS == sinal) {
return letra.getValor() + VALOR_SINAL;
}
return letra.getValor() - VALOR_SINAL;
}
}
NotaTest
import static org.junit.jupiter.api.Assertions.assertEquals;
import static org.junit.jupiter.api.Assertions.assertThrows;
import static org.junit.jupiter.api.Assertions.assertTrue;
import org.junit.jupiter.api.Test;
class NotaTest {
@Test
void deveRetornarNotaA() {
Nota actual = Nota.of("A");
Nota actualPlus = Nota.of("A+");
Nota actualMinus = Nota.of("A-");
assertEquals(4.0, actual.getValor());
assertEquals(4.0, actualPlus.getValor());
assertEquals(3.7, actualMinus.getValor());
}
@Test
void deveRetornarNotaB() {
Nota actual = Nota.of("B");
Nota actualPlus = Nota.of("B+");
Nota actualMinus = Nota.of("B-");
assertEquals(3.0, actual.getValor());
assertEquals(3.3, actualPlus.getValor());
assertEquals(2.7, actualMinus.getValor());
}
@Test
void deveRetornarNotaC() {
Nota actual = Nota.of("C");
Nota actualPlus = Nota.of("C+");
Nota actualMinus = Nota.of("C-");
assertEquals(2.0, actual.getValor());
assertEquals(2.3, actualPlus.getValor());
assertEquals(1.7, actualMinus.getValor());
}
@Test
void deveRetornarNotaD() {
Nota actual = Nota.of("D");
Nota actualPlus = Nota.of("D+");
Nota actualMinus = Nota.of("D-");
assertEquals(1.0, actual.getValor());
assertEquals(1.3, actualPlus.getValor());
assertEquals(0.7, actualMinus.getValor());
}
@Test
void deveRetornarNotaF() {
Nota actual = Nota.of("F");
Nota actualPlus = Nota.of("F+");
Nota actualMinus = Nota.of("F-");
assertEquals(0.0, actual.getValor());
assertEquals(0.0, actualPlus.getValor());
assertEquals(0.0, actualMinus.getValor());
}
@Test
void deveLancarExcecaoNovaVazia() {
IllegalArgumentException exception = assertThrows(IllegalArgumentException.class, () -> Nota.of(""));
assertTrue(exception.getMessage().contains("Nota inválida"));
}
@Test
void deveLancarExcecaoNovaNull() {
IllegalArgumentException exception = assertThrows(IllegalArgumentException.class, () -> Nota.of(null));
assertTrue(exception.getMessage().contains("Nota inválida"));
}
@Test
void deveLancarExcecaoLetraInvalida() {
IllegalArgumentException exception = assertThrows(IllegalArgumentException.class, () -> Nota.of("G"));
assertTrue(exception.getMessage().contains("Letra inválida"));
}
@Test
void deveLancarExcecaoSinalInvalida() {
IllegalArgumentException exception = assertThrows(IllegalArgumentException.class, () -> Nota.of("A*"));
assertTrue(exception.getMessage().contains("Sinal inválido"));
}
}
1 curtida
Se ela chega com esse código nem precisa estudar os outros semetres kkkkkkkk, muito bom!!
1 curtida