You hover over a menu. It doesn't open.

You submit a form. The page just sits there, staring at you.

That's the web without JavaScript — technically functional, completely lifeless.

Every dropdown, animation, real-time update, and form validation you've ever interacted with online — That's JavaScript doing its job.

In this article, we're covering what JavaScript actually is, how it's different from the languages you might have heard of, where it runs, and why it's still the most relevant language in web development after nearly 30 years.

By the end, you'll have a clear mental model of what JS does and where it fits in the stack.

What we're covering 👇

• What a programming language is — and what makes JS different
• JavaScript vs ECMAScript — the naming confusion, cleared up
• Where JS actually runs — browser, server, and beyond
• JavaScript's role in the HTML / CSS / JS trio
• What JS can and can't do
• Why JS is still the #1 language to learn in 2026

JavaScript — the language that makes web pages do things

At its simplest, JavaScript is a programming language.

A programming language is a set of rules that lets you write instructions a computer can understand and execute.

Python, Java, Ruby — they're all programming languages. So is JavaScript.

But JavaScript has a specific superpower — it's the only language that runs natively inside every web browser. You don't install it. You don't compile anything.

Open Chrome, press F12, click Console, and you're running JavaScript right now. That's what makes it unique.

Python is great for data science. Java dominates enterprise backends. Ruby is elegant for certain APIs.

But if you want to make a webpage respond to a user clicking a button — JavaScript is the only tool that does that job natively, everywhere, without any setup.

Here's the technical short version, just so you have it in your head:

• Interpreted (or more accurately, JIT-compiled — your browser compiles it on the fly as it runs)
• Dynamically typed (you don't declare what type a variable is — we'll cover this properly in a later article)
• Single-threaded (it handles one thing at a time, which sounds limiting until you learn about the event loop — in a later article)
• Prototypal inheritance (its object model is different from Java or Python — in a later article)

Don't worry about understanding all of that right now.

What matters at this stage is simple — JavaScript runs in your browser, right now, without you doing anything to set it up.

JavaScript's place in the HTML / CSS / JS trio

If you're new to web development, you've probably heard these three names together. Here's what they actually do:

• HTML gives structure. It says — "there's a heading here, a paragraph there, a button at the bottom."
• CSS handles presentation. It says — "that heading should be blue and 32px, the button should have rounded corners."
• JavaScript handles behaviour. It says — "when someone clicks that button, show this message."

Without JavaScript, a web page is like a printed flyer.

It looks nice, it has information, but it can't respond to you. JavaScript is what turns a document into an application.

JavaScript vs ECMAScript — the naming confusion 🤔

You'll see both terms used. They're related but not the same thing.

JavaScript is the language you write. ECMAScript (often abbreviated as ES) is the official specification — the formal rulebook that defines what JavaScript should do. The people at TC39 (a committee of language experts) maintain that spec and release new versions of it periodically.

When you hear "ES6" or "ES2015", that means the 2015 version of the ECMAScript specification. Features like let, const, arrow functions, and template literals all came from that release.

You can read the full ECMAScript spec if you want to go deep — but fair warning, it reads like a legal document.

So, ECMAScript is the standard.

JavaScript is the implementation of that standard that your browser runs.

Same idea, different contexts.

You'll write JavaScript. Occasionally you'll read about ECMAScript when trying to understand why a specific feature exists or behaves the way it does.

Where JavaScript actually runs

JavaScript started in the browser. That's still where most people learn it. But it runs in several places now.

In the browser (client-side): This is the original home of JavaScript.

When a webpage loads, the browser parses the HTML, finds the <script> tag, and hands the JavaScript to its built-in engine to execute.

Chrome uses V8. Firefox uses SpiderMonkey. Safari uses JavaScriptCore.

Each is different under the hood, but they all run the same JavaScript you wrote.

// This runs in the browser — the engine finds the button and waits for a click
document.querySelector("button").addEventListener("click", () => {
  console.log("Button clicked!"); // → appears in your browser console
});

Each browser has its own engine, but the JavaScript you write works across all of them. That cross-browser consistency is something the ECMAScript spec is specifically designed to guarantee.

On the server (Node.js, Deno, Bun): In 2009, Node.js took the V8 engine out of Chrome and put it on a server.

Now JavaScript can read files, talk to databases, and handle HTTP requests — the things that server-side languages like Python or Ruby traditionally handled. Same language, completely different environment.

// This runs in Node.js on a server — not available in a browser
const fs = require("fs");
const content = fs.readFileSync("data.txt", "utf8");
console.log(content); // → reads a file from the server's filesystem

The key distinction — the browser gives JavaScript access to the DOM, fetch, alert, and browser-specific APIs. Node.js gives it access to the filesystem, network sockets, and server APIs. The core language is identical.

What's available depends on where it's running.

What JavaScript can and can't do

This trips up a lot of beginners.

JavaScript is powerful, but it has real limits — and most of them are there on purpose.

What it can do:

• Respond to user events: clicks, keypresses, form submissions, scroll position
• Update the page dynamically without a full reload — the foundation of modern SPAs
• Make network requests to APIs via fetch and handle the responses
• Store data in the browser via localStorage or cookies
• Run server logic, query databases, handle file I/O — when running in Node.js

What it can't do (in a browser):

• Access your local filesystem directly (⚠️ this is a security feature, not a limitation)
• Run multiple tasks truly in parallel — it's single-threaded; asynchronous execution is not the same as multi-threaded
• Do anything the browser's security sandbox doesn't explicitly permit

The filesystem restriction is intentional. If a random webpage could read your files just by you visiting it, that would be a serious problem.

The browser sandbox keeps JavaScript contained to what it's permitted to touch. You'll appreciate this design decision more once you start thinking about security.

Adding JavaScript to a webpage

There are three ways to include JavaScript in a webpage. You'll see all three in the wild, so knowing the difference matters.

Inline — directly on an HTML element. Works for one-off tests, doesn't scale to anything real. Don't build real projects this way.

// ❌ Before: inline event handlers get unmanageable fast
<button onclick="alert('clicked')">Click me</button>

Internal script — a <script> block inside your HTML file. Fine for learning and quick experiments.

<!-- Works, but mixing JS and HTML becomes painful at any real scale -->
<script>
  console.log("Page loaded"); // → shows in your browser console
</script>

External file — a separate .js file linked from your HTML. This is how real projects work.

<!-- In index.html, inside <body> — the right way to do it -->
<script src="script.js" defer></script>

// In script.js — clean, separate, and actually maintainable
document.querySelector("h1").textContent = "Hello from an external file";
// ✅ JS lives here, HTML lives in its own file — no spaghetti

💡 That defer attribute tells the browser, "don't run this script until the HTML has fully loaded."

Without it, your JavaScript might try to find a button that doesn't exist in the DOM yet — and fail silently.

The external file approach is the right default. It keeps your HTML clean, makes your JavaScript testable, and keeps your future self from having a bad day.

Frontend vs backend JavaScript

Same language. Completely different environment and purpose.

Frontend (browser): JavaScript here controls what the user sees and interacts with.

Frameworks like React, Vue, and Svelte are all JavaScript that runs in the browser and manages the UI layer.

Backend (Node.js): JavaScript here handles the server side — routing, database queries, authentication, and API logic.

Frameworks like Express and NestJS run on top of Node.js and bring structure to that work.

The reason this distinction matters early — when you hit a wall because "JavaScript can't access the filesystem", it's because you're thinking about browser JavaScript. When someone says "just use Node for that", they mean switch environments — same language, different capabilities. Context is everything.

Why JavaScript is still the language to learn in 2026

Some questions come up endlessly in developer communities — "Is JavaScript dying? Should I just learn Python? Is TypeScript replacing it?"

Short answers: No. Depends what you want to build. TypeScript compiles to JavaScript, so they coexist rather than compete.

JavaScript consistently tops developer surveys and GitHub usage data, and it remains one of the most in-demand skills in engineering job listings globally.

It runs on browsers, servers, mobile apps (React Native), desktop apps (Electron), serverless functions at the edge, and IoT devices. The npm ecosystem — with over two million open-source packages — is the largest package registry that exists.

That's not marketing. That's infrastructure. Knowing JavaScript means you can go full-stack with a single language. That matters when you're learning, and it matters when you're interviewing.

Summary

JavaScript is the language of interactivity on the web. It runs natively in every browser, powers the server via Node.js, and sits at the centre of the most active developer ecosystem in the world. It has real quirks and deliberate limitations — and you'll meet all of them in this series. But it's the foundational skill for anyone building for the web, and everything in the JavaScript Mastery Series builds on exactly what you just read.

TL;DR

• JavaScript is the only language that runs natively in every browser — no setup required
• ECMAScript is the official spec; JavaScript is the implementation your browser runs
• In the browser, JS controls the UI. In Node.js, JS handles the server. Same language, different environment
• Use external .js files with defer — not inline scripts
• JavaScript is still the most employable, versatile language for anyone building for the web in 2026

Up next → JavaScript's History Is a Mess — And That's Why It's Great — why understanding JS's origin story explains half of its weird decisions.

Also worth reading → What Can We Actually Build With JavaScript? — a practical look at what you can make once you know the basics.

