Skip to main content

Find Maximum sum of non adjacent elements

Here given code implementation process.

/*
    C program for
    Find Maximum sum of non adjacent elements
*/
#include <stdio.h>

// Display array elements
void printArray(int arr[], int n)
{
	for (int i = 0; i < n; ++i)
	{
		printf("  %d", arr[i]);
	}
}
int maxValue(int a, int b)
{
	if (a > b)
	{
		return a;
	}
	return b;
}
void maxNonAdjacentSum(int arr[], int n)
{
	if (n <= 0)
	{
		return;
	}
	// Declare the auxiliary variables
	int includeSum = arr[0];
	int excludeSum = 0;
	int result = 0;
	// Execute this loop from 1...n
	for (int i = 1; i < n; ++i)
	{
		// Get max value of include and exclude sum
		result = maxValue(includeSum, excludeSum);
		includeSum = excludeSum + arr[i];
		// Assign max value
		excludeSum = result;
	}
	result = maxValue(includeSum, excludeSum);
	// Display calculated result
	printf("\n  Result :  %d \n", result);
}
int main(int argc, char const *argv[])
{
	int arr1[] = {
		1 , 2 , 3 , -4 , -4 , -5 , 2
	};
	int arr2[] = {
		1 , 4 , 0 , 6 , 2
	};
	int arr3[] = {
		3 , 5 , 1 , 2
	};
	// Get the size of arrays
	int l = sizeof(arr1) / sizeof(arr1[0]);
	int m = sizeof(arr2) / sizeof(arr2[0]);
	int n = sizeof(arr3) / sizeof(arr3[0]);
	// Test A
	printArray(arr1, l);
	/*
	   arr =  [1, 2, 3, -4, -4, -5, 2]

	   [1,3,2]  Max Non-adjacent
	   ---------------------
	   Result sum : 6
	*/
	maxNonAdjacentSum(arr1, l);
	// Test B
	printArray(arr2, m);
	/*
	   arr =  [1, 4, 0, 6, 2]

	   [4, 6]  Max Non-adjacent
	   ---------------------
	   Result sum : 10
	*/
	maxNonAdjacentSum(arr2, m);
	// Test C
	printArray(arr3, n);
	/*
	   arr =  [3, 5, 1, 2]

	   [5,2]  Max Non-adjacent
	   ---------------------
	   Result sum : 7
	*/
	maxNonAdjacentSum(arr3, n);
	return 0;
}

Output

  1  2  3  -4  -4  -5  2
  Result :  6
  1  4  0  6  2
  Result :  10
  3  5  1  2
  Result :  7
/*
    Java program for
    Find Maximum sum of non adjacent elements
*/
public class MaximumSum
{
    // Display array elements
    public void printArray(int[] arr, int n)
    {
        for (int i = 0; i < n; ++i)
        {
            System.out.print(" " + arr[i]);
        }
    }
    // Return a max value of given numbers
    public int maxValue(int a, int b)
    {
        if (a > b)
        {
            return a;
        }
        return b;
    }
    public void maxNonAdjacentSum(int[] arr, int n)
    {
        if (n <= 0)
        {
            return;
        }
        // Declare the auxiliary variables
        int includeSum = arr[0];
        int excludeSum = 0;
        int result = 0;
        // Execute this loop from 1...n
        for (int i = 1; i < n; ++i)
        {
            // Get max value of include and exclude sum
            result = maxValue(includeSum, excludeSum);
            includeSum = excludeSum + arr[i];
            // Assign max value
            excludeSum = result;
        }
        result = maxValue(includeSum, excludeSum);
        // Display calculated result
        System.out.print("\n Result : " + result + " \n");
    }
    public static void main(String[] args)
    {
        MaximumSum task = new MaximumSum();
        int[] arr1 = {
            1 , 2 , 3 , -4 , -4 , -5 , 2
        };
        int[] arr2 = {
            1 , 4 , 0 , 6 , 2
        };
        int[] arr3 = {
            3 , 5 , 1 , 2
        };
        // Get the size of arrays
        int l = arr1.length;
        int m = arr2.length;
        int n = arr3.length;
        // Test A
        task.printArray(arr1, l);
        /*
           arr =  [1, 2, 3, -4, -4, -5, 2]

           [1,3,2]  Max Non-adjacent
           ---------------------
           Result sum : 6
        */
        task.maxNonAdjacentSum(arr1, l);
        // Test B
        task.printArray(arr2, m);
        /*
           arr =  [1, 4, 0, 6, 2]

           [4, 6]  Max Non-adjacent
           ---------------------
           Result sum : 10
        */
        task.maxNonAdjacentSum(arr2, m);
        // Test C
        task.printArray(arr3, n);
        /*
           arr =  [3, 5, 1, 2]

           [5,2]  Max Non-adjacent
           ---------------------
           Result sum : 7
        */
        task.maxNonAdjacentSum(arr3, n);
    }
}

