---
title: "Array Programs (Collections/Vectors)"
category: "notes"
summary: ". Number Logic Programs"
date: "2026-02-22"
---

 #. **Number Logic Programs**

## **1. Prime Number Check**


```rust
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

```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





----


_