# Efficiently find level sum of bitwise and Operation in binary tree

Here given code implementation process.

``````import java.util.HashMap;
import java.util.ArrayList;
/*
Java program for
Efficiently find level sum of bitwise and
Operation in binary tree.
*/
// Binary Tree node
class TreeNode
{
public int data;
public TreeNode left;
public TreeNode right;
public TreeNode(int data)
{
// Set node value
this.data = data;
this.left = null;
this.right = null;
}
}
public class BinaryTree
{
public TreeNode root;
public BinaryTree()
{
// Set initial value
this.root = null;
}
public void getLevelNodes(
TreeNode node,
HashMap < Integer, ArrayList < Integer >> record,
int level)
{
if (node != null)
{
if (!record.containsKey(level))
{
// Create new level
record.put(level, new ArrayList < Integer > ());
}
// Visit left and right subtree
getLevelNodes(node.left, record, level + 1);
getLevelNodes(node.right, record, level + 1);
}
}
public void levelAndSum()
{
if (this.root == null)
{
return;
}
// Auxiliary variables
int sum = 0;
int auxiliary = 0;
// Level start 0
int level = 0;
// This are capable to collect level nodes
HashMap < Integer, ArrayList < Integer >> record =
new HashMap < Integer, ArrayList < Integer >> ();
// This are collecting level nodes in binary tree
this.getLevelNodes(this.root, record, 0);
// Execute loop from top to bottom manner level 0 to n
while (level < record.size())
{
ArrayList < Integer > value = record.get(level);
// Execute level nodes
for (int j = 0; j < value.size(); ++j)
{
if (j == 0)
{
auxiliary = value.get(j);
}
else
{
// Perform bitwise And operation
auxiliary = auxiliary & value.get(j);
}
// Display level node
System.out.print("  " + value.get(j));
}
// Include new line
System.out.print("\n");
sum += auxiliary;
level++;
}
System.out.println(" Result : " + sum);
}
public static void main(String[] args)
{
BinaryTree tree1 = new BinaryTree();
BinaryTree tree2 = new BinaryTree();
/*
1
/   \
2     7
/ \     \
11   7     19
/
-2
-----------------
Construct Tree 1
*/
tree1.root = new TreeNode(1);
tree1.root.left = new TreeNode(2);
tree1.root.right = new TreeNode(7);
tree1.root.right.right = new TreeNode(19);
tree1.root.left.right = new TreeNode(7);
tree1.root.left.left = new TreeNode(11);
tree1.root.right.right.left = new TreeNode(-2);
/*
3
/   \
2     7
/ \
7   8

-----------------
Construct Tree 2
*/
tree2.root = new TreeNode(3);
tree2.root.left = new TreeNode(2);
tree2.root.right = new TreeNode(7);
tree2.root.left.right = new TreeNode(8);
tree2.root.left.left = new TreeNode(7);
/*
-----------------
Tree 1
-----------------

1           1              = 1
/   \
2     7        2 & 7          = 2
/ \     \
11   7     19     11 & 7 & 19    = 3
/
-2       -2             = -2
-----------------------------------------
1 + 2 + 3 -2            =  4
*/
tree1.levelAndSum();
/*
-----------------
Tree 2
----------------

3           3  = 3
/   \
2     7    2 & 7  = 2
/ \
7   8        7 & 8  = 0
-----------------------------------------
3  + 2 + 0  =  5
*/
tree2.levelAndSum();
}
}``````

#### Output

``````  1
2  7
11  7  19
-2
Result : 4
3
2  7
7  8
Result : 5``````
``````// Include header file
#include <iostream>
#include <unordered_map>
#include <vector>

