10 Days of JavaScript Hackerrank Solution

10 days of JavaScript is a set of tutorials and challenges on the hackerrank website. Hackerrank is known for its challenging programming questions, which are crucial for a programmer to ace coding interviews and are foundational pavements in the learning journey of a student.

10 days of JavaScript is structured in such a way that it covers every aspect of JavaScript, from basic to advanced. Going through these challenges ensures that one has a good grasp of the foundational concepts of JavaScript.

Solving these problems can be challenging sometimes, and taking suggestions and seeing solutions can help in such scenarios. This article aims to help you with this purpose. In it, we will discuss the solutions to problems from each day of the 10 days of JavaScript from hackerrank.

Day 0: Hello World!

Hello World of the 10 Days of JavaScript covers the basics of the language and introduces the learner to the very first concepts of a programming language. It covers printing outputs, identifiers, comments, basic syntax, and literals in the JavaScript programming language.

Problem:

A greeting function with the parameter variable parameterVariable is provided by the editor. To finish the challenge, display Hello, World! And the contents of the parameterVariable using console.log().

Solution:

function greeting(parameterVariable) {
  // This line prints 'Hello, World!' to the console:
  console.log('Hello, World!');

  // Print the contents of the parameterVariable on a new line:
  console.log(parameterVariable);
}

The editor provides the greeting function. It prints "Hello, World!" already.

It has been added to the missing line: console.log(parameterVariable). This line prints the value of the parameterVariable argument that is passed to the function.

Day 0: Data Types

The next chapter unravels another very important concept of JavaScript: data types. Data Types of the 10 Days of JavaScript covers all the data types, type of operators, dynamic typing, naming of the variables, declaration, and initialization, etc.

Problem:

The editor declares the variables firstInteger, firstDecimal, and firstString. It would help if you used the + operator to concatenate firstString and secondString, turn secondDecimal to a floating-point number and add it to firstDecimal, and convert secondInteger to an integer and add it to firstInteger. Make sure firstString is printed first when you print the outcome on a new line.

Solution:

function performOperation(secondInteger, secondDecimal, secondString) {
  // Declare a variable named 'firstInteger' and initialize with integer value 4.
  const firstInteger = 4;

  // Declare a variable named 'firstDecimal' and initialize with floating-point value 4.0.
  const firstDecimal = 4.0;

  // Declare a variable named 'firstString' and initialize it with the string "HackerRank ".
  const firstString = 'HackerRank ';

  // 1. The sum of firstInteger and secondInteger (converted to integer)
  console.log(firstInteger + Number(secondInteger));

  // 2. The sum of firstDecimal and secondDecimal (converted to float)
  console.log(firstDecimal + parseFloat(secondDecimal));

  // 3. Concatenation of firstString and secondString
  console.log(firstString + secondString);
}

The logic for operations such as concatenating first and second strings, summing first and second integers, and summing first and second decimals is included in the perform Operation function. It parses the secondInteger string into a floating-point number, transforms it to a number, and outputs the outcome. The concatenation operator, +, is used in the function.

Day 1: Arithmetic Operators

Arithmetic Operators of the 10 Days of JavaScript covers a crucial topic of JavaScript: operators. This section classifies operators as unary, binary, and ternary and covers arithmetic operators.

Problem:

In the editor below, do the following tasks:

The function getArea(length, width) determines and returns the area of a rectangle with length and width as its sides.
The function getPerimeter(length, width) computes and yields the perimeter of a rectangle with length and width as its sides.

Solution:

function getArea(length, width) {
  // Area of a rectangle is length multiplied by width
  const area = length * width;
  return area;
}

function getPerimeter(length, width) {
  // Perimeter of a rectangle is 2(length + width)
  const perimeter = 2 * (length + width);
  return perimeter;
}

The getArea and getPerimeter functions calculate the area and perimeter, respectively, using the formulas length * width and 2 * (length + width) and return the calculated values.

Day 1: Functions

This chapter covers the basics of advanced functions in Javascript and introduces a very important concept of programming: recursion. Recursion occurs when a function call takes place within the function definition.

Problem:

Implement a function that takes n as a parameter and returns its factorial, i.e., n!

Solution:

function factorial(n) {
  if (n === 0 || n === 1) {
    return 1;
  } else {
    return n * factorial(n - 1);
  }
}
console.log(factorial(5)); // Output: 120

