Maximum equilibrium sum in an array

Here given code implementation process.

/*
    C program for
    Maximum equilibrium sum in an array
*/
#include <stdio.h>

#include <limits.h>
 // Display given array elements
void printArray(int arr[], int n)
{
	for (int i = 0; i < n; ++i)
	{
		printf(" %d", arr[i]);
	}
}
// Returns the maximum value of given two numbers
int maxValue(int a, int b)
{
	if (a > b)
	{
		return a;
	}
	return b;
}
void findMaximumSum(int arr[], int n)
{
	int sum = 0;
	int prefix = 0;
	int result = INT_MIN;
	// Sum of array elements
	for (int i = 0; i < n; ++i)
	{
		sum += arr[i];
	}
	// Find equilibrium sum
	for (int i = 0; i < n; i++)
	{
		// Prefix sum
		prefix = prefix + arr[i];
		if (prefix == sum)
		{
			result = maxValue(result, prefix);
		}
		// Reduce sum by current array element  
		sum = sum - arr[i];
	}
	printArray(arr, n);
	printf("\n Result : %d \n", result);
}
int main()
{
	// Given array elements
	int arr1[] = {
		6 , 5 , 2 , -5 , 8 , 1 , 4 , -4 , 7
	};
	int arr2[] = {
		3 , -2 , 1 , 4 , 5 , -3
	};
	// Test A
	// Get the number of elements
	int n = sizeof(arr1) / sizeof(arr1[0]);
	//  [6, 5, 2, -5, 8] == [8, 1, 4, -4, 7]
	// Result 16 [6 + 5 + 2 + -5 + 8]
	findMaximumSum(arr1, n);
	// Test B
	// Get the number of elements
	n = sizeof(arr2) / sizeof(arr2[0]);
	// [ 3, -2, 1, 4] == [4, 5,-3]
	// Result 6 [ 3 + -2 + 1 + 4]
	findMaximumSum(arr2, n);
	return 0;
}

Output

 6 5 2 -5 8 1 4 -4 7
 Result : 16
 3 -2 1 4 5 -3
 Result : 6

/*
    Java Program for
    Maximum equilibrium sum in an array
*/
public class EquilibriumSum
{
	// Display given array elements
	public void printArray(int[] arr, int n)
	{
		for (int i = 0; i < n; ++i)
		{
			System.out.print(" " + arr[i]);
		}
	}
	// Returns the maximum value of given two numbers
	public int maxValue(int a, int b)
	{
		if (a > b)
		{
			return a;
		}
		return b;
	}
	public void findMaximumSum(int[] arr, int n)
	{
		int sum = 0;
		int prefix = 0;
		int result = Integer.MIN_VALUE;
		// Sum of array elements
		for (int i = 0; i < n; ++i)
		{
			sum += arr[i];
		}
		// Find equilibrium sum
		for (int i = 0; i < n; i++)
		{
			// Prefix sum
			prefix = prefix + arr[i];
			if (prefix == sum)
			{
				result = maxValue(result, prefix);
			}
			// Reduce sum by current array element  
			sum = sum - arr[i];
		}
		printArray(arr, n);
		System.out.print("\n Result : " + result + " \n");
	}
	public static void main(String[] args)
	{
		EquilibriumSum task = new EquilibriumSum();
		// Given array elements
		int[] arr1 = {
			6 , 5 , 2 , -5 , 8 , 1 , 4 , -4 , 7
		};
		int[] arr2 = {
			3 , -2 , 1 , 4 , 5 , -3
		};
		// Test A
		// Get the number of elements
		int n = arr1.length;
		//  [6, 5, 2, -5, 8] == [8, 1, 4, -4, 7]
		// Result 16 [6 + 5 + 2 + -5 + 8]
		task.findMaximumSum(arr1, n);
		// Test B
		// Get the number of elements
		n = arr2.length;
		// [ 3, -2, 1, 4] == [4, 5,-3]
		// Result 6 [ 3 + -2 + 1 + 4]
		task.findMaximumSum(arr2, n);
	}
}

Output

 6 5 2 -5 8 1 4 -4 7
 Result : 16
 3 -2 1 4 5 -3
 Result : 6

// Include header file
#include <iostream>
#include <limits.h>

