Merge pull request dubesar#4 from dubesar/master

update

Author: kunal299

.idea/misc.xml

@@ -0,0 +1,31 @@
+/**
+ * Fibonacci series in Java
+ * Program that prints the first N numbers of the Fibonacci series
+ * The first number in the series is 1, the second number is 1, and each of the
+ * following is the sum of the previous two
+ * 
+ * @author IryaDev
+ */
+
+import java.util.*;
+public class Fibonacci{
+
+    public static void main(String[] args){
+        Scanner sc = new Scanner(System.in);
+        long number,fib_1 = 1,fib_2 = 1,i;
+  
+        do{
+            System.out.print("Enter a number greater than one: ");
+            number = sc.nextInt();
+        }while(number<=1);
+        System.out.println("The first " + number + " terms of the Fibonacci series are:");                 
+        System.out.print(fib_1 + " ");
+        
+        for(i=2;i<=number;i++){
+            System.out.print(fib_2 + " ");         
+            fib_2 = fib_1 + fib_2;
+            fib_1 = fib_2 - fib_1;
+        }
+        System.out.println();
+    }
+}

Algorithms/Fibonacci.java

@@ -0,0 +1,39 @@
+import java.util.Arrays;
+
+public class FloydWarshall {
+    static final int INF = 10000;
+
+    public static int[][] solve(int graph[][]) {
+        int result[][] = new int[graph.length][graph.length];
+
+        for (int i = 0; i < graph.length; i++)
+        for (int j = 0; j < graph.length; j++)
+        result[i][j] = graph[i][j];
+
+        for (int k = 0; k < graph.length; k++)
+        {
+            for (int i = 0; i < graph.length; i++)
+            {
+                for (int j = 0; j < graph.length; j++)
+                {
+                    result[i][j] = Math.min(result[i][j], result[i][k] + result[k][j]);
+                }
+            }
+        }
+
+        return result;
+    }
+
+    public static void main(String args[])
+    {
+        int graph[][] =
+            {{0, 3, INF, INF, 2},
+            {INF, 0, 3, INF, 4},
+            {1, INF, 0, 1, 3},
+            {INF, 2, INF, 0, INF},
+            {4, 5, INF, INF, 0}};
+
+        int result[][] = solve(graph);
+        System.out.println(Arrays.deepToString(result));
+    }
+}

Algorithms/FloydWarshall.java

@@ -0,0 +1,114 @@
+import java.util.Scanner;
+
+public class mainclass {
+    //got this convert to fraction from stack overflow
+    static private String convertDecimalToFraction(double x){
+        if (x < 0){
+            return "-" + convertDecimalToFraction(-x);
+        }
+        double tolerance = 1.0E-6;
+        double h1=1; double h2=0;
+        double k1=0; double k2=1;
+        double b = x;
+        do {
+            double a = Math.floor(b);
+            double aux = h1; h1 = a*h1+h2; h2 = aux;
+            aux = k1; k1 = a*k1+k2; k2 = aux;
+            b = 1/(b-a);
+        } while (Math.abs(x-h1/k1) > x*tolerance);
+        if (k1==1)
+            return ""+h1;
+        else
+            return h1+"/"+k1;
+    }
+    private static void  displayMat(float[][] matrixdisp)
+    {
+        for (int i=0;i<3;i++)
+        {
+            for (int j=0;j<4;j++)
+            {
+                System.out.print(convertDecimalToFraction(matrixdisp[i][j])+ "   ");
+
+            }
+            System.out.println();
+        }
+        System.out.println("***********************************************************");
+    }
+    private static void pivot(float[][] piviotmat, int x, int y)
+    {
+        float value= piviotmat[x][y];
+        float z=1/value;// value to piviot
+        System.out.println("piviting  row "+ x+ "by multiplying "+convertDecimalToFraction(z));
+        for (int k=0;k<4;k++) {
+
+            piviotmat[x][k] = piviotmat[x][k]  * z;//here we multiply the pivit
+        }
+        displayMat(piviotmat);
+        float multiplier;
+        for (int l=0;l<3;l++)
+        {
+            if (l!=y) {
+                multiplier = piviotmat[l][y];//value to multiply to piviot
+                System.out.println("multiplying  row "+ x+ "by  "+convertDecimalToFraction(multiplier));
+                for (int k = 0; k < 4; k++) {
+                    piviotmat[x][k] = piviotmat[x][k] * multiplier;//multiply pivit with row multiplier
+                }
+                displayMat(piviotmat);
+                System.out.println("substracting   row "+ l+ "from  row "+x);
+                for (int k = 0; k < 4; k++) {
+                    piviotmat[l][k] = piviotmat[l][k] - piviotmat[x][k];
+
+                }
+                displayMat(piviotmat);
+                System.out.println("restoring pivit  row "+ x+ "by dividing  "+convertDecimalToFraction(multiplier));
+                for (int k = 0; k < 4; k++) {
+                    piviotmat[x][k] = piviotmat[x][k] /multiplier;//restore the multipied pivit matrix
+                }
+                displayMat(piviotmat);
+            }
+
+        }
+
+    }
+    public static void main(String[] args) {
+        float[][] matrix;
+        matrix = new float[3][4];
+        for (int i=0;i<3;i++)
+        {
+            for (int j=0;j<4;j++)
+            {
+                System.out.println("enter the values : ");
+                Scanner sc= new Scanner(System.in);
+                float value=   sc.nextFloat();
+                matrix[i][j]=value;// checking matrix
+
+            }
+        }
+        displayMat(matrix);
+        for (int i=0;i<3;i++)
+        {
+            for (int j=0;j<4;j++)
+            {
+                if (i==j&&matrix[i][j]!=1)
+                {
+                    pivot(matrix, i, j);
+
+                }
+            }
+        }
+        for (int m=0;m<3;m++)
+        {
+            switch (m)
+            {
+                case 0:  System.out.println("value of x is "+ convertDecimalToFraction(matrix[0][3]));
+                         break;
+                case 1:  System.out.println("value of y is "+ convertDecimalToFraction(matrix[1][3]));
+                    break;
+                case 2:  System.out.println("value of z is "+ convertDecimalToFraction(matrix[2][3]));
+                    break;
+            }
+        }
+    }
+}
+
+