If the numbers 1 to 5 are written out in words: one, two, three, four, five, then there are 3 + 3 + 5 + 4 + 4 = 19 letters used in total.

If all the numbers from 1 to 1000 (one thousand) inclusive were written out in words, how many letters would be used?

NOTE: Do not count spaces or hyphens. For example, 342 (three hundred and forty-two) contains 23 letters and 115 (one hundred and fifteen) contains 20 letters. The use of "and" when writing out numbers is in compliance with British usage.

Problem Description

Well, writing the numbers in words form and counting the number of alphabets used is our problem here. Looks interesting, right?!

Yeah, we have to write out all the numbers from 1 to 1000 in words. And count the total number of alphabets, ignoring spaces and hyphens.

Approach

Yes, this problem can be approached in N different ways.

The way I approached this(inspired by a freecodecamp article/video 😎) is to split the number into thousands, hundreds and tens. Convert the number to words, append it to a string and then count the number of alphabets using String.prototype.length.

The Hackerrank version of this problem is quite different. Their word spelling, using space and and rules vary too. The Numbers in their test cases are quite big - 0 <= N <= 1,000,000,000,000

For the Hackerrank solution, I used Map object in Javascript and split the given number in 100s before combining them with proper denominations like billion, million etc.

Note: Please note that the solution provided is only for learning purposes. Once you understand the problem, please try it on your own before referring to my solution below.

Solution

let words = {
    'units': ['', 'one', 'two', 'three', 'four', 'five', 'six', 'seven', 'eight', 'nine',
        'ten', 'eleven', 'twelve', 'thirteen', 'fourteen', 'fifteen', 'sixteen', 'seventeen', 'eighteen', 'nineteen'],
    'tenth': ['', 'ten', 'twenty', 'thirty', 'forty', 'fifty', 'sixty', 'seventy', 'eighty', 'ninety']
}

let numToWordsCount = (limit) => {

    let sum = 0;

    for (let i = 1; i <= limit; i++) {

        let num = i
        let numStr = ''

        let thousands = Math.floor(num / 1000)
        if (thousands > 0) {
            numStr = numStr + words['units'][thousands] + 'thousand'
            num = num - (thousands * 1000)
        }

        let hundreds = Math.floor(num / 100)
        if (hundreds > 0) {
            numStr = numStr + words['units'][hundreds] + 'hundred'
            num = num - (hundreds * 100)
            if (num > 0) {
                numStr = numStr + 'and'
            }
        }

        if (num < 20) {
            numStr = numStr + words['units'][num]
        } else {
           let tens = Math.floor(num / 10)
            numStr = numStr + words['tenth'][tens]
            num = num - (tens * 10)
            numStr = numStr + words['units'][num]
        }

        sum = sum + numStr.length
    }

    return sum
}

console.log(numToWordsCount(1000))

You can find my solution on GitHub 17

If you have any feedback, please leave it below.

If you have any suggestions to improve my code or another way to approach this problem, leave it in the comment.

For the other Project Euler Solutions, please follow the series Project Euler Solutions in JS.

Thank you!

Reference:

• More on Javascript Maps at MDN.

2¹⁵ = 32768 and the sum of its digits is 3 + 2 + 7 + 6 + 8 = 26.

What is the sum of the digits of the number 2¹⁰⁰⁰?

Problem Description

The problem is pretty self-explanatory. 2¹⁵ is 32768 and the sum of its digits is 3 + 2 + 7 + 6 + 8 = 26. So what will be the sum of digits of 2¹⁰⁰⁰?

Approach

While handling bigger power, the resulting large number can not be handled by Javascript.

One approach is to use column multiplication using arrays.

Another approach, which I have opted for is to use BigInt with 2 ** n, where n is the power.

BigInt is a built-in object in JavaScript that represents whole numbers larger than 2⁵³.

Note that, We could have used Math.pow() but BigInt can not be used with a Math object as they expect Number as arguments. And BigInt can't accurately convert to a Number. So we settle with 2 ** n.

Note: Please note that the solution provided is only for learning purposes. Once you understand the problem, please try it on your own before referring to my solution below.

Solution

const digitSum = n => {
    let power = 2n ** BigInt(n);
    // Convert BigInt into a String by concatenating with an empty string.
    let strNum = '' + power; 

    return strNum.split('').map(Number).reduce((acc, curr) => acc + curr, 0);
}

console.log(digitSum(1000));

You can find my solution on GitHub 16

For Hackerrank, the above solution works fine for all 10 test cases.

If you have any feedback, please leave it below.

If you have any suggestions to improve my code or another way to approach this problem, leave it in the comment.

For the other Project Euler Solutions, please follow the series Project Euler Solutions in JS.

Thank you!

Reference:

• For more on BigInt, refer to the articles in smashing magazine and MDN

Starting in the top left corner of a 2*2 grid, and only being able to move to the right and down, there are exactly 6 routes to the bottom right corner.

How many such routes are there through a 20*20 grid?

Problem Description

We are given a 2*2 grid and the number of paths to travel from the top-right corner to the bottom-left corner are 6 routes. Note that it is from the top-right corner to the bottom-right corner and not from the top-right cell to the bottom-right cell.

In a n*m grid, we have (n + 1) * (m + 1) corners or points through which we trace the path.

At any given point, we can either move RIGHT or DOWN. No other direction is possible.

Now, we must find the number of such paths in a 20*20 grid.

Approach

Well, this is another problem that gave me sleepless nights. I had to do some research before figuring out the best solution. 🧾

First let's understand what is a Lattice, and a Lattice Path. 🤔

Lattice Points & Lattice Paths:

A Lattice point is a repeating point arranged in a pattern like a square, rectangle or hexagon. The below diagram is a 2D square lattice arrangement.

Now, the lattice path is a sequence of steps connecting adjacent lattice points. Also, we restrict the movement to two directions, one-way horizontal and one-way vertical.

Since we are starting from the top-left corner, we move either RIGHT or DOWN.

Counting the Paths:

In the given problem, all possible lattice paths in a 2*2 grid is calculated as 6 paths. Remember, we can either go Right or Down.

One way to count lattice paths is by adding the number of ways in which we can reach each dot in the lattice. Remember, we can only go RIGHT or DOWN and always start from the same corner.

In the example 4x4 lattice below, the blue and red paths indicate two possible ways to get to the first bottom-right point. So, we marked it with a 2.

In the same way, to reach the next point, we calculate that there are 3 possible paths(2 from left & 1 from top), marked in blue, green and red.

And for the next point to the right, there are 4 possible paths (3 from left & 1 from top) and so on.

All the points along the left are marked with 1. From the top-left corner to the bottom-left corner, there is only one path available - remember we can either move RIGHT or DOWN. In the same way, all the points along the top are marked with 1.

Following this process, we count all paths till the desired point.

We use a few methods to count the lattice paths and can be used to count the paths of a lattice of any size. Let us consider the above 4 * 4 grid and assign cartesian coordinates to each dot in the lattice for path calculation.

The top-left corner is marked as (0, 0) and the bottom-right corner is marked as (4 4). Let us count the paths from (0, 0) to (3, 4) in this grid (marked in red).

Method 1: Recursive method

In this method, we count the paths recursively from (3, 4) to (0, 0). That is, from (m, n) to (0, 0). Using variables, (m, n) is (3, 4).

On one look at the diagram above, we can say that the number of paths from (0, 0) to (3, 4) is equal to the number of paths from (0, 0) to (2, 4) plus the number of paths from (0, 0) to (3, 3).

Thus, to count the path at (m, n) we use (0, 0) -> (m-1, n) + (0, 0) -> (m, n-1).

This way, we calculate the path recursively till (0, 0) and add all the counts. When it is at any of the 0 coordinates, we return 1.

function countPath(m, n)
    if n = 0 or m = 0 then
        return 1 
    else
        return countPath(m-1, n) + countPath(m, n-1)
end function

But this is too slow to answer in a reasonable time. If time constraints or space constraints are involved, then it would eventually time out. If you are executing this solution in Hackerrank, then it would time out for more than half of your test cases.

Method 2: Dynamic Programming or Iterative method

Instead of starting from m = 20 & n = 20 and counting all the way to m = 0 & n = 0, we start from our base all the way to the desired point, saving our result in a 2D-like array.

This approach is more like dynamic programming, where we use grid[i][j] for every point. I have not tried this method yet.

Method 3: Combinatorics

The number of lattice paths from (0, 0) to (m, n) is equal to the number of combinations of m objects out of m + n options. And the formula for counting the number of combinations m out of n objects(n choose m) is,

$${k}C_n = \frac{k!}{(k - n)! * n!} where (k = m + n)$$

At the location (3, 4), m = 3 and n = 4. Then the number of lattice paths is the combination of m = 3 out of m + n = (3+4) = 7 options.

In other words, it's the number given by "7 choose 3", which is,

And that is the number of lattice paths from (0, 0) to (3, 4) in the above 4 * 4 grid.

Similarly, we can calculate for 20 * 20 grid.

Method 4: Binomial Coefficient

The count at the point (n, m) corresponds to the binomial coefficient,

$$\binom{n + m}{m} OR \binom{n + m}{n}$$