Output

 1 2 3 -4 -4 -5 2
 Result : 6
 1 4 0 6 2
 Result : 10
 3 5 1 2
 Result : 7
// Include header file
#include <iostream>

using namespace std;
/*
    C++ program for
    Find Maximum sum of non adjacent elements
*/
class MaximumSum
{
	public:
		// Display array elements
		void printArray(int arr[], int n)
		{
			for (int i = 0; i < n; ++i)
			{
				cout << " " << arr[i];
			}
		}
	// Return a max value of given numbers
	int maxValue(int a, int b)
	{
		if (a > b)
		{
			return a;
		}
		return b;
	}
	void maxNonAdjacentSum(int arr[], int n)
	{
		if (n <= 0)
		{
			return;
		}
		// Declare the auxiliary variables
		int includeSum = arr[0];
		int excludeSum = 0;
		int result = 0;
		// Execute this loop from 1...n
		for (int i = 1; i < n; ++i)
		{
			// Get max value of include and exclude sum
			result = this->maxValue(includeSum, excludeSum);
			includeSum = excludeSum + arr[i];
			// Assign max value
			excludeSum = result;
		}
		result = this->maxValue(includeSum, excludeSum);
		// Display calculated result
		cout << "\n Result : " << result << " \n";
	}
};
int main()
{
	MaximumSum *task = new MaximumSum();
	int arr1[] = {
		1 , 2 , 3 , -4 , -4 , -5 , 2
	};
	int arr2[] = {
		1 , 4 , 0 , 6 , 2
	};
	int arr3[] = {
		3 , 5 , 1 , 2
	};
	// Get the size of arrays
	int l = sizeof(arr1) / sizeof(arr1[0]);
	int m = sizeof(arr2) / sizeof(arr2[0]);
	int n = sizeof(arr3) / sizeof(arr3[0]);
	// Test A
	task->printArray(arr1, l);
	/*
	   arr =  [1, 2, 3, -4, -4, -5, 2]
	   [1,3,2]  Max Non-adjacent
	   ---------------------
	   Result sum : 6
	        
	*/
	task->maxNonAdjacentSum(arr1, l);
	// Test B
	task->printArray(arr2, m);
	/*
	   arr =  [1, 4, 0, 6, 2]
	   [4, 6]  Max Non-adjacent
	   ---------------------
	   Result sum : 10
	        
	*/
	task->maxNonAdjacentSum(arr2, m);
	// Test C
	task->printArray(arr3, n);
	/*
	   arr =  [3, 5, 1, 2]
	   [5,2]  Max Non-adjacent
	   ---------------------
	   Result sum : 7
	        
	*/
	task->maxNonAdjacentSum(arr3, n);
	return 0;
}

Output

 1 2 3 -4 -4 -5 2
 Result : 6
 1 4 0 6 2
 Result : 10
 3 5 1 2
 Result : 7