using namespace std;
/*
    C++ Program for
    Maximum equilibrium sum in an array
*/
class EquilibriumSum
{
	public:
		// Display given array elements
		void printArray(int arr[], int n)
		{
			for (int i = 0; i < n; ++i)
			{
				cout << " " << arr[i];
			}
		}
	// Returns the maximum value of given two numbers
	int maxValue(int a, int b)
	{
		if (a > b)
		{
			return a;
		}
		return b;
	}
	void findMaximumSum(int arr[], int n)
	{
		int sum = 0;
		int prefix = 0;
		int result = INT_MIN;
		// Sum of array elements
		for (int i = 0; i < n; ++i)
		{
			sum += arr[i];
		}
		// Find equilibrium sum
		for (int i = 0; i < n; i++)
		{
			// Prefix sum
			prefix = prefix + arr[i];
			if (prefix == sum)
			{
				result = this->maxValue(result, prefix);
			}
			// Reduce sum by current array element  
			sum = sum - arr[i];
		}
		this->printArray(arr, n);
		cout << "\n Result : " << result << " \n";
	}
};
int main()
{
	EquilibriumSum *task = new EquilibriumSum();
	// Given array elements
	int arr1[] = {
		6 , 5 , 2 , -5 , 8 , 1 , 4 , -4 , 7
	};
	int arr2[] = {
		3 , -2 , 1 , 4 , 5 , -3
	};
	// Test A
	// Get the number of elements
	int n = sizeof(arr1) / sizeof(arr1[0]);
	//  [6, 5, 2, -5, 8] == [8, 1, 4, -4, 7]
	// Result 16 [6 + 5 + 2 + -5 + 8]
	task->findMaximumSum(arr1, n);
	// Test B
	// Get the number of elements
	n = sizeof(arr2) / sizeof(arr2[0]);
	// [ 3, -2, 1, 4] == [4, 5,-3]
	// Result 6 [ 3 + -2 + 1 + 4]
	task->findMaximumSum(arr2, n);
	return 0;
}

Output

 6 5 2 -5 8 1 4 -4 7
 Result : 16
 3 -2 1 4 5 -3
 Result : 6

// Include namespace system
using System;
/*
    Csharp Program for
    Maximum equilibrium sum in an array
*/
public class EquilibriumSum
{
	// Display given array elements
	public void printArray(int[] arr, int n)
	{
		for (int i = 0; i < n; ++i)
		{
			Console.Write(" " + arr[i]);
		}
	}
	// Returns the maximum value of given two numbers
	public int maxValue(int a, int b)
	{
		if (a > b)
		{
			return a;
		}
		return b;
	}
	public void findMaximumSum(int[] arr, int n)
	{
		int sum = 0;
		int prefix = 0;
		int result = int.MinValue;
		// Sum of array elements
		for (int i = 0; i < n; ++i)
		{
			sum += arr[i];
		}
		// Find equilibrium sum
		for (int i = 0; i < n; i++)
		{
			// Prefix sum
			prefix = prefix + arr[i];
			if (prefix == sum)
			{
				result = this.maxValue(result, prefix);
			}
			// Reduce sum by current array element  
			sum = sum - arr[i];
		}
		this.printArray(arr, n);
		Console.Write("\n Result : " + result + " \n");
	}
	public static void Main(String[] args)
	{
		EquilibriumSum task = new EquilibriumSum();
		// Given array elements
		int[] arr1 = {
			6 , 5 , 2 , -5 , 8 , 1 , 4 , -4 , 7
		};
		int[] arr2 = {
			3 , -2 , 1 , 4 , 5 , -3
		};
		// Test A
		// Get the number of elements
		int n = arr1.Length;
		//  [6, 5, 2, -5, 8] == [8, 1, 4, -4, 7]
		// Result 16 [6 + 5 + 2 + -5 + 8]
		task.findMaximumSum(arr1, n);
		// Test B
		// Get the number of elements
		n = arr2.Length;
		// [ 3, -2, 1, 4] == [4, 5,-3]
		// Result 6 [ 3 + -2 + 1 + 4]
		task.findMaximumSum(arr2, n);
	}
}

Output

 6 5 2 -5 8 1 4 -4 7
 Result : 16
 3 -2 1 4 5 -3
 Result : 6

package main
import "math"
import "fmt"
/*
    Go Program for
    Maximum equilibrium sum in an array
*/