using namespace std;
/*
C++ program for
Efficiently find level sum of bitwise and
Operation in binary tree.
*/
// Binary Tree node
class TreeNode
{
public: int data;
TreeNode *left;
TreeNode *right;
TreeNode(int data)
{
// Set node value
this->data = data;
this->left = NULL;
this->right = NULL;
}
};
class BinaryTree
{
public: TreeNode *root;
BinaryTree()
{
this->root = NULL;
}
void getLevelNodes(TreeNode *node,
unordered_map < int, vector < int > > &record,
int level)
{
if (node != NULL)
{
record[level].push_back(node->data);
// Visit left and right subtree
this->getLevelNodes(node->left, record, level + 1);
this->getLevelNodes(node->right, record, level + 1);
}
}
void levelAndSum()
{
if (this->root == NULL)
{
return;
}
// Auxiliary variables
int sum = 0;
int auxiliary = 0;
// Level start 0
int level = 0;
// This are capable to collect level nodes
unordered_map < int, vector < int > > record;
// This are collecting level nodes in binary tree
this->getLevelNodes(this->root, record, 0);
// Execute loop from top to bottom manner level 0 to n
while (level < record.size())
{
// Execute level nodes
for (int j = 0; j < record[level].size(); ++j)
{
if (j == 0)
{
auxiliary = record[level][j];
}
else
{
// Perform bitwise And operation
auxiliary = auxiliary & record[level][j];
}
// Display level node
cout << "  " << record[level][j];
}
// Include new line
cout << "\n";
sum += auxiliary;
level++;
}
cout << " Result : " << sum << endl;
}
};
int main()
{
BinaryTree *tree1 = new BinaryTree();
BinaryTree *tree2 = new BinaryTree();
/*
1
/   \
2     7
/ \     \
11   7     19
/
-2
-----------------
Construct Tree 1
*/
tree1->root = new TreeNode(1);
tree1->root->left = new TreeNode(2);
tree1->root->right = new TreeNode(7);
tree1->root->right->right = new TreeNode(19);
tree1->root->left->right = new TreeNode(7);
tree1->root->left->left = new TreeNode(11);
tree1->root->right->right->left = new TreeNode(-2);
/*
3
/   \
2     7
/ \
7   8

-----------------
Construct Tree 2
*/
tree2->root = new TreeNode(3);
tree2->root->left = new TreeNode(2);
tree2->root->right = new TreeNode(7);
tree2->root->left->right = new TreeNode(8);
tree2->root->left->left = new TreeNode(7);
/*
-----------------
Tree 1
-----------------
1           1              = 1
/   \
2     7        2 & 7          = 2
/ \     \
11   7     19     11 & 7 & 19    = 3
/
-2       -2             = -2
-----------------------------------------
1 + 2 + 3 -2            =  4
*/
tree1->levelAndSum();
/*
-----------------
Tree 2
----------------
3           3  = 3
/   \
2     7    2 & 7  = 2
/ \
7   8        7 & 8  = 0
-----------------------------------------
3  + 2 + 0  =  5
*/
tree2->levelAndSum();
return 0;
}``````

#### Output

``````  1
2  7
11  7  19
-2
Result : 4
3
2  7
7  8
Result : 5``````
``````// Include namespace system
using System;
using System.Collections.Generic;
/*
Csharp program for
Efficiently find level sum of bitwise and
Operation in binary tree.
*/
// Binary Tree node
public class TreeNode
{
public int data;
public TreeNode left;
public TreeNode right;
public TreeNode(int data)
{
// Set node value
this.data = data;
this.left = null;
this.right = null;
}
}
public class BinaryTree
{
public TreeNode root;
public BinaryTree()
{
// Set initial value
this.root = null;
}
public void getLevelNodes(TreeNode node,
Dictionary < int, List < int >> record,
int level)
{
if (node != null)
{
if (!record.ContainsKey(level))
{
// Create new level
record.Add(level, new List < int > ());
}
// Visit left and right subtree
this.getLevelNodes(node.left, record, level + 1);
this.getLevelNodes(node.right, record, level + 1);
}
}
public void levelAndSum()
{
if (this.root == null)
{
return;
}
// Auxiliary variables
int sum = 0;
int auxiliary = 0;
// Level start 0
int level = 0;
// This are capable to collect level nodes
Dictionary < int, List < int >> record =
new Dictionary < int, List < int >> ();
// This are collecting level nodes in binary tree
this.getLevelNodes(this.root, record, 0);
// Execute loop from top to bottom manner level 0 to n
while (level < record.Count)
{
List < int > value = record[level];
// Execute level nodes
for (int j = 0; j < value.Count; ++j)
{
if (j == 0)
{
auxiliary = value[j];
}
else
{
// Perform bitwise And operation
auxiliary = auxiliary & value[j];
}
// Display level node
Console.Write("  " + value[j]);
}
// Include new line
Console.Write("\n");
sum += auxiliary;
level++;
}
Console.WriteLine(" Result : " + sum);
}
public static void Main(String[] args)
{
BinaryTree tree1 = new BinaryTree();
BinaryTree tree2 = new BinaryTree();
/*
1
/   \
2     7
/ \     \
11   7     19
/
-2
-----------------
Construct Tree 1
*/
tree1.root = new TreeNode(1);
tree1.root.left = new TreeNode(2);
tree1.root.right = new TreeNode(7);
tree1.root.right.right = new TreeNode(19);
tree1.root.left.right = new TreeNode(7);
tree1.root.left.left = new TreeNode(11);
tree1.root.right.right.left = new TreeNode(-2);
/*
3
/   \
2     7
/ \
7   8

-----------------
Construct Tree 2
*/
tree2.root = new TreeNode(3);
tree2.root.left = new TreeNode(2);
tree2.root.right = new TreeNode(7);
tree2.root.left.right = new TreeNode(8);
tree2.root.left.left = new TreeNode(7);
/*
-----------------
Tree 1
-----------------
1           1              = 1
/   \
2     7        2 & 7          = 2
/ \     \
11   7     19     11 & 7 & 19    = 3
/
-2       -2             = -2
-----------------------------------------
1 + 2 + 3 -2            =  4
*/
tree1.levelAndSum();
/*
-----------------
Tree 2
----------------
3           3  = 3
/   \
2     7    2 & 7  = 2
/ \
7   8        7 & 8  = 0
-----------------------------------------
3  + 2 + 0  =  5
*/
tree2.levelAndSum();
}
}``````