Algorithms/GaussJordanAlgo.java

@@ -0,0 +1,21 @@
+public static int jumpSearch(int[] arrayToSearch, int element) {
+    int blockSize = (int) Math.floor(Math.sqrt(arrayToSearch.length));
+
+    int currentLastIndex = blockSize-1;
+    
+    // Jump to next block as long as target element is > currentLastIndex
+    // and the array end has not been reached
+    while (currentLastIndex < arrayToSearch.length && element > arrayToSearch[currentLastIndex]) {
+        currentLastIndex += blockSize;
+    }
+
+    // Find accurate position of target element using Linear Search
+    for (int currentSearchIndex = currentLastIndex - blockSize + 1;
+         currentSearchIndex <= currentLastIndex && currentSearchIndex < arrayToSearch.length; currentSearchIndex++) {
+        if (element == arrayToSearch[currentSearchIndex]) {
+            return currentSearchIndex;
+        }
+    }
+    // Target element not found. Return negative integer as element position.
+    return -1;
+}

Algorithms/Jump_Search.java

@@ -0,0 +1,153 @@
+import java.util.Scanner;
+ 
+
+public class Strassen
+{
+    // Function to multiply matrices
+    public int[][] multiply(int[][] A, int[][] B)
+    {        
+        int n = A.length;
+        int[][] R = new int[n][n];
+
+        /** base case **/
+        if (n == 1)
+            R[0][0] = A[0][0] * B[0][0];
+        else
+        {
+            int[][] A11 = new int[n/2][n/2];
+            int[][] A12 = new int[n/2][n/2];
+            int[][] A21 = new int[n/2][n/2];
+            int[][] A22 = new int[n/2][n/2];
+            int[][] B11 = new int[n/2][n/2];
+            int[][] B12 = new int[n/2][n/2];
+            int[][] B21 = new int[n/2][n/2];
+            int[][] B22 = new int[n/2][n/2];
+ 
+            /** Dividing matrix A into 4 halves **/
+            split(A, A11, 0 , 0);
+            split(A, A12, 0 , n/2);
+            split(A, A21, n/2, 0);
+            split(A, A22, n/2, n/2);
+
+
+            /** Dividing matrix B into 4 halves **/
+            split(B, B11, 0 , 0);
+            split(B, B12, 0 , n/2);
+            split(B, B21, n/2, 0);
+            split(B, B22, n/2, n/2);
+ 
+            /** 
+              M1 = (A11 + A22)(B11 + B22)
+              M2 = (A21 + A22) B11
+              M3 = A11 (B12 - B22)
+              M4 = A22 (B21 - B11)
+              M5 = (A11 + A12) B22
+              M6 = (A21 - A11) (B11 + B12)
+              M7 = (A12 - A22) (B21 + B22)
+            **/
+ 
+            int [][] M1 = multiply(add(A11, A22), add(B11, B22));
+            int [][] M2 = multiply(add(A21, A22), B11);
+            int [][] M3 = multiply(A11, sub(B12, B22));
+            int [][] M4 = multiply(A22, sub(B21, B11));
+            int [][] M5 = multiply(add(A11, A12), B22);
+            int [][] M6 = multiply(sub(A21, A11), add(B11, B12));
+            int [][] M7 = multiply(sub(A12, A22), add(B21, B22));
+ 
+            /**
+              C11 = M1 + M4 - M5 + M7
+              C12 = M3 + M5
+              C21 = M2 + M4
+              C22 = M1 - M2 + M3 + M6
+            **/
+
+            int [][] C11 = add(sub(add(M1, M4), M5), M7);
+            int [][] C12 = add(M3, M5);
+            int [][] C21 = add(M2, M4);
+            int [][] C22 = add(sub(add(M1, M3), M2), M6);
+ 
+            /** Joining 4 halves into one result matrix **/
+            join(C11, R, 0 , 0);
+            join(C12, R, 0 , n/2);
+            join(C21, R, n/2, 0);
+            join(C22, R, n/2, n/2);
+        }
+
+        /** Returning the resultant matrix **/    
+        return R;
+    }
+
+    /** Funtion to add two matrices **/
+    public int[][] add(int[][] A, int[][] B)
+    {
+        int n = A.length;
+        int[][] C = new int[n][n];
+        for (int i = 0; i < n; i++)
+            for (int j = 0; j < n; j++)
+                C[i][j] = A[i][j] + B[i][j];
+        return C;
+    }
+
+    /** Funtion to subtract two matrices **/
+    public int[][] sub(int[][] A, int[][] B)
+    {
+        int n = A.length;
+        int[][] C = new int[n][n];
+        for (int i = 0; i < n; i++)
+            for (int j = 0; j < n; j++)
+                C[i][j] = A[i][j] - B[i][j];
+        return C;
+    }
+
+    /** Funtion to split parent matrix into child matrices **/
+    public void split(int[][] P, int[][] C, int iB, int jB) 
+    {
+        for(int i1 = 0, i2 = iB; i1 < C.length; i1++, i2++)
+            for(int j1 = 0, j2 = jB; j1 < C.length; j1++, j2++)
+                C[i1][j1] = P[i2][j2];
+    }
+
+    /** Funtion to join child matrices intp parent matrix **/
+    public void join(int[][] C, int[][] P, int iB, int jB) 
+    {
+        for(int i1 = 0, i2 = iB; i1 < C.length; i1++, i2++)
+            for(int j1 = 0, j2 = jB; j1 < C.length; j1++, j2++)
+                P[i2][j2] = C[i1][j1];
+    }
+
+    /** Main function **/
+    public static void main (String[] args) 
+    {
+        Scanner sc = new Scanner(System.in);
+
+        /** Making an object of Strassen class **/
+        Strassen s = new Strassen();
+ 
+        System.out.println("Enter the order of matrices (n) :");
+        int N = sc.nextInt();
+
+        /** Accepting two 2d matrices **/
+        System.out.println("Enter N*N order matrix 1\n");
+        int[][] A = new int[N][N];
+        for (int i = 0; i < N; i++)
+            for (int j = 0; j < N; j++)
+                A[i][j] = sc.nextInt();
+ 
+        System.out.println("Enter N*N order matrix 2\n");
+        int[][] B = new int[N][N];
+        for (int i = 0; i < N; i++)
+            for (int j = 0; j < N; j++)
+                B[i][j] = sc.nextInt();
+ 
+        int[][] C = s.multiply(A, B);
+ 
+        System.out.println("\nProduct of matrices 1 and 2 is : ");
+        for (int i = 0; i < N; i++)
+        {
+            for (int j = 0; j < N; j++)
+                System.out.print(C[i][j] +" ");
+            System.out.println();
+        }
+ 
+    }
+}