Bab 25: List coding interview JavaScript dari semua industri

1. Pertanyaan tentang dasar-dasar JavaScript seperti variable, loop, conditional, function, dan object.

2. Pertanyaan tentang manipulasi DOM (Document Object Model) dan event handling.

3. Pertanyaan tentang framework atau library populer seperti React, Angular, dan Vue.

4. Pertanyaan tentang asynchronous programming dengan menggunakan callback, promise, dan async/await.

5. Pertanyaan tentang performance optimization dan debugging JavaScript code.

6. Pertanyaan tentang pengetahuan tentang web development lainnya, seperti HTML, CSS, dan web security.

7. Pertanyaan tentang implementasi fitur spesifik seperti form validation, autocomplete, atau drag and drop.

8. Pertanyaan tentang integrasi dengan API atau database.

9. Pertanyaan tentang mobile development menggunakan JavaScript, seperti React Native atau Ionic.

10. Pertanyaan tentang testing dan pengelolaan dependencies dengan tools seperti Jest, Mocha, atau npm.

11. Itu hanyalah beberapa contoh dari pertanyaan yang dapat diajukan dalam wawancara coding JavaScript, namun bisa saja berbeda sesuai dengan industri dan posisi yang dilamar.

Contoh pertanyaan coding interview yang sering ditanyakan dalam proses rekrutmen pekerjaan yang menggunakan JavaScript

1. Bagaimana cara mengurangi duplikasi data pada array?

2. Bagaimana cara mengecek apakah suatu variable adalah function atau bukan?

3. Bagaimana cara meng-clone sebuah object di JavaScript?

4. Bagaimana cara mengecek apakah sebuah object kosong atau tidak?

5. Bagaimana cara meng-merge 2 object di JavaScript?

6. Bagaimana cara mengimplementasikan sebuah closure di JavaScript?

7. Bagaimana cara mengimplementasikan sebuah event delegation di JavaScript?

8. Bagaimana cara meng-handle asynchronusity di JavaScript?

9. Bagaimana cara mengimplementasikan sebuah promise di JavaScript?

10. Bagaimana cara mengimplementasikan sebuah component di React?

11. Itu hanyalah beberapa contoh dari pertanyaan yang dapat diajukan dalam wawancara coding JavaScript, namun bisa saja berbeda sesuai dengan industri dan posisi yang dilamar.

Tips dan trik dalam menjawab pertanyaan-pertanyaan tersebut, seperti memperhatikan waktu eksekusi dan memperhatikan kasus-kasus edge

Beberapa tips dan trik yang dapat digunakan dalam menjawab pertanyaan-pertanyaan coding interview JavaScript adalah:

1. Fokus pada solusi yang efisien dari segi waktu eksekusi dan ruang penyimpanan. Ingatlah bahwa solusi yang efisien dapat menjadi perbedaan antara diterima atau tidak diterima dalam pekerjaan.

2. Jelaskan proses pemikiran Anda saat mencari solusi. Ini akan menunjukkan kepada pewawancara bahwa Anda memahami masalah yang dihadapi dan menunjukkan metode pemecahan masalah yang baik.

3. Berikan contoh kasus edge atau kondisi tidak normal yang mungkin terjadi dan jelaskan bagaimana solusi Anda akan menangani situasi tersebut.

4. Latih diri Anda dengan menyelesaikan soal-soal coding yang mirip dengan yang mungkin diajukan dalam wawancara.

5. Jangan ragu untuk menanyakan klarifikasi jika Anda tidak yakin tentang apa yang diminta dalam pertanyaan.

6. Jangan terlalu cepat mengambil kesimpulan dan terus berpikir secara kritis.

7. Jangan lupa untuk tetap tenang dan fokus, ini akan membuat Anda lebih percaya diri dan membuat jawaban Anda lebih baik.

8. Selalu test kode Anda sebelum menjawab pertanyaan. Pastikan bahwa kode Anda bekerja dengan benar dan tidak terdapat bug.

9. Jika diperlukan, gunakan diagram atau ilustrasi untuk membantu menjelaskan solusi Anda.

10. Berikan contoh kode yang dapat dijalankan dan diuji untuk menunjukkan implementasi solusi Anda.

11. Jangan takut untuk mengakui jika Anda tidak tahu jawabannya, tetapi berikan usaha untuk mencari jawaban atau solusi.

12. Selalu berusaha untuk menjelaskan dengan jelas dan mudah dipahami.

13. Selalu berusaha untuk menyederhanakan masalah dan menyederhanakan solusi.

14. Selalu berusaha untuk menjaga komunikasi yang baik dengan pewawancara dan menjawab pertanyaan dengan jujur.

