search

vanderleipinto / TT1

0 stars 0 forks source link

TT1 1 #5

Open vanderleipinto opened 6 months ago

vanderleipinto commented 6 months ago
Tabela employees first_name last_name cpf team_id job_title_id
Pedro Alves 665.415.876-80 2 3 Cell
Tiago Nogueira 032.336.130-75 1 1 Cell
João Neves 461.636.517-23 1 2 Cell
Tabela teams id name
1 Ti
2 Suporte
3 Financeiro

Tabela job_titles

id name
1 Desenvolvedor back-endimpr
2 Desenvolvedor front-end
3 Encantador de clientes 
//Java
public boolear isEmpty(String s) {
   return s.length() == 0;
}
//Ruby
def empty?(s)
   return s.size == 0
end
vanderleipinto commented 5 months ago

1

Faça uma função que receba uma string e retorne verdadeiro caso ela seja palíndromo, do contrário ela deve retornar falso. (palíndromos são palavras ou frases que podem ser lidas da esquerda para a direita ou da direita para a esquerda.)

def palindrome?(word)
  return word == word.reverse
end
vanderleipinto commented 5 months ago

2

Faça uma função que receba uma string contendo um CPF e verifique se ele está formatado de acordo com a máscara 999.999.999-99. A função deve usar regex para fazer a validação da máscara e deve retornar verdadeiro ou falso. cpf = “461.636.517-23”

def cpf_mask?(cpf)
  return cpf.match?(/^\d{3}\.\d{3}\.\d{3}-\d{2}$/)
end
vanderleipinto commented 5 months ago

3

O fatorial de um número n!, é definido como o produto de todos os números inteiros de 1 a n. Por exemplo: 5! é 5 4 3 2 1 = 120 A maioria das implementações de cálculo de fatoriais usam uma função recursiva para determinar o valor fatorial(n). No entanto, a maioria dos sistemas não consegue lidar com pilhas de recursividade maiores que 2000. Implemente uma função para calcular o fatorial de números arbitrariamente grandes, sem utilizar recursividade. Regras ● n < 0 deve retornar nil ● n = 0 deve retornar 1 ● n > 0 deve retornar n!

def fatorial(n)
  return nil if n < 0
  return 1 if n == 0

  result = 1
  (1..n).each do |i|
    result *= i
  end
  result
end
vanderleipinto commented 5 months ago

4

A partir das tabelas do banco de dados abaixo, escreva uma query sql que através de join, retorne o nome completo, cpf, equipe e cargo dos colaboradores ordenando os por cpf.

Tabela employees first_name last_name cpf team_id job_title_id
Pedro Alves 665.415.876-80 2 3 Cell
Tiago Nogueira 032.336.130-75 1 1 Cell
João Neves 461.636.517-23 1 2 Cell
Tabela teams id name
1 Ti
2 Suporte
3 Financeiro

Tabela job_titles

id name
1 Desenvolvedor back-endimpr
2 Desenvolvedor front-end
3 Encantador de clientes

Resposta:

SELECT CONCAT(employees.first_name,' ', employees.last_name) AS full_name,
cpf, teams.name AS equipe,
job_titles.name AS cargo FROM employees
JOIN teams ON employees.team_id = teams.id
JOIN job_titles ON employees.job_title_id = job_titles.id
ORDER BY CPF;
vanderleipinto commented 5 months ago

5

Classes das models:

Employee

class Employee < ApplicationRecord
  belongs_to :team
  belongs_to :job_title
end

Team

class Team < ApplicationRecord
  has_many :employees
end

JobTitle

class JobTitle < ApplicationRecord
  has_many :employees
end

Query em ActiveRecord

employee = Employee.joins(:team, :job_title)
                   .select("CONCAT(employees.first_name, ' ', employees.last_name) AS full_name, employees.cpf, teams.name AS equipe, job_titles.name AS cargo")
                   .order(:cpf)

employee.each do |employee|
  puts "Nome completo: #{employee.full_name}, CPF: #{employee.cpf}, Equipe: #{employee.equipe}, Cargo: #{employee.cargo}"
end
vanderleipinto commented 5 months ago

6

O comando a ||= b é um exemplo de operador de atribuição condicional, comumente utilizado em muitas linguagens de programação, incluindo Ruby. Ele é amplamente utilizado devido à sua conveniência e legibilidade. Vamos explicar o que este comando faz e por que é tão popular:

  1. O que faz: O operador ||= atribui o valor de b a a somente se a for considerado falso ou nulo (ou seja, se a for nil ou false). Se a já tiver um valor verdadeiro, a expressão a ||= b não faz nada, deixando a com seu valor atual.

  2. Por que é amplamente utilizado:

    • Concisão: O operador ||= é uma forma concisa de atribuir um valor padrão a uma variável, caso essa variável ainda não tenha sido definida ou esteja indefinida.
    • Legibilidade: O código usando ||= é mais claro e legível do que uma sequência de condições e atribuições explícitas. Ele expressa de forma direta a intenção de atribuir um valor padrão a uma variável apenas se ela não tiver sido atribuída anteriormente.
    • Redução de erros: Evita erros comuns que podem ocorrer ao usar condições explícitas para verificar se uma variável está definida ou possui um valor.
    • Facilita a inicialização de variáveis: É útil ao inicializar variáveis de configuração, onde se deseja definir um valor padrão apenas se o valor original não estiver definido.
    • Padrão de código: É um padrão de código bem estabelecido na comunidade Ruby e é amplamente adotado em projetos Ruby on Rails e outros frameworks.