// Include namespace system
using System;
/*
    Csharp program for
    Find Maximum sum of non adjacent elements
*/
public class MaximumSum
{
	// Display array elements
	public void printArray(int[] arr, int n)
	{
		for (int i = 0; i < n; ++i)
		{
			Console.Write(" " + arr[i]);
		}
	}
	// Return a max value of given numbers
	public int maxValue(int a, int b)
	{
		if (a > b)
		{
			return a;
		}
		return b;
	}
	public void maxNonAdjacentSum(int[] arr, int n)
	{
		if (n <= 0)
		{
			return;
		}
		// Declare the auxiliary variables
		int includeSum = arr[0];
		int excludeSum = 0;
		int result = 0;
		// Execute this loop from 1...n
		for (int i = 1; i < n; ++i)
		{
			// Get max value of include and exclude sum
			result = this.maxValue(includeSum, excludeSum);
			includeSum = excludeSum + arr[i];
			// Assign max value
			excludeSum = result;
		}
		result = this.maxValue(includeSum, excludeSum);
		// Display calculated result
		Console.Write("\n Result : " + result + " \n");
	}
	public static void Main(String[] args)
	{
		MaximumSum task = new MaximumSum();
		int[] arr1 = {
			1 , 2 , 3 , -4 , -4 , -5 , 2
		};
		int[] arr2 = {
			1 , 4 , 0 , 6 , 2
		};
		int[] arr3 = {
			3 , 5 , 1 , 2
		};
		// Get the size of arrays
		int l = arr1.Length;
		int m = arr2.Length;
		int n = arr3.Length;
		// Test A
		task.printArray(arr1, l);
		/*
		   arr =  [1, 2, 3, -4, -4, -5, 2]
		   [1,3,2]  Max Non-adjacent
		   ---------------------
		   Result sum : 6
		        
		*/
		task.maxNonAdjacentSum(arr1, l);
		// Test B
		task.printArray(arr2, m);
		/*
		   arr =  [1, 4, 0, 6, 2]
		   [4, 6]  Max Non-adjacent
		   ---------------------
		   Result sum : 10
		        
		*/
		task.maxNonAdjacentSum(arr2, m);
		// Test C
		task.printArray(arr3, n);
		/*
		   arr =  [3, 5, 1, 2]
		   [5,2]  Max Non-adjacent
		   ---------------------
		   Result sum : 7
		        
		*/
		task.maxNonAdjacentSum(arr3, n);
	}
}

Output

 1 2 3 -4 -4 -5 2
 Result : 6
 1 4 0 6 2
 Result : 10
 3 5 1 2
 Result : 7
<?php
/*
    Php program for
    Find Maximum sum of non adjacent elements
*/
class MaximumSum
{
	// Display array elements
	public	function printArray($arr, $n)
	{
		for ($i = 0; $i < $n; ++$i)
		{
			echo(" ".$arr[$i]);
		}
	}
	// Return a max value of given numbers
	public	function maxValue($a, $b)
	{
		if ($a > $b)
		{
			return $a;
		}
		return $b;
	}
	public	function maxNonAdjacentSum($arr, $n)
	{
		if ($n <= 0)
		{
			return;
		}
		// Declare the auxiliary variables
		$includeSum = $arr[0];
		$excludeSum = 0;
		$result = 0;
		// Execute this loop from 1...n
		for ($i = 1; $i < $n; ++$i)
		{
			// Get max value of include and exclude sum
			$result = $this->maxValue($includeSum, $excludeSum);
			$includeSum = $excludeSum + $arr[$i];
			// Assign max value
			$excludeSum = $result;
		}
		$result = $this->maxValue($includeSum, $excludeSum);
		// Display calculated result
		echo("\n Result : ".$result." \n");
	}
}

function main()
{
	$task = new MaximumSum();
	$arr1 = array(1, 2, 3, -4, -4, -5, 2);
	$arr2 = array(1, 4, 0, 6, 2);
	$arr3 = array(3, 5, 1, 2);
	// Get the size of arrays
	$l = count($arr1);
	$m = count($arr2);
	$n = count($arr3);
	// Test A
	$task->printArray($arr1, $l);
	/*
	   arr =  [1, 2, 3, -4, -4, -5, 2]
	   [1,3,2]  Max Non-adjacent
	   ---------------------
	   Result sum : 6
	        
	*/
	$task->maxNonAdjacentSum($arr1, $l);
	// Test B
	$task->printArray($arr2, $m);
	/*
	   arr =  [1, 4, 0, 6, 2]
	   [4, 6]  Max Non-adjacent
	   ---------------------
	   Result sum : 10
	        
	*/
	$task->maxNonAdjacentSum($arr2, $m);
	// Test C
	$task->printArray($arr3, $n);
	/*
	   arr =  [3, 5, 1, 2]
	   [5,2]  Max Non-adjacent
	   ---------------------
	   Result sum : 7
	        
	*/
	$task->maxNonAdjacentSum($arr3, $n);
}
main();

Output

 1 2 3 -4 -4 -5 2
 Result : 6
 1 4 0 6 2
 Result : 10
 3 5 1 2
 Result : 7
package main
import "fmt"
/*
    Go program for
    Find Maximum sum of non adjacent elements
*/