The function factorial takes n as a parameter and returns 1 if n is 0 or 1. Otherwise, the function returns the product of n and factorial(n-1). Thus, the concept of recursion is used here to calculate the factorial of a given number. There can be another approach to solve this problem, i.e., using loops.

Day 2: let and const

This chapter of the series covers let, var, and const in Javascript. These are useful in different scenarios, and this chapter discusses their use and importance. Solving the challenge below ensures a good grasp of this concept.

Problem:

Declare a constant variable, PI, and give it the value Math.PI. Next, read a value from stdin that represents a circle's radius, r. Use PI and r to get the area and perimeter of a circle with radius r. Console.log the parameter and area.

Solution:

function main() {
    // Declare a constant variable PI and give it the value Math.PI
    const PI = Math.PI;

    // Read a value from stdin that represents a circle's radius, r
    const radius = parseFloat(readLine());

    // Calculate the area of the circle
    const area = PI * Math.pow(radius, 2);

    // Calculate the perimeter (or parameter) of the circle
    const perimeter = 2 * PI * radius;

    // Print the area and perimeter of the circle
    console.log(area);
    console.log(perimeter);
}

This code declares the constant variable PI, and its value is Math.PI. The circle's radius is then read from stdin. Using the supplied formulas, the circle's area and perimeter are computed before printing the results using console.log().

Day 3: Conditional Statements: If-Else

The very first chapter of conditional statements covers if-else statements, which are useful in many scenarios. The problem below presents a practice challenge.

Problem:

Finish the editor's getGrade(score) function. Its only argument is an integer that represents Julia's exam point total. The letter that corresponds to her grade must be returned.

Solution:

function getGrade(score) {
  let grade;
  if (score >= 90) {
    grade = 'A';
  } else if (score >= 80) {
    grade = 'B';
  } else if (score >= 70) {
    grade = 'C';
  } else if (score >= 60) {
    grade = 'D';
  } else {
    grade = 'F';
  }
  return grade;
}

The code defines a function called getGrade that takes an integer score and returns its letter grade. It uses a series of if-else statements to determine the appropriate grade based on the following criteria: if the score is greater than or equal to 90, "A", "B", "C", "D", or "F", and if the score is greater than or equal to 60, "D". Otherwise, the grade is "F".

Day 3: Conditional Statements: Switch

This chapter unravels another important conditional statement, i.e., the switch statement. This allows one to check for various cases without using the hectic if-else-if ladder.

Problem:

Complete the getLetter(s) function in the editor. It has one parameter: a string consisting of lowercase English alphabetic letters (i.e., a through z). It must return A, B, C, or D depending on the following criteria:

Solution:

function getLetter(s) {
    let letter;
    switch (s[0]) {
        case 'a':
        case 'e':
        case 'i':
        case 'o':
        case 'u':
            letter = 'A';
            break;
        case 'b':
        case 'c':
        case 'd':
        case 'f':
        case 'g':
            letter = 'B';
            break;
        case 'h':
        case 'j':
        case 'k':
        case 'l':
        case 'm':
            letter = 'C';
            break;
        Default:
            letter = 'D';
            break;
    }
    return letter;
}

This code creates the method getLetter, which determines the category of the first letter in a string s by using a switch statement and a string s as input. The function uses the guidelines in the challenge to determine which letter ('A, B, C, or D') corresponds to it.

Day 3: Loops

This chapter explores a variety of JavaScript looping techniques and offers a thorough analysis of key control flow methods. It covers for, while, do-while, for-in, and for-of loops.

Problem:

First, print each vowel on a new line. The English vowels are a, e, i, o, and u, and each vowel must be printed in the same order as it appeared.

Second, print each consonant (i.e., non-vowel) on a new line in the same order as it appeared.

Solution:

function vowelsAndConsonants(s) {
    const vowels = 'aeiou';
    let consonants = '';

    for (let char of s) {
        if (vowels.includes(char)) {
            console.log(char);
        } else {
            consonants += char + '\n';
        }
    }

    console.log(consonants.trim());
}

// Example:
// If the input string is "javascriptloops"
// Output:
// a
// a
// i
// o
// o
// e
// j
// v
// s
// c
// r
// p
// t
// l
// p
// s

This code defines the vowelsAndConsonants function, which iterates through each letter in a string as input. It determines if the letter is a vowel and, if so, prints it on a new line. If it is a consonant, the letter is added to the consonant string, and the whole list of consonants is written on separate lines after the vowels.