15. Jangan lupa untuk tetap berpikir out of the box dan tidak takut untuk mencoba hal baru.

16. Jangan lupa untuk selalu belajar dan meningkatkan keterampilan Anda di JavaScript dan teknologi terkait.

17. Jangan takut untuk mencoba proyek baru atau mengejar kesempatan untuk meningkatkan keterampilan Anda.

18. Jangan lupa untuk mengejar kesempatan untuk mengikuti training atau workshop yang terkait dengan JavaScript.

19. Jangan lupa untuk mengejar kesempatan untuk bergabung dengan komunitas atau grup yang terkait dengan JavaScript.

20. Jangan lupa untuk mengejar kesempatan untuk berkontribusi pada proyek open-source yang terkait dengan JavaScript.

Semua tips dan trik yang disebutkan di atas dapat membantu Anda dalam meningkatkan pemahaman dan keterampilan Anda dalam JavaScript dan dalam mencari pekerjaan yang menggunakan JavaScript. Namun, ingatlah bahwa setiap proses rekrutmen atau proyek yang berbeda dapat memiliki persyaratan yang berbeda, jadi pastikan untuk selalu siap dan berusaha untuk belajar dan meningkatkan diri Anda sebanyak mungkin.

Contoh jawaban dan penjelasan untuk setiap pertanyaan yang disajikan

1. Diberikan sebuah array angka, tentukan angka yang paling sering muncul.

• Contoh: [4, 5, 4, 3, 5, 4, 5, 4]

• Jawaban: 4

function mostFrequent(arr) {
    // menyimpan jumlah kemunculan setiap angka
    let count = {};
    // menyimpan angka yang paling sering muncul
    let mostFrequent;
    // menyimpan jumlah muncul terbanyak
    let maxCount = 0;
 
    for (let i = 0; i < arr.length; i++) {
      // jika angka sudah pernah muncul, tambahkan 1 pada jumlah muncul
      if (count[arr[i]]) {
        count[arr[i]]++;
      } else {
        // jika belum pernah muncul, tambahkan angka ke objek count dan set jumlah muncul menjadi 1
        count[arr[i]] = 1;
      }
      // jika jumlah muncul saat ini lebih besar daripada jumlah muncul terbanyak sebelumnya, update mostFrequent dan maxCount
      if (count[arr[i]] > maxCount) {
        maxCount = count[arr[i]];
        mostFrequent = arr[i];
      }
    }
    return mostFrequent;
  }
  console.log(mostFrequent([4, 5, 4, 3, 5, 4, 5, 4])); // 4

1. Diberikan sebuah string, hitung jumlah kata yang ada dalam string tersebut.

• Contoh: "Hello world, welcome to JavaScript"

• Jawaban: 6

• Menghitung jumlah kata dalam sebuah string:

function countWords(string) {
    return string.split(" ").length;
  }
  console.log(countWords("Hello world, welcome to JavaScript")); // 6 

1. Diberikan sebuah array multidimensi, tentukan jumlah angka yang habis dibagi 3.

• Contoh: [[1,2,3], [4,5,6], [7,8,9]]

• Jawaban: 3

function countDivisibleBy3(arr) {
  let count = 0;
  for (let i = 0; i < arr.length; i++) {
      for (let j = 0; j < arr[i].length; j++) {
          if (arr[i][j] % 3 === 0) {
              count++;
          }
      }
  }
  return count;
}


console.log(countDivisibleBy3([[1,2,3], [4,5,6], [7,8,9]]));

1. Diberikan sebuah string, tentukan apakah string tersebut merupakan palindrome atau tidak.

• Contoh: "racecar"

• Jawaban: true

function isPalindrome(str) {
  // Membuat sebuah variable untuk menyimpan string yang dibalik
  let reversed = "";
  // Membuat loop untuk mengecek setiap karakter dari string
  for (let i = str.length - 1; i >= 0; i--) {
      // Menambahkan karakter ke reversed
      reversed += str[i];
  }
  // Membandingkan string asli dengan string yang dibalik
  return str === reversed;
}
console.log(isPalindrome("racecar")); // true
console.log(isPalindrome("hello")); // false

1. Diberikan sebuah array, tentukan jumlah angka yang muncul lebih dari 2 kali.

• Contoh: [1,2,3,4,5,1,2,3,4,1,2]