// Display array elements
func printArray(arr[] int, n int) {
	for i := 0 ; i < n ; i++ {
		fmt.Print(" ", arr[i])
	}
}
// Return a max value of given numbers
func maxValue(a, b int) int {
	if a > b {
		return a
	}
	return b
}
func maxNonAdjacentSum(arr[] int, n int) {
	if n <= 0 {
		return
	}
	// Declare the auxiliary variables
	var includeSum int = arr[0]
	var excludeSum int = 0
	var result int = 0
	// Execute this loop from 1...n
	for i := 1 ; i < n ; i++ {
		// Get max value of include and exclude sum
		result = maxValue(includeSum, excludeSum)
		includeSum = excludeSum + arr[i]
		// Assign max value
		excludeSum = result
	}
	result = maxValue(includeSum, excludeSum)
	// Display calculated result
	fmt.Print("\n Result : ", result, " \n")
}
func main() {

	var arr1 = [] int { 1 , 2 , 3 , - 4 , - 4 , - 5 , 2 }
	var arr2 = [] int { 1 , 4 , 0 , 6 , 2 }
	var arr3 = [] int { 3 , 5 , 1 , 2 }
	// Get the size of arrays
	var l int = len(arr1)
	var m int = len(arr2)
	var n int = len(arr3)
	// Test A
	printArray(arr1, l)
	/*
	   arr =  [1, 2, 3, -4, -4, -5, 2]
	   [1,3,2]  Max Non-adjacent
	   ---------------------
	   Result sum : 6
	        
	*/
	maxNonAdjacentSum(arr1, l)
	// Test B
	printArray(arr2, m)
	/*
	   arr =  [1, 4, 0, 6, 2]
	   [4, 6]  Max Non-adjacent
	   ---------------------
	   Result sum : 10
	        
	*/
	maxNonAdjacentSum(arr2, m)
	// Test C
	printArray(arr3, n)
	/*
	   arr =  [3, 5, 1, 2]
	   [5,2]  Max Non-adjacent
	   ---------------------
	   Result sum : 7
	        
	*/
	maxNonAdjacentSum(arr3, n)
}

Output

 1 2 3 -4 -4 -5 2
 Result : 6
 1 4 0 6 2
 Result : 10
 3 5 1 2
 Result : 7
/*
    Node JS program for
    Find Maximum sum of non adjacent elements
*/
class MaximumSum
{
	// Display array elements
	printArray(arr, n)
	{
		for (var i = 0; i < n; ++i)
		{
			process.stdout.write(" " + arr[i]);
		}
	}
	// Return a max value of given numbers
	maxValue(a, b)
	{
		if (a > b)
		{
			return a;
		}
		return b;
	}
	maxNonAdjacentSum(arr, n)
	{
		if (n <= 0)
		{
			return;
		}
		// Declare the auxiliary variables
		var includeSum = arr[0];
		var excludeSum = 0;
		var result = 0;
		// Execute this loop from 1...n
		for (var i = 1; i < n; ++i)
		{
			// Get max value of include and exclude sum
			result = this.maxValue(includeSum, excludeSum);
			includeSum = excludeSum + arr[i];
			// Assign max value
			excludeSum = result;
		}
		result = this.maxValue(includeSum, excludeSum);
		// Display calculated result
		process.stdout.write("\n Result : " + result + " \n");
	}
}

function main()
{
	var task = new MaximumSum();
	var arr1 = [1, 2, 3, -4, -4, -5, 2];
	var arr2 = [1, 4, 0, 6, 2];
	var arr3 = [3, 5, 1, 2];
	// Get the size of arrays
	var l = arr1.length;
	var m = arr2.length;
	var n = arr3.length;
	// Test A
	task.printArray(arr1, l);
	/*
	   arr =  [1, 2, 3, -4, -4, -5, 2]
	   [1,3,2]  Max Non-adjacent
	   ---------------------
	   Result sum : 6
	        
	*/
	task.maxNonAdjacentSum(arr1, l);
	// Test B
	task.printArray(arr2, m);
	/*
	   arr =  [1, 4, 0, 6, 2]
	   [4, 6]  Max Non-adjacent
	   ---------------------
	   Result sum : 10
	        
	*/
	task.maxNonAdjacentSum(arr2, m);
	// Test C
	task.printArray(arr3, n);
	/*
	   arr =  [3, 5, 1, 2]
	   [5,2]  Max Non-adjacent
	   ---------------------
	   Result sum : 7
	        
	*/
	task.maxNonAdjacentSum(arr3, n);
}
main();