Day 4: Arrays

This chapter provides a thorough overview of the basic operations on arrays in JavaScript, enabling you to utilize the capabilities of this adaptable data structure fully. It starts with array generation and moves through important subjects like indexing and accessing array objects.

Problem:

This challenge teaches about arrays and their use in Python. The function getSecondLargest takes an array of integers as input and returns the second largest number in the array.

Solution:

function getSecondLargest(nums) {
    // Remove duplicates by converting the array to a Set and then back to an array
    const uniqueNums = Array.from(new Set(nums));

    // Sort the array in descending order
    const sortedNums = uniqueNums.sort((a, b) => b - a);

    // Return the second element in the sorted array
    return sortedNums[1];
}

function main() {
    const n = +(readLine());
    const nums = readLine().split(' ').map(Number);
    
    console.log(getSecondLargest(nums));
}

This implementation removes duplicates from the array, sorts it in descending order, and then returns the second element, which is the second largest number.

Day 4: Try, Catch, and Finally

"String Basics" and "Error Handling," two essential components of JavaScript programming, are clarified in this chapter.

Problem:

Split, reverse, and join techniques may be used to reverse a string using the reverseString function, which takes a string input, s. If an exception is thrown, a new line is written with the message. The inverted string is returned if no exception was thrown, and the original string is returned if one was.

Solution:

function reverseString(s) {
    try {
        // Attempt to reverse the string using split, reverse, and join
        const reversedString = s.split('').reverse().join('');
        console.log(reversedString);
    } catch (error) {
        // Catch and print the exception's message if an error occurs
        console.log(error.message);
    } finally {
        // Print the original string regardless of success or failure
        console.log(s);
    }
}

// Example usage:
const inputString = "Hello, World!";
reverseString(inputString);

This function attempts to reverse the input string using the split, reverse, and join methods.

Day 4: Throw

This chapter covers Javascript errors: try, catch, finally, and throw. Thus, it completes Javascript error handling.

Problem:

The argument for the isPositive function is an integer called a. It returns YES if an is positive and throws an error otherwise. It throws a Negative Error if an is negative and returns a Zero Error if it is 0.

Solution:

function isPositive(a) {
    if (a > 0) {
        return "YES";
    } else if (a === 0) {
        throw new Error("Zero Error");
    } else {
        throw new Error("Negative Error");
    }
}

// Example usage:
try {
    const result = isPositive(5); // Change the argument to test different cases
    console.log(result);
} catch (error) {
    console.log(error.message);
}

This function determines whether the integer entered is positive. The string "YES" is returned if an is positive. It throws an error with the message "Zero Error" if an is 0. It throws an error with the message "Negative Error" if an is negative.

Day 5: Create a Rectangle Object

This chapter explores Javascript objects. It starts with a basic introduction and then proceeds to create objects.

Problem:

The function Rectangle provides an object that represents a rectangle and accepts two arguments, a and b. The rectangle object should have the factors that follow: area equal to the product of length and width, perimeter equal to the sum of length and width, and length equal to a.

Solution:

function Rectangle(a, b) {
  this.length = a;
  this.width = b;
  this.perimeter = 2 * (a + b);
  this.area = a * b;
}

const rect = new Rectangle(5, 3);
console.log(rect.length); // Output: 5
console.log(rect.width); // Output: 3
console.log(rect.perimeter); // Output: 16
console.log(rect.area); // Output: 15

The above given code solves the proposed problem perfectly.

Day 5: Count Objects

This chapter covers for, for in, forEach loops to count objects.

Problem:

The editor function requires an array of objects with two integer properties, x and y. Its goal is to return the count of objects o in the array satisfying o.x==o.y.

Solution:

function getCount(objects) {
    let count = 0;

    for (let obj of objects) {
        if (obj.x === obj.y) {
            count++;
        }
    }

    return count;
}

// Example usage:
const sampleObjects = [
    { x: 1, y: 1 },
    { x: 2, y: 3 },
    { x: 4, y: 4 },
    { x: 5, y: 5 },
];

const result = getCount(sampleObjects);
console.log(result); // Output: 3

Day 5: Classes

This chapter covers the basics of object-oriented programming in JavaScript.

Problem:

Make a Polygon class and test the perimeter() function and constructor in the editor. The constructor accepts an array of integer values for side lengths, and the perimeter method returns the polygon's perimeter.