which is equivalent to the "n + m choose m" or "n + m choose n" expression from the above combinatorics. The formula used is the same as above where k = n + m

$$\binom{k}{n} = \frac{k!}{(n - k)! * n!}$$

Method 5: Pascal's Triangle

There is another method where the binomial coefficient is arranged in pascal's triangle from which we can count the number of lattice paths in the n * m grid. No, I have not tried this method too. You can refer to the wiki link provided at the end of this post for more information.

Note: Please note that the solution provided is only for learning purposes. Once you understand the problem, please try it on your own before referring to my solution below.

Solution

const latticePathsRecursive = (m, n = m) => {
    if (m < 0 || n < 0) return 0; // to make sure of any negatives
    if (m === 0 && n === 0) return 1;
    return (latticePathsRecursive(m - 1, n) + latticePathsRecursive(m, n - 1));
}

const latticePathsCombinatorics = (m, n) => {
    const factorial = (number) => {
        if (number === 1 || number === 0) {
            return 1;
        } else {
            return number * factorial(number - 1);
        }
    }

    let k = m + n;
    let res = factorial(k) / (factorial(k-n) * factorial(n));
    return res;
}

console.log(latticePathsCombinatorics(4, 4)); // 70
console.log(latticePathsCombinatorics(3, 4)); // 35
console.log(latticePathsCombinatorics(20, 20)); // 137846528820

You can find my solution on GitHub 15

For Hackerrank, the recursive method timed out for 8 out of 11 test cases. But the combinatorics method worked fine along with BigInt and the modulo (1000000007) given in the problem.

If you have any feedback, please leave it below.

If you have any suggestions to improve my code or another way to approach this problem, leave it in the comment.

For the other project Euler solutions, please follow the series Project Euler Solutions in JS.

Thank you!

Reference note:

• Most of the diagrams here are from stemhash.com. My examples are based on these diagrams.

• Refer to these wiki pages for more on Lattice and binomial coefficients.

• Another great video source on Binomial Coefficients & Lattice paths is here.

• One of the best stackoverflow answers that explain the concept.

The following iterative sequence is defined for the set of positive integers:

n → n/2 (n is even) n → 3n + 1 (n is odd)

Using the rule above and starting with 13, we generate the following sequence:

13 → 40 → 20 → 10 → 5 → 16 → 8 → 4 → 2 → 1

It can be seen that this sequence (starting at 13 and finishing at 1) contains 10 terms. Although it has not been proved yet (Collatz Problem), it is thought that all starting numbers finish at 1.

Which starting number, under one million, produces the longest chain?

NOTE: Once the chain starts the terms are allowed to go above one million.

Problem Description

According to Wikipedia, the Collatz conjecture or Collatz problem is,

The Collatz conjecture is one of the most famous unsolved problems in mathematics. The conjecture asks whether repeating two simple arithmetic operations will eventually transform every positive integer into 1.

Depending on whether n is odd or even, we perform either one of the operations until we reach 1.

Example sequence of 13 is 13 → 40 → 20 → 10 → 5 → 16 → 8 → 4 → 2 → 1 and it contains 10 terms

We need to find the number with the longest sequence under 1000000

Approach

We can approach this in two steps.

First, for each n, we apply the above formula until we reach 1 and count the number of times we have applied the formula. This gives the length of the chain for n.

Then we compare it with the longest sequence so far until we reach the limit of one million. This way we can return the number with the longest sequence under one million.

Another smart way is to cache all the sequence lengths along the way. Look up the cache for the sequence length of n and if found, then return the length or else continue with the calculation.

Note: Please note that the solution provided is only for learning purposes. Once you understand the problem, please try it on your own before referring to my solution below.

Solution

const collatzSeqCount = n => {
    let seqCount = 1;

    if (n === 1) seqCount = 1;

    while (n > 1) {
        if (n % 2 === 0) {
            n = n / 2;
        } else {
            // You can skip to next possible odd using (3n + 1)/2 while adding 2 to the counter 
            // as (3n + 1) always results in even which again is divided by 2 in the next step.
            // Check HackerreankSolution.js for that approach.
            n = (3 * n + 1);
        }
        seqCount++;
    }
    return seqCount;
}

const calcLongestSeq = limit => {
    let longestSeq = 1,
        longestVal = 1;

    for (let i = 2; i <= limit; i++) {
        let getSeqArrCount = collatzSeqCount(i);

        if (getSeqArrCount >= longestSeq) {
            longestSeq = getSeqArrCount;
            longestVal = i;
        }
    }
    return longestVal;

}

console.log(calcLongestSeq(1000000));

Using the caching technique, the collatzSeqCount method can be rewritten as,

let seqCountMap = new Map();
const collatzSeqCountAnoterMethod = n => {
    let seqCount = 1,
        initial = n;

    if (n === 1) {
        seqCount = 1;
    }

    while (n > 1) {
        if (seqCountMap.has(n)) {
            seqCount += seqCountMap.get(n);
            return seqCount;
        }

        if (n % 2 === 0) {
            n = n / 2;
        } else {
            n = (3 * n + 1);
        }
        seqCount++;
    }
    seqCountMap.set(initial, seqCount);
    return seqCount;
}

Used Javascript Map() object for caching the calculated sequence length. This function can be further optimised.

You can find my solution on GitHub 14

For Hackerrank, modified the solution a bit as we know the upper bound of all the test cases to be 5 million. HR solution can be found in this repo. As said before, the code can be further optimised.

If you have any feedback, please leave it below.

If you have any suggestions to improve my code or another way to approach this problem, leave it in the comment.

For the other Project Euler Solutions, please follow the series Project Euler Solutions in JS.

Thank you!

Work out the first ten digits of the sum of the following one-hundred 50-digit numbers.

37107287533902102798797998220837590246510135740250
46376937677490009712648124896970078050417018260538
74324986199524741059474233309513058123726617309629
91942213363574161572522430563301811072406154908250
23067588207539346171171980310421047513778063246676
89261670696623633820136378418383684178734361726757
28112879812849979408065481931592621691275889832738
44274228917432520321923589422876796487670272189318
47451445736001306439091167216856844588711603153276
70386486105843025439939619828917593665686757934951
62176457141856560629502157223196586755079324193331
64906352462741904929101432445813822663347944758178
92575867718337217661963751590579239728245598838407
58203565325359399008402633568948830189458628227828
80181199384826282014278194139940567587151170094390
35398664372827112653829987240784473053190104293586
86515506006295864861532075273371959191420517255829
71693888707715466499115593487603532921714970056938
54370070576826684624621495650076471787294438377604
53282654108756828443191190634694037855217779295145
36123272525000296071075082563815656710885258350721
45876576172410976447339110607218265236877223636045
17423706905851860660448207621209813287860733969412
81142660418086830619328460811191061556940512689692
51934325451728388641918047049293215058642563049483
62467221648435076201727918039944693004732956340691
15732444386908125794514089057706229429197107928209
55037687525678773091862540744969844508330393682126
18336384825330154686196124348767681297534375946515
80386287592878490201521685554828717201219257766954
78182833757993103614740356856449095527097864797581
16726320100436897842553539920931837441497806860984
48403098129077791799088218795327364475675590848030
87086987551392711854517078544161852424320693150332
59959406895756536782107074926966537676326235447210
69793950679652694742597709739166693763042633987085
41052684708299085211399427365734116182760315001271
65378607361501080857009149939512557028198746004375
35829035317434717326932123578154982629742552737307
94953759765105305946966067683156574377167401875275
88902802571733229619176668713819931811048770190271
25267680276078003013678680992525463401061632866526
36270218540497705585629946580636237993140746255962
24074486908231174977792365466257246923322810917141
91430288197103288597806669760892938638285025333403
34413065578016127815921815005561868836468420090470
23053081172816430487623791969842487255036638784583
11487696932154902810424020138335124462181441773470
63783299490636259666498587618221225225512486764533
67720186971698544312419572409913959008952310058822
95548255300263520781532296796249481641953868218774
76085327132285723110424803456124867697064507995236
37774242535411291684276865538926205024910326572967
23701913275725675285653248258265463092207058596522
29798860272258331913126375147341994889534765745501
18495701454879288984856827726077713721403798879715
38298203783031473527721580348144513491373226651381
34829543829199918180278916522431027392251122869539
40957953066405232632538044100059654939159879593635
29746152185502371307642255121183693803580388584903
41698116222072977186158236678424689157993532961922
62467957194401269043877107275048102390895523597457
23189706772547915061505504953922979530901129967519
86188088225875314529584099251203829009407770775672
11306739708304724483816533873502340845647058077308
82959174767140363198008187129011875491310547126581
97623331044818386269515456334926366572897563400500
42846280183517070527831839425882145521227251250327
55121603546981200581762165212827652751691296897789
32238195734329339946437501907836945765883352399886
75506164965184775180738168837861091527357929701337
62177842752192623401942399639168044983993173312731
32924185707147349566916674687634660915035914677504
99518671430235219628894890102423325116913619626622
73267460800591547471830798392868535206946944540724
76841822524674417161514036427982273348055556214818
97142617910342598647204516893989422179826088076852
87783646182799346313767754307809363333018982642090
10848802521674670883215120185883543223812876952786
71329612474782464538636993009049310363619763878039
62184073572399794223406235393808339651327408011116
66627891981488087797941876876144230030984490851411
60661826293682836764744779239180335110989069790714
85786944089552990653640447425576083659976645795096
66024396409905389607120198219976047599490197230297
64913982680032973156037120041377903785566085089252
16730939319872750275468906903707539413042652315011
94809377245048795150954100921645863754710598436791
78639167021187492431995700641917969777599028300699
15368713711936614952811305876380278410754449733078
40789923115535562561142322423255033685442488917353
44889911501440648020369068063960672322193204149535
41503128880339536053299340368006977710650566631954
81234880673210146739058568557934581403627822703280
82616570773948327592232845941706525094512325230608
22918802058777319719839450180888072429661980811197
77158542502016545090413245809786882778948721859617
72107838435069186155435662884062257473692284509516
20849603980134001723930671666823555245252804609722
53503534226472524250874054075591789781264330331690

