Arithmetic Slices

                                            
class Solution {
public:
    int numberOfArithmeticSlices(vector<int>& nums) {
        int n = nums.size();
        if(n < 3) {
            return 0;
        }
        
        int count = 0;
        int result = 0;
        
        for(int i = 2; i < n; i++) {
            if(nums[i] - nums[i-1] == nums[i-1] - nums[i-2]) {
                count++;
                result += count;
            } else {
                count = 0;
            }
        }
        
        return result;
    }
};

                                            
class Solution {
    public int numberOfArithmeticSlices(int[] nums) {
        int n = nums.length;
        int count = 0;
        
        for (int i = 0; i < n - 2; i++) {
            int diff = nums[i + 1] - nums[i];
            for (int j = i + 2; j < n; j++) {
                if (nums[j] - nums[j - 1] == diff) {
                    count++;
                } else {
                    break;
                }
            }
        }
        
        return count;
    }
}

                                            
class Solution(object):
    def numberOfArithmeticSlices(self, nums):
        """
        :type nums: List[int]
        :rtype: int
        """
        count = 0
        sum_slices = 0
        
        for i in range(2, len(nums)):
            if nums[i] - nums[i-1] == nums[i-1] - nums[i-2]:
                count += 1
                sum_slices += count
            else:
                count = 0
        
        return sum_slices

                                            
int numberOfArithmeticSlices(int* nums, int numsSize) {
    int count = 0;
    for (int i = 0; i < numsSize - 2; i++) {
        int diff = nums[i + 1] - nums[i];
        for (int j = i + 2; j < numsSize; j++) {
            if (nums[j] - nums[j - 1] == diff) {
                count++;
            } else {
                break;
            }
        }
    }
    return count;
}

                                            
public class Solution {
    public int NumberOfArithmeticSlices(int[] nums) {
        int count = 0;
        int result = 0;
        
        for (int i = 2; i < nums.Length; i++) {
            if (nums[i] - nums[i - 1] == nums[i - 1] - nums[i - 2]) {
                count++;
                result += count;
            } else {
                count = 0;
            }
        }
        
        return result;
    }
}

                                            
/**
 * @param {number[]} nums
 * @return {number}
 */
var numberOfArithmeticSlices = function(nums) {
    let count = 0;
    let dp = 0;
    
    for (let i = 2; i < nums.length; i++) {
        if (nums[i] - nums[i - 1] === nums[i - 1] - nums[i - 2]) {
            dp = dp + 1;
            count += dp;
        } else {
            dp = 0;
        }
    }
    
    return count;
};

                                            
function numberOfArithmeticSlices(nums: number[]): number {
    let count = 0;
    
    for (let i = 0; i < nums.length - 2; i++) {
        const diff = nums[i + 1] - nums[i];
        for (let j = i + 2; j < nums.length; j++) {
            if (nums[j] - nums[j - 1] === diff) {
                count++;
            } else {
                break;
            }
        }
    }
    
    return count;
};

                                            
class Solution {
    /**
     * @param Integer[] $nums
     * @return Integer
     */
    function numberOfArithmeticSlices($nums) {
        $n = count($nums);
        $count = 0;
        
        for ($i = 0; $i < $n - 2; $i++) {
            $diff = $nums[$i + 1] - $nums[$i];
            
            for ($j = $i + 2; $j < $n; $j++) {
                if ($nums[$j] - $nums[$j - 1] == $diff) {
                    $count++;
                } else {
                    break;
                }
            }
        }
        
        return $count;
    }
}

                                            
class Solution {
    fun numberOfArithmeticSlices(nums: IntArray): Int {
        var count = 0
        var sum = 0
        for (i in 2 until nums.size) {
            if (nums[i] - nums[i-1] == nums[i-1] - nums[i-2]) {
                count++
                sum += count
            } else {
                count = 0
            }
        }
        return sum
    }
}

                                            
class Solution {
  int numberOfArithmeticSlices(List<int> nums) {
    int count = 0;
    int result = 0;

    for (int i = 2; i < nums.length; i++) {
      if (nums[i] - nums[i - 1] == nums[i - 1] - nums[i - 2]) {
        count++;
        result += count;
      } else {
        count = 0;
      }
    }

    return result;
  }
}

                                            
func numberOfArithmeticSlices(nums []int) int {
    count := 0
    result := 0
    for i := 2; i < len(nums); i++ {
        if nums[i]-nums[i-1] == nums[i-1]-nums[i-2] {
            count++
            result += count
        } else {
            count = 0
        }
    }
    return result
}

                                            
# @param {Integer[]} nums
# @return {Integer}
def number_of_arithmetic_slices(nums)
    count = 0
    result = 0
    (2...nums.size).each do |i|
        if nums[i] - nums[i-1] == nums[i-1] - nums[i-2]
            count += 1
            result += count
        else
            count = 0
        end
    end
    result
