postado por @Padfoot em 24/01/2023 22:06

Dessa vez em Go:
Versão convertendo pra string usando "two pointers":


Versão sem converter pra string, saiu mais lenta, mas usou menos memória

def is_palindrome(x)
    x.to_s == x.to_s.reverse
end

class Solution:
    def isPalindrome(self, x: int) -> bool:
        before = str(x)
        after = before[::-1]
        return (before == after)

class Solution {
public:
    bool isPalindrome(int x) {
        int digit;
        long y = 0;
        int aux = x;

        while (aux > 0){
            digit = aux % 10;
            aux = (aux -  digit) /10;
            y = y * 10 + digit;
        }
        return ( x == y);
    }
}

postado por @thrsa em 24/01/2023 10:54

Provavelmente fiz um baita rolo, mas o que importa é o que é importante.

postado por @oxe em 24/01/2023 18:51

Finalmente consegui avançar o suficiente no tutorial de C++ pra conseguir participar do desafio

Aqui vai meu código de iniciante, to bem orgulhoso de ter conseguido completar.

postado por @Abra em 25/01/2023 11:33

Ruby tira um pouco da graça dessas paradas :/

def is_palindrome(x)
    x.to_s == x.to_s.reverse
end

postado por @Giovanni em 26/01/2023 08:08

dá certo assim
Para os exercícios mais simples dá para usar todos métodos da linguagem tipo toString(), reverse, join, etc... mais para frente nos exercícios mais avançado começamos a perceber que esses métodos são custosos em termos computacionais e temos que achar uma solução mais eficiente

essa é a beleza do leetcode, primeiro fazemos o método "força bruta", depois vamos procurando as respostas "otimizadas" para ver outras possibilidades

o no caso o objetivo é ficar no O(n) ou O(n*m) ou O(n+m) sempre que possível :)

postado por @thrsa em 26/01/2023 08:46

Giovanni , quando você fez o TOP já começou desde os Fundamentals a usar essas plataformas tipo o Leetcode pra praticar algoritmos, ou esperou ter uma bagagem maior antes de começar?

postado por @oxe em 24/01/2023 23:07

Muito legal essa segunda forma. A variável div é automaticamente truncada pro menor inteiro mais próximo, né?

Quando eu fui resolver, pensei que teria que mapear o número todo, mas na verdade a questão só pediu a comparação com o número lido ao contrário.

E também não precisa verificar se é negativo porque, construindo um número lido ao contrário positivo, a comparação sempre vai retornar falsa mesmo que o número não seja exatamente igual ao contrário do número original.

Muito legal, aprendi bastante sobre focar no problema e eliminar o supérfluo. Obrigado! 

postado por @Giovanni em 26/01/2023 08:54

comecei assim que cheguei na parte de backend, ainda to nela, como forma de ir praticando outras coisas, e principalmente porque isso é preparatório para entrevistas técnicas também

tem gente que passa meses só fazendo isso antes de entrevista técnica
acho que o jeito que a gente tá fazendo aqui que é ir fazendo 1 por semana, começando pelos mais simples, é uma boa porta de entrada e não atrapalha os estudos

postado por @thrsa em 26/01/2023 12:16

Bem legal, Giovanni . Comecei lá em dezembro por recomendação tua, ainda estou em Foundations e Fundamentals JS 3 lá. Demais a qualidade do TOP, cara. Assim que terminar aquela parte específica ali do JS Basics vou me aprofundar mais no Leetcode e os desafios que tu compartilha aqui já estão me dando uma base.

postado por @Hme05 em 26/01/2023 12:24

Esse TOP é um curso? 

postado por @Giovanni em 26/01/2023 18:41

galera que tá participando, um muito obrigado e um badge para vocês !

class Solution:
    def isPalindrome(self, x: int) -> bool:
        xint = str(x)
        xreverse = xint[::-1]
        return xint == xreverse

postado por @Giovanni em 26/01/2023 08:26

tenta fazer sem usar os built in métodos da linguagem para dar emoção

def is_palindrome(x)
    return false if x < 0

    number_as_array = x.digits
    ary_size        = number_as_array.size
    first_half = (number_as_array.size / 2) - 1 # Array starts at Zero

    first_half = first_half - 1 if ary_size.odd? && ary_size > 3

    (0..first_half).each do |n, index|
      if number_as_array[n] != number_as_array[-(n+1)]
        return false
      end
    end

    return true
end

postado por @FlyCavok em 26/01/2023 21:12

Por que python tá passando o argumento como int ??

Ps: eu sei que é 'hint' e que ele aceita QQ coisa... Mas é estranho

CoragemCaoCovarde meio ilegível pra quem não é fera em python mas ficou legal hahahaha 

Presumo que o ::-1 inverte a string ne ? Presumi pelo ==... Se vc já tá comparando só pode tá invertida

