// Javascript code to linearly search x in arr[]. 

// If x is present then return its location, 
// otherwise return -1
function linearSearch(arr, n, x) {
    let i;
    for (i = 0; i < n; i++)
        if (arr[i] == x)
            return i;
    return -1;
}

// Function to call Linear Search method
function searchInArr(arr, n, x) {

    // Function call
    let result = linearSearch(arr, n, x);
    if (result == -1)
        console.log("Element is not present in array");
    else
        console.log("Element is present at index " + result);
}

// Driver code

let arr = [10, 30, 50, 60, 70];
let n = arr.length;

let x1 = 50;
searchInArr(arr, n, x1);

let x2 = 5;
searchInArr(arr, n, x2);

// Iterative function to implement Binary Search
let iterativeFunction = function (arr, x) {

    let start=0, end=arr.length-1;
        
    // Iterate while start not meets end
    while (start<=end){

        // Find the mid index
        let mid=Math.floor((start + end)/2);

        // If element is present at mid, return True
        if (arr[mid]===x) return true;

        // Else look in left or right half accordingly
        else if (arr[mid] < x)
            start = mid + 1;
        else
            end = mid - 1;
    }

    return false;
}

// Driver code
let arr = [1, 3, 5, 7, 8, 9];
let x = 5;

if (iterativeFunction(arr, x, 0, arr.length-1))
    console.log("Element found!");
else console.log("Element not found!");

x = 6;

if (iterativeFunction(arr, x, 0, arr.length-1))
    console.log("Element found!");
else console.log("Element not found!");

function swap(arr, xp, yp)
{
    var temp = arr[xp];
    arr[xp] = arr[yp];
    arr[yp] = temp;
}

// An optimized version of Bubble Sort
function bubbleSort( arr, n)
{
var i, j;
for (i = 0; i < n-1; i++)
{
    for (j = 0; j < n-i-1; j++)
    {
        if (arr[j] > arr[j+1])
        {
        swap(arr,j,j+1);
        
        }
    }

}
}

/* Function to print an array */
function printArray(arr, size)
{
    var i;
    for (i=0; i < size; i++)
        console.log(arr[i]+ " ");

}

// Driver program to test above functions
var arr = [5, 1, 4, 2, 8];
    var n = 5;
    console.log("UnSorted array:");
    printArray(arr, n);

    bubbleSort(arr, n);
    console.log("Sorted array: ");
    printArray(arr, n);

// Javascript program for insertion sort

// Function to sort an array using insertion sort
function insertionSort(arr, n)
{
    let i, key, j;
    for (i = 1; i < n; i++)
    {
        key = arr[i];
        j = i - 1;

        /* Move elements of arr[0..i-1], that are
        greater than key, to one position ahead
        of their current position */
        while (j >= 0 && arr[j] > key)
        {
            arr[j + 1] = arr[j];
            j = j - 1;
        }
        arr[j + 1] = key;
    }
}

// A utility function to print an array of size n
function printArray(arr, n)
{
    let i;
    for (i = 0; i < n; i++)
        console.log(arr[i] + " ");
    
}

// Driver code
    let arr = [12, 11, 13, 5, 6 ];
    let n = arr.length;
    console.log("Elements before sorting:")
    printArray(arr, n);
    insertionSort(arr, n);
    console.log("Elements after sorting:")
    printArray(arr, n);

// Javascript program for implementation of selection sort
function swap(arr,xp, yp)
{
    var temp = arr[xp];
    arr[xp] = arr[yp];
    arr[yp] = temp;
}

function selectionSort(arr, n)
{
    var i, j, min_idx;

    // One by one move boundary of unsorted subarray
    for (i = 0; i < n-1; i++)
    {
        // Find the minimum element in unsorted array
        min_idx = i;
        for (j = i + 1; j < n; j++)
        if (arr[j] < arr[min_idx])
            min_idx = j;

        // Swap the found minimum element with the first element
        swap(arr,min_idx, i);
    }
}

