CS_learn/hello-algo
1
0
Fork 0
mirror of https://github.com/krahets/hello-algo.git synced 2026-07-07 11:36:46 +08:00
Code Issues Packages Projects Releases Wiki Activity

build

Browse Source
This commit is contained in:
krahets
2026-03-29 05:06:58 +08:00
parent 37523d4ceb
commit 967293c421
51 changed files with 288 additions and 5073 deletions
Download Patch File Download Diff File Expand all files Collapse all files

222
ru/docs/chapter_computational_complexity/iteration_and_recursion.md
View File

@@ -185,13 +185,7 @@ comments: true
=== "Ruby"
```ruby title="iteration.rb"
=begin
File: iteration.rb
Created Time: 2024-03-30
Author: Xuan Khoa Tu Nguyen (ngxktuzkai2000@gmail.com), Cy (9738314@gmail.com)
=end
# ## Цикл for ###
### Цикл for ###
def for_loop(n)
res = 0
@@ -419,25 +413,7 @@ comments: true
=== "Ruby"
```ruby title="iteration.rb"
=begin
File: iteration.rb
Created Time: 2024-03-30
Author: Xuan Khoa Tu Nguyen (ngxktuzkai2000@gmail.com), Cy (9738314@gmail.com)
=end
# ## Цикл for ###
def for_loop(n)
res = 0
# Циклическое суммирование 1, 2, ..., n-1, n
for i in 1..n
res += i
end
res
end
# ## Цикл while ###
### Цикл while ###
def while_loop(n)
res = 0
i = 1 # Инициализация условной переменной
@@ -680,39 +656,7 @@ comments: true
=== "Ruby"
```ruby title="iteration.rb"
=begin
File: iteration.rb
Created Time: 2024-03-30
Author: Xuan Khoa Tu Nguyen (ngxktuzkai2000@gmail.com), Cy (9738314@gmail.com)
=end
# ## Цикл for ###
def for_loop(n)
res = 0
# Циклическое суммирование 1, 2, ..., n-1, n
for i in 1..n
res += i
end
res
end
# ## Цикл while ###
def while_loop(n)
res = 0
i = 1 # Инициализация условной переменной
# Циклическое суммирование 1, 2, ..., n-1, n
while i <= n
res += i
i += 1 # Обновить условную переменную
end
res
end
# ## Цикл while (двойное обновление) ###
### Цикл while (двойное обновление) ###
def while_loop_ii(n)
res = 0
i = 1 # Инициализация условной переменной
@@ -948,55 +892,7 @@ comments: true
=== "Ruby"
```ruby title="iteration.rb"
=begin
File: iteration.rb
Created Time: 2024-03-30
Author: Xuan Khoa Tu Nguyen (ngxktuzkai2000@gmail.com), Cy (9738314@gmail.com)
=end
# ## Цикл for ###
def for_loop(n)
res = 0
# Циклическое суммирование 1, 2, ..., n-1, n
for i in 1..n
res += i
end
res
end
# ## Цикл while ###
def while_loop(n)
res = 0
i = 1 # Инициализация условной переменной
# Циклическое суммирование 1, 2, ..., n-1, n
while i <= n
res += i
i += 1 # Обновить условную переменную
end
res
end
# ## Цикл while (двойное обновление) ###
def while_loop_ii(n)
res = 0
i = 1 # Инициализация условной переменной
# Циклическое суммирование 1, 4, 10, ...
while i <= n
res += i
# Обновить условную переменную
i += 1
i *= 2
end
res
end
# ## Двойной цикл for ###
### Двойной цикл for ###
def nested_for_loop(n)
res = ""
@@ -1224,13 +1120,7 @@ comments: true
=== "Ruby"
```ruby title="recursion.rb"
=begin
File: recursion.rb
Created Time: 2024-03-30
Author: Xuan Khoa Tu Nguyen (ngxktuzkai2000@gmail.com)
=end
# ## Рекурсия ###
### Рекурсия ###
def recur(n)
# Условие завершения
return 1 if n == 1
@@ -1445,43 +1335,7 @@ comments: true
=== "Ruby"
```ruby title="recursion.rb"
=begin
File: recursion.rb
Created Time: 2024-03-30
Author: Xuan Khoa Tu Nguyen (ngxktuzkai2000@gmail.com)
=end
# ## Рекурсия ###
def recur(n)
# Условие завершения
return 1 if n == 1
# Рекурсия: рекурсивный вызов
res = recur(n - 1)
# Возврат: вернуть результат
n + res
end
# ## Имитация рекурсии итерацией ###
def for_loop_recur(n)
# Использовать явный стек для имитации системного стека вызовов
stack = []
res = 0
# Рекурсия: рекурсивный вызов
for i in n.downto(0)
# Имитировать «рекурсию» с помощью операции помещения в стек
stack << i
end
# Возврат: вернуть результат
while !stack.empty?
res += stack.pop
end
# res = 1+2+3+...+n
res
end
# ## Хвостовая рекурсия ###
### Хвостовая рекурсия ###
def tail_recur(n, res)
# Условие завершения
return res if n == 0
@@ -1705,51 +1559,7 @@ comments: true
=== "Ruby"
```ruby title="recursion.rb"
=begin
File: recursion.rb
Created Time: 2024-03-30
Author: Xuan Khoa Tu Nguyen (ngxktuzkai2000@gmail.com)
=end
# ## Рекурсия ###
def recur(n)
# Условие завершения
return 1 if n == 1
# Рекурсия: рекурсивный вызов
res = recur(n - 1)
# Возврат: вернуть результат
n + res
end
# ## Имитация рекурсии итерацией ###
def for_loop_recur(n)
# Использовать явный стек для имитации системного стека вызовов
stack = []
res = 0
# Рекурсия: рекурсивный вызов
for i in n.downto(0)
# Имитировать «рекурсию» с помощью операции помещения в стек
stack << i
end
# Возврат: вернуть результат
while !stack.empty?
res += stack.pop
end
# res = 1+2+3+...+n
res
end
# ## Хвостовая рекурсия ###
def tail_recur(n, res)
# Условие завершения
return res if n == 0
# Хвостовой рекурсивный вызов
tail_recur(n - 1, res + n)
end
# ## Последовательность Фибоначчи: рекурсия ###
### Последовательность Фибоначчи: рекурсия ###
def fib(n)
# Условие завершения: f(1) = 0, f(2) = 1
return n - 1 if n == 1 || n == 2
@@ -2084,23 +1894,7 @@ comments: true
=== "Ruby"
```ruby title="recursion.rb"
=begin
File: recursion.rb
Created Time: 2024-03-30
Author: Xuan Khoa Tu Nguyen (ngxktuzkai2000@gmail.com)
=end
# ## Рекурсия ###
def recur(n)
# Условие завершения
return 1 if n == 1
# Рекурсия: рекурсивный вызов
res = recur(n - 1)
# Возврат: вернуть результат
n + res
end
# ## Имитация рекурсии итерацией ###
### Имитация рекурсии итерацией ###
def for_loop_recur(n)
# Использовать явный стек для имитации системного стека вызовов
stack = []

