1.

Write a simple program which will print Fibonacci series e.g. 1 1 2 3 5 8 13 ... . up to a
given number
1. Using non-recursive/ iterative method

function fibonacci(num) {
let start = 1;
let result = 0;
let temp;

while (num >= 0) {

temp = start;
start += result;
result = temp;
num--;
}

return result;
}

2. Using recursive method

function fibonacci(num, memoization) {

memoization = memoization || {};

if (memoization[num]) {
return memoization[num];
}

if (num <= 1) {
return 1;
}

return memoization[num] = fibonacci(num - 1, memoization) + fibonacci(num -

2, memoization);
}

 2. Write a simple function to check if a given number is prime or not. Remember, a prime
number is a

number which is not divisible by any other number e.g. 3, 5, 7, 11, 13, 17, etc.

function isPrime(num) {

if (num <= 1) {
return false;
}

if (num === 2) {
return true;
}

let numberToLoop = Math.ceil(Math.sqrt(num));

for (let i = 2; i <= numberToLoop; i++) {

if (num % i === 0) {
return false;
}
}
return true;
}

3. Write a simple function to check if a given String is palindrome or not. A Palindrome is a

String which is

equal to the reverse of itself e.g. "Bob" is a palindrome because the reverse of "Bob" is
also "Bob".

1. Using non-recursive/ iterative method

function isPalindrome(word) {
let len = word.length;

if (len < 2) {
return true;
}

for (let i = 0; i < len / 2; i++) {

if (word.toLowerCase().charAt(i) !== word.toLowerCase().charAt(len - 1 -
i)) {
return false;
}
return true;
}
}


2. Using recursive method

function isPalindrome(word) {

if (word.toLowerCase()[0] === word.toLowerCase()[word.length - 1]) {

console.log(word.slice(1, -1));
return word.length <= 1 ? true : isPalindrome(word.slice(1, -1));
}
return false;
}

4. Write a function to check if two given String is Anagram of each other. Your function
should return true if the two Strings are Anagram, false otherwise. A string is said to be
an anagram if it contains the same characters and the same length but in different order
e.g. army and Mary are anagrams.

function isAnagram(firstWord, secondWord) {

if (firstWord === secondWord) {
return true;
}

if(firstWord.length !== secondWord.length) {

return false;
}

let letter = {};

for (let i in firstWord) {

letter[firstWord[i].toLowerCase()] = (letter[firstWord[i]] || 0) + 1;
letter[secondWord[i].toLowerCase()] = (letter[secondWord[i]] || 0) - 1;

for(let j in letter) {
if (letter[j] !== 0) {
return false;
}
}

return true;
}

 Tree
5. Write a pre-order traversal function (recursive) to traverse the tree Output = 9, 12, 14,
17, 19, 23, 50, 54, 67, 72, 66
6. Write a pre-order traversal function (iterative / non recursive) to traverse the tree
Output = 9, 12, 14, 17, 19, 23, 50, 54, 67, 72, 66

class Node {
constructor(val) {
this.val = val;
this.right = null;
this.left = null;
};
};

class BST {
constructor() {
this.root = null;
};

create(val) {
const newNode = new Node(val);
if (!this.root) {
this.root = newNode;
return this;
};
let current = this.root;

const addSide = side => {

if (!current[side]) {
current[side] = newNode;
return this;
};
current = current[side];
};

while(true) {
if (val === current.val) {
return this;
}
if (val < current.val) {
addSide('left');
} else {
addSide('right');
};
};
};

preOrder() {
let visited = [];
let current = this.root;
 let traverse = node => {
visited.push(node.val);
if (node.left) traverse(node.left);
if (node.right) traverse(node.right);
};

traverse(current);
return visited;
};

postOrder() {
let visited = []
let current = this.root;

let traverse = node => {

if (node.left) traverse(node.left);
if (node.right) traverse(node.right);
visited.push(node.val);
};

traverse(current);
return visited;
};

inOrder() {
let visited = [];
let current = this.root;

let traverse = node => {

if (node.left) traverse(node.left);
visited.push(node.val);
if (node.right) traverse(node.right);
};

traverse(current);
return visited;
}

};

const tree = new BST();

tree.create(50);
tree.create(17);
tree.create(72);
tree.create(12);
tree.create(23);
tree.create(54);
tree.create(76);
tree.create(9);
 tree.create(14);
tree.create(19);
tree.create(67);

// console.log(tree);
// console.log(tree.root);
// console.log(tree.root.left);
// console.log(tree.root.right);

console.log(tree.preOrder()); // [ 50, 17, 12, 9, 14, 23, 19, 72, 54, 67, 76
]
console.log(tree.postOrder()); // [ 9, 14, 12, 19, 23, 17, 67, 54, 76, 72, 50
]
console.log(tree.inOrder()); // [ 9, 12, 14, 17, 19, 23, 50, 54, 67, 72, 76 ]

7. Given a series of nodes, that will form a shape. Nodes’ are given in clockwise order.
Every line formed between two nodes is either a horizontal or vertical line. Write an
algorithm to determine the number of individual shapes formed, if there is a set of
rectangles that intersect the bigger shape described before.

The number of individual shapes in the illustration is 3.

--- 0o0 ---

Problem Solving Test Diberikan struktur data berbentuk linked
list seperti berikut:

class LinkedList:
def __init__(self):

self.head = None

class Node:
def __init__(self, value):

self.value = value self.next = None

Susunlah algoritma untuk function-function berikut ini:

1. void addFirst(int value)

2. 2. int deleteLast()
3. 3. int removeAt(int index)

class Node {
constructor(val) {
this.val = val;
this.next = null;
this.prev = null;
};
};

class linkedList {
constructor() {
this.head = null;
this.tail = null;
this.length = 0;
};

addFirst(val) {
let newNode = new Node(val);

if (!this.head) {
this.head = newNode;
this.tail = this.head;
}

this.head.prev = newNode;
newNode.next = this.head;
this.head = newNode;

this.length++;
return this;
}
deleteLast() {
let removed = this.tail;

if (!this.tail) {
return undefined;
}

if (this.length === 1) {
this.head = null;
this.tail = null;
};

this.tail = removed.prev;
this.tail.next = null;

this.length--;
return removed;
}

find(index) {
let current;

if (index < 0 || index >= this.length) {

return undefined;
}

if (index <= this.length / 2) {

current = this.head;
for (let i = 0; i < index; i++) {
current = current.next;
}
} else {
current = this.tail;
for (let i = this.length; i > index; i--) {
current = current.prev;
}
}
return current
}

removeAt(index) {
if (index < 0 || index >= this.length) {
return null;
}

let removed = this.find(index);

removed.prev.next = removed.next;
removed.next.prev = removed.prev;

this.length--;
return removed;
 }
};

const list = new linkedList();

list.addFirst(7);
list.addFirst(3);
list.addFirst(35);
list.addFirst(21);

list.deleteLast()
list.removeAt(2);

console.log(list);

Problem Solving Test

Sebuah ekspresi Matematika hanya bisa dikerjakan oleh komputer bilamana ekspresi
tersebut telah

disusun dalam bentuk prefix (atau postfix) . Contoh: Bentuk infix

4 + 5 * 10 - 3

setelah diubah menjadi bentuk prefix akan menjadi seperti berikut ini:

+ 4 - * 5 10 3

Susunlah algoritma, yang dapat membantu komputer untuk menghitung ekspresi prefix di
atas.