// Display given array elements
func printArray(arr[] int, n int) {
	for i := 0 ; i < n ; i++ {
		fmt.Print(" ", arr[i])
	}
}
// Returns the maximum value of given two numbers
func maxValue(a, b int) int {
	if a > b {
		return a
	}
	return b
}
func findMaximumSum(arr[] int, n int) {
	var sum int = 0
	var prefix int = 0
	var result int = math.MaxInt64
	// Sum of array elements
	for i := 0 ; i < n ; i++ {
		sum += arr[i]
	}
	// Find equilibrium sum
	for i := 0 ; i < n ; i++ {
		// Prefix sum
		prefix = prefix + arr[i]
		if prefix == sum {
			result = maxValue(result, prefix)
		}
		// Reduce sum by current array element  
		sum = sum - arr[i]
	}
	printArray(arr, n)
	fmt.Print("\n Result : ", result, " \n")
}
func main() {
	
	// Given array elements
	var arr1 = [] int { 6 , 5 , 2 , -5 , 8 , 1 , 4 , -4 , 7 }
	var arr2 = [] int { 3 , -2 , 1 , 4 , 5 , -3 }
	// Test A
	// Get the number of elements
	var n int = len(arr1)
	//  [6, 5, 2, -5, 8] == [8, 1, 4, -4, 7]
	// Result 16 [6 + 5 + 2 + -5 + 8]
	findMaximumSum(arr1, n)
	// Test B
	// Get the number of elements
	n = len(arr2)
	// [ 3, -2, 1, 4] == [4, 5,-3]
	// Result 6 [ 3 + -2 + 1 + 4]
	findMaximumSum(arr2, n)
}

Output

 6 5 2 -5 8 1 4 -4 7
 Result : 16
 3 -2 1 4 5 -3
 Result : 6

<?php
/*
    Php Program for
    Maximum equilibrium sum in an array
*/
class EquilibriumSum
{
	// Display given array elements
	public	function printArray($arr, $n)
	{
		for ($i = 0; $i < $n; ++$i)
		{
			echo(" ".$arr[$i]);
		}
	}
	// Returns the maximum value of given two numbers
	public	function maxValue($a, $b)
	{
		if ($a > $b)
		{
			return $a;
		}
		return $b;
	}
	public	function findMaximumSum($arr, $n)
	{
		$sum = 0;
		$prefix = 0;
		$result = -PHP_INT_MAX;
		// Sum of array elements
		for ($i = 0; $i < $n; ++$i)
		{
			$sum += $arr[$i];
		}
		// Find equilibrium sum
		for ($i = 0; $i < $n; $i++)
		{
			// Prefix sum
			$prefix = $prefix + $arr[$i];
			if ($prefix == $sum)
			{
				$result = $this->maxValue($result, $prefix);
			}
			// Reduce sum by current array element  
			$sum = $sum - $arr[$i];
		}
		$this->printArray($arr, $n);
		echo("\n Result : ".$result.
			" \n");
	}
}

function main()
{
	$task = new EquilibriumSum();
	// Given array elements
	$arr1 = array(6, 5, 2, -5, 8, 1, 4, -4, 7);
	$arr2 = array(3, -2, 1, 4, 5, -3);
	// Test A
	// Get the number of elements
	$n = count($arr1);
	//  [6, 5, 2, -5, 8] == [8, 1, 4, -4, 7]
	// Result 16 [6 + 5 + 2 + -5 + 8]
	$task->findMaximumSum($arr1, $n);
	// Test B
	// Get the number of elements
	$n = count($arr2);
	// [ 3, -2, 1, 4] == [4, 5,-3]
	// Result 6 [ 3 + -2 + 1 + 4]
	$task->findMaximumSum($arr2, $n);
}
main();

Output

 6 5 2 -5 8 1 4 -4 7
 Result : 16
 3 -2 1 4 5 -3
 Result : 6

/*
    Node JS Program for
    Maximum equilibrium sum in an array
*/
class EquilibriumSum
{
	// Display given array elements
	printArray(arr, n)
	{
		for (var i = 0; i < n; ++i)
		{
			process.stdout.write(" " + arr[i]);
		}
	}
	// Returns the maximum value of given two numbers
	maxValue(a, b)
	{
		if (a > b)
		{
			return a;
		}
		return b;
	}
	findMaximumSum(arr, n)
	{
		var sum = 0;
		var prefix = 0;
		var result = -Number.MAX_VALUE;
		// Sum of array elements
		for (var i = 0; i < n; ++i)
		{
			sum += arr[i];
		}
		// Find equilibrium sum
		for (var i = 0; i < n; i++)
		{
			// Prefix sum
			prefix = prefix + arr[i];
			if (prefix == sum)
			{
				result = this.maxValue(result, prefix);
			}
			// Reduce sum by current array element  
			sum = sum - arr[i];
		}
		this.printArray(arr, n);
		process.stdout.write("\n Result : " + result + " \n");
	}
}