#### Output

``````  1
2  7
11  7  19
-2
Result : 4
3
2  7
7  8
Result : 5``````
``````package main
import "fmt"
/*
Go program for
Efficiently find level sum of bitwise and
Operation in binary tree.
*/
// Binary Tree node
type TreeNode struct {
data int
left * TreeNode
right * TreeNode
}
func getTreeNode(data int) * TreeNode {
var me *TreeNode = &TreeNode {}
// Set node value
me.data = data
me.left = nil
me.right = nil
return me
}
type BinaryTree struct {
root * TreeNode
}
func getBinaryTree() * BinaryTree {
var me *BinaryTree = &BinaryTree {}
// Set initial value
me.root = nil
return me
}
func(this *BinaryTree) getLevelNodes(node * TreeNode,
record map[int] [] int,
level int) {
if node != nil {
if _, found := record[level] ; !found {
// Create new level
record[level] = make([]int,0)
}
record[level] = append(record[level], node.data)
// Visit left and right subtree
this.getLevelNodes(node.left, record, level + 1)
this.getLevelNodes(node.right, record, level + 1)
}
}
func(this BinaryTree) levelAndSum() {
if this.root == nil {
return
}
// Auxiliary variables
var sum int = 0
var auxiliary int = 0
// Level start 0
var level int = 0
// This are capable to collect level nodes
var record = make(map[int] [] int )
// This are collecting level nodes in binary tree
this.getLevelNodes(this.root, record, 0)
// Execute loop from top to bottom manner level 0 to n
for (level < len(record)) {
var value = record[level]
// Execute level nodes
for j := 0 ; j < len(value) ; j++ {
if j == 0 {
auxiliary = value[j]
} else {
// Perform bitwise And operation
auxiliary = auxiliary & value[j]
}
// Display level node
fmt.Print("  ", value[j])
}
// Include new line
fmt.Print("\n")
sum += auxiliary
level++
}
fmt.Println(" Result : ", sum)
}
func main() {
var tree1 * BinaryTree = getBinaryTree()
var tree2 * BinaryTree = getBinaryTree()
/*
1
/   \
2     7
/ \     \
11   7     19
/
-2
-----------------
Construct Tree 1
*/
tree1.root = getTreeNode(1)
tree1.root.left = getTreeNode(2)
tree1.root.right = getTreeNode(7)
tree1.root.right.right = getTreeNode(19)
tree1.root.left.right = getTreeNode(7)
tree1.root.left.left = getTreeNode(11)
tree1.root.right.right.left = getTreeNode(-2)
/*
3
/   \
2     7
/ \
7   8

-----------------
Construct Tree 2
*/
tree2.root = getTreeNode(3)
tree2.root.left = getTreeNode(2)
tree2.root.right = getTreeNode(7)
tree2.root.left.right = getTreeNode(8)
tree2.root.left.left = getTreeNode(7)
/*
-----------------
Tree 1
-----------------
1           1              = 1
/   \
2     7        2 & 7          = 2
/ \     \
11   7     19     11 & 7 & 19    = 3
/
-2       -2             = -2
-----------------------------------------
1 + 2 + 3 -2            =  4
*/
tree1.levelAndSum()
/*
-----------------
Tree 2
----------------
3           3  = 3
/   \
2     7    2 & 7  = 2
/ \
7   8        7 & 8  = 0
-----------------------------------------
3  + 2 + 0  =  5
*/
tree2.levelAndSum()
}``````

#### Output