Problem Description

We are given 100 50-digit numbers. We need to find the first 10 digits of the sum of these 100 numbers.

Approach

Since we have 50-digit numbers, the sum of these numbers will be even bigger.

Languages with BigInteger support(Python or Javascript), can solve this problem in two lines of code.

In Javascript, we can approach this with or without using the BigInt data type.

Simply iterating through the given 100 numbers and adding to sum results in an even bigger number that is represented in a scientific format. Eg: 3.43608945e+38

We can then use Number.prototype.toLocaleString() function to convert the sum into a string and slice the first 10 digits from it. Refer to MDN for more on the parameters used in .toLoacleString().

Note: Please note that the solution provided is only for learning purposes. Once you understand the problem, please try it on your own before referring to my solution below.

Solution

const findSum = input => {
    let values = input.split('\n'),
        sum = 0;

    values.forEach(value => {
        // `+` is prefixed to convert to `Number` as it is passed as `String`
        // console.log(typeOf value); // string
        sum += +(value);
    })
    // to display full width digits for bigger numbers represented in scientific format eg 3.84568473654e+49
    // 'useGrouping' to say whether to use grouping separators, such as thousands separators
    return sum.toLocaleString('fullwide', { useGrouping: false }).slice(0, 10);
}

const input = `37107287533902102798797998220837590246510135740250
46376937677490009712648124896970078050417018260538
74324986199524741059474233309513058123726617309629
91942213363574161572522430563301811072406154908250
23067588207539346171171980310421047513778063246676
89261670696623633820136378418383684178734361726757
28112879812849979408065481931592621691275889832738
44274228917432520321923589422876796487670272189318
47451445736001306439091167216856844588711603153276
70386486105843025439939619828917593665686757934951
62176457141856560629502157223196586755079324193331
64906352462741904929101432445813822663347944758178
92575867718337217661963751590579239728245598838407
58203565325359399008402633568948830189458628227828
80181199384826282014278194139940567587151170094390
35398664372827112653829987240784473053190104293586
86515506006295864861532075273371959191420517255829
71693888707715466499115593487603532921714970056938
54370070576826684624621495650076471787294438377604
53282654108756828443191190634694037855217779295145
36123272525000296071075082563815656710885258350721
45876576172410976447339110607218265236877223636045
17423706905851860660448207621209813287860733969412
81142660418086830619328460811191061556940512689692
51934325451728388641918047049293215058642563049483
62467221648435076201727918039944693004732956340691
15732444386908125794514089057706229429197107928209
55037687525678773091862540744969844508330393682126
18336384825330154686196124348767681297534375946515
80386287592878490201521685554828717201219257766954
78182833757993103614740356856449095527097864797581
16726320100436897842553539920931837441497806860984
48403098129077791799088218795327364475675590848030
87086987551392711854517078544161852424320693150332
59959406895756536782107074926966537676326235447210
69793950679652694742597709739166693763042633987085
41052684708299085211399427365734116182760315001271
65378607361501080857009149939512557028198746004375
35829035317434717326932123578154982629742552737307
94953759765105305946966067683156574377167401875275
88902802571733229619176668713819931811048770190271
25267680276078003013678680992525463401061632866526
36270218540497705585629946580636237993140746255962
24074486908231174977792365466257246923322810917141
91430288197103288597806669760892938638285025333403
34413065578016127815921815005561868836468420090470
23053081172816430487623791969842487255036638784583
11487696932154902810424020138335124462181441773470
63783299490636259666498587618221225225512486764533
67720186971698544312419572409913959008952310058822
95548255300263520781532296796249481641953868218774
76085327132285723110424803456124867697064507995236
37774242535411291684276865538926205024910326572967
23701913275725675285653248258265463092207058596522
29798860272258331913126375147341994889534765745501
18495701454879288984856827726077713721403798879715
38298203783031473527721580348144513491373226651381
34829543829199918180278916522431027392251122869539
40957953066405232632538044100059654939159879593635
29746152185502371307642255121183693803580388584903
41698116222072977186158236678424689157993532961922
62467957194401269043877107275048102390895523597457
23189706772547915061505504953922979530901129967519
86188088225875314529584099251203829009407770775672
11306739708304724483816533873502340845647058077308
82959174767140363198008187129011875491310547126581
97623331044818386269515456334926366572897563400500
42846280183517070527831839425882145521227251250327
55121603546981200581762165212827652751691296897789
32238195734329339946437501907836945765883352399886
75506164965184775180738168837861091527357929701337
62177842752192623401942399639168044983993173312731
32924185707147349566916674687634660915035914677504
99518671430235219628894890102423325116913619626622
73267460800591547471830798392868535206946944540724
76841822524674417161514036427982273348055556214818
97142617910342598647204516893989422179826088076852
87783646182799346313767754307809363333018982642090
10848802521674670883215120185883543223812876952786
71329612474782464538636993009049310363619763878039
62184073572399794223406235393808339651327408011116
66627891981488087797941876876144230030984490851411
60661826293682836764744779239180335110989069790714
85786944089552990653640447425576083659976645795096
66024396409905389607120198219976047599490197230297
64913982680032973156037120041377903785566085089252
16730939319872750275468906903707539413042652315011
94809377245048795150954100921645863754710598436791
78639167021187492431995700641917969777599028300699
15368713711936614952811305876380278410754449733078
40789923115535562561142322423255033685442488917353
44889911501440648020369068063960672322193204149535
41503128880339536053299340368006977710650566631954
81234880673210146739058568557934581403627822703280
82616570773948327592232845941706525094512325230608
22918802058777319719839450180888072429661980811197
77158542502016545090413245809786882778948721859617
72107838435069186155435662884062257473692284509516
20849603980134001723930671666823555245252804609722
53503534226472524250874054075591789781264330331690`;

console.log(findSum(input));

You can find my solution on GitHub 13

For Hackerrank, both the above approach and the BigInt approach works for all test cases.

If you have any feedback, please leave it below.

If you have any suggestions to improve my code or another way to approach this problem, leave it in the comment.

For the other Project Euler Solutions, please follow the series Project Euler Solutions in JS.

Thank you!

The sequence of triangle numbers is generated by adding the natural numbers. So the 7th triangle number would be 1 + 2 + 3 + 4 + 5 + 6 + 7 = 28. The first ten terms would be:

1, 3, 6, 10, 15, 21, 28, 36, 45, 55, ...

Let us list the factors of the first seven triangle numbers:

1: 1
3: 1,3
6: 1,2,3,6
10: 1,2,5,10
15: 1,3,5,15
21: 1,3,7,21
28: 1,2,4,7,14,28

We can see that 28 is the first triangle number to have over 5 divisors.

What is the value of the first triangle number to have over five hundred divisors?

Problem Description

The triangular number sequence is the representation of the numbers in the form of an equilateral triangle arranged in a series or sequence.

The sum of the previous number and the order of the succeeding number results in the sequence of triangular numbers.

Given in the problem is an example of factors of the first 7 triangular sequence numbers. The triangular Number 28 which is the 7th has 6 factors/divisors. This is the first triangular number in the sequence that has more than 5 divisors.

We need to find the first triangular number that has over 500 divisors.

Approach

This is an interesting problem involving triangular numbers.

More on triangular numbers on this wiki page.

If we are to find the nth triangular number, then we can use the formula,

$$T_n = \frac{n(n + 1)}{2}$$

But we don't need the nth number, instead, we need to find the number with over 500 divisors.

We can approach this in two steps.

1. Find the triangular number n

2. Find the number of divisors of n and if the count is greater than or equals 500, then print that number n.

For finding the triangular number of n, we can either use the formula above or can use a global variable to add all the previous triangular numbers till n.

For getting all the divisors of n, we can iterate through i <= sqrt(n) instead of i <= n. For every valid divisor i, there is another divisor j, as j = n/i. More on this algorithm at finding the proper divisor of n

Count the divisors of n and when it is greater than or equals 500, then that is our Answer.

Note: Please note that the solution provided is only for learning purposes. Once you understand the problem, please try it on your own before referring to my solution below.

Solution

