HackerRank #13 | Substring Comparisons | 🇧🇷
Tags: java, string, compareto
Published: 2021-08-27 18:23:38

[Esse problema](https://www.hackerrank.com/challenges/java-string-compare/problem) pede dois inputs: uma `string` e um `int`. Essa `string` terá seus caracteres separados do tamanho do `int` que receber.

Exemplo de `input`:
```
estratosfera
2
```

Os caracteres serão divididos pelo número de entrada (no caso acima, 2):
`es tr at os fe ra`

A partir desse `input`, e sabendo que devemos dividir os caracteres de acordo com o número de entrada, usaremos o `.compareTo()` para organizar as silabas em ordem alfanumérica.
O output deve ser organizado em dois resultados:

```
conjunto de caracteres de menor valor
conjunto de caracteres de maior valor
```

Isso significa que primeiro receberemos a divisão que começa com a primeira letra possível do alfabeto (e, por isso, com o menor valor) e depois receberemos com a última letra possível do alfabeto. A palavra `estratosfera` seria organizada, pelo método `.compareTo()`, da seguinte forma:

`at es fe os ra tr`

Mas, como queremos apenar o conjunto de caracteres de menor e de maior valor, o output será:

```
at    //.. conjunto de caracteres de menor valor
tr    //.. conjunto de caracteres de maior valor
```

=======================

O código começa assim:

```
import java.util.Scanner;

public class Solution {

    public static String getSmallestAndLargest(String s, int k) {
        String smallest = "";
        String largest = "";
        
        // Complete the function
        // 'smallest' must be the lexicographically smallest substring of length 'k'
        // 'largest' must be the lexicographically largest substring of length 'k'
        
        return smallest + "\n" + largest;
    }


    public static void main(String[] args) {
        Scanner scan = new Scanner(System.in);
        String s = scan.next();
        int k = scan.nextInt();
        scan.close();
      
        System.out.println(getSmallestAndLargest(s, k));
    }
}
```

=========

#### O passo a passo consiste em:

* Declarar que as variáveis `smallest` e `largest` começam em 0 e tem o tamanho de caracteres declarados pelo input `k`. Essa declaração é só para começar, porque será substituída posteriormente. Por isso as duas são iguais.
* Declarar um `int` que começa em 0
* Fazer um `while` que some a variável `i` com `k` (número de entrada no input)
* Enquanto essa soma for menor ou do mesmo tamanho da `string`, fazer uma `substring` que comece em `i` (a partir de 0) e termine no número de input `k + i`. Se for menor do que 0, significa que o conjunto de caracteres é menor alfanumericamente.
* Se o conjunto de caracteres for menor alfanumericamente, isso significa que vamos substituir o valor de `smallest`.
* Se o conjunto de caracteres não for menor (e, portanto, não retornar um número negativo), vai para o segundo `if`. Se, na comparação, o conjunto de caracteres for maior do que o valor inicial declarado no `largest`, este conjunto substitui o valor anterior.
* Por fim, somamos mais uma posição `(i++)` para dar cabo à iteração e ir comparando todos os conjuntos de caracteres até que termine as possibilidades de acordo com o tamanho `(length)` da `String` de input `(s)`.

========= 

#### Solução

```
        String smallest = s.substring(0,k);
        String largest = s.substring(0,k);
        int i = 0;

        while (i+k <= s.length()) {
            if(s.substring(i,i+k).compareTo(smallest) < 0 ) {
                smallest = s.substring(i,i+k);
            } else if (s.substring(i,i+k).compareTo(largest) > 0) {
                largest = s.substring(i,i+k);
            }
            i++;
        }
```

========= 

#### Referências

- [CompareTo() e Substring](https://dev.to/beatrizmaciel/hackerrank-12-strings-introduction-2d1n) : dev.to/beatrizmaciel

============

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](https://dev.to/beatrizmaciel/hackerrank-6-scanner-e-endoffile-462c)
- [HackerRank #7 | Int to String / String to Int](https://dev.to/beatrizmaciel/hackerrank-7-int-em-string-e-vice-versa-4n1e)
- [HackerRank #8 | Date and Time](https://dev.to/beatrizmaciel/hackerrank-8-date-and-time-1f78)
- [HackerRank #9 | Static Initializer Block](https://dev.to/beatrizmaciel/hackerrank-9-static-initializer-block-48ha)
- [HackerRank #10 | Currency Formatter](https://dev.to/beatrizmaciel/hackerrank-10-currency-formatter-22oj)
- [HackerRank #11 | DataTypes](https://dev.to/beatrizmaciel/hackerrank-11-datatypes-2e9h)
- [HackerRank #12 | Strings Introduction](https://dev.to/beatrizmaciel/hackerrank-12-strings-introduction-2d1n)
- HackerRank #13 | Substring Comparisons
- [HackerRank #14 | Abstract Class](https://dev.to/beatrizmaciel/hackerrank-14-abstract-class-3h5d)
- [HackerRank #18 | BigInteger](https://dev.to/beatrizmaciel/hackerrank-18-biginteger-4jad)
- [HackerRank #19 | Loops II](https://dev.to/beatrizmaciel/hackerrank-19-loops-ii-385n)
- [HackerRank #20 | String Reverse](https://dev.to/beatrizmaciel/hackerrank-20-string-reverse-nec)
- [HackerRank #23 | Instanceof keyword](https://dev.to/beatrizmaciel/hackerrank-23-instanceof-keyword-3lh6)
- [HackerRank #26 | Generics](https://dev.to/beatrizmaciel/hackerrank-26-generics-55p8)
- [HackerRank #27 | 1D Array](https://dev.to/beatrizmaciel/hackerrank-27-1d-array-5f80)
- [HackerRank #28 | Anagrams](https://dev.to/beatrizmaciel/hackerrank-28-anagrams-boi)
- [HackerRank #33 | Arraylist](https://dev.to/beatrizmaciel/hackerrank-33-arraylist-2lj1)
- [HackerRank #34 | Exception Handling Try / Catch](https://dev.to/beatrizmaciel/hackerrank-34-exception-handling-try-catch-144f)
- [HackerRank #36 | Exception Handling](https://dev.to/beatrizmaciel/hackerrank-35-exception-handling-44e)
- [HackerRank #37 | List](https://dev.to/beatrizmaciel/hackerrank-37-list-4gmj)
- [HackerRank #38 | SubArray](https://dev.to/beatrizmaciel/hackerrank-38-subarray-1693)
- [HackerRank #39 | HashSet](https://dev.to/beatrizmaciel/hackerrank-39-hashset-3jb3)
- [HackerRank #40 | Java Dequeue](https://dev.to/beatrizmaciel/hackerrank-40-java-dequeue--497h)