function countDuplicates(arr) {
  // Membuat sebuah objek untuk menyimpan jumlah kemunculan setiap angka
  let counts = {};
  // Membuat loop untuk mengecek setiap elemen dari array
  for (let i = 0; i < arr.length; i++) {
      // Menambahkan jumlah kemunculan dari setiap elemen
      counts[arr[i]] = counts[arr[i]] ? counts[arr[i]] + 1 : 1;
  }
  // Membuat variable untuk menyimpan jumlah angka yang muncul lebih dari 2 kali
  let duplicateCount = 0;
  // Membuat loop untuk mengecek jumlah kemunculan dari setiap elemen
  for (let key in counts) {
      if (counts[key] > 2) {
          duplicateCount++;
      }
  }
  return duplicateCount;
}


console.log(countDuplicates([1,2,3,4,5,1,2,3,4,1,2])); // 2

1. Diberikan sebuah array dan target, tentukan apakah target ada dalam array atau tidak.

• Contoh: ([1,2,3,4,5], 3)

• Jawaban: true

function findInArray(arr, target) {
  return arr.indexOf(target) !== -1;
}
console.log(findInArray([1,2,3,4,5], 3))

1. Diberikan sebuah array, urutkan angka-angka dalam array tersebut dari yang terkecil ke yang terbesar.

• Contoh: [5,7,2,8,1,6]

• Jawaban: [1,2,5,6,7,8]

function sortArray(arr) {
  return arr.sort(function(a, b) {
      return a - b;
  });
}

1. Diberikan sebuah array, tentukan jumlah pasangan angka yang memiliki jumlah sama.

• Contoh: [1, 2, 3, 2, 3, 4]

• Jawaban: 2

function countPairs(arr) {
  let count = 0;
  let map = new Map();
  for (let i = 0; i < arr.length; i++) {
      if (map.has(arr[i])) {
          count += map.get(arr[i]);
          map.set(arr[i], map.get(arr[i]) + 1);
      } else {
          map.set(arr[i], 1);
      }
  }
  return count;
}
let arr = [1, 2, 3, 2, 3, 4];
console.log(countPairs(arr)); // Output: 2

9. Diberikan sebuah tree, tentukan jumlah rute yang dapat dilalui dari root ke leaf

• Contoh:

• 1

• /

• 2 3

• /

• 4 5

• Jawaban: 3

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


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


  countRoutes(node = this.root, count = 0) {
      if (node === null) {
          return count;
      }
      if (node.left === null && node.right === null) {
          count++;
      }
      count = this.countRoutes(node.left, count);
      count = this.countRoutes(node.right, count);
      return count;
  }
}
let tree = new Tree();
tree.root = new Node(1);
tree.root.left = new Node(2);
tree.root.right = new Node(3);
tree.root.left.left = new Node(4);
tree.root.left.right = new Node(5);
console.log(tree.countRoutes()); // Output: 3

Soal II

1. Buat fungsi yang menerima input berupa array angka dan mengembalikan angka terbesar dalam array tersebut.

function findLargestNumber(arr) {
  let largest = arr[0];
  for (let i = 1; i < arr.length; i++) {
      if (arr[i] > largest) {
          largest = arr[i];
      }
  }
  return largest;
}
let numbers = [5, 7, 2, 8, 1, 6];
console.log(findLargestNumber(numbers)); // Output: 8

1. Buat fungsi yang menerima input berupa string dan mengembalikan string yang dibalik urutannya.

function reverseString(str) {
  return str.split('').reverse().join('');
}
let word = "Hello";
console.log(reverseString(word)); // Output: "olleH"

1. Buat fungsi yang menerima input berupa array of object, dan mengembalikan object dengan properti yang memiliki nilai tertinggi.

function findObjectWithMaxValue(arr, prop) {
  let maxValue = arr[0][prop];
  let maxObject = arr[0];
  for (let i = 1; i < arr.length; i++) {
      if (arr[i][prop] > maxValue) {
          maxValue = arr[i][prop];
          maxObject = arr[i];
      }
  }
  return maxObject;
}
let people = [
  {name: "John", age: 25},
  {name: "Jane", age: 32},
  {name: "Bob", age: 21},
];
console.log(findObjectWithMaxValue(people, "age")); // Output: {name: "Jane", age: 32}

1. Buat algoritma untuk mencari bilangan prima dari 1-100

function findPrimeNumbers() {
  let primeNumbers = [];
  for (let i = 2; i <= 100; i++) {
      let isPrime = true;
      for (let j = 2; j <= Math.sqrt(i); j++) {
          if (i % j === 0) {
              isPrime = false;
              break;
          }
      }
      if (isPrime) {
          primeNumbers.push(i);
      }
  }
  return primeNumbers;
}
console.log(findPrimeNumbers()); // Output: [2, 3, 5, 7, 11, 13, 17, 19, 23, 29, 31, 37, 41, 43, 47, 53, 59, 61, 67, 71, 73, 79, 83, 89, 97]

1. Buat algoritma untuk mengurutkan array of number menggunakan algoritma bubble sort.