Me explica aquele if < 0 bizarro ali. Significa o que? String vazia ? Empty string não era pra ser palíndromo ??

postado por @Padfoot em 26/01/2023 09:49

Isso mesmo, como div é um int, quando fazemos a divisão só ficamos com a parte antes da virgula.

Sobre eliminar os problemas supérfluos, confesso que várias vezes faço validações redundantes haha

O que tenho feito é dar uma ultima olhada no código depois da solução ser aceita pra verificar melhorias.

postado por @miwan em 28/01/2023 13:29

Neste caso de verificar melhorias geralmente há uma preocupação com a otimização do tempo de execução. 

No meu entendimento, os computadores tem muito poder de processamento de forma geral. Então em um primeiro momento é interessante escrever o código com a forma mais clara possível, facilitando a leitura e o entendimento para uma pessoa fazer a manutenção do código. Para isso, é interessante nomear variáveis de forma clara, utilizar métodos ao invés de linhas de IF gigantes com operações OR, AND.

Outro passo importante, seria evitar erros no runtime. O código precisa rodar de forma satisfatória para quem usa, sem mostrar erros não tratados e sem um crash total.

Claro que a eficiência é importante para escalar o código, mas é um terceiro passo.

Um exercício interessante é revisitar o código alguns dias depois. Tentar entender o que foi escrito e reescrever trazendo para uma linguagem mais humana.

postado por @Abra em 27/01/2023 00:08
Aí, Giovanni : Versão Foderoso da Esquina:

1. Já retorna falso pra número negativo.
2. Pra positivo ele transforma o número numa lista.
3. Percorre até metade da lista testando os pares: primeiro com último, segundo com penultimo...

3.1 Se achar um caso que seja diferente já retorna falso e para de percorrer a lista.
4. Se chegou até aqui retorna verdadeiro
Para o passo 3 eu tô aproveitando de uma característica das listas do Ruby:

O índice para o primeiro elemento começa em 0(zero). Mas, em Ruby, você pode usar o índice negativo e andar na lista de trás pra frente. Sendo assim:
lista[0] é o primeiro elemento.
lista[1] é o segundo elemento.
lista[2] é o terceiro elemento.
lista[-3] é o ante-penúltimo elemento.
lista[-2] é o penúltimo elemento.
lista[-1] é o último elemento.

def is_palindrome(x)
    return false if x < 0

    number_as_array = x.digits
    ary_size        = number_as_array.size
    first_half = (number_as_array.size / 2) - 1 # Array starts at Zero

    first_half = first_half - 1 if ary_size.odd? &amp;&amp; ary_size > 3

    (0..first_half).each do |n, index|
      if number_as_array[n] != number_as_array[-(n+1)]
        return false
      end
    end

    return true
end

postado por @Vitis em 27/01/2023 09:12
FlyCavok, Minha solução ficou muito parecida com a do amigo CoragemCaoCovarde, então, tomo a liberdade de responder pelo amigo...

O "< 0" ele utilizou para testar se o número é negativo, boa sacada (não havia pensado nisso), assim, sempre que um número for negativo, a rotina já retorna um False, pois qualquer número negativo não pode ser palíndromo (ex. não existe 101-)

Quanto ao fatiamento de string, funciona assim, você pode colocar a posição [inicial : final : step], quando passa string[ : :-1] se está "dizendo" que quer toda a string, em um step de -1, ou seja, começa da posição -1 (final) e vai até a posição 0, passando por todos os caracteres. Se colocar 1 por exemplo, o resultado será o default, ou seja, a string completa.
Espero ter colaborado um pouco.

postado por @Vitis em 27/01/2023 09:12
FlyCavok, Minha solução ficou muito parecida com a do amigo CoragemCaoCovarde, então, tomo a liberdade de responder pelo amigo...

O "< 0" ele utilizou para testar se o número é negativo, boa sacada (não havia pensado nisso), assim, sempre que um número for negativo, a rotina já retorna um False, pois qualquer número negativo não pode ser palíndromo (ex. não existe 101-)

Quanto ao fatiamento de string, funciona assim, você pode colocar a posição [inicial : final : step], quando passa string[ : :-1] se está "dizendo" que quer toda a string, em um step de -1, ou seja, começa da posição -1 (final) e vai até a posição 0, passando por todos os caracteres. Se colocar 1 por exemplo, o resultado será o default, ou seja, a string completa.
Espero ter colaborado um pouco.

postado por @ContinuousStudy em 07/02/2023 09:18

Semanas atrasado, mas segue aí

print("Digite o número que vc deseja verificar se é um palindromo:")
num = int(input(":"))

indo = []
voltando = []
teste = []

lista = list(str(num))
#print(lista)

for i in lista:
  indo.append(i)
  teste.append(i)

for i in range(len(lista)):
  voltando.append(teste[-1])
  teste.pop()

#print(indo)
#print(voltando)
print("...")
print(indo == voltando)