LCM of given array elements

// Java Program to find LCM of n elements
import java.io.*;

public class GFG {
    
    public static long lcm_of_array_elements(int[] element_array)
    {
        long lcm_of_array_elements = 1;
        int divisor = 2;
        
        while (true) {
            int counter = 0;
            boolean divisible = false;
            
            for (int i = 0; i < element_array.length; i++) {

                // lcm_of_array_elements (n1, n2, ... 0) = 0.
                // For negative number we convert into
                // positive and calculate lcm_of_array_elements.

                if (element_array[i] == 0) {
                    return 0;
                }
                else if (element_array[i] < 0) {
                    element_array[i] = element_array[i] * (-1);
                }
                if (element_array[i] == 1) {
                    counter++;
                }

                // Divide element_array by devisor if complete
                // division i.e. without remainder then replace
                // number with quotient; used for find next factor
                if (element_array[i] % divisor == 0) {
                    divisible = true;
                    element_array[i] = element_array[i] / divisor;
                }
            }

            // If divisor able to completely divide any number
            // from array multiply with lcm_of_array_elements
            // and store into lcm_of_array_elements and continue
            // to same divisor for next factor finding.
            // else increment divisor
            if (divisible) {
                lcm_of_array_elements = lcm_of_array_elements * divisor;
            }
            else {
                divisor++;
            }

            // Check if all element_array is 1 indicate 
            // we found all factors and terminate while loop.
            if (counter == element_array.length) {
                return lcm_of_array_elements;
            }
        }
    }
    
    // Driver Code
    public static void main(String[] args)
    {
        int[] element_array = { 2, 7, 3, 9, 4 };
        System.out.println(lcm_of_array_elements(element_array));
    }
}

// Code contributed by Mohit Gupta_OMG

import java.util.*;
import java.io.*;

class GFG
{

  // Recursive function to return gcd of a and b  
  static int __gcd(int a, int b)  
  {  
    return b == 0? a:__gcd(b, a % b);     
  }

  // recursive implementation
  static int LcmOfArray(int[] arr, int idx)
  {

    // lcm(a,b) = (a*b/gcd(a,b))
    if (idx == arr.length - 1){
      return arr[idx];
    }
    int a = arr[idx];
    int b = LcmOfArray(arr, idx+1);
    return (a*b/__gcd(a,b)); // 
  }


  public static void main(String[] args)
  {

    int[] arr = {1,2,8,3};
    System.out.print(LcmOfArray(arr, 0)+ "\n");
    int[]  arr1 = {2,7,3,9,4};
    System.out.print(LcmOfArray(arr1,0)+ "\n");
  }
} 

// This code is contributed by gauravrajput1 

import java.util.*;

public class Main {

    public static int gcd(int num1, int num2)
    {
        if (num2 == 0)
            return num1;
        return gcd(num2, num1 % num2);
    }

    public static int lcm_of_array(ArrayList<Integer> arr)
    {
        int lcm = arr.get(0);
        for (int i = 1; i < arr.size(); i++) {
            int num1 = lcm;
            int num2 = arr.get(i);
            int gcd_val = gcd(num1, num2);
            lcm = (lcm * arr.get(i)) / gcd_val;
        }
        return lcm;
    }

    public static void main(String[] args)
    {
        ArrayList<Integer> arr1
            = new ArrayList<>(Arrays.asList(1, 2, 8, 3));
        ArrayList<Integer> arr2
            = new ArrayList<>(Arrays.asList(2, 7, 3, 9, 4));
        System.out.println(
            lcm_of_array(arr1)); // Output: 24
        System.out.println(
            lcm_of_array(arr2)); // Output: 252
    }
}

// Java code to find LCM of given numbers using reduce()
// function
import java.util.*;
import java.util.function.*;
import java.util.stream.*;

class Main {
    static int lcm(List<Integer> numbers)
    {
        return numbers.stream().reduce(
            1, (x, y) -> (x * y) / gcd(x, y));
    }

    static int gcd(int a, int b)
    {
        if (b == 0)
            return a;
        return gcd(b, a % b);
    }

    public static void main(String[] args)
    {
        List<Integer> numbers = Arrays.asList(2, 3, 4, 5);
        int LCM = lcm(numbers);
        System.out.println("LCM of " + numbers + " is "
                           + LCM);
    }
}