Dar ao sistema 2 numeros inteiros e positivos e é para averiguar se o ultimo digito é igual.
lastDigit(7, 17) → true
lastDigit(6, 17) → false
lastDigit(3, 113) → true
Fiz assim:
import java.util.Scanner;
public class lastDigit{
public static void main(String[] args){
Scanner sc = new Scanner(System.in);
System.out.print(“Digite numero a:”);
int a = sc.nextInt();
System.out.print(“Digite numero b:”);
int b = sc.nextInt();
last(a,b);
}
public static boolean last(int a,int b){
boolean res = true;
if(a%10 == b%10){
return true;
}else{
res = false;
return false;
}
}
}
Não aparece o true ou false.
Não aparece nada porque você só chama o método last, mas não usa o valor retornado para nada.
Se quer que apareça na tela, você tem que imprimir o retorno dele:
System.out.println(last(a, b));
Claro, você também poderia guardar o resultado em uma variável:
boolean result = last(a, b);
System.out.println(result);
Mas se você só quer imprimir e depois não vai usar o resultado para mais nada, nem precisaria da variável result. Imprima direto e pronto.
Outro detalhe é que dá para simplificar o método. Toda comparação (com ==, !=, >, etc) retorna um boolean, então toda expressão do tipo:
if (condição) {
return true;
} else {
return false;
}
Pode ser simplificada para:
return condição;
Sendo assim, o método poderia ser apenas assim:
public static boolean last(int a, int b) {
return a % 10 == b % 10;
}
Outra coisa, quando postar no fórum, por favor coloque o código formatado. Basta selecioná-lo e usar o botão </> do editor:
1 curtida
muito obrigado pelas dicas todas!!!
E só pra completar, isso não vai funcionar se um dos números for negativo.
Por exemplo, -72 % 10 resulta em -2, então last(-72, 2) retornaria false - mas o último dígito não é 2 para ambos?
Se quiser que last(-72, 2) retorne true, uma alternativa é usar Math.abs para obter o valor sem sinal:
public static boolean last(int a, int b) {
return Math.abs(a % 10) == Math.abs(b % 10);
}
1 curtida
Eu faria de forma diferente: transformaria em string e compararia o último dígito. Isso eliminaria o problema dos números negativos e simplificaria em muito o código:
public static void main(String[] args) {
Scanner entrada = new Scanner(System.in);
System.out.print("Digite o primeiro número: ");
int a = entrada.nextInt();
System.out.print("Digite o segundo número: ");
int b = entrada.nextInt();
if (String.valueOf(a).charAt(String.valueOf(a).length()-1) == String.valueOf(b).charAt(String.valueOf(b).length()-1)) {
System.out.println("Os últimos dígitos são iguais!");
} else {
System.out.println("Os últimos dígitos são diferentes.");
}
entrada.close();
}
1 curtida
Eu não faria assim, pois além de - na minha opinião - ser mais complicado, ainda por cima fica muito mais lento. Fiz um teste com o JMH e a diferença é grande:
Benchmark Mode Samples Score Score error Units
o.s.MyBenchmark.testString thrpt 200 2911222,634 91376,826 ops/s
o.s.MyBenchmark.testMatematica thrpt 200 43640217,591 697345,256 ops/s
O dado importante é o score: no modo throughput (thrpt) ele indica a quantidade de operações por segundo (ops/s), ou seja, quanto maior, melhor.
No caso, a solução com strings foi cerca de 14 vezes pior.
Isso acontece porque criar strings é bem mais ineficiente do que fazer cálculos simples. Se quer manipular números, a solução matemática geralmente será melhor (além de gastar menos memória).
Claro que para programas pequenos (ainda mais exercícios) não fará tanta diferença assim (afinal, para poucos dados, tudo é rápido), mas em programas maiores é bom se atentar para isso e não ficar criando strings à toa (não só pela velocidade, mas também pela alocação de memória adicional que isso gera).
O código do teste:
import org.openjdk.jmh.annotations.Benchmark;
import org.openjdk.jmh.annotations.Scope;
import org.openjdk.jmh.annotations.Setup;
import org.openjdk.jmh.annotations.State;
import org.openjdk.jmh.infra.Blackhole;
import org.openjdk.jmh.runner.Runner;
import org.openjdk.jmh.runner.RunnerException;
import org.openjdk.jmh.runner.options.Options;
import org.openjdk.jmh.runner.options.OptionsBuilder;
@State(Scope.Benchmark)
public class MyBenchmark {
public static void main(String[] args) throws RunnerException {
Options opt = new OptionsBuilder().include(MyBenchmark.class.getSimpleName()).warmupIterations(2).measurementIterations(2).forks(2).build();
new Runner(opt).run();
}
int[][] values;
@Setup
public void setup() {
values = new int[][] { { 1, 2 }, { 1924, 4893894 }, { -12942, 3049122 }, { -183848, -439585 }, { Integer.MAX_VALUE, Integer.MIN_VALUE } };
}
@Benchmark
public void testMatematica(Blackhole bh) {
for (int[] v: values) {
bh.consume(matematica(v[0], v[1]));
}
}
@Benchmark
public void testString(Blackhole bh) {
for (int[] v: values) {
bh.consume(strings(v[0], v[1]));
}
}
private boolean matematica(int a, int b) {
return Math.abs(a % 10) == Math.abs(b % 10);
}
private boolean strings(int a, int b) {
return String.valueOf(a).charAt(String.valueOf(a).length()-1) == String.valueOf(b).charAt(String.valueOf(b).length()-1);
}
}
1 curtida
É uma forma, mas bem mais lenta e com muito desperdício de memória.
2 curtidas