function printArray( arr, size)
{
    var i;
    for (i = 0; i < size; i++)
        console.log(arr[i] + " ");
}

var arr = [64, 25, 12, 22, 11];
var n = 5;
console.log("UnSorted array: ");
printArray(arr, n);    
selectionSort(arr, n);
console.log("Sorted array:");
printArray(arr, n);

// javascript recursive function to
// solve tower of hanoi puzzle
function towerOfHanoi(n, from_rod, to_rod, aux_rod)
{
        if (n == 0)
        {
            return;
        }
        towerOfHanoi(n - 1, from_rod, aux_rod, to_rod);
        console.log("Move disk " + n + " from rod " + from_rod +
        " to rod " + to_rod);
        towerOfHanoi(n - 1, aux_rod, to_rod, from_rod);
    }

    // Driver code
    var N = 3;
    
    // A, B and C are names of rods
    towerOfHanoi(N, 'A', 'C', 'B');

// This code is contributed by gauravrajput1

// JavaScript program to print DFS
    // traversal from a given
    // graph

    // This class represents a
    // directed graph using adjacency
    // list representation
    class Graph
    {
    
        // Constructor
        constructor(v) {
        this.V = v;
        this.adj = new Array(v).fill([]);
        }

        // Function to Add an edge into the graph
        AddEdge(v, w) {
        this.adj[v].push(w); // Add w to v's list.
        }

        // A function used by DFS
        DFSUtil(v, visited)
        {
        
        // Mark the current
        // node as visited and print it
        visited[v] = true;
        console.log(v + " ");

        // Recur for all the
        // vertices adjacent to this
        // vertex
        for (const n of this.adj[v]) {
            if (!visited[n]) this.DFSUtil(n, visited);
        }
        }

        // The function to do
        // DFS traversal. It uses recursive
        // DFSUtil()
        DFS()
        {
        
        // Mark all the vertices as not visited(set as
        var visited = new Array(this.V).fill(false);

        // Call the recursive helper
        // function to print DFS
        // traversal starting from
        // all vertices one by one
        for (var i = 0; i < this.V; ++i)
            if (visited[i] == false) this.DFSUtil(i, visited);
        }
    }
    
    // Driver Code
    var g = new Graph(4);

    g.AddEdge(0, 1);
    g.AddEdge(0, 2);
    g.AddEdge(1, 2);
    g.AddEdge(2, 0);
    g.AddEdge(2, 3);
    g.AddEdge(3, 3);

    console.log("Following is Depth First Traversal<br>");

    g.DFS();
    
    // This code is contributed by rdtank.

//Fibonacci Series using Recursion
    let n = 9;
    
    // function returns the Fibonacci number
    function fib(n) {
    if (n <= 1)
        return n;
    return fib(n-1) + fib(n-2);
}

    //function call
    console.log(fib(n));
//This code is contributed by Surbhi Tyagi

// Javascript program for above approach

// N is the size of the 2D matrix N*N
let N = 9;

/* Takes a partially filled-in grid and attempts
    to assign values to all unassigned locations in
    such a way to meet the requirements for
    Sudoku solution (non-duplication across rows,
    columns, and boxes) */
function solveSudoku(grid, row, col)
{
    
    /* If we have reached the 8th
    row and 9th column (0
    indexed matrix) ,
    we are returning true to avoid further
    backtracking     */
    if (row == N - 1 && col == N)
        return true;

    // Check if column value becomes 9 ,
    // we move to next row
    // and column start from 0
    if (col == N)
    {
        row++;
        col = 0;
    }

    // Check if the current position
    // of the grid already
    // contains value >0, we iterate
    // for next column
    if (grid[row][col] != 0)
        return solveSudoku(grid, row, col + 1);

    for(let num = 1; num < 10; num++)
    {
        
        // Check if it is safe to place
        // the num (1-9) in the given
        // row ,col ->we move to next column
        if (isSafe(grid, row, col, num))
        {
            
            /* assigning the num in the current
            (row,col) position of the grid and
            assuming our assigned num in the position
            is correct */
            grid[row][col] = num;

            // Checking for next
            // possibility with next column
            if (solveSudoku(grid, row, col + 1))
                return true;
        }
        
        /* removing the assigned num , since our
        assumption was wrong , and we go for next
        assumption with diff num value */
        grid[row][col] = 0;
    }
    return false;
}