function main()
{
	var task = new EquilibriumSum();
	// Given array elements
	var arr1 = [6, 5, 2, -5, 8, 1, 4, -4, 7];
	var arr2 = [3, -2, 1, 4, 5, -3];
	// Test A
	// Get the number of elements
	var n = arr1.length;
	//  [6, 5, 2, -5, 8] == [8, 1, 4, -4, 7]
	// Result 16 [6 + 5 + 2 + -5 + 8]
	task.findMaximumSum(arr1, n);
	// Test B
	// Get the number of elements
	n = arr2.length;
	// [ 3, -2, 1, 4] == [4, 5,-3]
	// Result 6 [ 3 + -2 + 1 + 4]
	task.findMaximumSum(arr2, n);
}
main();

Output

 6 5 2 -5 8 1 4 -4 7
 Result : 16
 3 -2 1 4 5 -3
 Result : 6

import sys
#    Python 3 Program for
#    Maximum equilibrium sum in an array
class EquilibriumSum :
	#  Display given list elements
	def printArray(self, arr, n) :
		i = 0
		while (i < n) :
			print(" ", arr[i], end = "")
			i += 1
		
	
	#  Returns the maximum value of given two numbers
	def maxValue(self, a, b) :
		if (a > b) :
			return a
		
		return b
	
	def findMaximumSum(self, arr, n) :
		sum = 0
		prefix = 0
		result = -sys.maxsize
		i = 0
		#  Sum of list elements
		while (i < n) :
			sum += arr[i]
			i += 1
		
		i = 0
		#  Find equilibrium sum
		while (i < n) :
			#  Prefix sum
			prefix = prefix + arr[i]
			if (prefix == sum) :
				result = self.maxValue(result, prefix)
			
			#  Reduce sum by current list element  
			sum = sum - arr[i]
			i += 1
		
		self.printArray(arr, n)
		print("\n Result : ", result ," ")
	

def main() :
	task = EquilibriumSum()
	#  Given list elements
	arr1 = [6, 5, 2, -5, 8, 1, 4, -4, 7]
	arr2 = [3, -2, 1, 4, 5, -3]
	#  Test A
	#  Get the number of elements
	n = len(arr1)
	#   [6, 5, 2, -5, 8] == [8, 1, 4, -4, 7]
	#  Result 16 [6 + 5 + 2 + -5 + 8]
	task.findMaximumSum(arr1, n)
	#  Test B
	#  Get the number of elements
	n = len(arr2)
	#  [ 3, -2, 1, 4] == [4, 5,-3]
	#  Result 6 [ 3 + -2 + 1 + 4]
	task.findMaximumSum(arr2, n)

if __name__ == "__main__": main()

Output

  6  5  2  -5  8  1  4  -4  7
 Result :  16
  3  -2  1  4  5  -3
 Result :  6

#    Ruby Program for
#    Maximum equilibrium sum in an array
class EquilibriumSum 
	#  Display given array elements
	def printArray(arr, n) 
		i = 0
		while (i < n) 
			print(" ", arr[i])
			i += 1
		end

	end

	#  Returns the maximum value of given two numbers
	def maxValue(a, b) 
		if (a > b) 
			return a
		end

		return b
	end

	def findMaximumSum(arr, n) 
		sum = 0
		prefix = 0
		result = -(2 ** (0. size * 8 - 2))
		i = 0
		#  Sum of array elements
		while (i < n) 
			sum += arr[i]
			i += 1
		end

		i = 0
		#  Find equilibrium sum
		while (i < n) 
			#  Prefix sum
			prefix = prefix + arr[i]
			if (prefix == sum) 
				result = self.maxValue(result, prefix)
			end

			#  Reduce sum by current array element  
			sum = sum - arr[i]
			i += 1
		end

		self.printArray(arr, n)
		print("\n Result : ", result ," \n")
	end