No geral, o operador ||= é uma ferramenta poderosa para inicializar variáveis de forma segura e expressiva em Ruby e é valorizado pela sua eficácia em manter o código limpo e legível.

vanderleipinto commented 5 months ago

7

A principal diferença entre esses dois métodos está na sintaxe e nas convenções de nomenclatura das linguagens Ruby e Java.

  1. Sintaxe:

    • Em Ruby, o método empty? é definido como uma função comum, usando a palavra-chave def, seguida do nome do método e seus parâmetros entre parênteses. O corpo do método é delimitado por end.
    • Em Java, o método isEmpty é definido dentro de uma classe (provavelmente uma classe utilitária ou de manipulação de strings) usando a palavra-chave public, indicando que o método pode ser acessado de fora da classe. A palavra-chave boolean indica que o método retorna um valor booleano (true ou false). O método é declarado como isEmpty e recebe um parâmetro do tipo String. O corpo do método é delimitado por chaves {}.

  2. Convenções de Nomenclatura:

    • Em Ruby, o método é nomeado como empty?, seguindo a convenção de que métodos que retornam um valor booleano (verdadeiro ou falso) terminam com um ponto de interrogação (?). Isso ajuda a indicar claramente a intenção do método, que é verificar se algo está vazio.
    • Em Java, o método é nomeado como isEmpty, seguindo a convenção de que métodos que verificam se uma coleção ou estrutura de dados está vazia são geralmente nomeados com isEmpty. Essa é uma convenção comum em Java, mas não é uma regra absoluta.

Além disso, as duas linguagens têm diferenças em relação ao uso de métodos de acesso para propriedades de objetos. Em Ruby, você geralmente usa métodos de acesso como size, length, empty?, entre outros, diretamente no objeto. Em Java, você geralmente usa métodos de acesso como length() diretamente em um objeto e usa o valor retornado em comparações, como no caso do método isEmpty.

Portanto, a principal diferença entre esses dois métodos é a sintaxe específica da linguagem e as convenções de nomenclatura adotadas em Ruby e Java.

vanderleipinto commented 5 months ago

8

O self em classes Ruby é uma palavra-chave especial que se refere ao próprio objeto em que o código está sendo executado. É como um pronome que permite acessar os atributos e métodos do objeto dentro de seu contexto.

Funções do self:

Exemplos:

class Pessoa
  attr_accessor :nome

  def initialize(nome)
    self.nome = nome
  end

  def apresentar
    puts "Meu nome é #{self.nome}"
  end
end

pessoa = Pessoa.new("João")
pessoa.apresentar # Imprime "Meu nome é João"

No exemplo acima, self é usado dentro do método initialize para acessar o atributo nome e dentro do método apresentar para recuperar o nome da instância específica da classe Pessoa.

Importância do self:

O self é fundamental para a programação orientada a objetos em Ruby, pois permite que os objetos sejam manipulados de forma flexível e eficiente. Ele facilita o acesso aos atributos e métodos do objeto, tornando o código mais legível e reutilizável.

Dicas para usar o self:

vanderleipinto commented 5 months ago

9

Vantagens da tipagem dinâmica em Ruby:

1. Código mais conciso: A ausência de declarações de tipo torna o código mais enxuto e fácil de ler e escrever.

2. Flexibilidade: Permite que o tipo de uma variável seja alterado durante a execução, proporcionando maior flexibilidade e adaptabilidade.

3. Desenvolvimento rápido: Facilita a criação de protótipos e testes rápidos de ideias, agilizando o processo de desenvolvimento.

4. Metaprogramação: Permite a manipulação de código em tempo de execução, abrindo portas para técnicas avançadas de desenvolvimento.

5. Expressividade: A tipagem dinâmica pode ser vista como mais natural e expressiva, permitindo que o código se concentre na lógica e não nos tipos.

Desvantagens da tipagem dinâmica em Ruby:

1. Erros em tempo de execução: Erros de tipo só são detectados durante a execução, o que pode levar a bugs difíceis de identificar.

2. Dificuldade de depuração: A falta de informações de tipo pode dificultar a depuração de erros, especialmente para programadores menos experientes.

3. Código menos robusto: A flexibilidade da tipagem dinâmica pode levar a código menos robusto e com maior probabilidade de falhas.

4. Dificuldade de documentação: A falta de informações de tipo pode dificultar a documentação do código e sua compreensão por outros programadores.

5. Desempenho: Em alguns casos, a tipagem dinâmica pode levar a um desempenho inferior em comparação com linguagens estaticamente tipadas.

Em resumo:

A tipagem dinâmica do Ruby oferece vantagens em termos de concisão, flexibilidade e agilidade no desenvolvimento. No entanto, é importante estar ciente das desvantagens, como a maior probabilidade de erros em tempo de execução e a dificuldade de depuração. A escolha de Ruby deve levar em consideração o estilo de programação, o tipo de projeto e as necessidades específicas do desenvolvedor.

Recursos adicionais: