algorithms_basic 0.1.0 → 1.0.1

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: c94e555e4fb775e5908d73c876ae01df49044891e0f3889d854373a2d1ecce21
-  data.tar.gz: 73390be3f09386c6f0e7b44ea74424c6d23232b0b851503abdbc4efd59260429
+  metadata.gz: db5233953a2baa9d25e7ade8ae61e6a6d7798a68597e3e991e43e0ef7be8351a
+  data.tar.gz: 0eb8abedb6d52038cbe47e8835c7933c66d840bb9897b066a302efe2d35c1393
 SHA512:
-  metadata.gz: 1def9e144031ca2a421bb7ad5e91fc750dbb1f982868a6284dbcae1d6ad33fd2149c1bd9e67da621da61793dfa3ebca88abc13717baa103bbb3f819fc1a67498
-  data.tar.gz: 42d9c0db22c9d03209f78010c2a0f7171379816a9e52de71d673ce919c0d11d169f5d4a2b59f5d3962d4f466c0cabd23596f076cda3b26145aad0eadeb6cd828
+  metadata.gz: 510c21c4c3c0a92261789644f6db9d19cf8f588efb35edf28a580d04f5f96be25f277ca7196181b3d1c14705fe8f746f83214ccd6d9e8e61cb1bf0c3d5ee77ef
+  data.tar.gz: c4b7d9da1948fdaf6ad34112155f22487565ffc9c94fb67defb1b661e58d12ce22b712cd3842aaed093fe9fee36b77d7ffe3f82e7b863a456f1da0d95353659b

data/lib/Algoritimos_fase1/Exercise.rb

@@ -0,0 +1,43 @@
+def search (arr)
+   arr.min
+end
+
+def ordenation (list)
+    list.count
+end
+
+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
+
+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
+
+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
+# lista = [31, 49, 1, 2, 7, 9]
+
+# menor = search(lista)
+# puts menor
+#
+# contador = ordenation(lista)
+# puts contador
+#
+# negativo = negativos(lista)
+# print negativo
+
+# resultado = verificar_list(lista)
+# puts resultado
+
+# new_result = deletado(lista)
+# print new_result

data/lib/Algoritimos_fase1/array_reversal.rb

@@ -0,0 +1,20 @@
+
+
+def reversal(arr, start, fim)
+	while start < fim
+		arr[start],arr[fim] = arr[fim], arr[start]
+		start += 1
+		fim -= 1
+	end
+end
+
+def rothate(arr ,d, n)
+	reversal(arr, 0, n - 1)
+	reversal(arr, 0, d - 1)
+	reversal(arr, d, n - 1)
+end
+array = [1,2,3,4,5,6,7,8,9,10]
+array.length
+k = 3
+rothate(array, k, array.length)
+print array.inspect

data/lib/Algoritimos_fase1/binary_search.rb

@@ -0,0 +1,15 @@
+def binary_search (arr,target)
+    arr.bsearch { |x| x >= target} #Essa função faz a pesquisa binária
+end
+
+
+arr = (10..100).to_a
+print "Insira um valor para saber se está na lista: "
+target = 99
+result = binary_search(arr,target)
+
+if result 
+    puts "valor encontrado: #{}"
+else 
+    puts "Valor não encontrado!"
+end

data/lib/Algoritimos_fase1/bubble_sort.rb

@@ -0,0 +1,21 @@
+class Bublle_sort
+	attr_accessor :arr
+	def initialize
+		@arr = arr
+	end
+
+	def bubble_sort(arr)
+		arr.each_index do |i|
+			max_index = arr[i..-1].each_with_index.min_by { |num, _| num }[1] + i
+			arr[i], arr[max_index] = arr[max_index], arr[i]
+			true
+		end
+		arr
+	end
+end
+
+lista = [9,2,6,3,7,1,-3,-8]
+result = Bublle_sort.new
+print result.bubble_sort(lista)
+
+# puts "Minha lista ficou ordenada da seguinte forma: #{result.inspect}"

data/lib/Algoritimos_fase1/counting_sort.rb

@@ -0,0 +1,33 @@
+# O algoritimo counting sort é baseado em três arrays
+
+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
+
+lista = [3,2,4,7,4,7,1,2,3]
+
+result = counting_sort(lista)
+
+puts "O resultado do coutintg sort é #{result}"

data/lib/Algoritimos_fase1/debug_codigos.rb

@@ -0,0 +1,19 @@
+require 'json'
+
+pasta_codigo = "/home/victoroliveira59/Documentos/Github/Ruby/Desenvolvendo_me_/Algoritimos_fase1"
+
+# Percorre todos os arquivos da pasta "Código"
+Dir.foreach(pasta_codigo) do |nome_arquivo|
+  caminho_arquivo = File.join(pasta_codigo, nome_arquivo)
+
+  # Verifica se é um arquivo JSON
+  if File.file?(caminho_arquivo) && nome_arquivo.end_with?('.json')
+    # Realize o debug com o arquivo JSON
+    json_data = File.read(caminho_arquivo)
+    dados = JSON.parse(json_data)
+
+    # Faça o que precisar com os dados do arquivo JSON
+    # Por exemplo, imprimir na tela:
+    puts dados
+  end
+end

data/lib/Algoritimos_fase1/exemplo_maximum.rb

@@ -0,0 +1,17 @@
+def maximum_sum(array, k)
+    array.sort!
+  
+    while k.positive?
+      array[array.index(array.min)] = -array.min
+  
+      k -= 1
+    end
+  
+    array
+  end
+  #
+  # lista = [9,8,8,5]
+  # n = 3
+  #
+  # result = maximum_sum(lista,n)
+  # puts result

data/lib/Algoritimos_fase1/greedy_algorithm.rb