end

def main() 
	task = EquilibriumSum.new()
	#  Given array elements
	arr1 = [6, 5, 2, -5, 8, 1, 4, -4, 7]
	arr2 = [3, -2, 1, 4, 5, -3]
	#  Test A
	#  Get the number of elements
	n = arr1.length
	#   [6, 5, 2, -5, 8] == [8, 1, 4, -4, 7]
	#  Result 16 [6 + 5 + 2 + -5 + 8]
	task.findMaximumSum(arr1, n)
	#  Test B
	#  Get the number of elements
	n = arr2.length
	#  [ 3, -2, 1, 4] == [4, 5,-3]
	#  Result 6 [ 3 + -2 + 1 + 4]
	task.findMaximumSum(arr2, n)
end

main()

Output

 6 5 2 -5 8 1 4 -4 7
 Result : 16 
 3 -2 1 4 5 -3
 Result : 6

/*
    Scala Program for
    Maximum equilibrium sum in an array
*/
class EquilibriumSum()
{
	// Display given array elements
	def printArray(arr: Array[Int], n: Int): Unit = {
		var i: Int = 0;
		while (i < n)
		{
			print(" " + arr(i));
			i += 1;
		}
	}
	// Returns the maximum value of given two numbers
	def maxValue(a: Int, b: Int): Int = {
		if (a > b)
		{
			return a;
		}
		return b;
	}
	def findMaximumSum(arr: Array[Int], n: Int): Unit = {
		var sum: Int = 0;
		var prefix: Int = 0;
		var result: Int = Int.MinValue;
		var i: Int = 0;
		// Sum of array elements
		while (i < n)
		{
			sum += arr(i);
			i += 1;
		}
		i = 0;
		// Find equilibrium sum
		while (i < n)
		{
			// Prefix sum
			prefix = prefix + arr(i);
			if (prefix == sum)
			{
				result = maxValue(result, prefix);
			}
			// Reduce sum by current array element  
			sum = sum - arr(i);
			i += 1;
		}
		printArray(arr, n);
		print("\n Result : " + result + " \n");
	}
}
object Main
{
	def main(args: Array[String]): Unit = {
		var task: EquilibriumSum = new EquilibriumSum();
		// Given array elements
		var arr1: Array[Int] = Array(6, 5, 2, -5, 8, 1, 4, -4, 7);
		var arr2: Array[Int] = Array(3, -2, 1, 4, 5, -3);
		// Test A
		// Get the number of elements
		var n: Int = arr1.length;
		//  [6, 5, 2, -5, 8] == [8, 1, 4, -4, 7]
		// Result 16 [6 + 5 + 2 + -5 + 8]
		task.findMaximumSum(arr1, n);
		// Test B
		// Get the number of elements
		n = arr2.length;
		// [ 3, -2, 1, 4] == [4, 5,-3]
		// Result 6 [ 3 + -2 + 1 + 4]
		task.findMaximumSum(arr2, n);
	}
}

Output

 6 5 2 -5 8 1 4 -4 7
 Result : 16
 3 -2 1 4 5 -3
 Result : 6

import Foundation;
/*
    Swift 4 Program for
    Maximum equilibrium sum in an array
*/
class EquilibriumSum
{
	// Display given array elements
	func printArray(_ arr: [Int], _ n: Int)
	{
		var i: Int = 0;
		while (i < n)
		{
			print(" ", arr[i], terminator: "");
			i += 1;
		}
	}
	// Returns the maximum value of given two numbers
	func maxValue(_ a: Int, _ b: Int) -> Int
	{
		if (a > b)
		{
			return a;
		}
		return b;
	}
	func findMaximumSum(_ arr: [Int], _ n: Int)
	{
		var sum: Int = 0;
		var prefix: Int = 0;
		var result: Int = Int.min;
		var i: Int = 0;
		// Sum of array elements
		while (i < n)
		{
			sum += arr[i];
			i += 1;
		}
		i = 0;
		// Find equilibrium sum
		while (i < n)
		{
			// Prefix sum
			prefix = prefix + arr[i];
			if (prefix == sum)
			{
				result = self.maxValue(result, prefix);
			}
			// Reduce sum by current array element  
			sum = sum - arr[i];
			i += 1;
		}
		self.printArray(arr, n);
		print("\n Result : ", result ," ");
	}
}
func main()
{
	let task: EquilibriumSum = EquilibriumSum();
	// Given array elements
	let arr1: [Int] = [6, 5, 2, -5, 8, 1, 4, -4, 7];
	let arr2: [Int] = [3, -2, 1, 4, 5, -3];
	// Test A
	// Get the number of elements
	var n: Int = arr1.count;
	//  [6, 5, 2, -5, 8] == [8, 1, 4, -4, 7]
	// Result 16 [6 + 5 + 2 + -5 + 8]
	task.findMaximumSum(arr1, n);
	// Test B
	// Get the number of elements
	n = arr2.count;
	// [ 3, -2, 1, 4] == [4, 5,-3]
	// Result 6 [ 3 + -2 + 1 + 4]
	task.findMaximumSum(arr2, n);
}
main();