end

                                            
object Solution {
    def numberOfArithmeticSlices(nums: Array[Int]): Int = {
        var count = 0
        var result = 0
        
        for (i <- 2 until nums.length) {
            if (nums(i) - nums(i - 1) == nums(i - 1) - nums(i - 2)) {
                count += 1
                result += count
            } else {
                count = 0
            }
        }
        
        result
    }
}

                                            
impl Solution {
    pub fn number_of_arithmetic_slices(nums: Vec<i32>) -> i32 {
        let n = nums.len();
        if n < 3 {
            return 0;
        }
        
        let mut dp = vec![0; n];
        let mut count = 0;
        
        for i in 2..n {
            if nums[i] - nums[i - 1] == nums[i - 1] - nums[i - 2] {
                dp[i] = dp[i - 1] + 1;
                count += dp[i];
            }
        }
        
        return count;
    }
}

To solve this coding challenge, we need to identify arithmetic subarrays within a given array of integers and determine how many such subarrays exist. A subarray in this context is a contiguous subsequence of the array.

Explanation

The key idea for solving this problem is to track each contiguous segment of the array that forms an arithmetic sequence. An arithmetic sequence is defined by a constant difference between consecutive elements. For a subarray to be arithmetic, it must contain at least three elements. The approach can be broken down into the following steps:

Initialize Variables :

count

: To keep track of the current length of the arithmetic subarray.
sum_slices

: To accumulate the number of arithmetic subarrays found so far.

Iterate Through the Array :

Loop through the array starting from the third element because a valid arithmetic subarray must consist of at least three elements.
Check whether the difference between the current element and the previous element is equal to the difference between the previous element and the one before it.

Update Counts :

If the differences are the same, increment the
count

which keeps track of consecutive equal differences.
Add
count

to
sum_slices

because if we find a new valid arithmetic subarray, it means that we have more arithmetic subarrays ending at the current element.
If the differences do not match, reset
count

to zero.

Return Result :

Return the accumulated
sum_slices

which contains the number of arithmetic subarrays.

Detailed Steps in Pseudocode

Initialize Variables :

                                            
SET count = 0  # To track length of current arithmetic subarray
SET sum_slices = 0  # To store total number of arithmetic subarrays

Iterate Through the Array :

                                            
FOR index FROM 2 TO length_of(nums) - 1 DO
# Check if the subarray ending at this index is arithmetic
IF nums[index] - nums[index - 1] == nums[index - 1] - nums[index - 2] THEN
INCREMENT count
ADD count TO sum_slices
ELSE
SET count = 0  # Reset because current element breaks arithmetic sequence

Return Result :

                                            
RETURN sum_slices  # Number of arithmetic subarrays found

This plan ensures that we systematically check each potential arithmetic subarray and correctly count the total number found within the given array. Below is the complete pseudocode with comments.

Pseudocode with Comments

                                            
# Initialize counting variables
SET current_arithmetic_segment_count = 0  
SET total_number_of_arithmetic_subarrays = 0  

# Iterate through the array starting from the third element
FOR index FROM 2 TO length_of(array_nums) - 1 DO
    # Check if the difference between current and previous element 
    # is the same as the difference between previous and the one before
    IF array_nums[index] - array_nums[index - 1] == array_nums[index - 1] - array_nums[index - 2] THEN
        # Increment the length of the current arithmetic segment
        INCREMENT current_arithmetic_segment_count
        # Add the count to the total number of arithmetic subarrays
        total_number_of_arithmetic_subarrays = total_number_of_arithmetic_subarrays + current_arithmetic_segment_count
    ELSE
        # If the sequence breaks, reset the current arithmetic segment count
        current_arithmetic_segment_count = 0

# Return the total number of arithmetic subarrays found
RETURN total_number_of_arithmetic_subarrays

This pseudocode is designed to carefully track and verify the arithmetic nature of subarrays within the provided integer array, ensuring accurate and efficient counting of valid subarrays. Remember, pseudocode should be converted to an actual programming language for execution but it comprehensively lays out the logical steps needed to solve the problem.