function bubbleSort(arr) {
  for (let i = 0; i < arr.length; i++) {
    for (let j = 0; j < arr.length - i - 1; j++) {
      if (arr[j] > arr[j + 1]) {
        let temp = arr[j];
        arr[j] = arr[j + 1];
        arr[j + 1] = temp;
      }
    }
  }
  return arr;
}

1. Buat algoritma untuk mencari rute terpendek dari node A ke node B menggunakan algoritma Dijkstra.

function dijkstra(graph, startNode, endNode) {
  // Create an object to store the distance from the start node to each other node
  const distances = {};
  for (const node in graph) {
    distances[node] = Infinity;
  }
  distances[startNode] = 0;


  // Create a set to store the unvisited nodes
  const unvisited = new Set(Object.keys(graph));


  // Create an object to store the previous node for each node
  const previous = {};


  // Create the main loop
  while (unvisited.size > 0) {
    let currentNode = null;
    let currentNodeDistance = Infinity;


    // Find the closest unvisited node
    for (const node of unvisited) {
      if (distances[node] < currentNodeDistance) {
        currentNode = node;
        currentNodeDistance = distances[node];
      }
    }


    // Remove the current node from the unvisited set
    unvisited.delete(currentNode);


    // Check if we've reached the end node
    if (currentNode === endNode) {
      break;
    }


    // Update the distances of the neighboring nodes
    for (const neighbor in graph[currentNode]) {
      const distance = graph[currentNode][neighbor];
      if (distances[neighbor] > distances[currentNode] + distance) {
        distances[neighbor] = distances[currentNode] + distance;
        previous[neighbor] = currentNode;
      }
    }
  }


  // Create the shortest path by following the previous nodes
  let shortestPath = [endNode];
  let currentNode = endNode;
  while (currentNode !== startNode) {
    currentNode = previous[currentNode];
    shortestPath.unshift(currentNode);
  }


  return {
    distance: distances[endNode],
    path: shortestPath
  };
}
const graph = {
  "A": {"B": 5, "C": 2},
  "B": {"D": 3, "E": 4},
  "C": {"B": 1, "D": 4},
  "D": {"E": 2},
  "E": {}
}
const startNode = "A";
const endNode = "E";


console.log(dijkstra(graph, startNode, endNode));

1. Buat algoritma untuk mencari common ancestor pada sebuah pohon biner.

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


function findCommonAncestor(root, node1, node2) {
  if (!root) return null;
  if (root === node1 || root === node2) return root;


  const left = findCommonAncestor(root.left, node1, node2);
  const right = findCommonAncestor(root.right, node1, node2);


  if (left && right) return root;
  if (left) return left;
  if (right) return right;
}


const root = new Node(1);
root.left = new Node(2);
root.right = new Node(3);
root.left.left = new Node(4);
root.left.right = new Node(5);
root.right.left = new Node(6);
root.right.right = new Node(7);


const node1 = root.left.left;
const node2 = root.left.right;


console.log(findCommonAncestor(root, node1, node2));

1. Buat algoritma untuk mencari jalur terpendek dalam sebuah graf menggunakan algoritma Breadth First Search (BFS).

function BFS(graph, start, end) {
  let queue = [start];
  let visited = new Set();
  let previous = new Map();
 
  while (queue.length > 0) {
      let current = queue.shift();
      visited.add(current);


      for (let neighbor of graph.get(current)) {
          if (visited.has(neighbor)) continue;
          previous.set(neighbor, current);
          queue.push(neighbor);
          if (neighbor === end) break;
      }
  }


  let path = [];
  let current = end;
  while (current !== start) {
      path.unshift(current);
      current = previous.get(current);
  }
  path.unshift(start);
  return path;
}
let graph = new Map();
graph.set('A', ['B', 'C']);
graph.set('B', ['A', 'D', 'E']);
graph.set('C', ['A', 'F']);
graph.set('D', ['B']);
graph.set('E', ['B', 'F']);
graph.set('F', ['C', 'E']);
console.log(BFS(graph, 'A', 'F'));

Untuk menyelesaikan soal-soal tersebut, kamu dapat menggunakan berbagai metode dan teknik dalam pemrograman JavaScript, seperti looping, conditional, dan pemanggilan fungsi built-in seperti Math.max() atau Array.sort(). Selain itu, penting juga untuk memperhatikan kompleksitas waktu eksekusi dari algoritma yang dibuat dan cara mengatasi kasus-kasus edge. Selain itu kamu juga harus memahami dasar-dasar dari algoritma yang ditanyakan seperti Dijkstra ataupun BFS agar dapat menyelesaikan soal dengan baik.