Este exercício pede que, a partir da entrada de duas strings, o console retorne:
- O número de caracteres através do tamanho da
string
(length) -
No
para que as strings estejam na ordem alfabética correta ouYes
se estiverem na ordem alfabética incorreta ou equivalente*. - A concatenação das strings, sendo que a primeira letra de cada palavra deve ser impressa em maiúsculo.
O passo a passo para a resolução desse problema é:
- Declarar uma variável
Scanner
- Escanear a
String A
e aString B
- Somar o tamanho da
String A
com o Tamanho daString B
System.out.println(A.length() + B.length());
- Usar o método
.compareTo()
para comparar a ordem alfabética daString A
com aString B
Interface java.lang.Comparable e método .compareTo()
O método .compareTo()
faz parte da interface Comparable
e organiza, por default, em ordem alfanumérica. Isso significa que organize em ordem crescente (para números) ou alfabética (para letras).
Veja o exemplo:
public CPF implements Comparable {
private int numero;
public int compareTo (CPF novoCPF){
if (this.numero < outroCPF.numero) {
return -1;
}
if (this.numero > outroCPF.numero) {
return 1;
}
if (this.numero == outroCPF.numero) {
return 0;
}
}
No primeiro if
, o .compareTo()
retorna um número negativo indicando que o this
deve vir antes de outroCPF. O exemplo usa -1 para ilustrar, mas poderia ser qualquer número negativo.
No segundo if
, o .compareTo()
retorna um número positivo para que o this
venha depois do outroCPF. O exemplo usa 1 para ilustrar, mas poderia ser qualquer número positivo.
No terceiro if
, se ambos foram iguais, o retorno será 0 e a ordem será mantida. Neste caso, o default é zero (0).
=========
Por fim, a última etapa é a de organizar as strings de forma que a primeira letra de cada palavra fique em maiúsculo. Para isso, usamos o método substring()
, da classe String.
O método substring()
retorna outra string, derivada da primeira string.
Aqui alguns exemplos:
"unhappy".substring(2) returns "happy"
"Harbison".substring(3) returns "bison"
"emptiness".substring(9) returns "" (an empty string)
Quando passamos dois parâmetros na substring (ex: .substring(0,10)
), significa que estamos selecionando aquela quantidade de caracteres. Exemplo:
String stringExemplo = "JavaScript e Java";
String resultado = stringExemplo.substring(0,10)
System.out.println(resultado);
Console:
JavaScript
Isso porque a palavra JavaScript tem 10 letras e selecionamos de 0 a 10.
Vamos usar essa seleção, mas de 0 a 1, para pegar a primeira letra das palavras que declararmos nas strings.
Dessa forma, o código vai ficar:
String A1 = (A.substring(0, 1)).toUpperCase() + A.substring(1);
String B1 = (B.substring(0, 1)).toUpperCase() + B.substring(1);
Por fim, somamos A.substring(1)
e B.substring(1)
porque precisamos dizer ao computador que voltaremos a imprimir os caracteres (a começar pela posição 1) em letras minúsculas. Sem essa adição, a impressão no console termina na primeira letra maiúscula, deixando de imprimir o resto em minúsculo.
Caso quiséssemos delimitar a quantidade de caracteres minúsculos, poderíamos usar dois parâmetros (1, 10) e depois voltar a imprimir caracteres maiúsculos usando um ou dois parâmetros.
=========
O código final fica assim:
public static void main(String[] args) {
Scanner scanner = new Scanner(System.in);
String A = scanner.next();
String B = scanner.next();
int sum = A.length() + B.length();
System.out.println(sum);
if(A.compareTo(B) > 0){
System.out.println("Yes");
} else {
System.out.println("No");
}
String A1 = (A.substring(0,1)).toUpperCase() + A.substring(1);
String B1 = (B.substring(0,1)).toUpperCase() + B.substring(1); ;
System.out.println(A1 + " " + B1);
}
}
=========
- Observação:
O método compareTo() usa o sistema menor para maior. Sendo assim, A < B < C < D < E ... < Z. Isso significa que, quando mais perto de Z, maior o "valor" de um caracter. E quanto mais perto de A, menor o seu valor. É por isso que pode parecer confuso que uma letra que vem primeiro retorne "No", mas é porque ela é menos "valiosa" do que uma letra que vem depois.
=========
Referências:
============
Essa publicação faz parte de uma série de exercícios resolvidos em Java no HackerRank. Acesse a série completa:
- HackerRank #6 | Scanner e End-of-file
- HackerRank #7 | Int to String / String to Int
- HackerRank #8 | Date and Time
- HackerRank #9 | Static Initializer Block
- HackerRank #10 | Currency Formatter
- HackerRank #11 | DataTypes
- HackerRank #12 | Strings Introduction
- HackerRank #13 | Substring Comparisons
- HackerRank #14 | Abstract Class
- HackerRank #18 | BigInteger
- HackerRank #19 | Loops II
- HackerRank #20 | String Reverse
- HackerRank #23 | Instanceof keyword
- HackerRank #26 | Generics
- HackerRank #27 | 1D Array
- HackerRank #28 | Anagrams
- HackerRank #33 | Arraylist
- HackerRank #34 | Exception Handling Try / Catch
- HackerRank #36 | Exception Handling
- HackerRank #37 | List
- HackerRank #38 | SubArray
- HackerRank #39 | HashSet
- HackerRank #40 | Java Dequeue
Top comments (0)