``````  1
2  7
11  7  19
-2
Result : 4
3
2  7
7  8
Result : 5``````
``````<?php
/*
Php program for
Efficiently find level sum of bitwise and
Operation in binary tree.
*/
// Binary Tree node
class TreeNode
{
public \$data;
public \$left;
public \$right;
public	function __construct(\$data)
{
// Set node value
\$this->data = \$data;
\$this->left = NULL;
\$this->right = NULL;
}
}
class BinaryTree
{
public \$root;
public	function __construct()
{
\$this->root = NULL;
}
public	function getLevelNodes(\$node, &\$record, \$level)
{
if (\$node != NULL)
{
if (!array_key_exists(\$level, \$record))
{
// Create new level
\$record[\$level] = array();
}
\$record[\$level][] = \$node->data;
// Visit left and right subtree
\$this->getLevelNodes(\$node->left, \$record, \$level + 1);
\$this->getLevelNodes(\$node->right, \$record, \$level + 1);
}
}
public	function levelAndSum()
{
if (\$this->root == NULL)
{
return;
}
// Auxiliary variables
\$sum = 0;
\$auxiliary = 0;
// Level start 0
\$level = 0;
// This are capable to collect level nodes
\$record = array();
// This are collecting level nodes in binary tree
\$this->getLevelNodes(\$this->root, \$record, 0);
// Execute loop from top to bottom manner level 0 to n
while (\$level < count(\$record))
{
\$value = \$record[\$level];
// Execute level nodes
for (\$j = 0; \$j < count(\$value); ++\$j)
{
if (\$j == 0)
{
\$auxiliary = \$value[\$j];
}
else
{
// Perform bitwise And operation
\$auxiliary = \$auxiliary & \$value[\$j];
}
// Display level node
echo("  ".\$value[\$j]);
}
// Include new line
echo("\n");
\$sum += \$auxiliary;
\$level++;
}
echo(" Result : ".\$sum.
"\n");
}
}

function main()
{
\$tree1 = new BinaryTree();
\$tree2 = new BinaryTree();
/*
1
/   \
2     7
/ \     \
11   7     19
/
-2
-----------------
Construct Tree 1
*/
\$tree1->root = new TreeNode(1);
\$tree1->root->left = new TreeNode(2);
\$tree1->root->right = new TreeNode(7);
\$tree1->root->right->right = new TreeNode(19);
\$tree1->root->left->right = new TreeNode(7);
\$tree1->root->left->left = new TreeNode(11);
\$tree1->root->right->right->left = new TreeNode(-2);
/*
3
/   \
2     7
/ \
7   8

-----------------
Construct Tree 2
*/
\$tree2->root = new TreeNode(3);
\$tree2->root->left = new TreeNode(2);
\$tree2->root->right = new TreeNode(7);
\$tree2->root->left->right = new TreeNode(8);
\$tree2->root->left->left = new TreeNode(7);
/*
-----------------
Tree 1
-----------------
1           1              = 1
/   \
2     7        2 & 7          = 2
/ \     \
11   7     19     11 & 7 & 19    = 3
/
-2       -2             = -2
-----------------------------------------
1 + 2 + 3 -2            =  4
*/
\$tree1->levelAndSum();
/*
-----------------
Tree 2
----------------
3           3  = 3
/   \
2     7    2 & 7  = 2
/ \
7   8        7 & 8  = 0
-----------------------------------------
3  + 2 + 0  =  5
*/
\$tree2->levelAndSum();
}
main();``````

#### Output

``````  1
2  7
11  7  19
-2
Result : 4
3
2  7
7  8
Result : 5``````
``````/*
Node JS program for
Efficiently find level sum of bitwise and
Operation in binary tree.
*/
// Binary Tree node
class TreeNode
{
constructor(data)
{
// Set node value
this.data = data;
this.left = null;
this.right = null;
}
}
class BinaryTree
{
constructor()
{
this.root = null;
}
getLevelNodes(node, record, level)
{
if (node != null)
{
if (!record.has(level))
{
// Create new level
record.set(level, []);
}
record.get(level).push(node.data);
// Visit left and right subtree
this.getLevelNodes(node.left, record, level + 1);
this.getLevelNodes(node.right, record, level + 1);
}
}
levelAndSum()
{
if (this.root == null)
{
return;
}
// Auxiliary variables
var sum = 0;
var auxiliary = 0;
// Level start 0
var level = 0;
// This are capable to collect level nodes
var record = new Map();
// This are collecting level nodes in binary tree
this.getLevelNodes(this.root, record, 0);
// Execute loop from top to bottom manner level 0 to n
while (level < record.size)
{
var value = record.get(level);
// Execute level nodes
for (var j = 0; j < value.length; ++j)
{
if (j == 0)
{
auxiliary = value[j];
}
else
{
// Perform bitwise And operation
auxiliary = auxiliary & value[j];
}
// Display level node
process.stdout.write("  " + value[j]);
}
// Include new line
process.stdout.write("\n");
sum += auxiliary;
level++;
}
console.log(" Result : " + sum);
}
}