/* A utility function to print grid */

// Check whether it will be legal
// to assign num to the
// given row, col
function isSafe(grid, row, col, num)
{
    
    // Check if we find the same num
    // in the similar row , we
    // return false
    for(let x = 0; x <= 8; x++)
        if (grid[row][x] == num)
            return false;

    // Check if we find the same num
    // in the similar column ,
    // we return false
    for(let x = 0; x <= 8; x++)
        if (grid[x][col] == num)
            return false;

    // Check if we find the same num
    // in the particular 3*3
    // matrix, we return false
    let startRow = row - row % 3,
        startCol = col - col % 3;
        
    for(let i = 0; i < 3; i++)
        for(let j = 0; j < 3; j++)
            if (grid[i + startRow][j + startCol] == num)
                return false;

    return true;
}

// Driver Code
let grid = [ [ 3, 0, 6, 5, 0, 8, 4, 0, 0 ],
            [ 5, 2, 0, 0, 0, 0, 0, 0, 0 ],
            [ 0, 8, 7, 0, 0, 0, 0, 3, 1 ],
            [ 0, 0, 3, 0, 1, 0, 0, 8, 0 ],
            [ 9, 0, 0, 8, 6, 3, 0, 0, 5 ],
            [ 0, 5, 0, 0, 9, 0, 6, 0, 0 ],
            [ 1, 3, 0, 0, 0, 0, 2, 5, 0 ],
            [ 0, 0, 0, 0, 0, 0, 0, 7, 4 ],
            [ 0, 0, 5, 2, 0, 6, 3, 0, 0 ] ];

if (solveSudoku(grid, 0, 0))
    console.log(grid);
else
    console.log("no solution exists ");

// This code is contributed by rag2127

// Number of vertices in the graph
    let V = 4;
    
    /* A utility function to print solution */
    function printSolution(color)
    {
        console.log("Solution Exists:" +
    " Following are the assigned colors ");
        for (let i = 0; i < V; i++)
            console.log("  " + color[i]);
        console.log(" ");
    }
    
    // check if the colored
// graph is safe or not
    function isSafe(graph,color)
    {
        // check for every edge
    for (let i = 0; i < V; i++)
    for (let j = i + 1; j < V; j++)
        if (graph[i][j] && color[j] == color[i])
        return false;
    return true;
    }
    
    
/* This function solves the m Coloring
    problem using recursion. It returns
    false if the m colours cannot be assigned,
    otherwise, return true and prints
    assignments of colours to all vertices.
    Please note that there may be more than
    one solutions, this function prints one
    of the feasible solutions.*/
    function graphColoring(graph,m,i,color)
    {
        // if current index reached end
    if (i == V) {

    // if coloring is safe
    if (isSafe(graph, color))
    {

        // Print the solution
        printSolution(color);
        return true;
    }
    return false;
    }

    // Assign each color from 1 to m
    for (let j = 1; j <= m; j++)
    {
    color[i] = j;

    // Recur of the rest vertices
    if (graphColoring(graph, m, i + 1, color))
        return true;
    color[i] = 0;
    }
    return false;
    }
    
    // Driver code
    
    /* Create following graph and
        test whether it is 3 colorable
        (3)---(2)
        | / |
        | / |
        | / |
        (0)---(1)
        */
    let graph=[[ false, true, true, true],
            [ true, false, true, false ],
            [ true, true, false, true ],
            [true, false, true, false]];
    
    let m = 3; // Number of colors
    
    // Initialize all color values as 0.
    // This initialization is needed
    // correct functioning of isSafe()
    let color = new Array(V);
    for (let i = 0; i < V; i++)
    color[i] = 0;
    
    if (!graphColoring(graph, m, 0, color))
    console.log("Solution does not exist");
    
    
    // This code is contributed by unknown2108