Output

  6  5  2  -5  8  1  4  -4  7
 Result :  16
  3  -2  1  4  5  -3
 Result :  6

/*
    Kotlin Program for
    Maximum equilibrium sum in an array
*/
class EquilibriumSum
{
	// Display given array elements
	fun printArray(arr: Array < Int > , n: Int): Unit
	{
		var i: Int = 0;
		while (i < n)
		{
			print(" " + arr[i]);
			i += 1;
		}
	}
	// Returns the maximum value of given two numbers
	fun maxValue(a: Int, b: Int): Int
	{
		if (a > b)
		{
			return a;
		}
		return b;
	}
	fun findMaximumSum(arr: Array < Int > , n: Int): Unit
	{
		var sum: Int = 0;
		var prefix: Int = 0;
		var result: Int = Int.MIN_VALUE;
		var i: Int = 0;
		// Sum of array elements
		while (i < n)
		{
			sum += arr[i];
			i += 1;
		}
		i = 0;
		// Find equilibrium sum
		while (i < n)
		{
			// Prefix sum
			prefix = prefix + arr[i];
			if (prefix == sum)
			{
				result = this.maxValue(result, prefix);
			}
			// Reduce sum by current array element  
			sum = sum - arr[i];
			i += 1;
		}
		this.printArray(arr, n);
		print("\n Result : " + result + " \n");
	}
}
fun main(args: Array < String > ): Unit
{
	val task: EquilibriumSum = EquilibriumSum();
	// Given array elements
	val arr1: Array < Int > = arrayOf(6, 5, 2, -5, 8, 1, 4, -4, 7);
	val arr2: Array < Int > = arrayOf(3, -2, 1, 4, 5, -3);
	// Test A
	// Get the number of elements
	var n: Int = arr1.count();
	//  [6, 5, 2, -5, 8] == [8, 1, 4, -4, 7]
	// Result 16 [6 + 5 + 2 + -5 + 8]
	task.findMaximumSum(arr1, n);
	// Test B
	// Get the number of elements
	n = arr2.count();
	// [ 3, -2, 1, 4] == [4, 5,-3]
	// Result 6 [ 3 + -2 + 1 + 4]
	task.findMaximumSum(arr2, n);
}

Output

 6 5 2 -5 8 1 4 -4 7
 Result : 16
 3 -2 1 4 5 -3
 Result : 6

« Previous Next »

Array

Shuffle the array elements

Sort an array of 0s 1s and 2s

Sort a given binary array

Move all negative elements at the end of array

Display Inversions pairs in array

Segregate even and odd numbers in array

Move all zeroes to end of array

Merge two sorted arrays without extra space

Alternative sorting of an array elements

Reorder an array according to given indexes

Split the array and add the first part to end

Print all distinct pairs with given difference in array

Find smallest element in sorted rotated array

Find the largest pair sum in an unsorted array

Find the largest and second largest element in an array

Find the largest and smallest element in array

Find the nearest smaller element on left side in an array

Find the smallest and second smallest element in an array

Find k closest numbers in an unsorted array

Sort elements by frequency

Find missing elements from an array

Segregate positive and negative numbers in array

Check if a given array is pairwise sorted or not

Check if an array is rotated sorted order

Count divisible pairs in an array

Count subarray with given sum

Count number of occurrences in a sorted array

Combine array elements by occurrence sequence

Find pair with greatest product in array

Find the rotation count in rotated sorted array

Sort elements in sorted and rotated array

Move all negative elements at the beginning of array

Find Equilibrium index of given array

Find leaders in an array

Find all symmetric pairs in an array