function main()
{
var tree1 = new BinaryTree();
var tree2 = new BinaryTree();
/*
1
/   \
2     7
/ \     \
11   7     19
/
-2
-----------------
Construct Tree 1
*/
tree1.root = new TreeNode(1);
tree1.root.left = new TreeNode(2);
tree1.root.right = new TreeNode(7);
tree1.root.right.right = new TreeNode(19);
tree1.root.left.right = new TreeNode(7);
tree1.root.left.left = new TreeNode(11);
tree1.root.right.right.left = new TreeNode(-2);
/*
3
/   \
2     7
/ \
7   8

-----------------
Construct Tree 2
*/
tree2.root = new TreeNode(3);
tree2.root.left = new TreeNode(2);
tree2.root.right = new TreeNode(7);
tree2.root.left.right = new TreeNode(8);
tree2.root.left.left = new TreeNode(7);
/*
-----------------
Tree 1
-----------------
1           1              = 1
/   \
2     7        2 & 7          = 2
/ \     \
11   7     19     11 & 7 & 19    = 3
/
-2       -2             = -2
-----------------------------------------
1 + 2 + 3 -2            =  4
*/
tree1.levelAndSum();
/*
-----------------
Tree 2
----------------
3           3  = 3
/   \
2     7    2 & 7  = 2
/ \
7   8        7 & 8  = 0
-----------------------------------------
3  + 2 + 0  =  5
*/
tree2.levelAndSum();
}
main();``````

#### Output

``````  1
2  7
11  7  19
-2
Result : 4
3
2  7
7  8
Result : 5``````
``````#    Python 3 program for
#    Efficiently find level sum of bitwise and
#    Operation in binary tree.

#  Binary Tree node
class TreeNode :
def __init__(self, data) :
#  Set node value
self.data = data
self.left = None
self.right = None

class BinaryTree :
def __init__(self) :
self.root = None

def getLevelNodes(self, node, record, level) :
if (node != None) :
if (not(level in record.keys())) :
#  Create new level
record[level] = []

record.get(level).append(node.data)
#  Visit left and right subtree
self.getLevelNodes(node.left, record, level + 1)
self.getLevelNodes(node.right, record, level + 1)

def levelAndSum(self) :
if (self.root == None) :
return

#  Auxiliary variables
sum = 0
auxiliary = 0
#  Level start 0
level = 0
#  This are capable to collect level nodes
record = dict()
#  This are collecting level nodes in binary tree
self.getLevelNodes(self.root, record, 0)
#  Execute loop from top to bottom manner level 0 to n
while (level < len(record)) :
value = record.get(level)
j = 0
#  Execute level nodes
while (j < len(value)) :
if (j == 0) :
auxiliary = value[j]
else :
#  Perform bitwise And operation
auxiliary = auxiliary & value[j]

#  Display level node
print("  ", value[j], end = "")
j += 1

#  Include new line
print(end = "\n")
sum += auxiliary
level += 1

print(" Result : ", sum)

def main() :
tree1 = BinaryTree()
tree2 = BinaryTree()
#         1
#       /   \
#      2     7
#     / \     \
#   11   7     19
#             /
#            -2
#    -----------------
#    Construct Tree 1
tree1.root = TreeNode(1)
tree1.root.left = TreeNode(2)
tree1.root.right = TreeNode(7)
tree1.root.right.right = TreeNode(19)
tree1.root.left.right = TreeNode(7)
tree1.root.left.left = TreeNode(11)
tree1.root.right.right.left = TreeNode(-2)
#         3
#       /   \
#      2     7
#     / \
#    7   8
#    -----------------
#    Construct Tree 2
tree2.root = TreeNode(3)
tree2.root.left = TreeNode(2)
tree2.root.right = TreeNode(7)
tree2.root.left.right = TreeNode(8)
tree2.root.left.left = TreeNode(7)
#    -----------------
#        Tree 1
#    -----------------
#         1           1              = 1
#       /   \
#      2     7        2 & 7          = 2
#     / \     \
#   11   7     19     11 & 7 & 19    = 3
#             /
#            -2       -2             = -2
#    -----------------------------------------
#            1 + 2 + 3 -2            =  4
tree1.levelAndSum()
#    -----------------
#      Tree 2
#    ----------------
#         3           3  = 3
#       /   \
#      2     7    2 & 7  = 2
#     / \
#    7   8        7 & 8  = 0
#    -----------------------------------------
#            3  + 2 + 0  =  5
tree2.levelAndSum()