const properDivisors = n => {
    let divisorsArr = [1];

    for (let i = 2; i * i <= n; i++) {
        if (n % i === 0) {
            divisorsArr.push(i, n / i);
            if (i === Math.sqrt(n)) { 
                divisorsArr.pop();
            }
        }
    }
    return divisorsArr.sort(function (a, b) { return a - b; });
}

const findTriangularNum = n => (n * (n + 1)) / 2;

const findDivTriNum = nDivs => {
    let i = 1,
        triNum = 0;
    while (true) {
        let divCount = 0;

        // Either use formula or a simple addition of previous numbers.
        //triNum = findTriangularNum(i); 
        triNum += i;
        divCount = properDivisors(triNum).length;

        if (divCount >= nDivs) return triNum;

        i += 1;
    }
}

console.log(findDivTriNum(500));

You can find my solution on GitHub 12

For Hackerrank, I have modified the above code slightly to pass all the test cases. The test cases involve finding the first triangle number to have over N divisors, where 1 <= N <= 1000. So, instead of finding the triangle number starting from 1 for each test case, made use of the upper bound given. You can find Hackerrank Solution on GitHub.

If you have any feedback, please leave it below.

If you have any suggestions to improve my code or another way to approach this problem, leave it in the comment.

For the other Project Euler Solutions, please follow the series Project Euler Solutions in JS.

Thank you!

Given a positive integer n. Find all the proper divisors of the integer n.

Approach

We can approach this in two ways.

• Brute force method

• Squareroot of n method

Brute force method:

The most basic approach is to apply the brute force method. Brute force solves a problem through exhaustion. It goes through all possible choices until a solution is found.

To find the divisors for a positive integer n, we iterate all the integers from 1, 2, 3, . . . , n, and divide n by each of those integers i, and those that divide evenly make up the set of divisors for n.

This is rather plain, easy and simple but is not quite an efficient solution.

The time complexity to find divisors of n is O(n).

Consider that we need to find the divisors of the number 100000. Then using the brute force method, we divide 100000 by 1 to 100000 taking 100000 iterations. This would take a long time to compute all the divisors of 100000.

So to solve this problem, we can use a more efficient solution like that of Squareroot of n method

Squareroot of n method:

Let us observe the divisors of 100 first as an example.

The proper divisors of 100 are 1, 2, 4, 5, 10, 20, 25, and 50 which can be written as 1, 2, 4, 5, 10, 100/5, 100/4, and 100/2.

If i is a divisor of n, then d = n/i is also a divisor of n because i * d = n. Hence the divisors can be organised into pairs of (i, d) = (i, n/i). The exception for this is if n is a perfect square and i = sqrt(n), then in this case both i and d are equal.

Thus the divisors of a number n usually, appear in pairs and using this method, the time complexity is O(sqrt(n))

For finding divisors of 100, it involves 10 iterations and for 100000, it takes roughly 316 iterations.

Example of finding divisors of n = 100 (Code given below)

Code

const properDivisors = n => {
    let divisors = [1];

    // Condition can either be `i <= sqrt(n)` OR `i * i <= n`. Both are equivalent.
    // if square of `i` = `n`, then always square root of `n` = `i`
    for (let i = 2; i * i <= n; i++) {
        if (n % i === 0) {
            divisors.push(i, n / i);
            if (i === Math.sqrt(n)) { // Condition can either be `i === sqrt(n)` OR `i * i === n`. Both are equivalent.
                divisors.pop();
            }
        }
    }
    return divisors.sort(function (a, b) { return a - b; });
}

console.log(properDivisors(100)); //  1,2,4,5,10,20,25,50
console.log(properDivisors(144)); // 1,2,3,4,6,8,9,12,16,18,24,36,48,72

You can find my solution here at ProperDivisors

I hope you learn something new and enjoy coding. If you have any feedback, please leave it below.

If you have any suggestions to improve my code or another way to approach this problem, leave it in the comment.

Thanks & Happy Coding!

In the 20×20 grid below, four numbers along a diagonal line have been marked in yellow.

08 02 22 97 38 15 00 40 00 75 04 05 07 78 52 12 50 77 91 08
49 49 99 40 17 81 18 57 60 87 17 40 98 43 69 48 04 56 62 00
81 49 31 73 55 79 14 29 93 71 40 67 53 88 30 03 49 13 36 65
52 70 95 23 04 60 11 42 69 24 68 56 01 32 56 71 37 02 36 91
22 31 16 71 51 67 63 89 41 92 36 54 22 40 40 28 66 33 13 80
24 47 32 60 99 03 45 02 44 75 33 53 78 36 84 20 35 17 12 50
32 98 81 28 64 23 67 10 26 38 40 67 59 54 70 66 18 38 64 70
67 26 20 68 02 62 12 20 95 63 94 39 63 08 40 91 66 49 94 21
24 55 58 05 66 73 99 26 97 17 78 78 96 83 14 88 34 89 63 72
21 36 23 09 75 00 76 44 20 45 35 14 00 61 33 97 34 31 33 95
78 17 53 28 22 75 31 67 15 94 03 80 04 62 16 14 09 53 56 92
16 39 05 42 96 35 31 47 55 58 88 24 00 17 54 24 36 29 85 57
86 56 00 48 35 71 89 07 05 44 44 37 44 60 21 58 51 54 17 58
19 80 81 68 05 94 47 69 28 73 92 13 86 52 17 77 04 89 55 40
04 52 08 83 97 35 99 16 07 97 57 32 16 26 26 79 33 27 98 66
88 36 68 87 57 62 20 72 03 46 33 67 46 55 12 32 63 93 53 69
04 42 16 73 38 25 39 11 24 94 72 18 08 46 29 32 40 62 76 36
20 69 36 41 72 30 23 88 34 62 99 69 82 67 59 85 74 04 36 16
20 73 35 29 78 31 90 01 74 31 49 71 48 86 81 16 23 57 05 54
01 70 54 71 83 51 54 69 16 92 33 48 61 43 52 01 89 19 67 48

The product of these numbers is 26 × 63 × 78 × 14 = 1788696.

What is the greatest product of four adjacent numbers in the same direction (up, down, left, right, or diagonally) in the 20×20 grid?

Problem Description

In this problem, given the numbers are in a 20 x 20 grid.

We need to find the greatest product of 4 adjacent numbers.

The 4 adjacent numbers should be in the same direction - UP or DOWN or LEFT or RIGHT or DIAGONAL, in the grid.

The example is highlighted in yellow in the above grid.

Approach

Well, this one hit me hard. I had two sleepless nights before solving this with the help of Scrimba and some comments in hacker rank.

We convert the given grid into an Array of arrays. We have an array of 20 items and each item is again an array of 20 numbers.

Then, we loop through the array horizontally, vertically and diagonally.

I have linked the Scrimba video here.

Solution

const grid = [
    [8, 2, 22, 97, 38, 15, 0, 40, 0, 75, 4, 5, 7, 78, 52, 12, 50, 77, 91, 8],
    [49, 49, 99, 40, 17, 81, 18, 57, 60, 87, 17, 40, 98, 43, 69, 48, 4, 56, 62, 0],
    [81, 49, 31, 73, 55, 79, 14, 29, 93, 71, 40, 67, 53, 88, 30, 3, 49, 13, 36, 65],
    [52, 70, 95, 23, 4, 60, 11, 42, 69, 24, 68, 56, 1, 32, 56, 71, 37, 2, 36, 91],
    [22, 31, 16, 71, 51, 67, 63, 89, 41, 92, 36, 54, 22, 40, 40, 28, 66, 33, 13, 80],
    [24, 47, 32, 60, 99, 3, 45, 2, 44, 75, 33, 53, 78, 36, 84, 20, 35, 17, 12, 50],
    [32, 98, 81, 28, 64, 23, 67, 10, 26, 38, 40, 67, 59, 54, 70, 66, 18, 38, 64, 70],
    [67, 26, 20, 68, 2, 62, 12, 20, 95, 63, 94, 39, 63, 8, 40, 91, 66, 49, 94, 21],
    [24, 55, 58, 5, 66, 73, 99, 26, 97, 17, 78, 78, 96, 83, 14, 88, 34, 89, 63, 72],
    [21, 36, 23, 9, 75, 0, 76, 44, 20, 45, 35, 14, 0, 61, 33, 97, 34, 31, 33, 95],
    [78, 17, 53, 28, 22, 75, 31, 67, 15, 94, 3, 80, 4, 62, 16, 14, 9, 53, 56, 92],
    [16, 39, 5, 42, 96, 35, 31, 47, 55, 58, 88, 24, 0, 17, 54, 24, 36, 29, 85, 57],
    [86, 56, 0, 48, 35, 71, 89, 7, 5, 44, 44, 37, 44, 60, 21, 58, 51, 54, 17, 58],
    [19, 80, 81, 68, 5, 94, 47, 69, 28, 73, 92, 13, 86, 52, 17, 77, 4, 89, 55, 40],
    [4, 52, 8, 83, 97, 35, 99, 16, 7, 97, 57, 32, 16, 26, 26, 79, 33, 27, 98, 66],
    [88, 36, 68, 87, 57, 62, 20, 72, 3, 46, 33, 67, 46, 55, 12, 32, 63, 93, 53, 69],
    [4, 42, 16, 73, 38, 25, 39, 11, 24, 94, 72, 18, 8, 46, 29, 32, 40, 62, 76, 36],
    [20, 69, 36, 41, 72, 30, 23, 88, 34, 62, 99, 69, 82, 67, 59, 85, 74, 4, 36, 16],
    [20, 73, 35, 29, 78, 31, 90, 1, 74, 31, 49, 71, 48, 86, 81, 16, 23, 57, 5, 54],
    [1, 70, 54, 71, 83, 51, 54, 69, 16, 92, 33, 48, 61, 43, 52, 1, 89, 19, 67, 48]
];