@@ -0,0 +1,22 @@
+#noinspection RubyScope
+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
+
+recebido = gets.chomp.to_i
+valor = gets.chomp.to_i
+
+result = greedy(recebido, valor)
+
+print result

data/lib/Algoritimos_fase1/linear_search.rb

@@ -0,0 +1,16 @@
+array = (10..100).to_a
+
+print "Insira um número: "
+number = gets.chomp.to_i
+
+found = false
+
+array.each do |element|
+    if element == number
+        puts "Valor encontrado #{element}"
+        found = true
+        break
+    end
+end
+
+puts "Valor não encontrado" unless found

data/lib/Algoritimos_fase1/maximiu_array.rb

@@ -0,0 +1,23 @@
+# O
+arr = [9,-8,8,3]
+
+a = arr.sort #essa função ordena o array em ordem crescente
+k = 3
+
+a.each_with_index do |value, i|
+	if k > 0
+		if value < 0 #Condição do valor menor que 0, multiplica por -1 e vira positivo decrementando o meu valor de K
+			a[i] *= - 1
+			k -= 1
+		elsif value == 0
+			k = 0
+			break
+		elsif value > 0 #Quando o menor valor do array e maior que zero ele é multiplicado por menos 1 e o codigo é parado
+			a[i] *= - 1
+			break
+		else
+			break
+		end
+	end
+end
+puts a.sum # Todos os elementos são somados e retornando o resultado

data/lib/Algoritimos_fase1/ordanition_name.rb

@@ -0,0 +1,8 @@
+def name (arr)
+    arr.sort
+end
+
+lista = %w[Carla José Maria Leandro Pablo Ana]
+
+result = name(lista)
+puts "Está é minha lista ordenada alfabética #{result}"

data/lib/Algoritimos_fase1/search_binary_teste.rb

@@ -0,0 +1,35 @@
+# Este código representa a pesquisa binaria essa pesquisa só funciona quando a lista é ordenada a sua notação é log2n
+
+def search(arr, target)
+	arr_init = 0
+	arr_fim = arr.length - 1 #Lê a quantidade de elementos decrementando
+
+	#Esse loop inicia com o inicio verificando se é menor que o fim
+	while arr_init <= arr_fim
+		mid = (arr_init + arr_fim) / 2 #Ele divide o a soma do inicio e o fim por 2
+		chute = arr[mid] # O resultado de mid é comparado pelo indice no array original e (chute passa a valer o numero indicado pelo indice)
+
+		if chute == target # Aqui e colocado uma condição para o valor obtido pela pesquisa comparando com o do usuario
+			return mid
+		elsif
+			chute > target
+			arr_fim = mid - 1 #Essa operação respresenta se o valor estiver acima, decrementa o valor obtido em mid e o arr_fim passa a ter o valor
+		else 								#Como a condição não foi solucionada volta ao inicio do loop
+			arr_init = mid + 1 # Nesta linha acontece que se o numero estiver a abaixo do chute e incrementado +1 a o arr_init
+		end
+	end
+
+end
+
+
+array = [1, 2, 3, 4, 5, 6, 7, 8, 9, 10]
+target = 11
+
+result = search(array, target)
+
+#Condição para saber se o valor foi enccontrado na lista ou não
+if result
+	puts "valor encontrado na posição: #{result}"
+else
+	puts "Valor não encontrado!"
+end

data/lib/ruby_version/version.rb

@@ -0,0 +1,4 @@
+
+module StudyRuby
+	VERSION = "0.1.1"
+end

data/lib/ruby_version.rb

@@ -0,0 +1,12 @@
+require_relative "ruby_version/version"
+
+module RubyVersion
+	class Error < StandardError; end
+	def teste_primeira_gem
+		"teste"
+	end
+end
+
+class String
+	include RubyVersion
+end

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: algorithms_basic
 version: !ruby/object:Gem::Version
-  version: 0.1.0
+  version: 1.0.1
 platform: ruby
 authors:
 - Victor Oliveira
 autorequire: 
-bindir: exe
+bindir: bin
 cert_chain: []
-date: 2023-08-18 00:00:00.000000000 Z
+date: 2023-09-03 00:00:00.000000000 Z
 dependencies: []
 description: This gem was created with the intention of developing my skills as a
   programmer and also provides help for beginners and precisely improve their logic.
@@ -18,7 +18,22 @@ executables: []
 extensions: []
 extra_rdoc_files: []
 files:
+- lib/Algoritimos_fase1/Exercise.rb
+- lib/Algoritimos_fase1/array_reversal.rb
+- lib/Algoritimos_fase1/binary_search.rb
+- lib/Algoritimos_fase1/bubble_sort.rb
+- lib/Algoritimos_fase1/counting_sort.rb
+- lib/Algoritimos_fase1/debug_codigos.rb
+- lib/Algoritimos_fase1/exemplo_maximum.rb
+- lib/Algoritimos_fase1/greedy_algorithm.rb
+- lib/Algoritimos_fase1/linear_search.rb
+- lib/Algoritimos_fase1/maximiu_array.rb
+- lib/Algoritimos_fase1/minimum_spanning.rb
+- lib/Algoritimos_fase1/ordanition_name.rb
+- lib/Algoritimos_fase1/search_binary_teste.rb
 - lib/algorithms_basic.rb
+- lib/ruby_version.rb
+- lib/ruby_version/version.rb
 homepage: https://github.com/victoroliveira59/gem_algorithms_criation
 licenses:
 - MIT
@@ -40,7 +55,7 @@ required_rubygems_version: !ruby/object:Gem::Requirement
     - !ruby/object:Gem::Version
       version: '0'
 requirements: []
-rubygems_version: 3.3.5
+rubygems_version: 3.2.22
 signing_key: 
 specification_version: 4
 summary: A gem to partition an array of integers based on parity