275
ru/docs/chapter_computational_complexity/space_complexity.md
View File

@@ -1157,39 +1157,13 @@ $$
=== "Ruby"
```ruby title="space_complexity.rb"
=begin
File: space_complexity.rb
Created Time: 2024-03-30
Author: Xuan Khoa Tu Nguyen (ngxktuzkai2000@gmail.com)
=end
require_relative '../utils/list_node'
require_relative '../utils/tree_node'
require_relative '../utils/print_util'
# ## Функция ###
### Функция ###
def function
# Выполнить некоторые операции
0
end
=begin
File: space_complexity.rb
Created Time: 2024-03-30
Author: Xuan Khoa Tu Nguyen (ngxktuzkai2000@gmail.com)
=end
require_relative '../utils/list_node'
require_relative '../utils/tree_node'
require_relative '../utils/print_util'
# ## Функция ###
def function
# Выполнить некоторые операции
0
end
# ## Постоянная сложность ###
### Постоянная сложность ###
def constant(n)
# Константы, переменные и объекты занимают O(1) памяти
a = 0
@@ -1468,36 +1442,7 @@ $$
=== "Ruby"
```ruby title="space_complexity.rb"
=begin
File: space_complexity.rb
Created Time: 2024-03-30
Author: Xuan Khoa Tu Nguyen (ngxktuzkai2000@gmail.com)
=end
require_relative '../utils/list_node'
require_relative '../utils/tree_node'
require_relative '../utils/print_util'
# ## Функция ###
def function
# Выполнить некоторые операции
0
end
# ## Постоянная сложность ###
def constant(n)
# Константы, переменные и объекты занимают O(1) памяти
a = 0
nums = [0] * 10000
node = ListNode.new
# Переменные в цикле занимают O(1) памяти
(0...n).each { c = 0 }
# Функции в цикле занимают O(1) памяти
(0...n).each { function }
end
# ## Линейная сложность ###
### Линейная сложность ###
def linear(n)
# Список длины n занимает O(n) памяти
nums = Array.new(n, 0)
@@ -1662,48 +1607,7 @@ $$
=== "Ruby"
```ruby title="space_complexity.rb"
=begin
File: space_complexity.rb
Created Time: 2024-03-30
Author: Xuan Khoa Tu Nguyen (ngxktuzkai2000@gmail.com)
=end
require_relative '../utils/list_node'
require_relative '../utils/tree_node'
require_relative '../utils/print_util'
# ## Функция ###
def function
# Выполнить некоторые операции
0
end
# ## Постоянная сложность ###
def constant(n)
# Константы, переменные и объекты занимают O(1) памяти
a = 0
nums = [0] * 10000
node = ListNode.new
# Переменные в цикле занимают O(1) памяти
(0...n).each { c = 0 }
# Функции в цикле занимают O(1) памяти
(0...n).each { function }
end
# ## Линейная сложность ###
def linear(n)
# Список длины n занимает O(n) памяти
nums = Array.new(n, 0)
# Хеш-таблица длины n занимает O(n) памяти
hmap = {}
for i in 0...n
hmap[i] = i.to_s
end
end
# ## Линейная сложность (рекурсивная реализация) ###
### Линейная сложность (рекурсивная реализация) ###
def linear_recur(n)
puts "Рекурсия n = #{n}"
return if n == 1
@@ -1937,55 +1841,7 @@ $$
=== "Ruby"
```ruby title="space_complexity.rb"
=begin
File: space_complexity.rb
Created Time: 2024-03-30
Author: Xuan Khoa Tu Nguyen (ngxktuzkai2000@gmail.com)
=end
require_relative '../utils/list_node'
require_relative '../utils/tree_node'
require_relative '../utils/print_util'
# ## Функция ###
def function
# Выполнить некоторые операции
0
end
# ## Постоянная сложность ###
def constant(n)
# Константы, переменные и объекты занимают O(1) памяти
a = 0
nums = [0] * 10000
node = ListNode.new
# Переменные в цикле занимают O(1) памяти
(0...n).each { c = 0 }
# Функции в цикле занимают O(1) памяти
(0...n).each { function }
end
# ## Линейная сложность ###
def linear(n)
# Список длины n занимает O(n) памяти
nums = Array.new(n, 0)
# Хеш-таблица длины n занимает O(n) памяти
hmap = {}
for i in 0...n
hmap[i] = i.to_s
end
end
# ## Линейная сложность (рекурсивная реализация) ###
def linear_recur(n)
puts "Рекурсия n = #{n}"
return if n == 1
linear_recur(n - 1)
end
# ## Квадратичная сложность ###
### Квадратичная сложность ###
def quadratic(n)
# Двумерный список занимает O(n^2) памяти
Array.new(n) { Array.new(n, 0) }
@@ -2163,61 +2019,7 @@ $$
=== "Ruby"
```ruby title="space_complexity.rb"
=begin
File: space_complexity.rb
Created Time: 2024-03-30
Author: Xuan Khoa Tu Nguyen (ngxktuzkai2000@gmail.com)
=end
require_relative '../utils/list_node'
require_relative '../utils/tree_node'
require_relative '../utils/print_util'
# ## Функция ###
def function
# Выполнить некоторые операции
0
end
# ## Постоянная сложность ###
def constant(n)
# Константы, переменные и объекты занимают O(1) памяти
a = 0
nums = [0] * 10000
node = ListNode.new
# Переменные в цикле занимают O(1) памяти
(0...n).each { c = 0 }
# Функции в цикле занимают O(1) памяти
(0...n).each { function }
end
# ## Линейная сложность ###
def linear(n)
# Список длины n занимает O(n) памяти
nums = Array.new(n, 0)
# Хеш-таблица длины n занимает O(n) памяти
hmap = {}
for i in 0...n
hmap[i] = i.to_s
end
end
# ## Линейная сложность (рекурсивная реализация) ###
def linear_recur(n)
puts "Рекурсия n = #{n}"
return if n == 1
linear_recur(n - 1)
end
# ## Квадратичная сложность ###
def quadratic(n)
# Двумерный список занимает O(n^2) памяти
Array.new(n) { Array.new(n, 0) }
end
# ## Квадратичная сложность (рекурсивная реализация) ###
### Квадратичная сложность (рекурсивная реализация) ###
def quadratic_recur(n)
return 0 unless n > 0
@@ -2410,70 +2212,7 @@ $$
=== "Ruby"
```ruby title="space_complexity.rb"
=begin
File: space_complexity.rb
Created Time: 2024-03-30
Author: Xuan Khoa Tu Nguyen (ngxktuzkai2000@gmail.com)
=end
require_relative '../utils/list_node'
require_relative '../utils/tree_node'
require_relative '../utils/print_util'
# ## Функция ###
def function
# Выполнить некоторые операции
0
end
# ## Постоянная сложность ###
def constant(n)
# Константы, переменные и объекты занимают O(1) памяти
a = 0
nums = [0] * 10000
node = ListNode.new
# Переменные в цикле занимают O(1) памяти
(0...n).each { c = 0 }
# Функции в цикле занимают O(1) памяти
(0...n).each { function }
end
# ## Линейная сложность ###
def linear(n)
# Список длины n занимает O(n) памяти
nums = Array.new(n, 0)
# Хеш-таблица длины n занимает O(n) памяти
hmap = {}
for i in 0...n
hmap[i] = i.to_s
end
end
# ## Линейная сложность (рекурсивная реализация) ###
def linear_recur(n)
puts "Рекурсия n = #{n}"
return if n == 1
linear_recur(n - 1)
end
# ## Квадратичная сложность ###
def quadratic(n)
# Двумерный список занимает O(n^2) памяти
Array.new(n) { Array.new(n, 0) }
end
# ## Квадратичная сложность (рекурсивная реализация) ###
def quadratic_recur(n)
return 0 unless n > 0
# Длина массива nums равна n, n-1, ..., 2, 1
nums = Array.new(n, 0)
quadratic_recur(n - 1)
end
# ## Экспоненциальная сложность (построение полного двоичного дерева) ###
### Экспоненциальная сложность (построение полного двоичного дерева) ###
def build_tree(n)
return if n == 0