if __name__ == "__main__": main()``````

#### Output

``````   1
2   7
11   7   19
-2
Result :  4
3
2   7
7   8
Result :  5``````
``````#    Ruby program for
#    Efficiently find level sum of bitwise and
#    Operation in binary tree.

#  Binary Tree node
class TreeNode
# Define the accessor and reader of class TreeNode
attr_accessor :data, :left, :right
def initialize(data)
#  Set node value
self.data = data
self.left = nil
self.right = nil
end

end

class BinaryTree
# Define the accessor and reader of class BinaryTree
attr_accessor :root
def initialize()
self.root = nil
end

def getLevelNodes(node, record, level)
if (node != nil)
if (!record.key?(level))
#  Create new level
record[level] = []
end

record[level].push(node.data)
#  Visit left and right subtree
self.getLevelNodes(node.left, record, level + 1)
self.getLevelNodes(node.right, record, level + 1)
end

end

def levelAndSum()
if (self.root == nil)
return
end

#  Auxiliary variables
sum = 0
auxiliary = 0
#  Level start 0
level = 0
#  This are capable to collect level nodes
record = Hash.new()
#  This are collecting level nodes in binary tree
self.getLevelNodes(self.root, record, 0)
#  Execute loop from top to bottom manner level 0 to n
while (level < record.size())
value = record[level]
j = 0
#  Execute level nodes
while (j < value.length)
if (j == 0)
auxiliary = value[j]
else

#  Perform bitwise And operation
auxiliary = auxiliary & value[j]
end

#  Display level node
print("  ", value[j])
j += 1
end

#  Include new line
print("\n")
sum += auxiliary
level += 1
end

print(" Result : ", sum, "\n")
end

end

def main()
tree1 = BinaryTree.new()
tree2 = BinaryTree.new()
#         1
#       /   \
#      2     7
#     / \     \
#   11   7     19
#             /
#            -2
#    -----------------
#    Construct Tree 1
tree1.root = TreeNode.new(1)
tree1.root.left = TreeNode.new(2)
tree1.root.right = TreeNode.new(7)
tree1.root.right.right = TreeNode.new(19)
tree1.root.left.right = TreeNode.new(7)
tree1.root.left.left = TreeNode.new(11)
tree1.root.right.right.left = TreeNode.new(-2)
#         3
#       /   \
#      2     7
#     / \
#    7   8
#    -----------------
#    Construct Tree 2
tree2.root = TreeNode.new(3)
tree2.root.left = TreeNode.new(2)
tree2.root.right = TreeNode.new(7)
tree2.root.left.right = TreeNode.new(8)
tree2.root.left.left = TreeNode.new(7)
#    -----------------
#        Tree 1
#    -----------------
#         1           1              = 1
#       /   \
#      2     7        2 & 7          = 2
#     / \     \
#   11   7     19     11 & 7 & 19    = 3
#             /
#            -2       -2             = -2
#    -----------------------------------------
#            1 + 2 + 3 -2            =  4
tree1.levelAndSum()
#    -----------------
#      Tree 2
#    ----------------
#         3           3  = 3
#       /   \
#      2     7    2 & 7  = 2
#     / \
#    7   8        7 & 8  = 0
#    -----------------------------------------
#            3  + 2 + 0  =  5
tree2.levelAndSum()
end

main()``````

#### Output

``````  1
2  7
11  7  19
-2
Result : 4
3
2  7
7  8
Result : 5
``````
``````import scala.collection.mutable._;
/*
Scala program for
Efficiently find level sum of bitwise and
Operation in binary tree.
*/

