HackerRank #28 | Anagrams | 🇧🇷
Tags: java, anagram, charat, wecoded
Published: 2021-09-01 16:04:31

[Este problema](https://www.hackerrank.com/challenges/java-anagrams/problem) espera que consigamos, a partir de dois `inputs`, identificar se as `strings` recebidas são anagramas, ou seja, que contém as mesmas letras em ordens diferentes.
Para isso, seguimos o passo a passo:

* Fazer o `Scanner` de duas `strings`.
* Como os anagramas não são case sensitive, vamos recebê-las e imediatamente transformá-las em `.toLowerCase()` (poderia ser `.toUpperCase()` também, tanto faz)
* Declaramos o `int sum = 0` porque faremos a verificação a partir de uma soma, onde somente o resultado `0` designa um anagrama.
* O primeiro critério é de que a palavra precisa conter caracteres de `a` a `z`. Para que a verificação aconteça, criamos um `for` que verifique cada posição de caracter. Fica assim:

`for (char c = 'a'; c <= 'z'; c++){`

> Neste `for` também estamos criando a variável `c`.

* Dentro deste `for`, criamos a verificação do segundo critério: checar caracter por caracter até o final da `String`. Para começar  usamos a `length` da `String a`, mas poderíamos ter usado a `length` da `String b`, também. Fica assim:

`for (int i=0; i < a.length(); i++) {`

* Agora sim, dentro desse segundo `for`, passaremos a verificação de caracter em caracter, de forma que na posição `0` ele identifique se existe a letra `a`. Se sim, soma 1 e passa para a posição 1, ainda procurando a letra `a` e assim até o final da `String`. Fazemos isso para a `String a` e para a `String b`.

```
                if (a.charAt(i) == c) {
                    sum++;
                }
                if (b.charAt(i) == c) {
                    sum--;
                }
```

* Se houver a letra `a` na mesma proporção nas duas Strings, o resultado da `sum = 0` o que nos leva a sair das chaves do segundo for (for (int i=0; i<a.length(); i++)) e entrar em um booleano:

```
            if (sum != 0) {
                return false;
            }
        }
        return true;
    }
```

> Enquanto o `a.length` não tiver terminado, continuamos nesse segundo `for`, verificando a existência de cada letra do alfabeto em cada posição. Quando acaba, retornamos `true` (o que quer dizer que, sim, as duas palavras são anagramas!)

=========

O resultado final é:

```


    static boolean isAnagram(String a, String b) {
        
        if (a.length() != b.length()) {
            return false;
        }
        
        a = a.toLowerCase();
        b = b.toLowerCase();
        int sum = 0;
        for (char c = 'a'; c <= 'z'; c++) {
            for (int i=0; i<a.length(); i++) {
                if (a.charAt(i) == c) {
                    sum++;
                }
                if (b.charAt(i) == c) {
                    sum--;
                }
            }
            if (sum != 0) {
                return false;
            }
        }
        return true;
    }
```

Ufa!

=========

#### Referências
[Discussão](https://www.hackerrank.com/challenges/java-anagrams/forum) : HackerRank

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

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](https://dev.to/beatrizmaciel/hackerrank-13-substring-comparisons-57ha)
- [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
- [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)