notes
Array Programs (Collections/Vectors)
obsidian source → .md
download#. Number Logic Programs
1. Prime Number Check
fn is_prime(n: u32) -> bool {
if n <= 1 { return false; }
let limit = (n as f64).sqrt() as u32;
for i in 2..=limit {
if n % i == 0 {
return false;
}
}
true
}
fn main() {
let num = 29;
println!("Is {} prime? {}", num, is_prime(num));
}
Output:
Is 29 prime? true
Ruby
Ruby
def is_prime(n)
return false if n <= 1
(2..Math.sqrt(n).to_i).each do |i|
return false if n % i == 0
end
true
end
num = 29
puts "#{num} is prime? #{is_prime(num)}"
```ruby
**Output:**
text
```ruby
29 is prime? true
```ruby
---
## **2. Fibonacci Series**
### **Rust**
```rust
fn fibonacci(n: u32) -> Vec<u64> {
let mut series = Vec::new();
let (mut a, mut b) = (0u64, 1u64);
for _ in 0..n {
series.push(a);
let next = a + b;
a = b;
b = next;
}
series
}
fn main() {
println!("Fibonacci series: {:?}", fibonacci(10));
}
```rust
**Output:**
text
```rust
Fibonacci series: [0, 1, 1, 2, 3, 5, 8, 13, 21, 34]
```rust
### **Ruby**
Ruby
```ruby
def fibonacci(n)
a, b = 0, 1
series = []
n.times do
series << a
a, b = b, a + b
end
series
end
puts "Fibonacci series: #{fibonacci(10)}"
```ruby
**Output:**
text
```ruby
Fibonacci series: [0, 1, 1, 2, 3, 5, 8, 13, 21, 34]
```ruby
---
## **3. Factorial**
### **Rust**
Rust
```rust
fn factorial(n: u64) -> u64 {
if n == 0 { return 1; }
n * factorial(n - 1)
}
fn main() {
let num = 5;
println!("Factorial of {}: {}", num, factorial(num));
}
```rust
**Output:**
text
```rust
Factorial of 5: 120
```rust
### **Ruby**
Ruby
```ruby
def factorial(n)
return 1 if n == 0
n * factorial(n - 1)
end
num = 5
puts "Factorial of #{num}: #{factorial(num)}"
```ruby
**Output:**
text
```ruby
Factorial of 5: 120
```ruby
---
## **4. Palindrome Number**
### **Rust**
Rust
```rust
fn is_palindrome(n: u32) -> bool {
let s = n.to_string();
s.chars().eq(s.chars().rev())
}
fn main() {
let num = 121;
println!("Is {} palindrome? {}", num, is_palindrome(num));
}
```rust
**Output:**
text
```rust
Is 121 palindrome? true
```rust
### **Ruby**
Ruby
```ruby
def is_palindrome(n)
s = n.to_s
s == s.reverse
end
num = 121
puts "#{num} is palindrome? #{is_palindrome(num)}"
```ruby
**Output:**
text
```ruby
121 is palindrome? true
```ruby
---
# **Array Programs (Collections/Vectors)**
## **1. Linear Search**
### **Rust**
Rust
```rust
fn linear_search(arr: &[i32], target: i32) -> Option<usize> {
for (i, &item) in arr.iter().enumerate() {
if item == target {
return Some(i);
}
}
None
}
fn main() {
let arr = [10, 20, 30, 40, 50];
let target = 30;
match linear_search(&arr, target) {
Some(index) => println!("Position of {}: {}", target, index),
None => println!("Element not found"),
}
}
```rust
**Output:**
text
```rust
Position of 30: 2
```rust
### **Ruby**
Ruby
```ruby
def linear_search(arr, target)
arr.index(target)
end
arr = [10, 20, 30, 40, 50]
target = 30
puts "Position of #{target}: #{linear_search(arr, target)}"
```ruby
**Output:**
text
```ruby
Position of 30: 2
```ruby
---
## **2. Bubble Sort**
### **Rust**
Rust
```rust
fn bubble_sort(arr: &mut [i32]) {
let n = arr.len();
for i in 0..n {
for j in 0..n - 1 - i {
if arr[j] > arr[j + 1] {
arr.swap(j, j + 1);
}
}
}
}
fn main() {
let mut arr = vec![64, 34, 25, 12, 22, 11, 90];
bubble_sort(&mut arr);
println!("Sorted array: {:?}", arr);
}
```rust
**Output:**
text
```rust
Sorted array: [11, 12, 22, 25, 34, 64, 90]
```rust
### **Ruby**
Ruby
```ruby
def bubble_sort(arr)
n = arr.length
(0...n).each do |i|
(0...(n - i - 1)).each do |j|
if arr[j] > arr[j + 1]
arr[j], arr[j + 1] = arr[j + 1], arr[j] # Swap
end
end
end
arr
end
arr = [64, 34, 25, 12, 22, 11, 90]
puts "Sorted array: #{bubble_sort(arr)}"
```ruby
**Output:**
text
```ruby
Sorted array: [11, 12, 22, 25, 34, 64, 90]
```ruby
---
## **3. Second Largest Element**
### **Rust**
Rust
```rust
fn second_largest(arr: &[i32]) -> Option<i32> {
if arr.len() < 2 { return None; }
let mut first = i32::MIN;
let mut second = i32::MIN;
for &num in arr.iter() {
if num > first {
second = first;
first = num;
} else if num > second && num != first {
second = num;
}
}
if second == i32::MIN { None } else { Some(second) }
}
fn main() {
let arr = vec![12, 35, 1, 10, 34, 1];
println!("Second largest: {:?}", second_largest(&arr));
}
```rust
**Output:**
text
```rust
Second largest: Some(34)
```rust
### **Ruby**
Ruby
```rb
def second_largest(arr)
# Using Ruby's sorting capability for concise solution
unique_sorted = arr.uniq.sort
return nil if unique_sorted.length < 2
unique_sorted[-2]
end
arr = [12, 35, 1, 10, 34, 1]
puts "Second largest: #{second_largest(arr)}"
```ruby
**Output:**
text
```ruby
Second largest: 34
```ruby
---
## **4. Array Rotation (Left Rotation by K)**
### **Rust**
Rust
```rust
fn rotate_array(arr: &mut Vec<i32>, k: usize) {
if arr.is_empty() { return; }
let k = k % arr.len();
// Simple implementation using cloning/concatenation (idiomatic for quick rotation)
let (head, tail) = arr.split_at(k);
let mut rotated = tail.to_vec();
rotated.extend_from_slice(head);
*arr = rotated; // Assign the new vector back
}
fn main() {
let mut arr = vec![1, 2, 3, 4, 5, 6, 7];
rotate_array(&mut arr, 3);
println!("Rotated array: {:?}", arr);
}
```rust
**Output:**
text
```rust
Rotated array: [4, 5, 6, 7, 1, 2, 3]
```rust
### **Ruby**
Ruby
```ruby
def rotate_array(arr, k)
arr.rotate(k)
end
arr = [1, 2, 3, 4, 5, 6, 7]
puts "Rotated array: #{rotate_array(arr, 3)}"
```ruby
**Output:**
text
```ruby
Rotated array: [4, 5, 6, 7, 1, 2, 3]
```ruby
---
## **5. Matrix Addition**
### **Rust**
Rust
```rust
fn matrix_addition(a: &Vec<Vec<i32>>, b: &Vec<Vec<i32>>) -> Vec<Vec<i32>> {
let rows = a.len();
let cols = a[0].len();
let mut result = vec![vec![0; cols]; rows];
for i in 0..rows {
for j in 0..cols {
result[i][j] = a[i][j] + b[i][j];
}
}
result
}
fn main() {
let a = vec![vec![1, 2], vec![3, 4]];
let b = vec![vec![5, 6], vec![7, 8]];
println!("Matrix sum: {:?}", matrix_addition(&a, &b));
}
```rust
**Output:**
text
```rust
Matrix sum: [[6, 8], [10, 12]]
```rust
### **Ruby**
Ruby
```ruby
def matrix_addition(a, b)
a.zip(b).map do |row_a, row_b|
row_a.zip(row_b).map { |val_a, val_b| val_a + val_b }
end
end
a = [[1, 2], [3, 4]]
b = [[5, 6], [7, 8]]
puts "Matrix sum: #{matrix_addition(a, b)}"
```ruby
**Output:**
text
```ruby
Matrix sum: [[6, 8], [10, 12]]
```ruby
---
## **6. Matrix Transpose**
### **Rust**
```rust
fn transpose_matrix(matrix: &Vec<Vec<i32>>) -> Vec<Vec<i32>> {
if matrix.is_empty() { return vec![]; }
let rows = matrix.len();
let cols = matrix[0].len();
let mut transposed = vec![vec![0; rows]; cols];
for i in 0..rows {
for j in 0..cols {
transposed[j][i] = matrix[i][j];
}
}
transposed
}
fn main() {
let matrix = vec![vec![1, 2, 3], vec![4, 5, 6]];
println!("Transpose: {:?}", transpose_matrix(&matrix));
}
```rust
**Output:**
text
```rust
Transpose: [[1, 4], [2, 5], [3, 6]]
```rust
### **Ruby**
Ruby
```rb
def transpose_matrix(matrix)
# Uses array access to iterate over columns first
num_rows = matrix.length
num_cols = matrix[0].length
(0...num_cols).map do |j|
(0...num_rows).map do |i|
matrix[i][j]
end
end
end
matrix = [[1, 2, 3], [4, 5, 6]]
puts "Transpose: #{transpose_matrix(matrix)}"
```ruby
**Output:**
text
```ruby
Transpose: [[1, 4], [2, 5], [3, 6]]
```ruby
---
## **7. Maximum Subarray Sum (Kadane's Algorithm)**
### **Rust**
Rust
```rust
fn max_subarray_sum(arr: &[i32]) -> i32 {
if arr.is_empty() { return 0; }
let mut max_sum = arr[0];
let mut current_sum = arr[0];
for &num in arr.iter().skip(1) {
// current_sum = max(num, current_sum + num)
current_sum = num.max(current_sum + num);
// max_sum = max(max_sum, current_sum)
max_sum = max_sum.max(current_sum);
}
max_sum
}
fn main() {
let arr = vec![-2, 1, -3, 4, -1, 2, 1, -5, 4];
println!("Maximum subarray sum: {}", max_subarray_sum(&arr));
}
```rust
**Output:**
text
```rust
Maximum subarray sum: 6
```rust
### **Ruby**
Ruby
```ruby
def max_subarray_sum(arr)
return 0 if arr.empty?
max_sum = arr[0]
current_sum = arr[0]
arr[1..-1].each do |num|
current_sum = [num, current_sum + num].max
max_sum = [max_sum, current_sum].max
end
max_sum
end
arr = [-2, 1, -3, 4, -1, 2, 1, -5, 4]
puts "Maximum subarray sum: #{max_subarray_sum(arr)}"
```ruby
**Output:**
text
```ruby
Maximum subarray sum: 6
```ruby
---
## **8. Find Missing Number (1 to N)**
### **Rust**
Rust
```rust
fn find_missing_number(arr: &[i32], n: i32) -> i32 {
// Sum of numbers from 1 to N: N * (N + 1) / 2
let total_sum = n * (n + 1) / 2;
// Sum of elements in the array
let arr_sum: i32 = arr.iter().sum();
total_sum - arr_sum
}
fn main() {
let arr = vec![1, 2, 4, 5, 6];
let n = 6;
println!("Missing number: {}", find_missing_number(&arr, n));
}
```rust
**Output:**
text
```rust
Missing number: 3
```rust
### **Ruby**
Ruby
```ruby
def find_missing_number(arr, n)
# Sum of numbers from 1 to N
total_sum = n * (n + 1) / 2
# Sum of elements in the array
arr_sum = arr.sum
total_sum - arr_sum
end
arr = [1, 2, 4, 5, 6]
n = 6
puts "Missing number: #{find_missing_number(arr, n)}"
```ruby
**Output:**
text
```ruby
Missing number: 3
```ruby
----
_