Top Level Namespace

Defined Under Namespace

Modules: RubyVersion, StudyRuby Classes: Array, Bublle_sort, String

Instance Method Summary collapse

Instance Method Details

#binary_search(arr, target) ⇒ Object 



1
2
3
 
# File 'lib/Algoritimos_fase1/binary_search.rb', line 1

def binary_search (arr,target)
    arr.bsearch { |x| x >= target} #Essa função faz a pesquisa binária
end

#counting_sort(arr) ⇒ Object

O algoritimo counting sort é baseado em três arrays



3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
 
# File 'lib/Algoritimos_fase1/counting_sort.rb', line 3

def counting_sort(arr)

	max_value = 7 #Essa linha indica que meu array deve ter no máximo 7 indices(0 a 6)
	count = Array.new(max_value, 0)

# O loop abaixo calcula a frequência de repetição dos arrays em um novo array(count) que armazena a repetição de cada número em seu indice
	arr.each do |element|
		count[element - 1] += 1 #Está linha verifica cada elemento e se houver uma repetição incrementa mais 1 ao indice do elemento
	end

# As linhas abaixo faz uma soma de acumulativo a partir do primeiro indice
count.each_with_index do |_, i|
	next if i == 0 #condição para iniciar a partir do primeiro indice
		count[i] += count[i - 1] #Calculo para calcular o indice atual mais o indice anterior
	end

array_b = Array.new(0) #Inicia o terceiro array

	(arr.length - 1).downto(0) do |i| #Loop para percorrer o array de trás para frente
		array_b[count[arr[i] - 1] - 1] = arr[i] # Essa linha está pedindo para poder ir no array principal(arr) pegar o ultimo numero desse array e comparar com o array(count)
																						# armazenar o numero correspondente do array(arr) baseado no numero do array(count) decrementado em menos 1 e armazenar no indice correspondente do array_b
		count[arr[i]-1] -= 1										# <= E a linha ao lado decrementa o número do indice usado na operação anterior em menos 1 par que se array(arr) tiver um numero repetido ele é armazenado no indice anterior
	end
	array_b
end

#deletado(enum) ⇒ Object 



23
24
25
26
27
 
# File 'lib/Algoritimos_fase1/Exercise.rb', line 23

def deletado (enum)
    numeros = enum.dup #Usado o (.dup) para fazer uma cópia do array original
    numeros.delete_at(2) # Utilizamos o delete_at() para deletar um elemento com base no seu indice
    numeros
end

#greedy(recebido, valor) ⇒ Object

noinspection RubyScope



2
3
4
5
6
7
8
9
10
11
12
13
14
15
 
# File 'lib/Algoritimos_fase1/greedy_algorithm.rb', line 2

def greedy (recebido, valor)

    moeda = [1, 5, 10, 25, 50]

    troco = Array.new(0)
    troco_total = recebido - valor

    while troco_total > 0
        maior_moeda = moeda.select { |moeda| moeda <= troco_total}.max
        troco << maior_moeda
        troco_total -= maior_moeda
    end
    troco
end

#maximum_sum(array, k) ⇒ Object 



1
2
3
4
5
6
7
8
9
10
11
 
# File 'lib/Algoritimos_fase1/exemplo_maximum.rb', line 1

def maximum_sum(array, k)
  array.sort!

  while k.positive?
    array[array.index(array.min)] = -array.min

    k -= 1
  end

  array
end

#name(arr) ⇒ Object 



1
2
3
 
# File 'lib/Algoritimos_fase1/ordanition_name.rb', line 1

def name (arr)
    arr.sort
end

#negativos(num) ⇒ Object 



9
10
11
12
13
14
15
 
# File 'lib/Algoritimos_fase1/Exercise.rb', line 9

def negativos (num)
    new_array = []
    num.each_with_index do |_, i | #Negativando os numeros de um array, os que são positivos viram negativos e vice versa
        new_array << num[i] * -1
    end
    new_array
end

#ordenation(list) ⇒ Object 



5
6
7
 
# File 'lib/Algoritimos_fase1/Exercise.rb', line 5

def ordenation (list)
    list.count
end

#reversal(arr, start, fim) ⇒ Object 



3
4
5
6
7
8
9
 
# File 'lib/Algoritimos_fase1/array_reversal.rb', line 3

def reversal(arr, start, fim)
	while start < fim
		arr[start],arr[fim] = arr[fim], arr[start]
		start += 1
		fim -= 1
	end
end

#rothate(arr, d, n) ⇒ Object 



11
12
13
14
15
 
# File 'lib/Algoritimos_fase1/array_reversal.rb', line 11

def rothate(arr ,d, n)
	reversal(arr, 0, n - 1)
	reversal(arr, 0, d - 1)
	reversal(arr, d, n - 1)
end

#search(arr, target) ⇒ Object

Este código representa a pesquisa binaria essa pesquisa só funciona quando a lista é ordenada a sua notação é log2n



3
4
5
 
# File 'lib/Algoritimos_fase1/search_binary_teste.rb', line 3

def search (arr)
   arr.min
end

#verificar_list(numb) ⇒ Object

Essa função verifica se todos os elementos da lista são pares se for imprimi true senão false



17
18
19
20
21
 
# File 'lib/Algoritimos_fase1/Exercise.rb', line 17

def verificar_list (numb) # Essa função verifica se todos os elementos da lista são pares se for imprimi true senão false
    numb.none? do |element|
        element.even?
    end
end