Output

 1 2 3 -4 -4 -5 2
 Result : 6
 1 4 0 6 2
 Result : 10
 3 5 1 2
 Result : 7
#    Python 3 program for
#    Find Maximum sum of non adjacent elements
class MaximumSum :
	#  Display list elements
	def printArray(self, arr, n) :
		i = 0
		while (i < n) :
			print(" ", arr[i], end = "")
			i += 1
		
	
	#  Return a max value of given numbers
	def maxValue(self, a, b) :
		if (a > b) :
			return a
		
		return b
	
	def maxNonAdjacentSum(self, arr, n) :
		if (n <= 0) :
			return
		
		#  Declare the auxiliary variables
		includeSum = arr[0]
		excludeSum = 0
		result = 0
		i = 1
		#  Execute this loop from 1...n
		while (i < n) :
			#  Get max value of include and exclude sum
			result = self.maxValue(includeSum, excludeSum)
			includeSum = excludeSum + arr[i]
			#  Assign max value
			excludeSum = result
			i += 1
		
		result = self.maxValue(includeSum, excludeSum)
		#  Display calculated result
		print("\n Result : ", result ," ")
	

def main() :
	task = MaximumSum()
	arr1 = [1, 2, 3, -4, -4, -5, 2]
	arr2 = [1, 4, 0, 6, 2]
	arr3 = [3, 5, 1, 2]
	#  Get the size of lists
	l = len(arr1)
	m = len(arr2)
	n = len(arr3)
	#  Test A
	task.printArray(arr1, l)
	#   arr =  [1, 2, 3, -4, -4, -5, 2]
	#   [1,3,2]  Max Non-adjacent
	#   ---------------------
	#   Result sum : 6
	task.maxNonAdjacentSum(arr1, l)
	#  Test B
	task.printArray(arr2, m)
	#   arr =  [1, 4, 0, 6, 2]
	#   [4, 6]  Max Non-adjacent
	#   ---------------------
	#   Result sum : 10
	task.maxNonAdjacentSum(arr2, m)
	#  Test C
	task.printArray(arr3, n)
	#   arr =  [3, 5, 1, 2]
	#   [5,2]  Max Non-adjacent
	#   ---------------------
	#   Result sum : 7
	task.maxNonAdjacentSum(arr3, n)

if __name__ == "__main__": main()

Output

  1  2  3  -4  -4  -5  2
 Result :  6
  1  4  0  6  2
 Result :  10
  3  5  1  2
 Result :  7
#    Ruby program for
#    Find Maximum sum of non adjacent elements
class MaximumSum 
	#  Display array elements
	def printArray(arr, n) 
		i = 0
		while (i < n) 
			print(" ", arr[i])
			i += 1
		end

	end

	#  Return a max value of given numbers
	def maxValue(a, b) 
		if (a > b) 
			return a
		end

		return b
	end

	def maxNonAdjacentSum(arr, n) 
		if (n <= 0) 
			return
		end

		#  Declare the auxiliary variables
		includeSum = arr[0]
		excludeSum = 0
		result = 0
		i = 1
		#  Execute this loop from 1...n
		while (i < n) 
			#  Get max value of include and exclude sum
			result = self.maxValue(includeSum, excludeSum)
			includeSum = excludeSum + arr[i]
			#  Assign max value
			excludeSum = result
			i += 1
		end

		result = self.maxValue(includeSum, excludeSum)
		#  Display calculated result
		print("\n Result : ", result ," \n")
	end

end

def main() 
	task = MaximumSum.new()
	arr1 = [1, 2, 3, -4, -4, -5, 2]
	arr2 = [1, 4, 0, 6, 2]
	arr3 = [3, 5, 1, 2]
	#  Get the size of arrays
	l = arr1.length
	m = arr2.length
	n = arr3.length
	#  Test A
	task.printArray(arr1, l)
	#   arr =  [1, 2, 3, -4, -4, -5, 2]
	#   [1,3,2]  Max Non-adjacent
	#   ---------------------
	#   Result sum : 6
	task.maxNonAdjacentSum(arr1, l)
	#  Test B
	task.printArray(arr2, m)
	#   arr =  [1, 4, 0, 6, 2]
	#   [4, 6]  Max Non-adjacent
	#   ---------------------
	#   Result sum : 10
	task.maxNonAdjacentSum(arr2, m)
	#  Test C
	task.printArray(arr3, n)
	#   arr =  [3, 5, 1, 2]
	#   [5,2]  Max Non-adjacent
	#   ---------------------
	#   Result sum : 7
	task.maxNonAdjacentSum(arr3, n)