Solution:

class Polygon {
    constructor(sideLengths) {
        this.sideLengths = sideLengths;
    }

    perimeter() {
        return this.sideLengths.reduce((sum, side) => sum + side, 0);
    }
}

// Example usage:
const polygon = new Polygon([3, 4, 5, 6]);
console.log(polygon.perimeter()); // Output: 18

This code presents the complete implementation of the solution for the given problem.

Day 6: Inheritance

This chapter of the 10 days of JavaScript set covers the basics of inheritance in JavaScript.

Problem:

The editor offers a Rectangle class implementation; to utilize it, you must add an area method to the prototype and make a square class that is a subclass of Rectangle, has a constructor, and can use the area method of the Rectangle class.

Solution:

class Rectangle {
    constructor(w, h) {
        this.w = w;
        this.h = h;
    }

    area() {
        return this.w * this.h;
    }
}

// Create a Square class that inherits from Rectangle
class Square extends Rectangle {
    constructor(side) {
        // Call the constructor of the parent class (Rectangle)
        super(side, side);
    }
}

// Example usage
if (JSON.stringify(Object.getOwnPropertyNames(Square.prototype)) === JSON.stringify(['constructor'])) {
    const rec = new Rectangle(3, 4);
    const sqr = new Square(3);

    console.log(rec.area()); // Output: 12
    console.log(sqr.area()); // Output: 9
} else {
    console.log(-1);
    console.log(-1);
}

The Square class is constructed as a subclass of Rectangle using the extends keyword, whereas the Rectangle class contains an area method for computing the rectangle area. Super(side, side) is how the Square class builds a constructor with a side length.

Day 6: Template Literals

Problem:

The function sides, which accept literals, an array of strings, and expressions, and a rest parameter holding values supplied via string interpolation, are needed to solve the problem. Using the formulas s₁ and s₂ = P ± √(P² - 16A)) / 4, the function should be able to determine the side lengths of a rectangle depending on its area and perimeter.

Solution:

function sides(literals, ...expressions) {
  // Extract the area and perimeter from the expressions array
  const [area, perimeter] = expressions;

  // Calculate s1 and s2 using the formula
  const s1 = (perimeter + Math.sqrt(perimeter * perimeter - (16 * area))) / 4;
  const s2 = (perimeter - Math.sqrt(perimeter * perimeter - (16 * area))) / 4;

  // Sort s1 and s2 in ascending order
  const sortedSides = [s1, s2].sort((a, b) => a - b);

  // Return the sorted array of side lengths
  return sortedSides;
}

const result = sides`The area is: ${area}, the perimeter is: ${perimeter}. 
The sides are: ${sides[0]} and ${sides[1]}.`;
console.log(result);

Day 6: Arrow Functions

This chapter explores the introduction and implementation of arrow functions.

Problem:

The editor's function accepts an array, nums, and multiplies even and odd items by two and three, each time iterating over the array before returning the updated array.

Solution:

function modifyArray(nums) {
    // Iterate through the array and modify elements based on their parity
    for (let i = 0; i < nums.length; i++) {
        if (nums[i] % 2 === 0) {
            // If the element is even, multiply by 2
            nums[i] *= 2;
        } else {
            // If the element is odd, multiply by 3
            nums[i] *= 3;
        }
    }

    // Return the modified array
    return nums;
}

// Example usage
const originalArray = [1, 2, 3, 4, 5];
const modifiedArray = modifyArray(originalArray);

console.log("Original Array:", originalArray);   // Output: [1, 2, 3, 4, 5]
console.log("Modified Array:", modifiedArray);   // Output: [3, 4, 9, 8, 15]

Day 7: Bitwise Operator

This chapter covers bitwise operators in JavaScript. It starts with number system conversions and then explores each bitwise operator with example usage.

Problem:

The task requires you to determine the greatest bitwise AND value that is less than a specific integer, k, for any two numbers, a and b, in a sequence S.

Solution:

function getMaxLessThanK(n, k) {
  // Initialize the result variable to 0
  let result = 0;

  // Iterate from n - 1 down to 1 (excluding n)
  for (let i = n - 1; i > 0; i--) {
    // Perform bitwise AND between the current element (i) and the result
    result = result & i;

    // Check if the result is no longer less than k
    if (result >= k) {
      break;
    }
  }

  // Return the final result
  return result;
}