Find element that appears only once in array

Find floor and ceil of a number in sorted array

Find max length subarray with given sum

Find max sum subarray in an array

Print longest bitonic subarray

Print all bitonic subarray

Find all triplets with zero sum

Find three largest element in array

Find three smallest element in array

Reverse the array elements

Find average of array

Find fixed point in array

Find maximum sum subarray of given size

Find a missing number in an array

Find median of two sorted arrays

Find smallest pair sum in an array

Find pairs with given difference in array

Find peak element in array

Find common elements in three sorted array

Find the closest pair from two sorted arrays

Find pair with given sum in sorted and rotated array

Find a pair with maximum product in array

Find unique elements in sorted array

Find floor of a number in a sorted array

Count inversions in an array

Find the largest absolute value in array

Find the union of two sorted arrays

Count all pairs of given product

Merge k sorted arrays

Print all possible rotations of a given Array

Print all left rotations of given array

Print K th right rotation of array elements

Print K th left rotation of array elements

Perform Bitwise XOR in a Binary array

Find a rotation with maximum hamming distance

Find maximum triplet in array

Find the element that appears twice in array

Find the two duplicate elements in array

Find the element that appears once in array

Find the element that appears once in array Set B

Find the all elements that appears n times

Find the Nth element in array after K left rotations

Sort a rotated sorted array

Find element at given index after a number of rotations

Find the distinct elements in a given array

Count smaller elements on right side

Find nearest smallest element of left side in array

Rearrange positive and negative numbers in array

Find the minimum distance between two numbers

Move all zeros to the beginning of the array

Move all zero to middle of array

Sum of elements in an array

Convert number to digits array

Move a given element from end of arrays

Find Second largest element in an array

Front and Back Search in unsorted array

Find minimum distance from zero to other elements

Convert linked list to array

Find floor and ceil in an unsorted array

Find Mean and median of an unsorted array

Find max distance between similar occurrences

Sum of all distinct elements in array

Maximize the median of array elements

Distance between two closest minimum elements

Find the frequency of a element in array

Find the sum of composite elements in array

Find closest number in array

Sum of xor of all pairs in an array

Find all pairs in array

Find sum of all bitwise and pairs in an array

Find all pairs whose sum exists in the array

Double the first element and move zero to end

Find the smallest contiguous sum pair in an array

Find closest higher value for every element in array

Find frequency of smallest element in an array

Find kth element in two sorted arrays

Split an array into two equal sum subarrays

Split array in three equal sum subarrays

Find minimum absolute difference in array

Sum of two numbers represented as arrays

Find ceiling in a sorted array

Largest sum contiguous subarray

Check if array can be sorted with single swap

Find surpasser count of each element in array

Remove duplicates from sorted array

Replace elements with greatest element on right side

Maximum circular subarray sum solution

Maximum equilibrium sum in an array

Find least average subarray of k length

Find maximum average subarray of k length

Find minimum subset product of an array

Sort an array which contains 1 to n values

Find the smallest missing number in sorted array

Check for majority element in a sorted array

Print all pairs of anagrams in a given array of strings

Check if an subarray is a form of hill

Find minimum number of merge operations to make an array palindrome

Count number of positive pairs in an array

Smallest subarray with sum greater than a given value

Find a triplet that sum to a given value

Find a triplet that sum to a given value using sorting

Find all common elements in given 3 sorted arrays

Replace array element by multiplication of previous and next

Find Maximum sum of non adjacent elements

Smallest positive missing number in an array

Check if array elements are consecutive

Find pythagorean triplet in array

Find all triplets which sum less than given value x

Count pairs in a sorted array whose product is less than k

Maximum prefix sum possible by merging two given arrays

Find the size of maximum sum subarray

Count the number of array elements whose digit sum are equal to K

Find all array elements whose digit sum are equal to perfect number

Find index with minimum sum of prefix and suffix sums in an array

Merge elements of three sorted arrays

Find third largest number in array

Program to count even and odd numbers in an array

Sum of even numbers at even position

Find intersection of all intervals

Longest subarray with all even or all odd elements

Find length of longest subarray with only even elements

Find length of longest subarray with only odd elements

Segregate 0s and 1s in an array

Comment

Please share your knowledge to improve code and content standard. Also submit your doubts, and test case. We improve by your feedback. We will try to resolve your query as soon as possible.

New Comment

Name