end

main()

Output

 1 2 3 -4 -4 -5 2
 Result : 6 
 1 4 0 6 2
 Result : 10 
 3 5 1 2
 Result : 7 

/*
    Scala program for
    Find Maximum sum of non adjacent elements
*/
class MaximumSum()
{
	// Display array elements
	def printArray(arr: Array[Int], n: Int): Unit = {
		var i: Int = 0;
		while (i < n)
		{
			print(" " + arr(i));
			i += 1;
		}
	}
	// Return a max value of given numbers
	def maxValue(a: Int, b: Int): Int = {
		if (a > b)
		{
			return a;
		}
		return b;
	}
	def maxNonAdjacentSum(arr: Array[Int], n: Int): Unit = {
		if (n <= 0)
		{
			return;
		}
		// Declare the auxiliary variables
		var includeSum: Int = arr(0);
		var excludeSum: Int = 0;
		var result: Int = 0;
		var i: Int = 1;
		// Execute this loop from 1...n
		while (i < n)
		{
			// Get max value of include and exclude sum
			result = maxValue(includeSum, excludeSum);
			includeSum = excludeSum + arr(i);
			// Assign max value
			excludeSum = result;
			i += 1;
		}
		result = maxValue(includeSum, excludeSum);
		// Display calculated result
		print("\n Result : " + result + " \n");
	}
}
object Main
{
	def main(args: Array[String]): Unit = {
		var task: MaximumSum = new MaximumSum();
		var arr1: Array[Int] = Array(1, 2, 3, -4, -4, -5, 2);
		var arr2: Array[Int] = Array(1, 4, 0, 6, 2);
		var arr3: Array[Int] = Array(3, 5, 1, 2);
		// Get the size of arrays
		var l: Int = arr1.length;
		var m: Int = arr2.length;
		var n: Int = arr3.length;
		// Test A
		task.printArray(arr1, l);
		/*
		   arr =  [1, 2, 3, -4, -4, -5, 2]
		   [1,3,2]  Max Non-adjacent
		   ---------------------
		   Result sum : 6
		        
		*/
		task.maxNonAdjacentSum(arr1, l);
		// Test B
		task.printArray(arr2, m);
		/*
		   arr =  [1, 4, 0, 6, 2]
		   [4, 6]  Max Non-adjacent
		   ---------------------
		   Result sum : 10
		        
		*/
		task.maxNonAdjacentSum(arr2, m);
		// Test C
		task.printArray(arr3, n);
		/*
		   arr =  [3, 5, 1, 2]
		   [5,2]  Max Non-adjacent
		   ---------------------
		   Result sum : 7
		        
		*/
		task.maxNonAdjacentSum(arr3, n);
	}
}

Output

 1 2 3 -4 -4 -5 2
 Result : 6
 1 4 0 6 2
 Result : 10
 3 5 1 2
 Result : 7