Day 7: JavaScript Dates

This chapter explores the dates and times in JavaScript and the method to fetch the dates using get.

Problem:

The function returns the day name of a date string in the format MM/DD/YYYY, which can be Sunday, Monday, Tuesday, Wednesday, Thursday, Friday, or Saturday, as an example, for example, 12/07/2016.

Solution:

function getDayName(dateString) {
    const daysOfWeek = ["Sunday", "Monday", "Tuesday", "Wednesday", "Thursday", "Friday", "Saturday"];

    // Create a Date object from the dateString
    const dateObject = new Date(dateString);

    // Get the day of the week index (0 for Sunday, 1 for Monday, and so on)
    const dayIndex = dateObject.getUTCDay();

    // Get the day name based on the index
    dayName = daysOfWeek[dayIndex];

    return dayName;
}

// Example usage
const exampleDateString = "12/07/2016";
const dayName = getDayName(exampleDateString);

console.log(`The day name for ${exampleDateString} is: ${dayName}`);

Day 8: Regular Expressions I

This chapter covers the basics of regular expressions in JavaScript.

Problem:

Returning a RegExp object, re, that matches any string s that starts and ends with the same vowel will complete the method in the editor below. Remember that there are five vowels in English: a, e, i, o, and u.

Solution:

function regexVar() {
    /*
     * Declare a RegExp object variable named 're'
     * It must match a string that starts and ends with the same vowel (i.e., {a, e, i, o, u})
     */

    // Using a regular expression with a capturing group for a vowel and a backreference,
    let re = /^([aeiou]).*\1$/;

    /*
     * Do not remove the return statement
     */
    return re;
}

// Example usage
const regex = regexVar();
const testString = "abcda"; // Replace this with any test string
console.log(regex.test(testString)); // Output: true or false

Day 8: Regular Expressions II

Covers intermediate level concepts of regular expressions in javascript.

Problem:

The editor's method produces a RegExp object called re, which matches any text that satisfies two requirements: the string must begin with one of the prefixes Mr., Mrs., Ms., Dr., or Er, and the remaining characters must be uppercase, lowercase, or capital letters in the English alphabet.

Solution:

function regexVar() {
    /*
     * Declare a RegExp object variable named 're'
     * It must match a string that starts with 'Mr.', 'Mrs.', 'Ms.', 'Dr.', or 'Er.', 
     * followed by one or more letters.
     */

    let re = /^(Mr\.|Mrs\.|Ms\.|Dr\.|Er\.)[a-zA-Z]+$/;

    /*
     * Do not remove the return statement
     */
    return re;
}

// Example usage
const regex = regexVar();
const testString = "Mr. Smith"; // Replace this with any test string
console.log(regex.test(testString)); // Output: true or false

Day 8: Regular Expressions III

This chapter of day 7 covers the advanced-level concepts of regular expressions in JavaScript.

Problem:

In the editor below, finish the function by giving back a RegExp object, re, that corresponds to each number in some string s.

Solution:

function regexVar() {
    /*
     * Declare a RegExp object variable named 're'
     * It must match ALL occurrences of numbers in a string.
     */

    let re = /\d+/g;

    /*
     * Do not remove the return statement
     */
    return re;
}

// Example usage
const regex = regexVar();
const testString = "There are 123 apples and 456 oranges in the basket.";
console.log(testString.match(regex)); // Output: ['123', '456']

Day 9: Create a Button

This chapter explores designing buttons in html and adding functionality to them using JavaScript.

Problem:

Make a clickable button with the following properties: id: btn, style properties: 96px width, 48px height, font size: 24px, initial text label: 0, increased by 1 with each click. The text label is an innerHTML attribute of the button. The height and breadth of the button are given.

Solution:

<!DOCTYPE html>
<html lang="en">
<head>
    <meta charset="UTF-8">
    <meta name="viewport" content="width=device-width, initial-scale=1.0">
    <style>
        #btn {
            width: 96px;
            height: 48px;
            font-size: 24px;
        }
    </style>
    <title>Clickable Button</title>
</head>
<body>

<button id="btn" onclick="incrementButtonClick()">0</button>

<script>
    let clickCount = 0;

    function incrementButtonClick() {
        clickCount++;
        document.getElementById("btn").innerHTML = clickCount;
    }
</script>

</body>
</html>

Day 9: Buttons Container

This chapter explores creating button containers and scaling button layouts using JavaScript.