function largestGridProduct(arr) {
    let maxProduct = 0;

    const maxProductChecker = n => {
        if (n > maxProduct) {
            return maxProduct = n;
        }
    }

    for (let r = 0; r < arr.length; r++) {
        for (let c = 0; c < arr.length; c++) {
            let currProduct = 0;
            const limit = arr.length - 3;

            // Horizontal Check - Left/Right adjacent numbers 
            if (c < limit) {
                currProduct = arr[r][c] * arr[r][c + 1] * arr[r][c + 2] * arr[r][c + 3];
                maxProductChecker(currProduct);
            }

            // Verticle Check - Up/Down adjacent check
            if (r < limit) {
                currProduct = arr[r][c] * arr[r + 1][c] * arr[r + 2][c] * arr[r + 3][c];
                maxProductChecker(currProduct);
            }

            // Right Diagonal check
            if (c < limit && r < limit) {
                currProduct = arr[r][c] * arr[r + 1][c + 1] * arr[r + 2][c + 2] * arr[r + 3][c + 3];
                maxProductChecker(currProduct);
            }

            // Left Diagonal Check
            if (c >= 3 && r < limit) {
                currProduct = arr[r][c] * arr[r + 1][c - 1] * arr[r + 2][c - 2] * arr[r + 3][c - 3];
                maxProductChecker(currProduct);
            }
        }
    }

    console.log(maxProduct);
    return maxProduct;
}

largestGridProduct(grid);

You can find my solution on GitHub 11.

This particular solution was executed in Hacker rank without failing a single test case.

If you have another or a better solution, please leave it in the comments below.

For the other Project Euler Solutions, please follow the series Project Euler Solutions in JS.

Thank you!

The sum of the primes below 10 is 2 + 3 + 5 + 7 = 17.

Find the sum of all the primes below two million.

Problem Description

The problem is pretty self-explanatory!

Sum of primes below 10 is 17.

Find the sum of primes below 2000000.

Approach

To calculate the sum of primes, we can use the brute force algorithm method, which solves a problem through exhaustion - it goes through all possible choices until a solution is found.

The brute force method is simple and consistent but very slow. It affects the time complexity of the program as it depends on the size of the input, in our case we need to loop two million times.

We loop through the numbers till 2 million and push them to an array allPrimes, if it is a prime number.

The steps involved in determining isPrime(n) is the same as we did with problem #3 - Largest Prime factor and problem #7 - 10001st Prime. Except that here, I opted for a while loop instead of for loop.

Finally, using the array reduce() method, the sum of all the primes in the array allPrimes is calculated.

Solution

const isPrime = n => {
    if (n === 2) return true;
    if (n === 3) return true;
    if (n % 2 === 0) return false;
    if (n % 3 === 0) return false;

    let i = 5,
        next = 2;
    while (i * i <= n) {
        if (n % i === 0) {
            return false;
        }
        i += next;
        next = 6 - next;
    }
    return true;
}

let allPrimes = [];

for (let i = 2; i <= 2000000; i++) {
    if (isPrime(i)) allPrimes.push(i);
}

console.log(allPrimes.reduce((a, b) => a + b, 0));

You can find my solution on GitHub 10.

The above solution failed 3 out of 10 test cases in Hacker rank(Of course Hacker rank uses a variety of test cases from a small number to a very big number).

Hence I tweaked the solution to achieve the time complexity for passing all the test cases.

First, I adjusted a bit while calculating isPrime(n).

const isPrime = n => {
            if (n === 1) return false;

            if (n < 4) return true; // 2 & 3 are prime
            if (n % 2 === 0) return false;

            // We have excluded 4, 6 & 8 in the previous step.
            if (n < 9) return true; 
            if (n % 3 === 0) return false;

            let i = 5;

            // n rounded to the greatest integer s so that s*s <= n
            let s = Math.floor(Math.sqrt(n)); 
            while (i <= s) {
                if (n % i === 0) return false;
                if (n % (i + 2) === 0) return false;
                i = i + 6;
            }

            return true;
        }

Note: The below code is only for the Hacker Rank solution to pass all test cases. 👇

Even after this, 2 test cases were timed out. So instead of getting the allPrimes for every test case, declare the allPrimes array as global to all test cases, push the prime numbers into this array from where we left in the last test case till we reach the current n. In this way, we won't repeat the same process again and again for each test case.

function main() {
    var t = parseInt(readLine());

    let allPrimes = []; // Moved this here. Common to all the input.

    for(var a0 = 0; a0 < t; a0++){
        var n = parseInt(readLine());

        // let allPrimes = [];
        let sum = 0, 
            temp = true;
        // If allPrimes has items, get the last item to lastNum
        // Else initialise lastNum to 1.
        // We will loop through from lastNum till we reach n
        // and add the prime numbers into the array allPrimes
        let lastNum = allPrimes.length !== 0 ? 
                            allPrimes[allPrimes.length-1] : 1;
        // If lastNum is greater than n, then we already have 
        // the prime numbers till n in the allPrime array.
        // So loop through allPrime array till <= n, and 
        // sum all the prime numbers
        if(lastNum > n){
            temp = false;
            for(let l = 0 ; l < allPrimes.length ; l++ ){
                if(allPrimes[l] <= n){
                    sum += allPrimes[l];  
                }
            }
        }
        // Else, from lastNum + 1, we need to find the prime till n
        lastNum++
        while(lastNum <= n){
            if(isPrime(lastNum)){
                allPrimes.push(lastNum)
            }
            lastNum++
        }
        if(temp){
            sum = allPrimes.reduce((acc,cur) => acc + cur, 0)
        }
        console.log(sum)
    }

}

If you have another or a better solution, please leave it in the comments below.

For the other Project Euler Solutions, please follow the series Project Euler Solutions in JS.

Thank you!

A Pythagorean triplet is a set of three natural numbers, a < b < c for which,

$$a^2 + b^2 = c^2$$

For example,

$$3^2 + 4^2 = 9 + 16 = 25 = 5^2$$

There exists exactly one Pythagorean triplet for which a + b + c = 1000.
Find the product abc.

Problem Description

In a Pythagorean triplet of natural numbers, a < b < c for which,

$$a^2 + b^2 = c^2$$

Example,

$$3^2 + 4^2 = 9 + 16 = 25 = 5^2$$

In this case a + b + c is 12 and a * b * c is 60

Same way, there exists one triplet, where a + b + c = 1000 and we need to find a * b * c of that triplet.

Approach

Let's approach this problem as finding some triplets where a + b + c = n.

There are as many different mathematical approaches to solving this(I have known only 2. But Wikipedia has more than that 😎).

The straightforward approach is to loop over a and b to check,

$$a^2 + b^2 = (n − a − b)^2$$

And since we have a < b < c, we use the below formula while looping through a and b - a <= (n - 3)/3 & b < (n - a)/2

Solution

const pythagoreanTriplet = n => {
    let maxProduct = -1;

    for(let a = 1; a <= (n - 3)/3; a++) {
        for (let b = a; b <= (n - a)/2 ; b++) {
            if( (a*a) + (b*b) === (n-a-b)*(n-a-b)) {
                maxProduct = a*b*(n-a-b);
            }
        }
    }
    return maxProduct;
}
console.log(pythagoreanTriplet(1000));

You can find my solution on GitHub 09. My GitHub solution is different from the above. To achieve 100% success(all test cases passed) in Hacker Rank, I tweaked a bit using the formula.

If you have another or a better solution, please leave it in the comments below.

For the other Project Euler Solutions, please follow the series Project Euler Solutions in JS.

Thank you!

The four adjacent digits in the 1000-digit number that has the greatest product is 9 × 9 × 8 × 9 = 5832.

73167176531330624919225119674426574742355349194934
96983520312774506326239578318016984801869478851843
85861560789112949495459501737958331952853208805511
12540698747158523863050715693290963295227443043557
66896648950445244523161731856403098711121722383113
62229893423380308135336276614282806444486645238749
30358907296290491560440772390713810515859307960866
70172427121883998797908792274921901699720888093776
65727333001053367881220235421809751254540594752243
52584907711670556013604839586446706324415722155397
53697817977846174064955149290862569321978468622482
83972241375657056057490261407972968652414535100474
82166370484403199890008895243450658541227588666881
16427171479924442928230863465674813919123162824586
17866458359124566529476545682848912883142607690042
24219022671055626321111109370544217506941658960408
07198403850962455444362981230987879927244284909188
84580156166097919133875499200524063689912560717606
05886116467109405077541002256983155200055935729725
71636269561882670428252483600823257530420752963450