import Foundation;
/*
    Swift 4 program for
    Find Maximum sum of non adjacent elements
*/
class MaximumSum
{
	// Display array elements
	func printArray(_ arr: [Int], _ n: Int)
	{
		var i: Int = 0;
		while (i < n)
		{
			print(" ", arr[i], terminator: "");
			i += 1;
		}
	}
	// Return a max value of given numbers
	func maxValue(_ a: Int, _ b: Int) -> Int
	{
		if (a > b)
		{
			return a;
		}
		return b;
	}
	func maxNonAdjacentSum(_ arr: [Int], _ n: Int)
	{
		if (n <= 0)
		{
			return;
		}
		// Declare the auxiliary variables
		var includeSum: Int = arr[0];
		var excludeSum: Int = 0;
		var result: Int = 0;
		var i: Int = 1;
		// Execute this loop from 1...n
		while (i < n)
		{
			// Get max value of include and exclude sum
			result = self.maxValue(includeSum, excludeSum);
			includeSum = excludeSum + arr[i];
			// Assign max value
			excludeSum = result;
			i += 1;
		}
		result = self.maxValue(includeSum, excludeSum);
		// Display calculated result
		print("\n Result : ", result ," ");
	}
}
func main()
{
	let task: MaximumSum = MaximumSum();
	let arr1: [Int] = [1, 2, 3, -4, -4, -5, 2];
	let arr2: [Int] = [1, 4, 0, 6, 2];
	let arr3: [Int] = [3, 5, 1, 2];
	// Get the size of arrays
	let l: Int = arr1.count;
	let m: Int = arr2.count;
	let n: Int = arr3.count;
	// Test A
	task.printArray(arr1, l);
	/*
	   arr =  [1, 2, 3, -4, -4, -5, 2]
	   [1,3,2]  Max Non-adjacent
	   ---------------------
	   Result sum : 6
	        
	*/
	task.maxNonAdjacentSum(arr1, l);
	// Test B
	task.printArray(arr2, m);
	/*
	   arr =  [1, 4, 0, 6, 2]
	   [4, 6]  Max Non-adjacent
	   ---------------------
	   Result sum : 10
	        
	*/
	task.maxNonAdjacentSum(arr2, m);
	// Test C
	task.printArray(arr3, n);
	/*
	   arr =  [3, 5, 1, 2]
	   [5,2]  Max Non-adjacent
	   ---------------------
	   Result sum : 7
	        
	*/
	task.maxNonAdjacentSum(arr3, n);
}
main();

Output

  1  2  3  -4  -4  -5  2
 Result :  6
  1  4  0  6  2
 Result :  10
  3  5  1  2
 Result :  7
/*
    Kotlin program for
    Find Maximum sum of non adjacent elements
*/
class MaximumSum
{
	// Display array elements
	fun printArray(arr: Array < Int > , n: Int): Unit
	{
		var i: Int = 0;
		while (i < n)
		{
			print(" " + arr[i]);
			i += 1;
		}
	}
	// Return a max value of given numbers
	fun maxValue(a: Int, b: Int): Int
	{
		if (a > b)
		{
			return a;
		}
		return b;
	}
	fun maxNonAdjacentSum(arr: Array < Int > , n: Int): Unit
	{
		if (n <= 0)
		{
			return;
		}
		// Declare the auxiliary variables
		var includeSum: Int = arr[0];
		var excludeSum: Int = 0;
		var result: Int ;
		var i: Int = 1;
		// Execute this loop from 1...n
		while (i < n)
		{
			// Get max value of include and exclude sum
			result = this.maxValue(includeSum, excludeSum);
			includeSum = excludeSum + arr[i];
			// Assign max value
			excludeSum = result;
			i += 1;
		}
		result = this.maxValue(includeSum, excludeSum);
		// Display calculated result
		print("\n Result : " + result + " \n");
	}
}
fun main(args: Array < String > ): Unit
{
	val task: MaximumSum = MaximumSum();
	val arr1: Array < Int > = arrayOf(1, 2, 3, -4, -4, -5, 2);
	val arr2: Array < Int > = arrayOf(1, 4, 0, 6, 2);
	val arr3: Array < Int > = arrayOf(3, 5, 1, 2);
	// Get the size of arrays
	val l: Int = arr1.count();
	val m: Int = arr2.count();
	val n: Int = arr3.count();
	// Test A
	task.printArray(arr1, l);
	/*
	   arr =  [1, 2, 3, -4, -4, -5, 2]
	   [1,3,2]  Max Non-adjacent
	   ---------------------
	   Result sum : 6
	        
	*/
	task.maxNonAdjacentSum(arr1, l);
	// Test B
	task.printArray(arr2, m);
	/*
	   arr =  [1, 4, 0, 6, 2]
	   [4, 6]  Max Non-adjacent
	   ---------------------
	   Result sum : 10
	        
	*/
	task.maxNonAdjacentSum(arr2, m);
	// Test C
	task.printArray(arr3, n);
	/*
	   arr =  [3, 5, 1, 2]
	   [5,2]  Max Non-adjacent
	   ---------------------
	   Result sum : 7
	        
	*/
	task.maxNonAdjacentSum(arr3, n);
}

Output

 1 2 3 -4 -4 -5 2
 Result : 6
 1 4 0 6 2
 Result : 10
 3 5 1 2
 Result : 7
Last updated on by Kalkicode




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