Problem:

The task involves creating nine buttons in a div, forming a 3 * 3 grid with distinct labels from 1 to 9, and ensuring that the outer buttons rotate clockwise when the middle button is clicked. The code must meet specific criteria in the editor.

Solution:

<!DOCTYPE html>
<html lang="en">
<head>
    <meta charset="UTF-8">
    <meta name="viewport" content="width=device-width, initial-scale=1.0">
    <style>
        #btns {
            width: 30%;
            margin: auto;
            display: grid;
            grid-template-columns: repeat(3, 1fr);
            gap: 5px;
        }

        button {
            width: 100%;
            height: 48px;
            font-size: 24px;
        }
    </style>
    <title>Rotating Buttons</title>
</head>
<body>

<div id="btns">
    <button id="btn1" onclick="rotateButtons()">1</button>
    <button id="btn2" onclick="rotateButtons()">2</button>
    <button id="btn3" onclick="rotateButtons()">3</button>
    <button id="btn4" onclick="rotateButtons()">4</button>
    <button id="btn5" onclick="rotateButtons()">5</button>
    <button id="btn6" onclick="rotateButtons()">6</button>
    <button id="btn7" onclick="rotateButtons()">7</button>
    <button id="btn8" onclick="rotateButtons()">8</button>
    <button id="btn9" onclick="rotateButtons()">9</button>
</div>

<script>
    function rotateButtons() {
        const outerButtonIds = ["btn1", "btn2", "btn3", "btn6", "btn9", "btn8", "btn7", "btn4"];
        const outerButtonValues = outerButtonIds.map(id => document.getElementById(id).innerHTML);

        // Rotate the values in a clockwise direction
        const rotatedValues = [outerButtonValues[7], ...outerButtonValues.slice(0, 7)];

        // Update the innerHTML of the outer buttons
        for (let i = 0; i < outerButtonIds.length; i++) {
            document.getElementById(outerButtonIds[i]).innerHTML = rotatedValues[i];
        }
    }
</script>

</body>
</html>

Day 10: Binary Calculator

This chapter covers the making of a calculator using multiple events.

Problem:

Implement a simple calculator that performs the following operations on binary numbers: addition, subtraction, multiplication, and division. Note that division operation must be integer division only; for example,1001/100 = 10.

Solution:

<!DOCTYPE html>
<html lang="en">
<head>
    <meta charset="UTF-8">
    <meta name="viewport" content="width=device-width, initial-scale=1.0">
    <style>
        body {
            width: 33%;
        }

        #res {
            background-color: lightgray;
            border: 1px solid black;
            height: 48px;
            font-size: 20px;
            padding: 5px;
            text-align: right;
            overflow: hidden;
        }

        button {
            width: 25%;
            height: 36px;
            font-size: 18px;
            margin: 0;
            float: left;
        }

        #btn0, #btn1 {
            background-color: lightgreen;
            color: brown;
        }

        #btnClr, #btnEql {
            background-color: darkgreen;
            color: white;
        }

        #btnSum, #btnSub, #btnMul, #btnDiv {
            background-color: black;
            color: red;
        }

        #btns {
            margin-top: 10px;
            overflow: hidden;
        }
    </style>
    <title>Binary Calculator</title>
</head>
<body>

<div id="res"></div>
<div id="btns">
    <button id="btn0" onclick="appendToResult('0')">0</button>
    <button id="btn1" onclick="appendToResult('1')">1</button>
    <button id="btnClr" onclick="clearResult()">C</button>
    <button id="btnEql" onclick="evaluateResult()">=</button>
    <button id="btnSum" onclick="appendToResult('+')">+</button>
    <button id="btnSub" onclick="appendToResult('-')">-</button>
    <button id="btnMul" onclick="appendToResult('*')">*</button>
    <button id="btnDiv" onclick="appendToResult('/')">/</button>
</div>

<script>
    function appendToResult(value) {
        document.getElementById('res').innerHTML += value;
    }

    function clearResult() {
        document.getElementById('res').innerHTML = '';
    }

    function evaluateResult() {
        try {
            const result = eval(document.getElementById('res').innerHTML);
            document.getElementById('res').innerHTML = result.toString(2);
        } catch (error) {
            document.getElementById('res').innerHTML = 'Error';
        }
    }
</script>

</body>
</html>

Next TopicBinary Numbers in JavaScript

← prev next →