// JavaScript program to solve N Queen
// Problem using backtracking
const N = 4

function printSolution(board)
{
    for(let i = 0; i < N; i++)
    {
        for(let j = 0; j < N; j++)
        {
            if(board[i][j] == 1)
                console.log("Q ")
            else
                console.log(". ")
        }
        
    }
}

// A utility function to check if a queen can
// be placed on board[row][col]. Note that this
// function is called when "col" queens are
// already placed in columns from 0 to col -1.
// So we need to check only left side for
// attacking queens
function isSafe(board, row, col)
{

    // Check this row on left side
    for(let i = 0; i < col; i++){
        if(board[row][i] == 1)
            return false
    }

    // Check upper diagonal on left side
    for (i = row, j = col; i >= 0 && j >= 0; i--, j--)
        if (board[i][j])
            return false

    // Check lower diagonal on left side
    for (i = row, j = col; j >= 0 && i < N; i++, j--)
        if (board[i][j])
            return false

    return true
}

function solveNQUtil(board, col){
    
    // base case: If all queens are placed
    // then return true
    if(col >= N)
        return true

    // Consider this column and try placing
    // this queen in all rows one by one
    for(let i=0;i<N;i++){

        if(isSafe(board, i, col)==true){
            
            // Place this queen in board[i][col]
            board[i][col] = 1

            // recur to place rest of the queens
            if(solveNQUtil(board, col + 1) == true)
                return true

            // If placing queen in board[i][col
            // doesn't lead to a solution, then
            // queen from board[i][col]
            board[i][col] = 0
        }
    }
    // if the queen can not be placed in any row in
    // this column col then return false
    return false
}

// This function solves the N Queen problem using
// Backtracking. It mainly uses solveNQUtil() to
// solve the problem. It returns false if queens
// cannot be placed, otherwise return true and
// placement of queens in the form of 1s.
// note that there may be more than one
// solutions, this function prints one of the
// feasible solutions.
function solveNQ(){
    let board = [ [0, 0, 0, 0],
            [0, 0, 0, 0],
            [0, 0, 0, 0],
            [0, 0, 0, 0] ]

    if(solveNQUtil(board, 0) == false){
        console.log("Solution does not exist")
        return false
    }

    printSolution(board)
    return true
}

// Driver Code
solveNQ()

// This code is contributed by shinjanpatra

// Javascript Program for nth
// Catalan Number

// A recursive function to
// find nth catalan number
function catalan(n)
{
    
    // Base case
    if (n <= 1)
        return 1;

    // catalan(n) is sum of
    // catalan(i)*catalan(n-i-1)
    let res = 0;
    for(let i = 0; i < n; i++)
        res += catalan(i) *
                catalan(n - i - 1);

    return res;
}

// Driver Code
for (let i = 0; i < 10; i++)
    console.log(catalan(i) + " ");

// This code is contributed _saurabh_jaiswal

// A Dynamic Programming based
// solution that uses table C to
// calculate the Binomial Coefficient

// Returns value of Binomial
// Coefficient C(n, k)
function binomialCoeff(n, k)
{
    var C = Array(n + 1).fill(0).map(
    x => Array(k + 1).fill(0));;
    var i, j;

    // Calculate value of Binomial
    // Coefficient in bottom up manner
    for(i = 0; i <= n; i++)
    {
        for(j = 0; j <= min(i, k); j++)
        {
            
            // Base Cases
            if (j == 0 || j == i)
                C[i][j] = 1;

            // Calculate value using
            // previously stored values
            else
                C[i][j] = C[i - 1][j - 1] +
                        C[i - 1][j];
        }
    }
    return C[n][k];
}

// A utility function to return
// minimum of two integers
function min(a, b)
{
    return (a < b) ? a : b;
}

// Driver code
var n = 5, k = 2;
console.log("Value of C(" + n + "," + k +
                    ") is " + binomialCoeff(n, k));

// This code is contributed by 29AjayKumar