// Binary Tree node
class TreeNode(var data: Int,
var left: TreeNode,
var right: TreeNode)
{
def this(data: Int)
{
// Set node value
this(data,null, null);
}
}
class BinaryTree(var root: TreeNode)
{
def this()
{
this(null);
}
def getLevelNodes(
node: TreeNode,
record: HashMap[Int, ArrayBuffer[Int]],
level: Int): Unit = {
if (node != null)
{
if (!record.contains(level))
{
// Create new level
}
record.get(level).get += node.data;
// Visit left and right subtree
getLevelNodes(node.left, record, level + 1);
getLevelNodes(node.right, record, level + 1);
}
}
def levelAndSum(): Unit = {
if (this.root == null)
{
return;
}
// Auxiliary variables
var sum: Int = 0;
var auxiliary: Int = 0;
// Level start 0
var level: Int = 0;
// This are capable to collect level nodes
var record: HashMap[Int, ArrayBuffer[Int]] =
new HashMap[Int, ArrayBuffer[Int]]();
// This are collecting level nodes in binary tree
this.getLevelNodes(this.root, record, 0);
// Execute loop from top to bottom manner level 0 to n
while (level < record.size)
{
var value: ArrayBuffer[Int] = record.get(level).get;
var j: Int = 0;
// Execute level nodes
while (j < value.size)
{
if (j == 0)
{
auxiliary = value(j);
}
else
{
// Perform bitwise And operation
auxiliary = auxiliary & value(j);
}
// Display level node
print("  " + value(j));
j += 1;
}
// Include new line
print("\n");
sum += auxiliary;
level += 1;
}
println(" Result : " + sum);
}
}
object Main
{
def main(args: Array[String]): Unit = {
var tree1: BinaryTree = new BinaryTree();
var tree2: BinaryTree = new BinaryTree();
/*
1
/   \
2     7
/ \     \
11   7     19
/
-2
-----------------
Construct Tree 1
*/
tree1.root = new TreeNode(1);
tree1.root.left = new TreeNode(2);
tree1.root.right = new TreeNode(7);
tree1.root.right.right = new TreeNode(19);
tree1.root.left.right = new TreeNode(7);
tree1.root.left.left = new TreeNode(11);
tree1.root.right.right.left = new TreeNode(-2);
/*
3
/   \
2     7
/ \
7   8

-----------------
Construct Tree 2
*/
tree2.root = new TreeNode(3);
tree2.root.left = new TreeNode(2);
tree2.root.right = new TreeNode(7);
tree2.root.left.right = new TreeNode(8);
tree2.root.left.left = new TreeNode(7);
/*
-----------------
Tree 1
-----------------
1           1              = 1
/   \
2     7        2 & 7          = 2
/ \     \
11   7     19     11 & 7 & 19    = 3
/
-2       -2             = -2
-----------------------------------------
1 + 2 + 3 -2            =  4
*/
tree1.levelAndSum();
/*
-----------------
Tree 2
----------------
3           3  = 3
/   \
2     7    2 & 7  = 2
/ \
7   8        7 & 8  = 0
-----------------------------------------
3  + 2 + 0  =  5
*/
tree2.levelAndSum();
}
}``````

#### Output

``````  1
2  7
11  7  19
-2
Result : 4
3
2  7
7  8
Result : 5``````
``````import Foundation;
/*
Swift 4 program for
Efficiently find level sum of bitwise and
Operation in binary tree.
*/
// Binary Tree node
class TreeNode
{
var data: Int;
var left: TreeNode? ;
var right: TreeNode? ;
init(_ data: Int)
{
// Set node value
self.data = data;
self.left = nil;
self.right = nil;
}
}
class BinaryTree
{
var root: TreeNode? ;
init()
{
self.root = nil;
}
func getLevelNodes(_ node: TreeNode? ,
_ record : inout[Int : [Int] ],
_ level: Int)
{
if (node  != nil)
{
if (!record.keys.contains(level))
{
// Create new level
record[level] = [Int]();
}
record[level]!.append(node!.data);
// Visit left and right subtree
self.getLevelNodes(node!.left, &record, level + 1);
self.getLevelNodes(node!.right, &record, level + 1);
}
}
func levelAndSum()
{
if (self.root == nil)
{
return;
}
// Auxiliary variables
var sum: Int = 0;
var auxiliary: Int = 0;
// Level start 0
var level: Int = 0;
// This are capable to collect level nodes
var record: [Int : [Int]] = [Int : [Int]]();
// This are collecting level nodes in binary tree
self.getLevelNodes(self.root, &record, 0);
// Execute loop from top to bottom manner level 0 to n
while (level < record.count)
{
let value: [Int] = record[level]!;
var j: Int = 0;
// Execute level nodes
while (j < value.count)
{
if (j == 0)
{
auxiliary = value[j];
}
else
{
// Perform bitwise And operation
auxiliary = auxiliary & value[j];
}
// Display level node
print("  ", value[j], terminator: "");
j += 1;
}
// Include new line
print(terminator: "\n");
sum += auxiliary;
level += 1;
}
print(" Result : ", sum);
}
}
func main()
{
let tree1: BinaryTree = BinaryTree();
let tree2: BinaryTree = BinaryTree();
/*
1
/   \
2     7
/ \     \
11   7     19
/
-2
-----------------
Construct Tree 1
*/
tree1.root = TreeNode(1);
tree1.root!.left = TreeNode(2);
tree1.root!.right = TreeNode(7);
tree1.root!.right!.right = TreeNode(19);
tree1.root!.left!.right = TreeNode(7);
tree1.root!.left!.left = TreeNode(11);
tree1.root!.right!.right!.left = TreeNode(-2);
/*
3
/   \
2     7
/ \
7   8

-----------------
Construct Tree 2
*/
tree2.root = TreeNode(3);
tree2.root!.left = TreeNode(2);
tree2.root!.right = TreeNode(7);
tree2.root!.left!.right = TreeNode(8);
tree2.root!.left!.left = TreeNode(7);
/*
-----------------
Tree 1
-----------------
1           1              = 1
/   \
2     7        2 & 7          = 2
/ \     \
11   7     19     11 & 7 & 19    = 3
/
-2       -2             = -2
-----------------------------------------
1 + 2 + 3 -2            =  4
*/
tree1.levelAndSum();
/*
-----------------
Tree 2
----------------
3           3  = 3
/   \
2     7    2 & 7  = 2
/ \
7   8        7 & 8  = 0
-----------------------------------------
3  + 2 + 0  =  5
*/
tree2.levelAndSum();
}
main();``````