Find the thirteen adjacent digits in the 1000-digit number that has the greatest product. What is the value of this product?

Problem Description

Well, a 1000-digit number is given to us.

The 4 adjacent digits with the greatest product are 9 × 9 × 8 × 9 = 5832.

We need to find the product of a 13 adjacent digits in this number and to top it off, it is the greatest product of any 13 adjacent digits in this 1000-digit number.

Approach

To solve this problem, first, we are going to convert this 1000-digit number to an array of length 1000. We use String.prototype.split() function to convert the number to an array.

Then, we loop through the array till we reach the last 13 digits.

Slice the array for every 13 digits using the Array slice() method and then calculate the product using the Array reduce() method.

Push this product to a new array.

Once all the digits are handled, then using Math.max(), return the greatest of the calculated product.

Slicing the array and calculating its product is a much better solution compared to looping through every digit and calculating its product in terms of time complexity.

Solution

const givenNumber = '7316717653133062491922511967442657474235534919493496983520312774506326239578318016984801869478851843858615607891129494954595017379583319528532088055111254069874715852386305071569329096329522744304355766896648950445244523161731856403098711121722383113622298934233803081353362766142828064444866452387493035890729629049156044077239071381051585930796086670172427121883998797908792274921901699720888093776657273330010533678812202354218097512545405947522435258490771167055601360483958644670632441572215539753697817977846174064955149290862569321978468622482839722413756570560574902614079729686524145351004748216637048440319989000889524345065854122758866688116427171479924442928230863465674813919123162824586178664583591245665294765456828489128831426076900422421902267105562632111110937054421750694165896040807198403850962455444362981230987879927244284909188845801561660979191338754992005240636899125607176060588611646710940507754100225698315520005593572972571636269561882670428252483600823257530420752963450';

const gvnNumArr = givenNumber.trim().split('').map(Number);

const largestProduct = n => {
    let prod = 0,
        prodArray = [];

    for (let i = 0; i <= gvnNumArr.length - n; i++) {
        const last = i + n;

        prod = gvnNumArr.slice(i, last).reduce((acc, curr) => acc * curr, 1);
        prodArray.push(prod);
    }

    return Math.max(...prodArray);
}

console.log(largestProduct(13));

You can find my solution on GitHub 08

This particular solution was executed with a better complexity in Hacker rank. If you have another solution, please leave it in the comments below.

For the other Project Euler Solutions, please follow the series Project Euler Solutions in JS.

Thank you!

By listing the first six prime numbers: 2, 3, 5, 7, 11, and 13, we can see that the 6th prime is 13.

What is the 10001st prime number?

Problem Description

We all know about Prime Numbers. A number that is divisible by 1 and itself is called a Prime Number. In other words, it has only 2 factors - 1 and itself.

So we need to find the nth prime number. For example, 3rd prime number is 5, 4th prime is 7, 6th prime is 13, 10th prime is 29 and so on.

We need to find the 10001st prime number.

Approach

To find nth prime number, we need to loop through a range of numbers from 2 to Number.MAX_SAFE_INTEGER.

Increase the counter by 1 for each prime number and once we find the nth prime, we break out of the loop.

To Check for the prime number, we use the same technique as in Problem #3 Largest prime factor

Solution

const isPrime = num => {
    if (num === 1) return false;
    if (num === 2 || num === 3) return true;
    if (num %2 === 0 || num % 3 === 0) return false;

    for (let i = 5; i <= Math.ceil(num / 2); i += 6) {
        if (num % i === 0 || num % (i+2) === 0) return false;
    }
    return true;
}

let count = 0;

for (let i = 2; i < Number.MAX_SAFE_INTEGER; i++) {
    if (isPrime(i)) count++;

    if (count === n) {
        console.log(i);
        break;
    }
}

console.time("10th");
console.log(nthPrime(10)); // 29
console.timeEnd("10th"); // 10th: 0.221923828125 ms

console.time("100th");
console.log(nthPrime(100)); // 541
console.timeEnd("100th"); // 100th: 0.68701171875 ms

console.time("10001th");
console.log(nthPrime(10001)); // 104743
console.timeEnd("10001th"); // 10001th: 827.61181640625 ms

You can find my solution on GitHub 07

This particular solution was timed out in Hacker rank for 2 out of 7 test cases. So a little bit of tweaking is necessary to achieve a better time complexity.

If you have a better solution, please leave it in the comments below.

But no worries, the above code works perfectly fine for our use case, 10001th prime number.

For the other Project Euler Solutions, please follow the series Project Euler Solutions in JS.

Thank you!

The sum of the squares of the first ten natural numbers is,

$$1^2 + 2^2 + 3^2 + 4^2 + 5^2 + 6^2 + 7^2 + 8^2 + 9^2 + 10^2 = 385$$

The square of the sum of the first ten natural numbers is,

$$(1+2+3+4+5+6+7+8+9+10)^2 = 55^2 = 3025$$

Hence the difference between the sum of the squares of the first ten natural numbers and the square of the sum is

$$3025 − 385 = 2640$$

Find the difference between the sum of the squares of the first one hundred natural numbers and the square of the sum.

Problem Description

Well, the problem itself is self-explanatory.

The example given is for first 10 natural numbers. We need to find the difference between the Sum of Squares & Squares of the Sum of first 100 natural numbers.

i.e. 1 to 100.

Approach

This is a detailed approach.

Two functions are involved. One function is to calculate the square of each number from 1 to 100 and add those squares.

Another function is to add the numbers from 1 to 100 and square their sum.

Finally, find the difference between both.

Very simple, Right?

Solution

const sumOfSqrNums = (start, end) => {
    let sumOfSqrs = 0;

    if (start > end) {
        console.log(`${start} > ${end}! Enter a valid Start & End.`);
    } else {
        for (let i = start; i <= end; i++) {
            sumOfSqrs += Math.pow(i, 2);
        }
    }
    return sumOfSqrs;
}

const sqrOfSumNums = (start, end) => {
    let sumOfNums = 0;

    if (start > end) {
        console.log(`${start} > ${end}! Enter a valid Start & End.`);
    } else {
        for (let i = start; i <= end; i++) {
            sumOfNums += i;
        }
    }
    return Math.pow(sumOfNums, 2);
}

let difference = sqrOfSumNums(1, 100) - sumOfSqrNums(1, 100);
console.log(difference);

You can find my solution on GitHub 06

This particular solution was executed with a better complexity in Hacker rank. But there are still much better solutions to this. If you have another or a better solution, please leave it in the comments below.

For the other Project Euler Solutions, please follow the series Project Euler Solutions in JS.

Thank you!

2520 is the smallest number that can be divided by each of the numbers from 1 to 10 without any remainder.

What is the smallest positive number that is evenly divisible by all of the numbers from 1 to 20?

Problem Description

The Problem is straightforward. The smallest number that is divisible by all the numbers from 1 to 10 is 2520.

We need to find the smallest positive number that is divisible by all the numbers from 1 to 20

Approach

To calculate, let's break down all the prime numbers between 2 and 20.

So we will have an array like [2, 3, 5, 7, 11, 13, 17, 19].

Then for each of these prime components, we need to find the maximum number of occurrences in each number. In other words, factorize each number from 2 to 20 and find the number of times a particular prime number occurs.

For example, 12 has 2 occurrence of prime number 2 and 1 occurrence of prime number 3. Below is a chart with the maximum occurrence for each number.

Then you raise each prime number to its maximum occurrence: 2^4, 3^2, 5^1, … and multiply the result: 16 * 9 * 5 * ...

In this calculation, we involve only prime numbers between 1 and 20 because the other numbers are eventually multiples of these prime numbers.

Solution

const findPrimeNumbers = (start, end) => {
    let primeArray = [];

    for (let i = start; i <= end; i++) {
        let isPrime = true;
        for (let j = 2; j <= Math.ceil(i / 2); j++) {
            if ((i % j) === 0) {
                isPrime = false;
                break;
            }
        }
        if (isPrime === true) {
            primeArray.push(i);
        }
    }
    return primeArray;
};

const findFactors = (number) => {
    var factorsArray = [];

    for (let i = 2; i <= number; i++) {
        while ((number % i) === 0) {
            factorsArray.push(i);
            number /= i;
        }
    }
    return factorsArray;
}

const smallestDivNumber = () => {
    const primeArr = findPrimeNumbers(2, 20);

    for (let i = 0; i < primeArr.length; i++) {
        let maxOccur = 0;
        for (let j = 2; j <= 20; j++) {
            if (!(primeArr[i] > j)) {
                const factArr = findFactors(j);
                let countOccur = factArr
                                    .filter(x => x === primeArr[i]).length;
                if (countOccur > maxOccurance) maxOccur = countOccur;
            }
        }
        if (maxOccur > 0) primeArr[i] = Math.pow(primeArr[i], maxOccur);
    }

    return primeArr.reduce((acc, val) => acc * val, 1);
}

console.time("Time");
console.log(smallestDivNumber());
console.timeEnd("Time");

You can find my solution on GitHub 05

If you have another or a better solution, please leave it in the comments below.

For the other Project Euler Solutions, please follow the series Project Euler Solutions in JS.