747
ru/docs/chapter_computational_complexity/time_complexity.md
View File

@@ -1182,13 +1182,7 @@ $$
=== "Ruby"
```ruby title="time_complexity.rb"
=begin
File: time_complexity.rb
Created Time: 2024-03-30
Author: Xuan Khoa Tu Nguyen (ngxktuzkai2000@gmail.com)
=end
# ## Постоянная сложность ###
### Постоянная сложность ###
def constant(n)
count = 0
size = 100000
@@ -1357,23 +1351,7 @@ $$
=== "Ruby"
```ruby title="time_complexity.rb"
=begin
File: time_complexity.rb
Created Time: 2024-03-30
Author: Xuan Khoa Tu Nguyen (ngxktuzkai2000@gmail.com)
=end
# ## Постоянная сложность ###
def constant(n)
count = 0
size = 100000
(0...size).each { count += 1 }
count
end
# ## Линейная сложность ###
### Линейная сложность ###
def linear(n)
count = 0
(0...n).each { count += 1 }
@@ -1557,30 +1535,7 @@ $$
=== "Ruby"
```ruby title="time_complexity.rb"
=begin
File: time_complexity.rb
Created Time: 2024-03-30
Author: Xuan Khoa Tu Nguyen (ngxktuzkai2000@gmail.com)
=end
# ## Постоянная сложность ###
def constant(n)
count = 0
size = 100000
(0...size).each { count += 1 }
count
end
# ## Линейная сложность ###
def linear(n)
count = 0
(0...n).each { count += 1 }
count
end
# ## Линейная сложность (обход массива) ###
### Линейная сложность (обход массива) ###
def array_traversal(nums)
count = 0
@@ -1796,42 +1751,7 @@ $$
=== "Ruby"
```ruby title="time_complexity.rb"
=begin
File: time_complexity.rb
Created Time: 2024-03-30
Author: Xuan Khoa Tu Nguyen (ngxktuzkai2000@gmail.com)
=end
# ## Постоянная сложность ###
def constant(n)
count = 0
size = 100000
(0...size).each { count += 1 }
count
end
# ## Линейная сложность ###
def linear(n)
count = 0
(0...n).each { count += 1 }
count
end
# ## Линейная сложность (обход массива) ###
def array_traversal(nums)
count = 0
# Число итераций пропорционально длине массива
for num in nums
count += 1
end
count
end
# ## Квадратичная сложность ###
### Квадратичная сложность ###
def quadratic(n)
count = 0
@@ -2133,56 +2053,7 @@ $$
=== "Ruby"
```ruby title="time_complexity.rb"
=begin
File: time_complexity.rb
Created Time: 2024-03-30
Author: Xuan Khoa Tu Nguyen (ngxktuzkai2000@gmail.com)
=end
# ## Постоянная сложность ###
def constant(n)
count = 0
size = 100000
(0...size).each { count += 1 }
count
end
# ## Линейная сложность ###
def linear(n)
count = 0
(0...n).each { count += 1 }
count
end
# ## Линейная сложность (обход массива) ###
def array_traversal(nums)
count = 0
# Число итераций пропорционально длине массива
for num in nums
count += 1
end
count
end
# ## Квадратичная сложность ###
def quadratic(n)
count = 0
# Число итераций квадратично зависит от размера данных n
for i in 0...n
for j in 0...n
count += 1
end
end
count
end
# ## Квадратичная сложность (пузырьковая сортировка) ###
### Квадратичная сложность (пузырьковая сортировка) ###
def bubble_sort(nums)
count = 0 # Счетчик
@@ -2438,77 +2309,7 @@ $$
=== "Ruby"
```ruby title="time_complexity.rb"
=begin
File: time_complexity.rb
Created Time: 2024-03-30
Author: Xuan Khoa Tu Nguyen (ngxktuzkai2000@gmail.com)
=end
# ## Постоянная сложность ###
def constant(n)
count = 0
size = 100000
(0...size).each { count += 1 }
count
end
# ## Линейная сложность ###
def linear(n)
count = 0
(0...n).each { count += 1 }
count
end
# ## Линейная сложность (обход массива) ###
def array_traversal(nums)
count = 0
# Число итераций пропорционально длине массива
for num in nums
count += 1
end
count
end
# ## Квадратичная сложность ###
def quadratic(n)
count = 0
# Число итераций квадратично зависит от размера данных n
for i in 0...n
for j in 0...n
count += 1
end
end
count
end
# ## Квадратичная сложность (пузырьковая сортировка) ###
def bubble_sort(nums)
count = 0 # Счетчик
# Внешний цикл: неотсортированный диапазон [0, i]
for i in (nums.length - 1).downto(0)
# Внутренний цикл: переместить максимальный элемент неотсортированного диапазона [0, i] в его правый конец
for j in 0...i
if nums[j] > nums[j + 1]
# Поменять местами nums[j] и nums[j + 1]
tmp = nums[j]
nums[j] = nums[j + 1]
nums[j + 1] = tmp
count += 3 # Обмен элементов включает 3 элементарные операции
end
end
end
count
end
# ## Экспоненциальная сложность (итеративная реализация) ###
### Экспоненциальная сложность (итеративная реализация) ###
def exponential(n)
count, base = 0, 1
@@ -2668,91 +2469,7 @@ $$
=== "Ruby"
```ruby title="time_complexity.rb"
=begin
File: time_complexity.rb
Created Time: 2024-03-30
Author: Xuan Khoa Tu Nguyen (ngxktuzkai2000@gmail.com)
=end
# ## Постоянная сложность ###
def constant(n)
count = 0
size = 100000
(0...size).each { count += 1 }
count
end
# ## Линейная сложность ###
def linear(n)
count = 0
(0...n).each { count += 1 }
count
end
# ## Линейная сложность (обход массива) ###
def array_traversal(nums)
count = 0
# Число итераций пропорционально длине массива
for num in nums
count += 1
end
count
end
# ## Квадратичная сложность ###
def quadratic(n)
count = 0
# Число итераций квадратично зависит от размера данных n
for i in 0...n
for j in 0...n
count += 1
end
end
count
end
# ## Квадратичная сложность (пузырьковая сортировка) ###
def bubble_sort(nums)
count = 0 # Счетчик
# Внешний цикл: неотсортированный диапазон [0, i]
for i in (nums.length - 1).downto(0)
# Внутренний цикл: переместить максимальный элемент неотсортированного диапазона [0, i] в его правый конец
for j in 0...i
if nums[j] > nums[j + 1]
# Поменять местами nums[j] и nums[j + 1]
tmp = nums[j]
nums[j] = nums[j + 1]
nums[j + 1] = tmp
count += 3 # Обмен элементов включает 3 элементарные операции
end
end
end
count
end
# ## Экспоненциальная сложность (итеративная реализация) ###
def exponential(n)
count, base = 0, 1
# На каждом шаге клетка делится надвое, образуя последовательность 1, 2, 4, 8, ..., 2^(n-1)
(0...n).each do
(0...base).each { count += 1 }
base *= 2
end
# count = 1 + 2 + 4 + 8 + .. + 2^(n-1) = 2^n - 1
count
end
# ## Экспоненциальная сложность (рекурсивная реализация) ###
### Экспоненциальная сложность (рекурсивная реализация) ###
def exp_recur(n)
return 1 if n == 1
exp_recur(n - 1) + exp_recur(n - 1) + 1
@@ -2943,97 +2660,7 @@ $$
=== "Ruby"
```ruby title="time_complexity.rb"
=begin
File: time_complexity.rb
Created Time: 2024-03-30
Author: Xuan Khoa Tu Nguyen (ngxktuzkai2000@gmail.com)
=end
# ## Постоянная сложность ###
def constant(n)
count = 0
size = 100000
(0...size).each { count += 1 }
count
end
# ## Линейная сложность ###
def linear(n)
count = 0
(0...n).each { count += 1 }
count
end
# ## Линейная сложность (обход массива) ###
def array_traversal(nums)
count = 0
# Число итераций пропорционально длине массива
for num in nums
count += 1
end
count
end
# ## Квадратичная сложность ###
def quadratic(n)
count = 0
# Число итераций квадратично зависит от размера данных n
for i in 0...n
for j in 0...n
count += 1
end
end
count
end
# ## Квадратичная сложность (пузырьковая сортировка) ###
def bubble_sort(nums)
count = 0 # Счетчик
# Внешний цикл: неотсортированный диапазон [0, i]
for i in (nums.length - 1).downto(0)
# Внутренний цикл: переместить максимальный элемент неотсортированного диапазона [0, i] в его правый конец
for j in 0...i
if nums[j] > nums[j + 1]
# Поменять местами nums[j] и nums[j + 1]
tmp = nums[j]
nums[j] = nums[j + 1]
nums[j + 1] = tmp
count += 3 # Обмен элементов включает 3 элементарные операции
end
end
end
count
end
# ## Экспоненциальная сложность (итеративная реализация) ###
def exponential(n)
count, base = 0, 1
# На каждом шаге клетка делится надвое, образуя последовательность 1, 2, 4, 8, ..., 2^(n-1)
(0...n).each do
(0...base).each { count += 1 }
base *= 2
end
# count = 1 + 2 + 4 + 8 + .. + 2^(n-1) = 2^n - 1
count
end
# ## Экспоненциальная сложность (рекурсивная реализация) ###
def exp_recur(n)
return 1 if n == 1
exp_recur(n - 1) + exp_recur(n - 1) + 1
end
# ## Логарифмическая сложность (итеративная реализация) ###
### Логарифмическая сложность (итеративная реализация) ###
def logarithmic(n)
count = 0
@@ -3190,109 +2817,7 @@ $$
=== "Ruby"
```ruby title="time_complexity.rb"
=begin
File: time_complexity.rb
Created Time: 2024-03-30
Author: Xuan Khoa Tu Nguyen (ngxktuzkai2000@gmail.com)
=end
# ## Постоянная сложность ###
def constant(n)
count = 0
size = 100000
(0...size).each { count += 1 }
count
end
# ## Линейная сложность ###
def linear(n)
count = 0
(0...n).each { count += 1 }
count
end
# ## Линейная сложность (обход массива) ###
def array_traversal(nums)
count = 0
# Число итераций пропорционально длине массива
for num in nums
count += 1
end
count
end
# ## Квадратичная сложность ###
def quadratic(n)
count = 0
# Число итераций квадратично зависит от размера данных n
for i in 0...n
for j in 0...n
count += 1
end
end
count
end
# ## Квадратичная сложность (пузырьковая сортировка) ###
def bubble_sort(nums)
count = 0 # Счетчик
# Внешний цикл: неотсортированный диапазон [0, i]
for i in (nums.length - 1).downto(0)
# Внутренний цикл: переместить максимальный элемент неотсортированного диапазона [0, i] в его правый конец
for j in 0...i
if nums[j] > nums[j + 1]
# Поменять местами nums[j] и nums[j + 1]
tmp = nums[j]
nums[j] = nums[j + 1]
nums[j + 1] = tmp
count += 3 # Обмен элементов включает 3 элементарные операции
end
end
end
count
end
# ## Экспоненциальная сложность (итеративная реализация) ###
def exponential(n)
count, base = 0, 1
# На каждом шаге клетка делится надвое, образуя последовательность 1, 2, 4, 8, ..., 2^(n-1)
(0...n).each do
(0...base).each { count += 1 }
base *= 2
end
# count = 1 + 2 + 4 + 8 + .. + 2^(n-1) = 2^n - 1
count
end
# ## Экспоненциальная сложность (рекурсивная реализация) ###
def exp_recur(n)
return 1 if n == 1
exp_recur(n - 1) + exp_recur(n - 1) + 1
end
# ## Логарифмическая сложность (итеративная реализация) ###
def logarithmic(n)
count = 0
while n > 1
n /= 2
count += 1
end
count
end
# ## Логарифмическая сложность (рекурсивная реализация) ###
### Логарифмическая сложность (рекурсивная реализация) ###
def log_recur(n)
return 0 unless n > 1
log_recur(n / 2) + 1
@@ -3502,115 +3027,7 @@ $$
=== "Ruby"
```ruby title="time_complexity.rb"
=begin
File: time_complexity.rb
Created Time: 2024-03-30
Author: Xuan Khoa Tu Nguyen (ngxktuzkai2000@gmail.com)
=end
# ## Постоянная сложность ###
def constant(n)
count = 0
size = 100000
(0...size).each { count += 1 }
count
end
# ## Линейная сложность ###
def linear(n)
count = 0
(0...n).each { count += 1 }
count
end
# ## Линейная сложность (обход массива) ###
def array_traversal(nums)
count = 0
# Число итераций пропорционально длине массива
for num in nums
count += 1
end
count
end
# ## Квадратичная сложность ###
def quadratic(n)
count = 0
# Число итераций квадратично зависит от размера данных n
for i in 0...n
for j in 0...n
count += 1
end
end
count
end
# ## Квадратичная сложность (пузырьковая сортировка) ###
def bubble_sort(nums)
count = 0 # Счетчик
# Внешний цикл: неотсортированный диапазон [0, i]
for i in (nums.length - 1).downto(0)
# Внутренний цикл: переместить максимальный элемент неотсортированного диапазона [0, i] в его правый конец
for j in 0...i
if nums[j] > nums[j + 1]
# Поменять местами nums[j] и nums[j + 1]
tmp = nums[j]
nums[j] = nums[j + 1]
nums[j + 1] = tmp
count += 3 # Обмен элементов включает 3 элементарные операции
end
end
end
count
end
# ## Экспоненциальная сложность (итеративная реализация) ###
def exponential(n)
count, base = 0, 1
# На каждом шаге клетка делится надвое, образуя последовательность 1, 2, 4, 8, ..., 2^(n-1)
(0...n).each do
(0...base).each { count += 1 }
base *= 2
end
# count = 1 + 2 + 4 + 8 + .. + 2^(n-1) = 2^n - 1
count
end
# ## Экспоненциальная сложность (рекурсивная реализация) ###
def exp_recur(n)
return 1 if n == 1
exp_recur(n - 1) + exp_recur(n - 1) + 1
end
# ## Логарифмическая сложность (итеративная реализация) ###
def logarithmic(n)
count = 0
while n > 1
n /= 2
count += 1
end
count
end
# ## Логарифмическая сложность (рекурсивная реализация) ###
def log_recur(n)
return 0 unless n > 1
log_recur(n / 2) + 1
end
# ## Линейно-логарифмическая сложность ###
### Линейно-логарифмическая сложность ###
def linear_log_recur(n)
return 1 unless n > 1
@@ -3835,125 +3252,7 @@ $$
=== "Ruby"
```ruby title="time_complexity.rb"
=begin
File: time_complexity.rb
Created Time: 2024-03-30
Author: Xuan Khoa Tu Nguyen (ngxktuzkai2000@gmail.com)
=end
# ## Постоянная сложность ###
def constant(n)
count = 0
size = 100000
(0...size).each { count += 1 }
count
end
# ## Линейная сложность ###
def linear(n)
count = 0
(0...n).each { count += 1 }
count
end
# ## Линейная сложность (обход массива) ###
def array_traversal(nums)
count = 0
# Число итераций пропорционально длине массива
for num in nums
count += 1
end
count
end
# ## Квадратичная сложность ###
def quadratic(n)
count = 0
# Число итераций квадратично зависит от размера данных n
for i in 0...n
for j in 0...n
count += 1
end
end
count
end
# ## Квадратичная сложность (пузырьковая сортировка) ###
def bubble_sort(nums)
count = 0 # Счетчик
# Внешний цикл: неотсортированный диапазон [0, i]
for i in (nums.length - 1).downto(0)
# Внутренний цикл: переместить максимальный элемент неотсортированного диапазона [0, i] в его правый конец
for j in 0...i
if nums[j] > nums[j + 1]
# Поменять местами nums[j] и nums[j + 1]
tmp = nums[j]
nums[j] = nums[j + 1]
nums[j + 1] = tmp
count += 3 # Обмен элементов включает 3 элементарные операции
end
end
end
count
end
# ## Экспоненциальная сложность (итеративная реализация) ###
def exponential(n)
count, base = 0, 1
# На каждом шаге клетка делится надвое, образуя последовательность 1, 2, 4, 8, ..., 2^(n-1)
(0...n).each do
(0...base).each { count += 1 }
base *= 2
end
# count = 1 + 2 + 4 + 8 + .. + 2^(n-1) = 2^n - 1
count
end
# ## Экспоненциальная сложность (рекурсивная реализация) ###
def exp_recur(n)
return 1 if n == 1
exp_recur(n - 1) + exp_recur(n - 1) + 1
end
# ## Логарифмическая сложность (итеративная реализация) ###
def logarithmic(n)
count = 0
while n > 1
n /= 2
count += 1
end
count
end
# ## Логарифмическая сложность (рекурсивная реализация) ###
def log_recur(n)
return 0 unless n > 1
log_recur(n / 2) + 1
end
# ## Линейно-логарифмическая сложность ###
def linear_log_recur(n)
return 1 unless n > 1
count = linear_log_recur(n / 2) + linear_log_recur(n / 2)
(0...n).each { count += 1 }
count
end
# ## Факториальная сложность (рекурсивная реализация) ###
### Факториальная сложность (рекурсивная реализация) ###
def factorial_recur(n)
return 1 if n == 0
@@ -4339,13 +3638,7 @@ $$
=== "Ruby"
```ruby title="worst_best_time_complexity.rb"
=begin
File: worst_best_time_complexity.rb
Created Time: 2024-03-30
Author: Xuan Khoa Tu Nguyen (ngxktuzkai2000@gmail.com)
=end
# ## Создать массив с элементами: 1, 2, ..., n в случайном порядке ###
### Создать массив с элементами: 1, 2, ..., n в случайном порядке ###
def random_numbers(n)
# Создать массив nums =: 1, 2, 3, ..., n
nums = Array.new(n) { |i| i + 1 }
@@ -4353,21 +3646,7 @@ $$
nums.shuffle!
end
=begin
File: worst_best_time_complexity.rb
Created Time: 2024-03-30
Author: Xuan Khoa Tu Nguyen (ngxktuzkai2000@gmail.com)
=end
# ## Создать массив с элементами: 1, 2, ..., n в случайном порядке ###
def random_numbers(n)
# Создать массив nums =: 1, 2, 3, ..., n
nums = Array.new(n) { |i| i + 1 }
# Случайно перемешать элементы массива
nums.shuffle!
end
# ## Найти индекс числа 1 в массиве nums ###
### Найти индекс числа 1 в массиве nums ###
def find_one(nums)
for i in 0...nums.length
# Когда элемент 1 находится в начале массива, достигается лучшая временная сложность O(1)