#### Output

``````   1
2   7
11   7   19
-2
Result :  4
3
2   7
7   8
Result :  5``````
``````/*
Kotlin program for
Efficiently find level sum of bitwise and
Operation in binary tree.
*/
// Binary Tree node
class TreeNode
{
var data: Int;
var left: TreeNode ? ;
var right: TreeNode ? ;
constructor(data: Int)
{
// Set node value
this.data = data;
this.left = null;
this.right = null;
}
}
class BinaryTree
{
var root: TreeNode ? ;
constructor()
{
this.root = null;
}
fun getLevelNodes(
node: TreeNode ? ,
record : HashMap < Int, MutableList < Int >>  ,
level : Int): Unit
{
if (node != null)
{
if (!record.containsKey(level))
{
// Create new level
record.put(level, mutableListOf < Int > ());
}
// Visit left and right subtree
this.getLevelNodes(node.left, record, level + 1);
this.getLevelNodes(node.right, record, level + 1);
}
}
fun levelAndSum(): Unit
{
if (this.root == null)
{
return;
}
// Auxiliary variables
var sum: Int = 0;
var auxiliary: Int = 0;
// Level start 0
var level: Int = 0;
// This are capable to collect level nodes
val record = HashMap < Int,MutableList< Int >> ();
// This are collecting level nodes in binary tree
this.getLevelNodes(this.root, record, 0);
// Execute loop from top to bottom manner level 0 to n
while (level < record.count())
{
val value: MutableList < Int > = record.getValue(level);
var j: Int = 0;
// Execute level nodes
while (j < value.size)
{
if (j == 0)
{
auxiliary = value[j];
}
else
{
// Perform bitwise And operation
auxiliary = auxiliary and value[j];
}
// Display level node
print("  " + value[j]);
j += 1;
}
// Include new line
print("\n");
sum += auxiliary;
level += 1;
}
println(" Result : " + sum);
}
}
fun main(args: Array < String > ): Unit
{
val tree1: BinaryTree = BinaryTree();
val tree2: BinaryTree = BinaryTree();
/*
1
/   \
2     7
/ \     \
11   7     19
/
-2
-----------------
Construct Tree 1
*/
tree1.root = TreeNode(1);
tree1.root?.left = TreeNode(2);
tree1.root?.right = TreeNode(7);
tree1.root?.right?.right = TreeNode(19);
tree1.root?.left?.right = TreeNode(7);
tree1.root?.left?.left = TreeNode(11);
tree1.root?.right?.right?.left = TreeNode(-2);
/*
3
/   \
2     7
/ \
7   8

-----------------
Construct Tree 2
*/
tree2.root = TreeNode(3);
tree2.root?.left = TreeNode(2);
tree2.root?.right = TreeNode(7);
tree2.root?.left?.right = TreeNode(8);
tree2.root?.left?.left = TreeNode(7);
/*
-----------------
Tree 1
-----------------
1           1              = 1
/   \
2     7        2 & 7          = 2
/ \     \
11   7     19     11 & 7 & 19    = 3
/
-2       -2             = -2
-----------------------------------------
1 + 2 + 3 -2            =  4
*/
tree1.levelAndSum();
/*
-----------------
Tree 2
----------------
3           3  = 3
/   \
2     7    2 & 7  = 2
/ \
7   8        7 & 8  = 0
-----------------------------------------
3  + 2 + 0  =  5
*/
tree2.levelAndSum();
}``````

#### Output

``````  1
2  7
11  7  19
-2
Result : 4
3
2  7
7  8
Result : 5``````

## 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.