Thank you!

A palindromic number reads the same both ways. The largest palindrome made from the product of two 2-digit numbers is 9009 = 91 × 99.

Find the largest palindrome made from the product of two 3-digit numbers.

Problem Description

A palindromic number reads the same both forward and also backward.

One such palindromic number is 9009 which is the largest palindrome made by multiplying two 2-digit numbers, 91 * 99

We need to find the largest Palindrome that can be made by multiplying two 3-digit numbers

Approach

The smallest 3-digit number is 100 and the largest is 999. Since we need the largest palindrome, we approach this from the largest to the smallest, 999 -> 100.

Two reversed for loops starting from 999 for each number, eg: 99 * 99, 99 * 98, 99 * 97 etc

To check if the product is Palindrome,

• convert the number to string,

• then split it into an array,

• reverse the array &

• join the items to get the reversed number in string format.

• Now convert the reversed number to a number format and compare with the original number.

• If both are equal, then it is a palindrome.

Solution

const checkPalindrome = (number) => {
    let reverse = String(number)
        .split('')
        .reverse()
        .join('');
      return Number(reverse) === number;
}

const retLargestPalindrome = () => {
    let maxVal = 0;

    for (let i = 999; i >= 100; i--) {
        for (let j = 999; j >= 100; j--) {
            let prod = i * j;
            if (checkPalindrome(prod)) {
                if (prod > maxVal) maxVal = prod;
                // Can also use maxVal = Math.max(maxVal, prod);
                break;
            }
        }
    }
    return maxVal;
}

console.log(retLargestPalindrome());

My Solution is found in 04

If you have another or a better solution, please leave it in the comments below.

For the other Project Euler Solutions, please follow the series Project Euler Solutions in JS.

Thank you!

The prime factors of 13195 are 5, 7, 13 and 29.

What is the largest prime factor of the number 600851475143?

Problem Description

If any given number, N is divisible by x without leaving a reminder, then x is a Factor of the Number N.

Similarly, a Prime Number is a number that is divisible by 1 and itself. In other words, it has only 2 factors - 1 and itself.

Well, 10 is not a prime number as it has other factors like 2 and 5. And 2 is the only even prime number we have and all the other prime numbers are odd. 1 is neither a prime nor composite number.

So, in our problem, we need to find the Largest Factor of a given number which is also a prime.

Given 13195, the prime factors are 5, 7, 13 and 29. Here 29 is our largest prime factor.

We need to find the Largest prime factor for 600851475143.

Approach

The approach here is to factorize the given number with a divisor starting from 2 and update the max with the divisor.

Here is how it is approached,

• Step: 1 - Initialise max to the lowest number possible. max = 0

• Step-2 - While the number n is divisible by 2, then assign max = 2 and divide n by 2. Continue this while loop till the number n is divisible by 2. In this step, we remove all possible even factors.

• Step-3 - Once the while loop(in step-2) finishes, n will be odd. Now while n is divisible by 3, then assign max = 3 and divide n by 3. Continue this while loop till the number n is divisible by 3. In this step, we remove all possible 3 factors

• Step-4 - We loop over all the possible odd factors and update the max to the largest prime factor. Now start a loop from i = 5 to the square root of n.

  • Step-4a - While i divides n, assign max = i, and divide n by i. After i fails to divide n, end this while

  • Step-4b: While i + 2 divides n, assign max = i + 2, and divide n by i + 2. After i + 2 fails to divide n, end this while

  • After both while, increment i by 6 and continue. In this way, we will iterate only for integers that do not have prime factors 2 and 3

• Check if n greater than 4. If so, then that would be the largest prime number factor or else max will be the largest prime factor.

Solution

function largestPrimeFact(n) {
    let max = 0;

   while(n % 2 == 0) {
        n /= 2; // Equivalent to n = n/2 OR n >>= 1(Right shift assignment)
        max = 2;
    }

    while(n % 3 == 0) {
        n /= 3; // Equivalent to n = n/3
        max = 3;
    }

    for (let i = 5; i <= Math.sqrt(n); i += 6) {
        while (n % i == 0) {
            max = i;
            n /= i; // Equivalent to n = n/i
        }

        while (n % (i + 2) == 0) {
            maxPrime = i + 2;
            n = n / (i + 2);
        }
    }

    return n > 4 ? n : max;
}
console.time("L2");
console.log(largestPrimeFact(600851475143)); // 6857
console.timeEnd("L2"); // L2: 0.155029296875 ms

I have another approach here on GitHub, using a straightforward while loop solution and it throws a timeout error for a very big number on HackerRank. You can find the code here 03.

If you have another or a better solution, please leave it in the comments below.

For the other Project Euler Solutions, please follow the series Project Euler Solutions in JS.

Thank you!

Note:

1. Right Shift Assignment (>>=).

2. I have created a sheet with the iterations for both approaches here.

Each new term in the Fibonacci sequence is generated by adding the previous two terms. By starting with 1 and 2, the first 10 terms will be:

1, 2, 3, 5, 8, 13, 21, 34, 55, 89, ...

By considering the terms in the Fibonacci sequence whose values do not exceed four million, find the sum of the even-valued terms.

Problem Description

A Fibonacci Sequence is a series in which each number is the sum of the two preceding ones.

The sequence commonly starts from 0 and 1, although some authors start the sequence from 1 and 1 or sometimes (as did Fibonacci) from 1 and 2. Starting from 0 and 1, the first few values in the sequence are

0, 1, 1, 2, 3, 5, 8, 13, 21, 34, 55, 89, 144

In our problem, it is stated that the sequence starts with 1 and 2. And the first 10 terms would be, 1, 2, 3, 5, 8, 13, 21, 34, 55, 89.

We want to find the Fibonacci sequence within 4 million and then find the sum of all the even numbers in that sequence.

Approach

This problem can be approached using a while loop and solved using the mathematical formula,

We need to find the Fibonacci Sequence that starts with 1 and 2, within 4 million. And our sequence looks like this, 1, 2, 3, 5, 8, 13, 21, 34, 55, 89, 144, 233, ... < 4000000

Now, add the even numbers in the sequence, 2 + 8 + 34 + 144 + ... which will be our result.

Solution

let fn_1 = 1, // first
    fn_2 = 2, // second
    sum = 0;

while (fn_1 < 4000000) {
    if (fn_1 % 2 === 0) sum += fn_1; 

    let fn = fn_1 + fn_2; 
    [fn_1, fn_2] = [fn_2, fn];
}
console.time('p#2');
console.log(sum);
console.timeEnd('p#2');

The GitHub repo for this problem is found at 02

If you have another or a better solution, please leave it in the comments below.

For the other Project Euler Solutions, please follow the series Project Euler Solutions in JS.

Thank you!

If we list all the natural numbers below 10 that are multiples of 3 or 5, we get 3, 5, 6 and 9. The sum of these multiples is 23.

Find the sum of all the multiples of 3 or 5 below 1000.

Problem Description

This is a more straightforward problem.

The natural numbers below 10 would be 1,2,3,4,5,6,7,8 and 9 (Since it is below 10, 10 is exclusive)

And those multiples of 3 are 3, 6 and 9

And multiples of 5 would be 5.

So now, the sum of all those multiples would be,

3 + 6 + 9 + 5 = 23.

So now, we want to find the sum of all the multiples of 3 and 5 below 1000 (1000 is exclusive)

Approach

My approach is to get all the multiples of 3 or 5 in an array - multiples and then use Array.prototype.reduce() function to calculate the sum of all items in that array multiples

For my solution, the time taken is between 0.11ms and 0.14ms.

Another approach can be to add the multiples directly to a variable, instead of pushing to an array. Inside the if, we can use sum += i and print the sum which is our result.

As I said before, there is more than one approach to each problem!

Solution

const multiples = [];

for (let i = 1; i < 1000; i++) {
    if (i % 3 === 0 || i % 5 === 0) {
        multiples.push(i);
    }
}

console.time("p#1");
console.log(multiples.reduce((acc, curVal) => acc + curVal));
console.timeEnd("p#1");

The GitHub repo for this problem is found at 01

If you have another solution, please leave it in the comments below.

For the other Project Euler Solutions, please follow the series Project Euler Solutions in JS.

Thank you!

The 'Project Euler' is a series of challenges that will need more than mathematical insights to solve. It helps in improving problem-solving and programming skills.

We can use any programming language to solve problems. In a way, it improves our data structure skills.

Usually, I try to solve the original project euler version of the problem. Then move on to the modified version of it in Hackerrank.

Hackerrank offers a heavily modified version of the problem with more test cases. It also has time and space constraints. So your code should be efficient to pass all the test cases. Most of the time, the brute force approach will time out in hackerrank.

Remember, there is no best solution for any problem.

Some problems involve many ways of solving them. I will be using Javascript to solve the problems.

If you guys find a better solution, please add it to the comment.

I have added all the solutions to GitHub. You can find the repository project-euler-solutions-javascript.

Note:

• Please note that the solution provided is only for learning purposes. Once you understand the problem, please try it on your own before referring to the solutions.

• I am a software engineer and have limited knowledge of mathematics. So while solving some problems, I would refer and link to math-related forums to understand the formula used.