diff --git a/1.1.exe b/1.1.exe new file mode 100644 index 0000000..52155d5 Binary files /dev/null and b/1.1.exe differ diff --git a/1.PreOrder - Using Stack.txt b/1.PreOrder - Using Stack.txt new file mode 100644 index 0000000..8b88bba --- /dev/null +++ b/1.PreOrder - Using Stack.txt @@ -0,0 +1,69 @@ +/** + * Definition for a binary tree node. + * struct TreeNode { + * int val; + * TreeNode *left; + * TreeNode *right; + * TreeNode() : val(0), left(nullptr), right(nullptr) {} + * TreeNode(int x) : val(x), left(nullptr), right(nullptr) {} + * TreeNode(int x, TreeNode *left, TreeNode *right) : val(x), left(left), right(right) {} + * }; + */ +class Solution { +public: + void preorder(TreeNode* root,vector &ans) + { + if(root==NULL) + { + return; + } + else + { + ans.push_back(root->val); + preorder(root->left,ans); + preorder(root->right,ans); + } + } +public: + vector preorderTraversal(TreeNode* root) { + vector ans; + preorder(root,ans); + return ans; + } +}; + + + + +Using stack + +class Solution { +public: + vector preorderTraversal(TreeNode* root) { + vector ans; + if(root==NULL) + { + return ans; + } + else + { + stack st; + st.push(root); + while(!st.empty()) + { + TreeNode* node = st.top(); + st.pop(); + if(node->right!=NULL) + { + st.push(node->right); + } + if(node->left!=NULL) + { + st.push(node->left); + } + ans.push_back(node->val); + } + return ans; + } + } +}; \ No newline at end of file diff --git a/16649524524186456099865449383486.jpg b/16649524524186456099865449383486.jpg new file mode 100644 index 0000000..cc6e70b Binary files /dev/null and b/16649524524186456099865449383486.jpg differ diff --git a/2.PostOrder - Using Stack.txt b/2.PostOrder - Using Stack.txt new file mode 100644 index 0000000..d08ac80 --- /dev/null +++ b/2.PostOrder - Using Stack.txt @@ -0,0 +1,87 @@ +/** + * Definition for a binary tree node. + * struct TreeNode { + * int val; + * TreeNode *left; + * TreeNode *right; + * TreeNode() : val(0), left(nullptr), right(nullptr) {} + * TreeNode(int x) : val(x), left(nullptr), right(nullptr) {} + * TreeNode(int x, TreeNode *left, TreeNode *right) : val(x), left(left), right(right) {} + * }; + */ +class Solution { + public: + void postorder(TreeNode* root,vector &ans) + { + if(root==NULL) + { + return; + } + else + { + postorder(root->left,ans); + postorder(root->right,ans); + ans.push_back(root->val); + } + } +public: + vector postorderTraversal(TreeNode* root) { + vector ans; + postorder(root,ans); + return ans; + } +}; + + + + +class Solution { +public: + vector postorderTraversal(TreeNode* root) { + vector ans; + if(root==NULL) + { + return ans; + } + else if(root->left==NULL&root->right==NULL) + { + ans.push_back(root->val); + return ans; + } + else + { + stack st; + TreeNode* curr = root; + TreeNode* temp; + while(curr!=NULL||!st.empty()) + { + if(curr!=NULL) + { + st.push(curr); + curr=curr->left; + } + else + { + temp = st.top()->right; + if(temp==NULL) + { + temp = st.top(); + st.pop(); + ans.push_back(temp->val); + while(!st.empty()&&temp==st.top()->right) + { + temp = st.top(); + st.pop(); + ans.push_back(temp->val); + } + } + else + { + curr = temp; + } + } + } + return ans; + } + } +}; \ No newline at end of file diff --git a/3.InOrder Using Stack.txt b/3.InOrder Using Stack.txt new file mode 100644 index 0000000..8708244 --- /dev/null +++ b/3.InOrder Using Stack.txt @@ -0,0 +1,82 @@ + +/** + * Definition for a binary tree node. + * struct TreeNode { + * int val; + * TreeNode *left; + * TreeNode *right; + * TreeNode() : val(0), left(nullptr), right(nullptr) {} + * TreeNode(int x) : val(x), left(nullptr), right(nullptr) {} + * TreeNode(int x, TreeNode *left, TreeNode *right) : val(x), left(left), right(right) {} + * }; + */ +class Solution { + public: + void inorder(TreeNode* root,vector &ans) + { + if(root==NULL) + { + return; + } + else + { + inorder(root->left,ans); + ans.push_back(root->val); + inorder(root->right,ans); + } + } +public: + vector inorderTraversal(TreeNode* root) { + vector ans; + inorder(root,ans); + return ans; + } +}; + + + + + +class Solution { +public: + vector inorderTraversal(TreeNode* root) { + vector ans; + if(!root) + { + return ans; + } + else if(root->left==NULL&&root->right==NULL) + { + ans.push_back(root->val); + return ans; + } + else + { + stack st; + TreeNode* node = root; + while(true) + { + if(node!=NULL) + { + st.push(node); + node=node->left; + } + else + { + if(st.empty()) + { + break; + } + else + { + node=st.top(); + ans.push_back(node->val); + st.pop(); + node = node->right; + } + } + } + return ans; + } + } +}; \ No newline at end of file diff --git a/31aug6.cpp b/31aug6.cpp new file mode 100644 index 0000000..eb35f71 --- /dev/null +++ b/31aug6.cpp @@ -0,0 +1,36 @@ +// Code to understand the working of the copy constructor. +#include +using namespace std; +class person +{ +private: + string name; + int age; + +public: + person(string person_name, int person_age) + { + cout << "Constructor for both name and age is called" << endl; + name = person_name; + age = person_age; + } + person(const person &obj) + { + cout << "Copy constructor is called" << endl; + name = obj.name; + age = obj.age; + } + void display() + { + cout << "Name of current object : " << name << endl; + cout << "Age of current object : " << age << endl; + cout << endl; + } +}; +int main() +{ + person obj1("First person", 25); + obj1.display(); + person obj2(obj1); + obj2.display(); +}; diff --git a/AES_algo.java b/AES_algo.java new file mode 100644 index 0000000..cb20a56 --- /dev/null +++ b/AES_algo.java @@ -0,0 +1,219 @@ +public class AES { + private static final byte[] sBox = new byte[] { + 0x63, 0x7c, 0x77, 0x7b, -0x0e, 0x6b, 0x6f, -0x3b, 0x30, 0x01, 0x67, 0x2b, -0x02, -0x29, -0x55, 0x76, + -0x36, -0x7e, -0x37, 0x7d, -0x06, 0x59, 0x47, -0x10, -0x53, -0x2c, -0x5e, -0x51, -0x64, -0x5c, 0x72, -0x40, + -0x49, -0x03, -0x6d, 0x26, 0x36, 0x3f, -0x09, -0x34, 0x34, -0x5b, -0x1b, -0x0f, 0x71, -0x28, 0x31, 0x15, + 0x04, -0x39, 0x23, -0x3d, 0x18, -0x6a, 0x05, -0x66, 0x07, 0x12, -0x80, -0x1e, -0x15, 0x27, -0x4e, 0x75, + 0x09, -0x7d, 0x2c, 0x1a, 0x1b, 0x6e, 0x5a, -0x60, 0x52, 0x3b, -0x2a, -0x4d, 0x29, -0x1d, 0x2f, -0x7c, + 0x53, -0x2f, 0x00, -0x13, 0x20, -0x04, -0x4f, 0x5b, 0x6a, -0x35, -0x42, 0x39, 0x4a, 0x4c, 0x58, -0x31, + -0x30, -0x11, -0x56, -0x05, 0x43, 0x4d, 0x33, -0x7b, 0x45, -0x07, 0x02, 0x7f, 0x50, 0x3c, -0x61, -0x58, + 0x51, -0x5d, 0x40, -0x71, -0x6e, -0x63, 0x38, -0x0b, -0x44, -0x4a, -0x26, 0x21, 0x10, -0x01, -0x0d, -0x2e, + -0x33, 0x0c, 0x13, -0x14, 0x5f, -0x69, 0x44, 0x17, -0x3c, -0x59, 0x7e, 0x3d, 0x64, 0x5d, 0x19, 0x73, + 0x60, -0x7f, 0x4f, -0x24, 0x22, 0x2a, -0x70, -0x78, 0x46, -0x12, -0x48, 0x14, -0x22, 0x5e, 0x0b, -0x25, + -0x20, 0x32, 0x3a, 0x0a, 0x49, 0x06, 0x24, 0x5c, -0x3e, -0x2d, -0x54, 0x62, -0x6f, -0x6b, -0x1c, 0x79, + -0x19, -0x38, 0x37, 0x6d, -0x73, -0x2b, 0x4e, -0x57, 0x6c, 0x56, -0x0c, -0x16, 0x65, 0x7a, -0x52, 0x08, + -0x46, 0x78, 0x25, 0x2e, 0x1c, -0x5a, -0x4c, -0x3a, -0x18, -0x23, 0x74, 0x1f, 0x4b, -0x43, -0x75, -0x76, + 0x70, 0x3e, -0x4b, 0x66, 0x48, 0x03, -0x0a, 0x0e, 0x61, 0x35, 0x57, -0x47, -0x7a, -0x3f, 0x1d, -0x62, + -0x1f, -0x08, -0x68, 0x11, 0x69, -0x27, -0x72, -0x6c, -0x65, 0x1e, -0x79, -0x17, -0x32, 0x55, 0x28, -0x21, + -0x74, -0x5f, -0x77, 0x0d, -0x41, -0x1a, 0x42, 0x68, 0x41, -0x67, 0x2d, 0x0f, -0x50, 0x54, -0x45, 0x16 + }; + private static final int NB = 4; + private static final int NK = 4; + private static final int NR = 10; + + private static final byte[] rCon = new byte[] { + 0x01, 0x02, 0x04, 0x08, 0x10, 0x20, 0x40, -0x80, 0x1b, 0x36 + }; + public byte[] key = new byte[4*NK]; + public byte[][] state = new byte[4][NB]; + public byte[][] keySchedule = new byte[NR+1][NB*4]; + + public AES(String stringKey) { + if (stringKey.length() == NK*8) { + this.key = hexStringToBytes(stringKey); + } + } + private static byte[] hexStringToBytes(String key) { + byte[] bytesKey = new byte[NK * 4]; + for (int i = 0; i < 4 * NK; i++) { + bytesKey[i] = (byte) Integer.parseInt(key.substring(2 * i, 2 * (i + 1)), 16); + } + return bytesKey; + } + public void setKey(String stringKey) { + if (stringKey.length() == NK*8) { + this.key = hexStringToBytes(stringKey); + } + } + /** + * returns string of ciphertext + * @param plainText text to encrypt + * @return ciphertext + */ + public String encrypt(String plainText) { + if (plainText.length() != 8 * NB || key.length != 4 * NK) { + return null; + } + byte[] bytePlainText = hexStringToBytes(plainText); + // place plaintext in state array + for (int r = 0; r < 4; r++) { + for (int c = 0; c < NB; c++) { + state[r][c] = bytePlainText[4 * c + r]; + } + } + keyExpansion(); + addRoundKey(0); // round 0 + for (int round = 1; round < NR; round++) { + subBytes(); + shiftRows(); + mixColumns(); + addRoundKey(round); + } + subBytes(); + shiftRows(); + addRoundKey(10); + return stateToOutput(state); + } + /** + * coverts state array to output string + * @param bytes state array + * @return bytes of state array ordered into a string + */ + private String stateToOutput(byte[][] bytes) { + StringBuilder res = new StringBuilder(); + for (int c = 0; c < NB; c++) { + for (int r = 0; r < 4; r++) { + String sB = Integer.toString(bytes[r][c] & 0xff, 16); + res.append(sB.length() == 1 ? '0' + sB : sB); + } + } + return res.toString(); + } + /** + * XORes the state with the appropriate words from the key schedule + * @param round current round to choose which word to use + */ + public void addRoundKey(int round) { + + for (int r = 0; r < 4; r++) { + for (int c = 0; c < NB; c++) { + state[r][c] ^= keySchedule[round][4 * c + r]; + } + } + } + /** + * creates key schedule for the algorithm from encryption key + */ + public void keyExpansion() { + System.arraycopy(key, 0, keySchedule[0], 0, 4*NK); // copy key into first indices of key schedule + for (int i = NK; i < NB * (NR + 1); i++) { + byte[] previousWord = new byte[4], temp; + System.arraycopy(keySchedule[(i - 1) / NK], 4 * ((i - 1) % NK), previousWord, 0, 4); + if (i % NK == 0) { + temp = subWord(rotateWord(previousWord)); + temp[0] ^= rCon[i / NK - 1]; // xor with the rConstant + } else { + temp = previousWord; + } + // copy the new word into the key schedule + for (int j = 0; j < 4; j++) { + keySchedule[i / NK][4 * (i % 4) + j] = (byte) (keySchedule[i / NK - 1][4 * (i % 4) + j] ^ temp[j]); + } + } + } + /** + * passes word through sBox for keyExpansion + * @param word word to sBox + * @return sBoxed word + */ + private static byte[] subWord(byte[] word) { + byte[] subbedWord = new byte[4]; + for (int i = 0; i < 4; i++) { + subbedWord[i] = sBox[word[i] & 0xff]; + } + return subbedWord; + } + /** + * rotates the word by one byte to the left + * @param word word to rotate + * @return rotate word + */ + public byte[] rotateWord(byte[] word) { + byte[] shiftedWord = new byte[4]; + for (int i = 0; i < 4; i++) { + shiftedWord[i] = word[(i + 1) % 4]; + } + return shiftedWord; + } + /** + * applies mixColumns operation on state array + */ + public void mixColumns() { + for (int c = 0; c < NB; c++) { + byte[] tempColumn = new byte[4]; + // first preform operation on temp array so not to overwrite the original needed values + for (int r = 0; r < 4; r++) { + tempColumn[r] = mixColumnsHelper(r, c); + } + + for (int r = 0; r < 4; r++) { + state[r][c] = tempColumn[r]; + } + } + } + /** + * returns XOR operation needed for mixColumns + * @param r row of byte + * @param c column of byte + * @return new value for byte in state array + */ + public byte mixColumnsHelper(int r, int c) { + return (byte) (multiplyBy02(state[r][c]) + ^ multiplyBy03(state[(r + 1) % 4][c]) + ^ state[(r + 2) % 4][c] + ^ state[(r + 3) % 4][c]); + } + + /** + * preforms multiplication by two in GF(2^8) + * @param val value to multiply with + * @return product + */ + public byte multiplyBy02(byte val) { + return (byte) ((val << 1) ^ ((val & 0x80) == 0x00 ? 0x00 : 0x11b)); + } + + public byte multiplyBy03(byte i) { + // 3 * z = 2 * z + 1 * z + return (byte) (multiplyBy02(i) ^ i); + } + + /** + * applies the shiftRows operation on the state array + */ + public void shiftRows() { + for (int r = 1; r < 4; r++) { + byte[] tempRow = new byte[NB]; + System.arraycopy(state[r], 0, tempRow, 0, NB); + for (int c = 0; c < NB; c++) { + state[r][c] = tempRow[(r + c) % NB]; + } + } + } + + /** + * preforms the sBox operation on the state array + */ + public void subBytes() { + for (int r = 0; r < NB; r++) { + for (int c = 0; c < NB; c++) { + state[r][c] = sBox[state[r][c] & 0xff]; + } + } + } + + public static void main(String[] args) { + AES aes = new AES("2b7e151628aed2a6abf7158809cf4f3c"); + System.out.println("Cipher Text: " + aes.encrypt("3243f6a8885a308d313198a2e0370734")); + } +} \ No newline at end of file diff --git a/ATM.java b/ATM.java new file mode 100644 index 0000000..dcfb829 --- /dev/null +++ b/ATM.java @@ -0,0 +1,75 @@ +//import required classes and packages +import java.util.Scanner; + +//create ATMExample class to implement the ATM functionality +public class ATMExample +{ + //main method starts + public static void main(String args[] ) + { + //declare and initialize balance, withdraw, and deposit + int balance = 100000, withdraw, deposit; + + //create scanner class object to get choice of user + Scanner sc = new Scanner(System.in); + + while(true) + { + System.out.println("Automated Teller Machine"); + System.out.println("Choose 1 for Withdraw"); + System.out.println("Choose 2 for Deposit"); + System.out.println("Choose 3 for Check Balance"); + System.out.println("Choose 4 for EXIT"); + System.out.print("Choose the operation you want to perform:"); + + //get choice from user + int choice = sc.nextInt(); + switch(choice) + { + case 1: + System.out.print("Enter money to be withdrawn:"); + + //get the withdrawl money from user + withdraw = sc.nextInt(); + + //check whether the balance is greater than or equal to the withdrawal amount + if(balance >= withdraw) + { + //remove the withdrawl amount from the total balance + balance = balance - withdraw; + System.out.println("Please collect your money"); + } + else + { + //show custom error message + System.out.println("Insufficient Balance"); + } + System.out.println(""); + break; + + case 2: + + System.out.print("Enter money to be deposited:"); + + //get deposite amount from te user + deposit = sc.nextInt(); + + //add the deposit amount to the total balanace + balance = balance + deposit; + System.out.println("Your Money has been successfully depsited"); + System.out.println(""); + break; + + case 3: + //displaying the total balance of the user + System.out.println("Balance : "+balance); + System.out.println(""); + break; + + case 4: + //exit from the menu + System.exit(0); + } + } + } +} diff --git a/AVLTreeJava.java b/AVLTreeJava.java new file mode 100644 index 0000000..0491737 --- /dev/null +++ b/AVLTreeJava.java @@ -0,0 +1,192 @@ +// AVL tree implementation in Java + +// Create node +class Node { + int item, height; + Node left, right; + + Node(int d) { + item = d; + height = 1; + } +} + +// Tree class +class AVLTreeJava { + Node root; + + int height(Node N) { + if (N == null) + return 0; + return N.height; + } + + int max(int a, int b) { + return (a > b) ? a : b; + } + + Node rightRotate(Node y) { + Node x = y.left; + Node T2 = x.right; + x.right = y; + y.left = T2; + y.height = max(height(y.left), height(y.right)) + 1; + x.height = max(height(x.left), height(x.right)) + 1; + return x; + } + + Node leftRotate(Node x) { + Node y = x.right; + Node T2 = y.left; + y.left = x; + x.right = T2; + x.height = max(height(x.left), height(x.right)) + 1; + y.height = max(height(y.left), height(y.right)) + 1; + return y; + } + + // Get balance factor of a node + int getBalanceFactor(Node N) { + if (N == null) + return 0; + return height(N.left) - height(N.right); + } + + // Insert a node + Node insertNode(Node node, int item) { + + // Find the position and insert the node + if (node == null) + return (new Node(item)); + if (item < node.item) + node.left = insertNode(node.left, item); + else if (item > node.item) + node.right = insertNode(node.right, item); + else + return node; + + // Update the balance factor of each node + // And, balance the tree + node.height = 1 + max(height(node.left), height(node.right)); + int balanceFactor = getBalanceFactor(node); + if (balanceFactor > 1) { + if (item < node.left.item) { + return rightRotate(node); + } else if (item > node.left.item) { + node.left = leftRotate(node.left); + return rightRotate(node); + } + } + if (balanceFactor < -1) { + if (item > node.right.item) { + return leftRotate(node); + } else if (item < node.right.item) { + node.right = rightRotate(node.right); + return leftRotate(node); + } + } + return node; + } + + Node nodeWithMimumValue(Node node) { + Node current = node; + while (current.left != null) + current = current.left; + return current; + } + + // Delete a node + Node deleteNode(Node root, int item) { + + // Find the node to be deleted and remove it + if (root == null) + return root; + if (item < root.item) + root.left = deleteNode(root.left, item); + else if (item > root.item) + root.right = deleteNode(root.right, item); + else { + if ((root.left == null) || (root.right == null)) { + Node temp = null; + if (temp == root.left) + temp = root.right; + else + temp = root.left; + if (temp == null) { + temp = root; + root = null; + } else + root = temp; + } else { + Node temp = nodeWithMimumValue(root.right); + root.item = temp.item; + root.right = deleteNode(root.right, temp.item); + } + } + if (root == null) + return root; + + // Update the balance factor of each node and balance the tree + root.height = max(height(root.left), height(root.right)) + 1; + int balanceFactor = getBalanceFactor(root); + if (balanceFactor > 1) { + if (getBalanceFactor(root.left) >= 0) { + return rightRotate(root); + } else { + root.left = leftRotate(root.left); + return rightRotate(root); + } + } + if (balanceFactor < -1) { + if (getBalanceFactor(root.right) <= 0) { + return leftRotate(root); + } else { + root.right = rightRotate(root.right); + return leftRotate(root); + } + } + return root; + } + + void preOrder(Node node) { + if (node != null) { + System.out.print(node.item + " "); + preOrder(node.left); + preOrder(node.right); + } + } + + // Print the tree + private void printTree(Node currPtr, String indent, boolean last) { + if (currPtr != null) { + System.out.print(indent); + if (last) { + System.out.print("R----"); + indent += " "; + } else { + System.out.print("L----"); + indent += "| "; + } + System.out.println(currPtr.item); + printTree(currPtr.left, indent, false); + printTree(currPtr.right, indent, true); + } + } + + // Driver code + public static void main(String[] args) { + AVLTree tree = new AVLTree(); + tree.root = tree.insertNode(tree.root, 33); + tree.root = tree.insertNode(tree.root, 13); + tree.root = tree.insertNode(tree.root, 53); + tree.root = tree.insertNode(tree.root, 9); + tree.root = tree.insertNode(tree.root, 21); + tree.root = tree.insertNode(tree.root, 61); + tree.root = tree.insertNode(tree.root, 8); + tree.root = tree.insertNode(tree.root, 11); + tree.printTree(tree.root, "", true); + tree.root = tree.deleteNode(tree.root, 13); + System.out.println("After Deletion: "); + tree.printTree(tree.root, "", true); + } +} \ No newline at end of file diff --git a/AVLTreeProgram.java b/AVLTreeProgram.java new file mode 100644 index 0000000..0491737 --- /dev/null +++ b/AVLTreeProgram.java @@ -0,0 +1,192 @@ +// AVL tree implementation in Java + +// Create node +class Node { + int item, height; + Node left, right; + + Node(int d) { + item = d; + height = 1; + } +} + +// Tree class +class AVLTreeJava { + Node root; + + int height(Node N) { + if (N == null) + return 0; + return N.height; + } + + int max(int a, int b) { + return (a > b) ? a : b; + } + + Node rightRotate(Node y) { + Node x = y.left; + Node T2 = x.right; + x.right = y; + y.left = T2; + y.height = max(height(y.left), height(y.right)) + 1; + x.height = max(height(x.left), height(x.right)) + 1; + return x; + } + + Node leftRotate(Node x) { + Node y = x.right; + Node T2 = y.left; + y.left = x; + x.right = T2; + x.height = max(height(x.left), height(x.right)) + 1; + y.height = max(height(y.left), height(y.right)) + 1; + return y; + } + + // Get balance factor of a node + int getBalanceFactor(Node N) { + if (N == null) + return 0; + return height(N.left) - height(N.right); + } + + // Insert a node + Node insertNode(Node node, int item) { + + // Find the position and insert the node + if (node == null) + return (new Node(item)); + if (item < node.item) + node.left = insertNode(node.left, item); + else if (item > node.item) + node.right = insertNode(node.right, item); + else + return node; + + // Update the balance factor of each node + // And, balance the tree + node.height = 1 + max(height(node.left), height(node.right)); + int balanceFactor = getBalanceFactor(node); + if (balanceFactor > 1) { + if (item < node.left.item) { + return rightRotate(node); + } else if (item > node.left.item) { + node.left = leftRotate(node.left); + return rightRotate(node); + } + } + if (balanceFactor < -1) { + if (item > node.right.item) { + return leftRotate(node); + } else if (item < node.right.item) { + node.right = rightRotate(node.right); + return leftRotate(node); + } + } + return node; + } + + Node nodeWithMimumValue(Node node) { + Node current = node; + while (current.left != null) + current = current.left; + return current; + } + + // Delete a node + Node deleteNode(Node root, int item) { + + // Find the node to be deleted and remove it + if (root == null) + return root; + if (item < root.item) + root.left = deleteNode(root.left, item); + else if (item > root.item) + root.right = deleteNode(root.right, item); + else { + if ((root.left == null) || (root.right == null)) { + Node temp = null; + if (temp == root.left) + temp = root.right; + else + temp = root.left; + if (temp == null) { + temp = root; + root = null; + } else + root = temp; + } else { + Node temp = nodeWithMimumValue(root.right); + root.item = temp.item; + root.right = deleteNode(root.right, temp.item); + } + } + if (root == null) + return root; + + // Update the balance factor of each node and balance the tree + root.height = max(height(root.left), height(root.right)) + 1; + int balanceFactor = getBalanceFactor(root); + if (balanceFactor > 1) { + if (getBalanceFactor(root.left) >= 0) { + return rightRotate(root); + } else { + root.left = leftRotate(root.left); + return rightRotate(root); + } + } + if (balanceFactor < -1) { + if (getBalanceFactor(root.right) <= 0) { + return leftRotate(root); + } else { + root.right = rightRotate(root.right); + return leftRotate(root); + } + } + return root; + } + + void preOrder(Node node) { + if (node != null) { + System.out.print(node.item + " "); + preOrder(node.left); + preOrder(node.right); + } + } + + // Print the tree + private void printTree(Node currPtr, String indent, boolean last) { + if (currPtr != null) { + System.out.print(indent); + if (last) { + System.out.print("R----"); + indent += " "; + } else { + System.out.print("L----"); + indent += "| "; + } + System.out.println(currPtr.item); + printTree(currPtr.left, indent, false); + printTree(currPtr.right, indent, true); + } + } + + // Driver code + public static void main(String[] args) { + AVLTree tree = new AVLTree(); + tree.root = tree.insertNode(tree.root, 33); + tree.root = tree.insertNode(tree.root, 13); + tree.root = tree.insertNode(tree.root, 53); + tree.root = tree.insertNode(tree.root, 9); + tree.root = tree.insertNode(tree.root, 21); + tree.root = tree.insertNode(tree.root, 61); + tree.root = tree.insertNode(tree.root, 8); + tree.root = tree.insertNode(tree.root, 11); + tree.printTree(tree.root, "", true); + tree.root = tree.deleteNode(tree.root, 13); + System.out.println("After Deletion: "); + tree.printTree(tree.root, "", true); + } +} \ No newline at end of file diff --git a/ActivitySelection.java b/ActivitySelection.java new file mode 100644 index 0000000..ab37a37 --- /dev/null +++ b/ActivitySelection.java @@ -0,0 +1,51 @@ +import java.util.ArrayList; +import java.util.Collections; + +public class ActivitySelection { + + static class Activity { + int start; + int end; + + public Activity(int start, int end) { + this.start = start; + this.end = end; + } + + @Override + public String toString(){ + return "[" + this.start + ", " + this.end + "]"; + } + } + + public static void maxActivities(ArrayList activities){ + + //sort the activities in ascending order of meeting finish time + System.out.println("Given Activities: " + activities); + Collections.sort(activities, (o1, o2) -> o1.end - o2.end); + + ArrayList selectedActivities = new ArrayList<>(); + int currentEnd = -1; + for (int i = 0; i currentEnd){ + selectedActivities.add(currentActivity); + currentEnd = currentActivity.end; + } + } + + //print selected activities + System.out.println("Selected Activities: " + selectedActivities); + } + + public static void main(String[] args) { + ArrayList activities = new ArrayList<>(); + activities.add(new Activity(1, 3)); + activities.add(new Activity(2, 5)); + activities.add(new Activity(0, 7)); + activities.add(new Activity(6, 8)); + activities.add(new Activity(9, 11)); + activities.add(new Activity(10, 12)); + maxActivities(activities); + } +} \ No newline at end of file diff --git a/AdvancedCalculator.java b/AdvancedCalculator.java new file mode 100644 index 0000000..ee9f81f --- /dev/null +++ b/AdvancedCalculator.java @@ -0,0 +1,33 @@ +class Calculator { + int add(int a , int b) + { + return a + b; + } + + int sub(int a , int b) + { + return a - b; + } +} + +public class AdvancedCalculator extends Calculator { + int mult(int a , int b) + { + return a * b; + } + + int div(int a , int b) + { + return a / b; + } + + public static void main(String args[]) + { + AdvancedCalculator cal = new AdvancedCalculator(); + + System.out.println( cal.add(1, 2) ); + System.out.println( cal.sub(1, 2) ); + System.out.println( cal.mult(1, 2) ); + System.out.println( cal.div(1, 2) ); + } +} \ No newline at end of file diff --git a/ApplicationExceptionHandler.java b/ApplicationExceptionHandler.java new file mode 100644 index 0000000..7406053 --- /dev/null +++ b/ApplicationExceptionHandler.java @@ -0,0 +1,35 @@ +package com.simactivation.advice; + + +import java.util.HashMap; +import java.util.Map; + +import org.springframework.http.HttpStatus; +import org.springframework.web.bind.MethodArgumentNotValidException; +import org.springframework.web.bind.annotation.ExceptionHandler; +import org.springframework.web.bind.annotation.ResponseStatus; +import org.springframework.web.bind.annotation.RestControllerAdvice; + +@RestControllerAdvice +public class ApplicationExceptionHandler { + + + @ResponseStatus(HttpStatus.BAD_REQUEST) + @ExceptionHandler(MethodArgumentNotValidException.class) + public Map handleInvalidArgument(MethodArgumentNotValidException ex) { + Map errorMap = new HashMap<>(); + ex.getBindingResult().getFieldErrors().forEach(error -> { + errorMap.put(error.getField(), error.getDefaultMessage()); + }); + return errorMap; + } + +// @ResponseStatus(HttpStatus.INTERNAL_SERVER_ERROR) +// @ExceptionHandler(UserNotFoundException.class) +// public Map handleBusinessException(UserNotFoundException ex) { +// Map errorMap = new HashMap<>(); +// errorMap.put("errorMessage", ex.getMessage()); +// return errorMap; +// } + +} diff --git a/Area of triangle b/Area of triangle new file mode 100644 index 0000000..4139003 --- /dev/null +++ b/Area of triangle @@ -0,0 +1,9 @@ + Uncomment below to take inputs from the user + a = float(input('Enter first side: ')) + b = float(input('Enter second side: ')) + c = float(input('Enter third side: ')) + +s = (a + b + c) / 2 + +area = (s*(s-a)*(s-b)*(s-c)) ** 0.5 +print('The area of the triangle is %0.2f' %area) diff --git a/Armstrong.java b/Armstrong.java new file mode 100644 index 0000000..9ee6eaf --- /dev/null +++ b/Armstrong.java @@ -0,0 +1,22 @@ +import java.util.Scanner; +public class ArmstrongNum { + static int number, originalNumber, remainder, result = 0; + public static void main(String[] args) { + Scanner s=new Scanner(System.in); + ArmstrongNum num = new ArmstrongNum(); + System.out.println("Enter the Number : "); + number = s.nextInt(); + originalNumber=number; + while (originalNumber != 0) + { + remainder = originalNumber % 10; + result += Math.pow(remainder, 3); + originalNumber /= 10; + } + + if(result == number) + System.out.println(number + " is an Armstrong number."); + else + System.out.println(number + " is not an Armstrong number."); + } +} diff --git a/Armstrong_Funtion.java b/Armstrong_Funtion.java new file mode 100644 index 0000000..f7d6c55 --- /dev/null +++ b/Armstrong_Funtion.java @@ -0,0 +1,40 @@ +import java.io.*; +class Armstrong_Funtion +{ + public int Number(int n) + { + int r,a=0,ano=n,flag=0; + while(n>0) + { + r = n%10; + a = a + (r*r*r); + n = (n-r)/10; + } + if(ano==a) + flag = 1; + else + flag = 0; + return(flag); + } + public static void main(String args[]) throws IOException + { + System.out.println("Armstrong Number"); + System.out.println("****************"); + System.out.println(""); + InputStreamReader isr=new InputStreamReader(System.in); + BufferedReader br=new BufferedReader(isr); + int d,p; + System.out.print("Enter Number : "); + d = Integer.parseInt(br.readLine()); + System.out.println(""); + Armstrong_Funtion ob = new Armstrong_Funtion(); + p = ob.Number(d); + if(p==1) + System.out.println("Number is Armstrong"); + else + System.out.println("Number is Not Armstrong"); + } +} + + + diff --git a/Assignment/Assets/entry.png b/Assignment/Assets/entry.png index 11d9bf3..5e71290 100644 Binary files a/Assignment/Assets/entry.png and b/Assignment/Assets/entry.png differ diff --git a/Assignment/Assets/error.png b/Assignment/Assets/error.png index f0fd445..e5042a3 100644 Binary files a/Assignment/Assets/error.png and b/Assignment/Assets/error.png differ diff --git a/Assignment/Assets/full.png b/Assignment/Assets/full.png index f772a1a..7b2cca5 100644 Binary files a/Assignment/Assets/full.png and b/Assignment/Assets/full.png differ diff --git a/Assignment/Assets/submit.png b/Assignment/Assets/submit.png index 56245ba..7fe1dc7 100644 Binary files a/Assignment/Assets/submit.png and b/Assignment/Assets/submit.png differ diff --git a/BLOG.png b/BLOG.png new file mode 100644 index 0000000..67c3bb0 Binary files /dev/null and b/BLOG.png differ diff --git a/BellmanFord.java b/BellmanFord.java new file mode 100644 index 0000000..e552da3 --- /dev/null +++ b/BellmanFord.java @@ -0,0 +1,45 @@ +import java.util.*; +public class Main { + public static void main(String[] args) { + Scanner scn = new Scanner(System.in); + int n = scn.nextInt(); + int m = scn.nextInt(); + int[][] matrix = new int[m][3]; + for (int i = 0; i + < m; i++) { + int u = scn.nextInt(); + int v = scn.nextInt(); + int w = scn.nextInt(); + matrix[i][0] = u - 1; + matrix[i][1] = v - 1; + matrix[i][2] = w; + } + int[] path = new int[n]; + Arrays.fill(path, Integer.MAX_VALUE); + path[0] = 0; + scn.close(); + for (int i = 0; i < n - 1; i++) { + for (int j = 0; j + < m; j++) { + int u = matrix[j][0]; + int v = matrix[j][1]; + int w = matrix[j][2]; + if (path[u] == Integer.MAX_VALUE) { + continue; + } + if (path[u] + w < path[v]) { + path[v] = path[u] + w; + } + } + } + for (int i = 1; i < path.length; i++) { + if (path[i] == Integer.MAX_VALUE) + { + System.out.print( "1000000000" + " " ); + } + else { + System.out.print(path[i] + " " ); + } + } + } +} \ No newline at end of file diff --git a/Binary Search.java b/Binary Search.java new file mode 100644 index 0000000..70f62dd --- /dev/null +++ b/Binary Search.java @@ -0,0 +1,24 @@ + +public class Solution { + + public static int binarySearch(int[] arr, int x) { + int start = 0; + int end = arr.length - 1; + + while (start <= end){ + int mid = (start + end)/2; + if (x == arr[mid]){ + return mid; + } else if (x < mid){ + end = mid - 1; + } if (x > mid){ + end = mid + 1; + } + + + } + return -1; + + } + +} diff --git a/Binary.java b/Binary.java new file mode 100644 index 0000000..c4f2e11 --- /dev/null +++ b/Binary.java @@ -0,0 +1,41 @@ +import java.util.Scanner; +import java.time.Duration; +import java.time.Instant; + + +public class Binary { + public static int binary_search(int[]A,int target){ + int lo=0; + int hi=A.length-1; + + while(lo<=hi) +{ + int mid=lo+(hi-lo)/2; + if(A[mid]==target) + return mid; + else if(A[mid] +using namespace std; +int binarySearch(int arr[], int l, int r, int x) +{ + if (r >= l) { + int mid = l + (r - l) / 2; + if (arr[mid] == x) + return mid; + if (arr[mid] > x) + return binarySearch(arr, l, mid - 1, x); + return binarySearch(arr, mid + 1, r, x); + } + return -1; +} + +int main(void) +{ + int arr[] = { 2, 3, 4, 10, 40 }; + int x = 10; + int n = sizeof(arr) / sizeof(arr[0]); + int result = binarySearch(arr, 0, n - 1, x); + (result == -1) + ? cout << "Element is not present in array" + : cout << "Element is present at index " << result; + return 0; +} diff --git a/BinarySearch.java b/BinarySearch.java index eeffdf1..62c47ed 100644 --- a/BinarySearch.java +++ b/BinarySearch.java @@ -1,65 +1,34 @@ -import java.util.Scanner; -/* - * Java Program to implement binary search without using recursion - */ public class BinarySearch { public static void main(String[] args) { - - Scanner commandReader = new Scanner(System.in); - System.out.println("Welcome to Java Program to perform - binary search on int array"); - System.out.println("Enter total number of elements : "); - int length = commandReader.nextInt(); - int[] input = new int[length]; - - System.out.printf("Enter %d integers %n", length); - for (int i = 0; i < length; i++) { - input[i] = commandReader.nextInt(); - } - - System.out.println("Please enter number to be searched in array - (sorted order)"); - int key = commandReader.nextInt(); - - int index = performBinarySearch(input, key); - - if (index == -1) { - System.out.printf("Sorry, %d is not found in array %n", key); - } else { - System.out.printf("%d is found in array at index %d %n", key, - index); - } - - commandReader.close(); - + int[] arr = { -18, -12, -4, 0, 2, 3, 4, 15, 16, 18, 22, 45, 89 }; + int target = 22; + int ans = binarySearch(arr, target); + System.out.println(ans); } - /** - * Java method to perform binary search. It accept an integer array and a - * number and return the index of number in the array. If number doesn't - * exists in array then it return -1 - * - * @param input - * @param number - * @return index of given number in array or -1 if not found - */ - public static int performBinarySearch(int[] input, int number) { - int low = 0; - int high = input.length - 1; - - while (high >= low) { - int middle = (low + high) / 2; - if (input[middle] == number) { - return middle; - } else if (input[middle] < number) { - low = middle + 1; - } else if (input[middle] > number) { - high = middle - 1; + // return the index + // return -1 if it does not exist + static int binarySearch(int[] arr, int target) { + int start = 0; + int end = arr.length - 1; + + while (start <= end) { + // find the middle element + // int mid = (start + end) / 2; // might be possible that (start + end) exceeds + // the range of int in java + int mid = start + (end - start) / 2; + + if (target < arr[mid]) { + end = mid - 1; + } else if (target > arr[mid]) { + start = mid + 1; + } else { + // ans found + return mid; } } return -1; } - -} +} \ No newline at end of file diff --git a/BinaryTree.java b/BinaryTree.java new file mode 100644 index 0000000..305a0bb --- /dev/null +++ b/BinaryTree.java @@ -0,0 +1,53 @@ +// Java implementation to find leaf count of a given Binary tree + +class Node +{ + int data; + Node left, right; + + public Node(int item) + { + data = item; + left = right = null; + } +} + +public class BinaryTree +{ + //Root of the Binary Tree + Node root; + + /* Function to get the count of leaf nodes in a binary tree*/ + int getLeafCount() + { + return getLeafCount(root); + } + + int getLeafCount(Node node) + { + if (node == null) // base condition + return 0; + if (node.left == null && node.right == null) + return 1; + else + return getLeafCount(node.left) + getLeafCount(node.right); + } + + /* Driver program to test above functions */ + public static void main(String args[]) + { + /* create a tree */ + BinaryTree tree = new BinaryTree(); + tree.root = new Node(1); + tree.root.left = new Node(2); + tree.root.right = new Node(3); + tree.root.left.left = new Node(4); + tree.root.left.right = new Node(5); + + /* get leaf count of the above tree */ + System.out.println("The leaf count of binary tree is : " + + tree.getLeafCount()); + } +} + + diff --git a/BinaryTreeCode.java b/BinaryTreeCode.java new file mode 100644 index 0000000..ef40744 --- /dev/null +++ b/BinaryTreeCode.java @@ -0,0 +1,59 @@ +class Node { + + int data; + Node left, right; + + Node(int d) { + data = d; + left = right = null; + } +} + +// Calculate height +class Height { + int height = 0; +} + +class BinaryTreeCode { + + Node root; + + // Check height balance + boolean checkHeightBalance(Node root, Height height) { + + // Check for emptiness + if (root == null) { + height.height = 0; + return true; + } + + Height leftHeighteight = new Height(), rightHeighteight = new Height(); + boolean l = checkHeightBalance(root.left, leftHeighteight); + boolean r = checkHeightBalance(root.right, rightHeighteight); + int leftHeight = leftHeighteight.height, rightHeight = rightHeighteight.height; + + height.height = (leftHeight > rightHeight ? leftHeight : rightHeight) + 1; + + if ((leftHeight - rightHeight >= 2) || (rightHeight - leftHeight >= 2)) + return false; + + else + return l && r; + } + + public static void main(String args[]) { + Height height = new Height(); + + BinaryTree tree = new BinaryTree(); + tree.root = new Node(1); + tree.root.left = new Node(2); + tree.root.right = new Node(3); + tree.root.left.left = new Node(4); + tree.root.left.right = new Node(5); + + if (tree.checkHeightBalance(tree.root, height)) + System.out.println("The tree is balanced"); + else + System.out.println("The tree is not balanced"); + } +} \ No newline at end of file diff --git a/Binary_Search.java b/Binary_Search.java new file mode 100644 index 0000000..147c9e9 --- /dev/null +++ b/Binary_Search.java @@ -0,0 +1,35 @@ +import java.util.*; +class Main{ + public static void main(String args[]){ + int numArray[] = {5,10,15,20,25,30,35}; + System.out.println("The input array: " + Arrays.toString(numArray)); + + int key = 20; + System.out.println("\nKey to be searched=" + key); + + int first = 0; + + int last=numArray.length-1; + + int mid = (first + last)/2; + + while( first <= last ){ + + if ( numArray[mid] < key ){ + first = mid + 1; + }else if ( numArray[mid] == key ){ + + System.out.println("Element is found at index: " + mid); + break; + }else{ + + last = mid - 1; + } + mid = (first + last)/2; + } + + if ( first > last ){ + System.out.println("Element is not found!"); + } + } +} diff --git a/Brainfuck.txt b/Brainfuck.txt new file mode 100644 index 0000000..3df2cda --- /dev/null +++ b/Brainfuck.txt @@ -0,0 +1,121 @@ +import java.util.*; + +class BrainFuck +{ + private static Scanner ob = new Scanner(System.in); + private static int ptr; // Data pointer + + // Max memory limit. It is the highest number which + // can be represented by an unsigned 16-bit binary + // number. Many computer programming environments + // beside brainfuck may have predefined + // constant values representing 65535. + private static int length = 65535; + + // Array of byte type simulating memory of max + // 65535 bits from 0 to 65534. + private static byte memory[] = new byte[length]; + + // Interpreter function which accepts the code + // a string parameter + private static void interpret(String s) + { + int c = 0; + + // Parsing through each character of the code + for (int i = 0; i < s.length(); i++) + { + // BrainFuck is a tiny language with only + // eight instructions. In this loop we check + // and execute all those eight instructions + + + // > moves the pointer to the right + if (s.charAt(i) == '>') + { + if (ptr == length - 1)//If memory is full + ptr = 0;//pointer is returned to zero + else + ptr ++; + } + + // < moves the pointer to the left + else if (s.charAt(i) == '<') + { + if (ptr == 0) // If the pointer reaches zero + + // pointer is returned to rightmost memory + // position + ptr = length - 1; + else + ptr --; + } + + // + increments the value of the memory + // cell under the pointer + else if (s.charAt(i) == '+') + memory[ptr] ++; + + // - decrements the value of the memory cell + // under the pointer + else if (s.charAt(i) == '-') + memory[ptr] --; + + // . outputs the character signified by the + // cell at the pointer + else if (s.charAt(i) == '.') + System.out.print((char)(memory[ptr])); + + // , inputs a character and store it in the + // cell at the pointer + else if (s.charAt(i) == ',') + memory[ptr] = (byte)(ob.next().charAt(0)); + + // [ jumps past the matching ] if the cell + // under the pointer is 0 + else if (s.charAt(i) == '[') + { + if (memory[ptr] == 0) + { + i++; + while (c > 0 || s.charAt(i) != ']') + { + if (s.charAt(i) == '[') + c++; + else if (s.charAt(i) == ']') + c--; + i ++; + } + } + } + + // ] jumps back to the matching [ if the + // cell under the pointer is nonzero + else if (s.charAt(i) == ']') + { + if (memory[ptr] != 0) + { + i --; + while (c > 0 || s.charAt(i) != '[') + { + if (s.charAt(i) == ']') + c ++; + else if (s.charAt(i) == '[') + c --; + i --; + } + i --; + } + } + } + } + + // Driver code + public static void main(String args[]) + { + System.out.println("Enter the code:"); + String code = ob.nextLine(); + System.out.println("Output:"); + interpret(code); + } +} diff --git a/BreadthFirstSearch.java b/BreadthFirstSearch.java new file mode 100644 index 0000000..2f155cf --- /dev/null +++ b/BreadthFirstSearch.java @@ -0,0 +1,67 @@ +import java.io.*; +import java.util.*; + +class Graph +{ + private int V; + private LinkedList adj[]; + + Graph(int v) + { + V = v; + adj = new LinkedList[v]; + for (int i=0; i queue = new LinkedList(); + + visited[s]=true; + queue.add(s); + + while (queue.size() != 0) + { + + s = queue.poll(); + System.out.print(s+" "); + + Iterator i = adj[s].listIterator(); + while (i.hasNext()) + { + int n = i.next(); + if (!visited[n]) + { + visited[n] = true; + queue.add(n); + } + } + } + } + + + public static void main(String args[]) + { + Graph 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); + + System.out.println("Breadth First Traversal "+ + "(starting from vertex 2)"); + + g.BFS(2); + } +} \ No newline at end of file diff --git a/BubbleSort.java b/BubbleSort.java index ae1ceaa..44c4ab6 100644 --- a/BubbleSort.java +++ b/BubbleSort.java @@ -1,35 +1,44 @@ -public class BubbleSortExample { - static void bubbleSort(int[] arr) { - int n = arr.length; - int temp = 0; - for(int i=0; i < n; i++){ - for(int j=1; j < (n-i); j++){ - if(arr[j-1] > arr[j]){ - //swap elements - temp = arr[j-1]; - arr[j-1] = arr[j]; - arr[j] = temp; - } - - } - } - - } - public static void main(String[] args) { - int arr[] ={3,60,35,2,45,320,5}; - - System.out.println("Array Before Bubble Sort"); - for(int i=0; i < arr.length; i++){ - System.out.print(arr[i] + " "); - } - System.out.println(); - - bubbleSort(arr);//sorting array elements using bubble sort - - System.out.println("Array After Bubble Sort"); - for(int i=0; i < arr.length; i++){ - System.out.print(arr[i] + " "); - } - - } -} \ No newline at end of file +import java.util.Scanner; + +public class BubbleSort { + public static void main(String[] args) { + Scanner scan = new Scanner(System.in); + int[] a = new int[5]; + System.out.println("Enter the elements of the array: "); + for (int i = 0; i a[j+1]){ + int temp = a[j+1]; + a[j+1] = a[j]; + a[j] = temp; + flag++; + } + } + if (flag == 0){ + break; + } + } + } +} diff --git a/BubbleSortExample.java b/BubbleSortExample.java new file mode 100644 index 0000000..c716ce0 --- /dev/null +++ b/BubbleSortExample.java @@ -0,0 +1,35 @@ +public class BubbleSortExample { + static void bubbleSort(int[] arr) { + int n = arr.length; + int temp = 0; + for(int i=0; i < n; i++){ + for(int j=1; j < (n-i); j++){ + if(arr[j-1] > arr[j]){ + //swap elements + temp = arr[j-1]; + arr[j-1] = arr[j]; + arr[j] = temp; + } + + } + } + + } + public static void main(String[] args) { + int arr[] ={3,60,35,2,45,320,5}; + + System.out.println("Array Before Bubble Sort"); + for(int i=0; i < arr.length; i++){ + System.out.print(arr[i] + " "); + } + System.out.println(); + + bubbleSort(arr);//sorting array elements using bubble sort + + System.out.println("Array After Bubble Sort"); + for(int i=0; i < arr.length; i++){ + System.out.print(arr[i] + " "); + } + + } +} \ No newline at end of file diff --git a/BubbleSt.java b/BubbleSt.java new file mode 100644 index 0000000..463a05f --- /dev/null +++ b/BubbleSt.java @@ -0,0 +1,35 @@ +public class BubbleSt { + static void bubbleSort(int[] arr) { + int n = arr.length; + int temp = 0; + for(int i=0; i < n; i++){ + for(int j=1; j < (n-i); j++){ + if(arr[j-1] > arr[j]){ + //swap elements + temp = arr[j-1]; + arr[j-1] = arr[j]; + arr[j] = temp; + } + + } + } + + } + public static void main(String[] args) { + int arr[] ={3,60,35,2,45,320,5}; + + System.out.println("Array Before Bubble Sort"); + for(int i=0; i < arr.length; i++){ + System.out.print(arr[i] + " "); + } + System.out.println(); + + bubbleSort(arr);//sorting array elements using bubble sort + + System.out.println("Array After Bubble Sort"); + for(int i=0; i < arr.length; i++){ + System.out.print(arr[i] + " "); + } + + } +} diff --git a/Bubblesort.cpp b/Bubblesort.cpp new file mode 100644 index 0000000..e75cc9b --- /dev/null +++ b/Bubblesort.cpp @@ -0,0 +1,45 @@ +#include +void swap(int *p1, int *p2) +{ +int temp = *p1; +*p1 = *p2; +*p2 = temp; +} +// This is an optimised code for the bubble sort +void bSort(int arrnumbers[], int n) +{ +int i, j; +bool check; +for (i = 0; i < n-1; i++) +{ +check = false; +for (j = 0; j < n-i-1; j++) +{ +if (arrnumbers[j] > arrnumbers[j+1]) +{ +swap(&arrnumbers[j], &arrnumbers[j+1]); +check = true; +} +} +// We are breaking from the loop in case two elements were not swapped by inner loop. +if (check == false) +break; +} +} +//This function is to print the array sequence as final output after sorting +void print(int arrnumbers[], int sizeofarray) +{ +int i; +for (i=0; i < sizeofarray; i++) +printf("%d ", arrnumbers[i]); +} +// This the main program from where the execution will start +int main() +{ +int arrnumbers[] = {5, 6, 1, 0, 2, 9}; +int n = sizeof(arrnumbers)/sizeof(arrnumbers[0]); +bSort(arrnumbers, n); +printf("Sorted array: \n"); +print(arrnumbers, n); +return 0; +} diff --git a/Bucketsort.java b/Bucketsort.java new file mode 100644 index 0000000..8742f34 --- /dev/null +++ b/Bucketsort.java @@ -0,0 +1,60 @@ +// Java program to sort an array +// using bucket sort +import java.util.*; +import java.util.Collections; + +class GFG { + + // Function to sort arr[] of size n + // using bucket sort + static void bucketSort(float arr[], int n) + { + if (n <= 0) + return; + + // 1) Create n empty buckets + @SuppressWarnings("unchecked") + Vector[] buckets = new Vector[n]; + + for (int i = 0; i < n; i++) { + buckets[i] = new Vector(); + } + + // 2) Put array elements in different buckets + for (int i = 0; i < n; i++) { + float idx = arr[i] * n; + buckets[(int)idx].add(arr[i]); + } + + // 3) Sort individual buckets + for (int i = 0; i < n; i++) { + Collections.sort(buckets[i]); + } + + // 4) Concatenate all buckets into arr[] + int index = 0; + for (int i = 0; i < n; i++) { + for (int j = 0; j < buckets[i].size(); j++) { + arr[index++] = buckets[i].get(j); + } + } + } + + // Driver code + public static void main(String args[]) + { + float arr[] = { (float)0.897, (float)0.565, + (float)0.656, (float)0.1234, + (float)0.665, (float)0.3434 }; + + int n = arr.length; + bucketSort(arr, n); + + System.out.println("Sorted array is "); + for (float el : arr) { + System.out.print(el + " "); + } + } +} + +// This code is contributed by Himangshu Shekhar Jha diff --git a/C Calculator b/C Calculator new file mode 100644 index 0000000..54cd196 --- /dev/null +++ b/C Calculator @@ -0,0 +1,39 @@ +#include +#include +#include +#include + + +int main(int argc, char *argv[]) +{ + float valueOne; + float valueTwo; + char operator; + float answer; + + printf("Enter calculation:\n"); + scanf("%f %c %f", &valueOne, &operator, & valueTwo); + + switch(operator) + { + case '/': answer = valueOne/valueTwo; + break; + case '*': answer = valueOne*valueTwo; + break; + case '+': answer = valueOne+valueTwo; + break; + case '-': answer = valueOne-valueTwo; + break; + case '^': answer = pow(valueOne,valueTwo); + break; + case ' ': answer = sqrt(valueTwo); + break; + default: goto fail; + } + printf("%.9g%c%.9g = %.6g\n\n",valueOne,operator, valueTwo, answer); + goto exit; + fail: + printf("Fail.\n"); + exit: + return 0; +} diff --git a/C to F Python.py b/C to F Python.py new file mode 100644 index 0000000..e7897f9 --- /dev/null +++ b/C to F Python.py @@ -0,0 +1,8 @@ +# Python Program to convert temperature in celsius to fahrenheit + +# change this value for a different result +celsius = 37.5 + +# calculate fahrenheit +fahrenheit = (celsius * 1.8) + 32 +print('%0.1f degree Celsius is equal to %0.1f degree Fahrenheit' %(celsius,fahrenheit)) \ No newline at end of file diff --git a/C++34.cpp b/C++34.cpp new file mode 100644 index 0000000..17a4da1 --- /dev/null +++ b/C++34.cpp @@ -0,0 +1,25 @@ +// Factorial of n = 1*2*3*...*n + +#include +using namespace std; + +int factorial(int); + +int main() { + int n, result; + + cout << "Enter a non-negative number: "; + cin >> n; + + result = factorial(n); + cout << "Factorial of " << n << " = " << result; + return 0; +} + +int factorial(int n) { + if (n > 1) { + return n * factorial(n - 1); + } else { + return 1; + } +} diff --git a/C++45.cpp b/C++45.cpp new file mode 100644 index 0000000..17a4da1 --- /dev/null +++ b/C++45.cpp @@ -0,0 +1,25 @@ +// Factorial of n = 1*2*3*...*n + +#include +using namespace std; + +int factorial(int); + +int main() { + int n, result; + + cout << "Enter a non-negative number: "; + cin >> n; + + result = factorial(n); + cout << "Factorial of " << n << " = " << result; + return 0; +} + +int factorial(int n) { + if (n > 1) { + return n * factorial(n - 1); + } else { + return 1; + } +} diff --git a/Calculator.java b/Calculator.java new file mode 100644 index 0000000..1b6faad --- /dev/null +++ b/Calculator.java @@ -0,0 +1,54 @@ +import java.util.Scanner; + +public class JavaExample { + + public static void main(String[] args) { + + double num1, num2; + Scanner scanner = new Scanner(System.in); + System.out.print("Enter first number:"); + + /* We are using data type double so that user + * can enter integer as well as floating point + * value + */ + num1 = scanner.nextDouble(); + System.out.print("Enter second number:"); + num2 = scanner.nextDouble(); + + System.out.print("Enter an operator (+, -, *, /): "); + char operator = scanner.next().charAt(0); + + scanner.close(); + double output; + + switch(operator) + { + case '+': + output = num1 + num2; + break; + + case '-': + output = num1 - num2; + break; + + case '*': + output = num1 * num2; + break; + + case '/': + output = num1 / num2; + break; + + /* If user enters any other operator or char apart from + * +, -, * and /, then display an error message to user + * + */ + default: + System.out.printf("You have entered wrong operator"); + return; + } + + System.out.println(num1+" "+operator+" "+num2+": "+output); + } +} diff --git a/Cellpadding And Cellspacing Attributes.txt b/Cellpadding And Cellspacing Attributes.txt new file mode 100644 index 0000000..ccbe9a7 --- /dev/null +++ b/Cellpadding And Cellspacing Attributes.txt @@ -0,0 +1,21 @@ + + +HTML TABLE + + + + + + + + + + + + + +
Name +Age +
ANKUSH25
Raman35
+ + \ No newline at end of file diff --git a/CocktailSort.java b/CocktailSort.java new file mode 100644 index 0000000..85463e9 --- /dev/null +++ b/CocktailSort.java @@ -0,0 +1,69 @@ + +public class CocktailSort +{ + void cocktailSort(int a[]) + { + boolean swapped = true; + int start = 0; + int end = a.length; + + while (swapped == true) + { + + swapped = false; + + for (int i = start; i < end - 1; ++i) + { + if (a[i] > a[i + 1]) { + int temp = a[i]; + a[i] = a[i + 1]; + a[i + 1] = temp; + swapped = true; + } + } + + + if (swapped == false) + break; + + + swapped = false; + + + end = end - 1; + + + for (int i = end - 1; i >= start; i--) + { + if (a[i] > a[i + 1]) + { + int temp = a[i]; + a[i] = a[i + 1]; + a[i + 1] = temp; + swapped = true; + } + } + + + start = start + 1; + } + } + + + void printArray(int a[]) + { + int n = a.length; + for (int i = 0; i < n; i++) + System.out.print(a[i] + " "); + System.out.println(); + } + + public static void main(String[] args) + { + CocktailSort ob = new CocktailSort(); + int a[] = { 5, 1, 4, 2, 8, 0, 2 }; + ob.cocktailSort(a); + System.out.println("Sorted array"); + ob.printArray(a); + } +} diff --git a/Code.txt b/Code.txt new file mode 100644 index 0000000..a61a278 --- /dev/null +++ b/Code.txt @@ -0,0 +1,125 @@ +Given two strings text1 and text2, return the length of their longest common subsequence. If there is no common subsequence, return 0. + +A subsequence of a string is a new string generated from the original string with some characters (can be none) deleted without changing the relative order of the remaining characters. + +For example, "ace" is a subsequence of "abcde". +A common subsequence of two strings is a subsequence that is common to both strings. + + + +Example 1: + +Input: text1 = "abcde", text2 = "ace" +Output: 3 +Explanation: The longest common subsequence is "ace" and its length is 3. +Example 2: + +Input: text1 = "abc", text2 = "abc" +Output: 3 +Explanation: The longest common subsequence is "abc" and its length is 3. +Example 3: + +Input: text1 = "abc", text2 = "def" +Output: 0 +Explanation: There is no such common subsequence, so the result is 0. + + +Constraints: + +1 <= text1.length, text2.length <= 1000 +text1 and text2 consist of only lowercase English characters. + + +Solution 1 Top Down + +class Solution { +public: + int f(int i,int j,string &si,string &sj,vector> &dp) + { + if(i<0||j<0) + { + return 0; + } + else if(si[i]==sj[j]) + { + return (1 + f(i-1,j-1,si,sj,dp)); + } + else if(dp[i][j]!=-1) + { + return dp[i][j]; + } + else + { + return dp[i][j] = max(f(i-1,j,si,sj,dp),f(i,j-1,si,sj,dp)); + } + } +public: + int longestCommonSubsequence(string text1, string text2) { + int l1 = text1.length(); + int l2 = text2.length(); + vector> dp(l1,vector(l2,-1)); + return f(l1-1,l2-1,text1,text2,dp); + } +}; + + + + +Solution 2 Bottom Up (with shifted coordinates make changes in i and j for the string only,not int the dp and make size of dp l1+1*l2+1) +class Solution { +public: + int longestCommonSubsequence(string text1, string text2) { + int l1=text1.length(); + int l2=text2.length(); + vector> dp(l1+1,vector(l2+1,0)); + for(int i=1;i<=l1;i++) + { + for(int j=1;j<=l2;j++) + { + if(text1[i-1]==text2[j-1]) + { + dp[i][j] = 1 + dp[i-1][j-1]; + } + else + { + dp[i][j] = max(dp[i-1][j],dp[i][j-1]); + } + } + } + return dp[l1][l2]; + } +}; + + + +Solution 3 : Space optimisation + +class Solution { +public: + int longestCommonSubsequence(string text1, string text2) { + int l1=text1.length(); + int l2=text2.length(); + vector curr(l2+1,0); + vector prev(l2+1,0); + for(int i=1;i<=l1;i++) + { + for(int j=1;j<=l2;j++) + { + if(text1[i-1]==text2[j-1]) + { + curr[j] = 1 + prev[j-1]; + } + else + { + curr[j] = max(prev[j],curr[j-1]); + } + } + prev=curr; + } + return prev[l2]; + } +}; + + + + diff --git a/CombSortInJave.java b/CombSortInJave.java new file mode 100644 index 0000000..4f0623a --- /dev/null +++ b/CombSortInJave.java @@ -0,0 +1,67 @@ + +class CombSort +{ + // To find gap between elements + int getNextGap(int gap) + { + // Shrink gap by Shrink factor + gap = (gap*10)/13; + if (gap < 1) + return 1; + return gap; + } + + // Function to sort arr[] using Comb Sort + void sort(int arr[]) + { + int n = arr.length; + + // initialize gap + int gap = n; + + // Initialize swapped as true to make sure that + // loop runs + boolean swapped = true; + + // Keep running while gap is more than 1 and last + // iteration caused a swap + while (gap != 1 || swapped == true) + { + // Find next gap + gap = getNextGap(gap); + + // Initialize swapped as false so that we can + // check if swap happened or not + swapped = false; + + // Compare all elements with current gap + for (int i=0; i arr[i+gap]) + { + // Swap arr[i] and arr[i+gap] + int temp = arr[i]; + arr[i] = arr[i+gap]; + arr[i+gap] = temp; + + // Set swapped + swapped = true; + } + } + } + } + + // Driver method + public static void main(String args[]) + { + CombSort ob = new CombSort(); + int arr[] = {8, 4, 1, 56, 3, -44, 23, -6, 28, 0}; + ob.sort(arr); + + System.out.println("sorted array"); + for (int i=0; i arr[i+gap]) + { + // Swap arr[i] and arr[i+gap] + int temp = arr[i]; + arr[i] = arr[i+gap]; + arr[i+gap] = temp; + + // Set swapped + swapped = true; + } + } + } + } + + // Driver method + public static void main(String args[]) + { + CombSort ob = new CombSort(); + int arr[] = {8, 4, 1, 56, 3, -44, 23, -6, 28, 0}; + ob.sort(arr); + + System.out.println("sorted array"); + for (int i=0; i0; j--) + { + System.out.print(bin_num[j]); + } + System.out.print("\n"); + } +} + diff --git a/Count the number of words in a string using HashMap.java b/Count the number of words in a string using HashMap.java new file mode 100644 index 0000000..8097cd7 --- /dev/null +++ b/Count the number of words in a string using HashMap.java @@ -0,0 +1,23 @@ +import java.util.HashMap; + +public class FinalCountWords { + + public static void main(String[] args) { + // TODO Auto-generated method stub + String str = "You are doing this Code"; + String[] split = str.split(" "); + + HashMap map = new HashMap(); + for (int i=0; i max) + max = array[i]; + } + int[] count = new int[max + 1]; + + // Initialize count array with all zeros + for (int i = 0; i < max; ++i) { + count[i] = 0; + } + + // Store the count of each element + for (int i = 0; i < size; i++) { + count[array[i]]++; + } + + // Store the cummulative count of each array + for (int i = 1; i <= max; i++) { + count[i] += count[i - 1]; + } + + // Find the index of each element of the original array in count array, and + // place the elements in output array + for (int i = size - 1; i >= 0; i--) { + output[count[array[i]] - 1] = array[i]; + count[array[i]]--; + } + + // Copy the sorted elements into original array + for (int i = 0; i < size; i++) { + array[i] = output[i]; + } + } + + // Driver code for the above code + public static void main(String args[]) { + int[] data = { 4, 2, 2, 8, 3, 3, 1 }; + int size = data.length; + CountingSort cs = new CountingSort(); + cs.countSort(data, size); + System.out.println("Sorted Array in Ascending Order: "); + System.out.println(Arrays.toString(data)); + } +} diff --git a/Counting_Sort.java b/Counting_Sort.java new file mode 100644 index 0000000..a4a6b4a --- /dev/null +++ b/Counting_Sort.java @@ -0,0 +1,45 @@ + +class CountingSort { + void sort(char arr[]) + { + int n = arr.length; + + char output[] = new char[n]; + + int count[] = new int[256]; + for (int i = 0; i < 256; ++i) + count[i] = 0; + + // store count of each character + for (int i = 0; i < n; ++i) + ++count[arr[i]]; + + + for (int i = 1; i <= 255; ++i) + count[i] += count[i - 1]; + + // Build the output character array + for (int i = 0; i < n; ++i) { + output[count[arr[i]] - 1] = arr[i]; + --count[arr[i]]; + } + + for (int i = 0; i < n; ++i) + arr[i] = output[i]; + } + + // Driver method + public static void main(String args[]) + { + CountingSort ob = new CountingSort(); + char arr[] = {'g', 'e', 'e', 'k', 's', 'f', 'o', + 'r', 'g', 'e', 'e', 'k', 's' }; + + ob.sort(arr); + + System.out.print("Sorted character array is "); + for (int i = 0; i < arr.length; ++i) + System.out.print(arr[i]); + } +} + diff --git a/CrossProduct.cpp b/CrossProduct.cpp new file mode 100644 index 0000000..76fe9d4 --- /dev/null +++ b/CrossProduct.cpp @@ -0,0 +1,66 @@ +#include +using namespace std; +template + +class vector +{ +public: + T *arr; + int size; + vector(int m) + { + size = m; + arr = new T[size]; + } + T crossproduct(vector &v /*,vector &v3*/) + { + int a; + for (int i = 0; i < size; i++) + { + + + a= ((arr[i + 1] * v.arr[i + 2]) - (arr[i + 2] * v.arr[i + 1])); + + a = ((arr[i + 2] * v.arr[i + 0]) - (arr[i + 0] * v.arr[i + 0])); + + a= ((arr[i + 0] * v.arr[i + 1]) - (arr[i + 1] * v.arr[i + 0])); + + } + return a; + } + void display() + { + int d[size]= crossproduct(); + return d; + } +}; + +int main() +{ + vector v1(3), v2(3); + + v1.arr[0] = 1; + v1.arr[1] = 2; + v1.arr[2] = 3; + + v2.arr[0] = 3; + v2.arr[1] = 2; + v2.arr[2] = 1; + + v1.crossproduct(v2); + v1.display(); + + //int d[size] = v1.crossproduct(v2); + //for(int j=0;j<3;j++) + //{ + // + // cout< +#include +main() +{ +int i=4,j; +clrscr(); +while(i>=1) +{ +j=1; +while(j<=i) +{ +cout<<"\2"; +j++; +} +cout<<"\n"; +i--; +} +i=2; +while(i<=4) +{ +j=1; +while(j<=i) +{ +cout<<"\2"; +j++; +} +cout<<"\n"; +i++; +} +getch(); +} diff --git a/DNFSort.java b/DNFSort.java new file mode 100644 index 0000000..daaacc4 --- /dev/null +++ b/DNFSort.java @@ -0,0 +1,49 @@ +public class DNFSort { + + // Sort the input array, the array is assumed to + // have values in {0, 1, 2} + static void sort012(int a[], int arr_size) { + int low = 0; + int high = arr_size - 1; + int mid = 0, temp = 0; + while (mid <= high) { + switch (a[mid]) { + case 0: { + temp = a[low]; + a[low] = a[mid]; + a[mid] = temp; + low++; + mid++; + break; + } + case 1: + mid++; + break; + case 2: { + temp = a[mid]; + a[mid] = a[high]; + a[high] = temp; + high--; + break; + } + } + } + } + + /* Utility function to print array arr[] */ + static void printArray(int arr[], int arr_size) { + for (int i = 0; i < arr_size; i++) { + System.out.print(arr[i] + " "); + } + System.out.println(""); + } + + /*Driver function to check for above functions*/ + public static void main(String[] args) { + int arr[] = {0, 1, 1, 0, 1, 2, 1, 2, 0, 0, 0, 1}; + int arr_size = arr.length; + sort012(arr, arr_size); + System.out.println("Array after seggregation "); + printArray(arr, arr_size); + } +} diff --git a/Date_and_time.java b/Date_and_time.java new file mode 100644 index 0000000..e6ce5e0 --- /dev/null +++ b/Date_and_time.java @@ -0,0 +1,32 @@ +// Java program to convert 24 hour +// time format to 12 hour format + +// Importing specific date class libraries +import java.util.Date; +import java.text.SimpleDateFormat; + +public class GFG { + +// Main driver method + public static void main(String[] args) + { + // Getting the current current time + Date date = new Date(); + + + System.out.println("Current Time is : " + date); + + // set format in 12 hours + SimpleDateFormat formatTime = new SimpleDateFormat("hh.mm aa"); + // hh = hours in 12hr format + // mm = minutes + // aa = am/pm + + String time = formatTime.format( + date); // changing the format of 'date' + + // display time as per format + System.out.println( + "Current Time in AM/PM Format is : " + time); + } +} diff --git a/Dequeue- basics/Double-End Queue.pdf b/Dequeue- basics/Double-End Queue.pdf new file mode 100644 index 0000000..6010260 Binary files /dev/null and b/Dequeue- basics/Double-End Queue.pdf differ diff --git a/Determinant_of_Matrix.java b/Determinant_of_Matrix.java new file mode 100644 index 0000000..bf856b9 --- /dev/null +++ b/Determinant_of_Matrix.java @@ -0,0 +1,94 @@ +// Java program to find Determinant of a matrix +class GFG { + + // Dimension of input square matrix + static final int N = 4; + + // Function to get determinant of matrix + static int determinantOfMatrix(int mat[][], int n) + { + int num1, num2, det = 1, index, + total = 1; // Initialize result + + // temporary array for storing row + int[] temp = new int[n + 1]; + + // loop for traversing the diagonal elements + for (int i = 0; i < n; i++) { + index = i; // initialize the index + + // finding the index which has non zero value + while (mat[index][i] == 0 && index < n) { + index++; + } + if (index == n) // if there is non zero element + { + // the determinant of matrix as zero + continue; + } + if (index != i) { + // loop for swaping the diagonal element row + // and index row + for (int j = 0; j < n; j++) { + swap(mat, index, j, i, j); + } + // determinant sign changes when we shift + // rows go through determinant properties + det = (int)(det * Math.pow(-1, index - i)); + } + + // storing the values of diagonal row elements + for (int j = 0; j < n; j++) { + temp[j] = mat[i][j]; + } + + // traversing every row below the diagonal + // element + for (int j = i + 1; j < n; j++) { + num1 = temp[i]; // value of diagonal element + num2 = mat[j] + [i]; // value of next row element + + // traversing every column of row + // and multiplying to every row + for (int k = 0; k < n; k++) { + // multiplying to make the diagonal + // element and next row element equal + mat[j][k] = (num1 * mat[j][k]) + - (num2 * temp[k]); + } + total = total * num1; // Det(kA)=kDet(A); + } + } + + // multiplying the diagonal elements to get + // determinant + for (int i = 0; i < n; i++) { + det = det * mat[i][i]; + } + return (det / total); // Det(kA)/k=Det(A); + } + + static int[][] swap(int[][] arr, int i1, int j1, int i2, + int j2) + { + int temp = arr[i1][j1]; + arr[i1][j1] = arr[i2][j2]; + arr[i2][j2] = temp; + return arr; + } + + // Driver code + public static void main(String[] args) + { + int mat[][] = { { 1, 0, 2, -1 }, + { 3, 0, 0, 5 }, + { 2, 1, 4, -3 }, + { 1, 0, 5, 0 } }; + + // Function call + System.out.printf( + "Determinant of the matrix is : %d", + determinantOfMatrix(mat, N)); + } +} diff --git a/Dijkstra.java b/Dijkstra.java new file mode 100644 index 0000000..bc06aa2 --- /dev/null +++ b/Dijkstra.java @@ -0,0 +1,134 @@ +// Java implementation of Dijkstra's Algorithm +// using Priority Queue +import java.util.*; +public class DPQ { + private int dist[]; + private Set settled; + private PriorityQueue pq; + private int V; // Number of vertices + List > adj; + + public DPQ(int V) + { + this.V = V; + dist = new int[V]; + settled = new HashSet(); + pq = new PriorityQueue(V, new Node()); + } + + // Function for Dijkstra's Algorithm + public void dijkstra(List > adj, int src) + { + this.adj = adj; + + for (int i = 0; i < V; i++) + dist[i] = Integer.MAX_VALUE; + + // Add source node to the priority queue + pq.add(new Node(src, 0)); + + // Distance to the source is 0 + dist[src] = 0; + while (settled.size() != V) { + + // remove the minimum distance node + // from the priority queue + int u = pq.remove().node; + + // adding the node whose distance is + // finalized + settled.add(u); + + e_Neighbours(u); + } + } + + // Function to process all the neighbours + // of the passed node + private void e_Neighbours(int u) + { + int edgeDistance = -1; + int newDistance = -1; + + // All the neighbors of v + for (int i = 0; i < adj.get(u).size(); i++) { + Node v = adj.get(u).get(i); + + // If current node hasn't already been processed + if (!settled.contains(v.node)) { + edgeDistance = v.cost; + newDistance = dist[u] + edgeDistance; + + // If new distance is cheaper in cost + if (newDistance < dist[v.node]) + dist[v.node] = newDistance; + + // Add the current node to the queue + pq.add(new Node(v.node, dist[v.node])); + } + } + } + + // Driver code + public static void main(String arg[]) + { + int V = 5; + int source = 0; + + // Adjacency list representation of the + // connected edges + List > adj = new ArrayList >(); + + // Initialize list for every node + for (int i = 0; i < V; i++) { + List item = new ArrayList(); + adj.add(item); + } + + // Inputs for the DPQ graph + adj.get(0).add(new Node(1, 9)); + adj.get(0).add(new Node(2, 6)); + adj.get(0).add(new Node(3, 5)); + adj.get(0).add(new Node(4, 3)); + + adj.get(2).add(new Node(1, 2)); + adj.get(2).add(new Node(3, 4)); + + // Calculate the single source shortest path + DPQ dpq = new DPQ(V); + dpq.dijkstra(adj, source); + + // Print the shortest path to all the nodes + // from the source node + System.out.println("The shorted path from node :"); + for (int i = 0; i < dpq.dist.length; i++) + System.out.println(source + " to " + i + " is " + + dpq.dist[i]); + } +} + +// Class to represent a node in the graph +class Node implements Comparator { + public int node; + public int cost; + + public Node() + { + } + + public Node(int node, int cost) + { + this.node = node; + this.cost = cost; + } + + @Override + public int compare(Node node1, Node node2) + { + if (node1.cost < node2.cost) + return -1; + if (node1.cost > node2.cost) + return 1; + return 0; + } +} \ No newline at end of file diff --git a/DijkstraAlgorithm.java b/DijkstraAlgorithm.java new file mode 100644 index 0000000..757d028 --- /dev/null +++ b/DijkstraAlgorithm.java @@ -0,0 +1,57 @@ + +import java.util.Scanner; +public class DijkstraAlgorithm { + private static void dijkstra(int[][] adjacencyMatrix) { + int v = adjacencyMatrix.length; + boolean visited[] = new boolean[v]; + int distance[] = new int[v]; + distance[0] = 0; + for (int i = 1; i < v; i++) { + distance[i] = Integer.MAX_VALUE; + } + for (int i = 0; i < v - 1; i++) { + + int minVertex = findMinVertex(distance, visited); + visited[minVertex] = true; + + for (int j = 0; j < v; j++) { + if (adjacencyMatrix[minVertex][j] != 0 && !visited[j] && + distance[minVertex] != Integer.MAX_VALUE) { + int newDist = distance[minVertex] + + adjacencyMatrix[minVertex][j]; + if (newDist < distance[j]) { + distance[j] = newDist; + } + } + } + } + + for (int i = 0; i < v; i++) { + System.out.println(i + " " + distance[i]); + } + } + private static int findMinVertex(int[] distance, boolean visited[]) { + int minVertex = -1; + for (int i = 0; i < distance.length; i++) { + if (!visited[i] && (minVertex == -1 || distance[i] < + distance[minVertex])) { + minVertex = i; + } + } + return minVertex; + } + public static void main(String[] args) { + Scanner s = new Scanner(System.in); + int v = s.nextInt(); + int e = s.nextInt(); + int adjacencyMatrix[][] = new int[v][v]; + for (int i = 0; i < e; i++) { + int v1 = s.nextInt(); + int v2 = s.nextInt(); + int weight = s.nextInt(); + adjacencyMatrix[v1][v2] = weight; + adjacencyMatrix[v2][v1] = weight; + } + dijkstra(adjacencyMatrix); + } +} \ No newline at end of file diff --git "a/Dijkstra\342\200\231s Shortest Path Algorithm" "b/Dijkstra\342\200\231s Shortest Path Algorithm" new file mode 100644 index 0000000..75de844 --- /dev/null +++ "b/Dijkstra\342\200\231s Shortest Path Algorithm" @@ -0,0 +1,109 @@ +// A Java program for Dijkstra's single source shortest path +// algorithm. The program is for adjacency matrix +// representation of the graph +import java.io.*; +import java.lang.*; +import java.util.*; + +class ShortestPath { + // A utility function to find the vertex with minimum + // distance value, from the set of vertices not yet + // included in shortest path tree + static final int V = 9; + int minDistance(int dist[], Boolean sptSet[]) + { + // Initialize min value + int min = Integer.MAX_VALUE, min_index = -1; + + for (int v = 0; v < V; v++) + if (sptSet[v] == false && dist[v] <= min) { + min = dist[v]; + min_index = v; + } + + return min_index; + } + + // A utility function to print the constructed distance + // array + void printSolution(int dist[]) + { + System.out.println( + "Vertex \t\t Distance from Source"); + for (int i = 0; i < V; i++) + System.out.println(i + " \t\t " + dist[i]); + } + + // Function that implements Dijkstra's single source + // shortest path algorithm for a graph represented using + // adjacency matrix representation + void dijkstra(int graph[][], int src) + { + int dist[] = new int[V]; // The output array. + // dist[i] will hold + // the shortest distance from src to i + + // sptSet[i] will true if vertex i is included in + // shortest path tree or shortest distance from src + // to i is finalized + Boolean sptSet[] = new Boolean[V]; + + // Initialize all distances as INFINITE and stpSet[] + // as false + for (int i = 0; i < V; i++) { + dist[i] = Integer.MAX_VALUE; + sptSet[i] = false; + } + + // Distance of source vertex from itself is always 0 + dist[src] = 0; + + // Find shortest path for all vertices + for (int count = 0; count < V - 1; count++) { + // Pick the minimum distance vertex from the set + // of vertices not yet processed. u is always + // equal to src in first iteration. + int u = minDistance(dist, sptSet); + + // Mark the picked vertex as processed + sptSet[u] = true; + + // Update dist value of the adjacent vertices of + // the picked vertex. + for (int v = 0; v < V; v++) + + // Update dist[v] only if is not in sptSet, + // there is an edge from u to v, and total + // weight of path from src to v through u is + // smaller than current value of dist[v] + if (!sptSet[v] && graph[u][v] != 0 + && dist[u] != Integer.MAX_VALUE + && dist[u] + graph[u][v] < dist[v]) + dist[v] = dist[u] + graph[u][v]; + } + + // print the constructed distance array + printSolution(dist); + } + + // Driver's code + public static void main(String[] args) + { + /* Let us create the example graph discussed above + */ + int graph[][] + = new int[][] { { 0, 4, 0, 0, 0, 0, 0, 8, 0 }, + { 4, 0, 8, 0, 0, 0, 0, 11, 0 }, + { 0, 8, 0, 7, 0, 4, 0, 0, 2 }, + { 0, 0, 7, 0, 9, 14, 0, 0, 0 }, + { 0, 0, 0, 9, 0, 10, 0, 0, 0 }, + { 0, 0, 4, 14, 10, 0, 2, 0, 0 }, + { 0, 0, 0, 0, 0, 2, 0, 1, 6 }, + { 8, 11, 0, 0, 0, 0, 1, 0, 7 }, + { 0, 0, 2, 0, 0, 0, 6, 7, 0 } }; + ShortestPath t = new ShortestPath(); + + // Function call + t.dijkstra(graph, 0); + } +} diff --git a/Disarium.java b/Disarium.java new file mode 100644 index 0000000..20966b3 --- /dev/null +++ b/Disarium.java @@ -0,0 +1,21 @@ +import java.util.*; +public class Disarium{ + boolean isDisarium(int n){ + byte c=0; + int b=0; + for(int i=n;i>0;c+=1,i/=10); + for(int i=n;i>0;b=b+(int)Math.pow(i%10,c--),i/=10); + if(n==b) + return true; + return false; + } + + public static void main(String args[]) + { + System.out.println("Enter a number:"); + if(new Disarium().isDisarium(new Scanner(System.in).nextInt())) + System.out.println("Disarium number"); + else + System.out.println("Not an Disarium number."); + } +} \ No newline at end of file diff --git a/Electricitybill.java b/Electricitybill.java new file mode 100644 index 0000000..8792ab8 --- /dev/null +++ b/Electricitybill.java @@ -0,0 +1,26 @@ +class ElectricityBillExample1 +{ + // main() method start + public static void main(String args[]) + { + // declare and initialize variable units + int units = 380; + // variable to calculate electricity bill to pay + double billToPay = 0; + // check whether units are less than 100 + if(units < 100) + { + billToPay = units * 1.20; + } + // check whether the units are less than 300 + else if(units < 300){ + billToPay = 100 * 1.20 + (units - 100) * 2; + } + // check whether the units are greater than 300 + else if(units > 300) + { + billToPay = 100 * 1.20 + 200 * 2 + (units - 300) * 3; + } + System.out.println("The electricity bill for " +units+ " is : " + billToPay); + } +} diff --git a/EvenOdd.java b/EvenOdd.java new file mode 100644 index 0000000..21eb851 --- /dev/null +++ b/EvenOdd.java @@ -0,0 +1,22 @@ +import java.util.*; + +public class EvenOdd { + public static void main(String[] args) { + int v=0,c=0; + Scanner sc = new Scanner(System.in); + + System.out.println("Enter String : "); + String a = sc.nextLine(); + + for (i=0; i<=a.length; i++){ + if(String.charAt[i]=='a' || String.charAt[i]=='e'||String.charAt[i]=='i'||String.charAt[i]=='o'||String.charAt[i]=='u'){ + v++; + } + else{ + c++; + } + } + System.out.println("Vowels: "+ v); + System.out.println("Consonents: "+ c); + } +} diff --git a/FactorialProgram.java b/FactorialProgram.java new file mode 100644 index 0000000..de1ecbc --- /dev/null +++ b/FactorialProgram.java @@ -0,0 +1,31 @@ +import java.util.Scanner; + +class Abc +{ + public int f=1,i=0; + + public void fact(int n) + { + for(i=1; i<=n; i++) + { + f = f*i; + } + + System.out.println(n + " Factorial is : " + f); + } +} + +class factorial +{ + public static void main(String arr[]) + { + Scanner m = new Scanner(System.in); + + System.out.print("Enter Elemnt TO find Factorial : "); + int n = m.nextInt(); + + Abc a1 = new Abc(); + a1.fact(n); + + } +} diff --git a/FibonacciSeries.java b/FibonacciSeries.java new file mode 100644 index 0000000..4e6629e --- /dev/null +++ b/FibonacciSeries.java @@ -0,0 +1,15 @@ +class Fibonacci{ +public static void main(String args[]) +{ + int n1=0,n2=1,n3,i,count=10; + System.out.print(n1+" "+n2);//printing 0 and 1 + + for(i=2;i ans = new Vector<>(); + + // Traversal + for (int i = n - 1; i >= 0; i--) + { + // Find denominations + while (V >= deno[i]) + { + V -= deno[i]; + ans.add(deno[i]); + } + } + + // Printing result + for (int i = 0; i < ans.size(); i++) + { + System.out.print( + " " + ans.elementAt(i)); + } + } + + public static void main(String[] args) + { + int n = 93; + System.out.print( + "Following is minimum number " + +"of change for " + n + ": "); + findMin(n); + } +} + + diff --git a/FloydTrg.java b/FloydTrg.java new file mode 100644 index 0000000..f28d709 --- /dev/null +++ b/FloydTrg.java @@ -0,0 +1,17 @@ +import java.io.*; +public class FloydTrg{ + void gen(int n){ + int c=0; + for(int i=1;i<=n;i++){ + for(int j=1;j<=i;j++) + System.out.print(++c+" "); + System.out.println(); + } + } + + public static void main(String args[])throws IOException + { + System.out.println("Enter the line numbers:"); + new FloydTrg().gen(Integer.parseInt(new BufferedReader(new InputStreamReader(System.in)).readLine())); + } +} \ No newline at end of file diff --git a/GCD of two numbers b/GCD of two numbers new file mode 100644 index 0000000..8303736 --- /dev/null +++ b/GCD of two numbers @@ -0,0 +1,11 @@ +def hcf(a, b): + if(b == 0): + return a + else: + return hcf(b, a % b) + +a = 60 +b = 48 + +print("The gcd of 60 and 48 is : ", end="") +print(hcf(60, 48)) diff --git a/GCD.java b/GCD.java new file mode 100644 index 0000000..284b664 --- /dev/null +++ b/GCD.java @@ -0,0 +1,29 @@ +/** + * Java program to find Greatest Common Divisor or GCD of + * two numbers using Euclid’s method.*/ + import java.util.*; +public class GCD{ + + public static void main(String args[]){ + + //Enter two number whose GCD needs to be calculated. + Scanner sc = new Scanner(System.in); + System.out.println("Please enter first number to find GCD"); + int num1 = sc.nextInt(); + System.out.println("Please enter second number to find GCD"); + int num2 = sc.nextInt(); + + System.out.println("GCD of two numbers " + num1 +" and " + + num2 +" is :" + GCD(num1,num2)); + + + } + private static int GCD(int num1, int num2) { + //base case + if(num2 == 0){ + return num1; + } + return GCD(num2, num1%num2); + } + +} \ No newline at end of file diff --git a/Gcd.java b/Gcd.java new file mode 100644 index 0000000..df4c4b9 --- /dev/null +++ b/Gcd.java @@ -0,0 +1,33 @@ +import java.util.*; +class Gcd +{ + public static int gcd(int n1,int n2) + { + while(n1!=n2) + { + if(n1>n2) + { + n1=n1-n2; + } + else + { + n2=n2-n1; + } + } + return n1; + + } + public static void main(String args[]) + { + int n1,n2; + Scanner Sc = new Scanner(System.in); + System.out.print("enter n1:"); + n1=Sc.nextInt(); + System.out.print("enter n2:"); + n2=Sc.nextInt(); + System.out.println("gcd of "+n1+" and "+n2+" is "+gcd(n1,n2)); + } + +} + + diff --git a/Greatest Number b/Greatest Number new file mode 100644 index 0000000..499e3bc --- /dev/null +++ b/Greatest Number @@ -0,0 +1,12 @@ +num1 = float(input("Enter first number: ")) +num2 = float(input("Enter second number: ")) +num3 = float(input("Enter third number: ")) + +if (num1 >= num2) and (num1 >= num3): + largest = num1 +elif (num2 >= num1) and (num2 >= num3): + largest = num2 +else: + largest = num3 + +print("The largest number is", largest) diff --git a/GuessNumber.java b/GuessNumber.java new file mode 100644 index 0000000..674d8e6 --- /dev/null +++ b/GuessNumber.java @@ -0,0 +1,45 @@ +package com.company; +import java.util.Random; +import java.util.Scanner; +public class GuessNumber +{ + + + + public static void main(String[] args) { + System.out.printf("***Welcome Guess Number game ****\n"); + + Random ra = new Random(); + int gen = ra.nextInt(10); + System.out.printf("Guess ? \n"); + int number ; + System.out.printf("Enter the number to guess between 0 to 9 \n"); + Scanner scan = new Scanner(System.in); + number = scan.nextInt(); + + do { + if (number>gen) + { + System.out.printf("Please try again Number %d > ? \n",number); + number = scan.nextInt(); + } + + else + { + + System.out.printf("Please try again Number %d < ? \n",number); + + number = scan.nextInt(); + + + } + + }while ( number!=gen); + + + System.out.println("Great you won " + " number is " + gen ); + + } + + +} diff --git a/GuessTheNumberGame.java b/GuessTheNumberGame.java new file mode 100644 index 0000000..7b5b3bd --- /dev/null +++ b/GuessTheNumberGame.java @@ -0,0 +1,34 @@ +import java.util.*; + +class GuessTheNumberGame +{ + public static void main(String[] args) + { + Scanner sc = new Scanner(System.in); + Random rm = new Random(); + + int cc = rm.nextInt(1,100); + int uc,count=0; + System.out.println("Guess the number : "); + + for(;;) + { + uc = sc.nextInt(); + count++; + + if(uc==cc) + { + System.out.println("You guessed the number in "+count+" turns."); + break; + } + else if(uccc) + { + System.out.println("This number is greater than computer's.\nTry again :"); + } + } + } +} \ No newline at end of file diff --git a/Hackfest.cpp b/Hackfest.cpp new file mode 100644 index 0000000..17a4da1 --- /dev/null +++ b/Hackfest.cpp @@ -0,0 +1,25 @@ +// Factorial of n = 1*2*3*...*n + +#include +using namespace std; + +int factorial(int); + +int main() { + int n, result; + + cout << "Enter a non-negative number: "; + cin >> n; + + result = factorial(n); + cout << "Factorial of " << n << " = " << result; + return 0; +} + +int factorial(int n) { + if (n > 1) { + return n * factorial(n - 1); + } else { + return 1; + } +} diff --git a/Harshpreet Singh3 b/Harshpreet Singh3 new file mode 100644 index 0000000..17a4da1 --- /dev/null +++ b/Harshpreet Singh3 @@ -0,0 +1,25 @@ +// Factorial of n = 1*2*3*...*n + +#include +using namespace std; + +int factorial(int); + +int main() { + int n, result; + + cout << "Enter a non-negative number: "; + cin >> n; + + result = factorial(n); + cout << "Factorial of " << n << " = " << result; + return 0; +} + +int factorial(int n) { + if (n > 1) { + return n * factorial(n - 1); + } else { + return 1; + } +} diff --git a/HeapSort.java b/HeapSort.java index fb34021..3330fdf 100644 --- a/HeapSort.java +++ b/HeapSort.java @@ -1,72 +1,59 @@ -public class HeapSort { - public void sort(int arr[]) - { - int N = arr.length; - - // Build heap (rearrange array) - for (int i = N / 2 - 1; i >= 0; i--) - heapify(arr, N, i); - - // One by one extract an element from heap - for (int i = N - 1; i > 0; i--) { - // Move current root to end - int temp = arr[0]; - arr[0] = arr[i]; - arr[i] = temp; - - // call max heapify on the reduced heap - heapify(arr, i, 0); - } - } - - // To heapify a subtree rooted with node i which is - // an index in arr[]. n is size of heap - void heapify(int arr[], int N, int i) - { - int largest = i; // Initialize largest as root - int l = 2 * i + 1; // left = 2*i + 1 - int r = 2 * i + 2; // right = 2*i + 2 - - // If left child is larger than root - if (l < N && arr[l] > arr[largest]) - largest = l; - - // If right child is larger than largest so far - if (r < N && arr[r] > arr[largest]) - largest = r; - - // If largest is not root - if (largest != i) { - int swap = arr[i]; - arr[i] = arr[largest]; - arr[largest] = swap; - - // Recursively heapify the affected sub-tree - heapify(arr, N, largest); - } - } - - /* A utility function to print array of size n */ - static void printArray(int arr[]) - { - int N = arr.length; - - for (int i = 0; i < N; ++i) - System.out.print(arr[i] + " "); - System.out.println(); - } - - // Driver's code - public static void main(String args[]) - { - int arr[] = { 12, 11, 13, 5, 6, 7 }; - int N = arr.length; - - // Function call - HeapSort ob = new HeapSort(); - ob.sort(arr); - - System.out.println("Sorted array is"); - printArray(arr); - } -} \ No newline at end of file +class HeapSort +{ +/* function to heapify a subtree. Here 'i' is the +index of root node in array a[], and 'n' is the size of heap. */ +static void heapify(int a[], int n, int i) +{ + int largest = i; // Initialize largest as root + int left = 2 * i + 1; // left child + int right = 2 * i + 2; // right child + // If left child is larger than root + if (left < n && a[left] > a[largest]) + largest = left; + // If right child is larger than root + if (right < n && a[right] > a[largest]) + largest = right; + // If root is not largest + if (largest != i) { + // swap a[i] with a[largest] + int temp = a[i]; + a[i] = a[largest]; + a[largest] = temp; + + heapify(a, n, largest); + } +} +/*Function to implement the heap sort*/ +static void heapSort(int a[], int n) +{ + for (int i = n / 2 - 1; i >= 0; i--) + heapify(a, n, i); + + // One by one extract an element from heap + for (int i = n - 1; i >= 0; i--) { + /* Move current root element to end*/ + // swap a[0] with a[i] + int temp = a[0]; + a[0] = a[i]; + a[i] = temp; + + heapify(a, i, 0); + } +} +/* function to print the array elements */ +static void printArr(int a[], int n) +{ + for (int i = 0; i < n; ++i) + System.out.print(a[i] + " "); +} +public static void main(String args[]) +{ + int a[] = {45, 7, 20, 40, 25, 23, -2}; + int n = a.length; + System.out.print("Before sorting array elements are - \n"); + printArr(a, n); + heapSort(a, n); + System.out.print("\nAfter sorting array elements are - \n"); + printArr(a, n); +} +} \ No newline at end of file diff --git a/Heap_Sort.java b/Heap_Sort.java new file mode 100644 index 0000000..f9800d7 --- /dev/null +++ b/Heap_Sort.java @@ -0,0 +1,70 @@ +public class HeapSort +{ + public void sort(int arr[]) + { + int n = arr.length; + + // Build heap (rearrange array) + for (int i = n / 2 - 1; i >= 0; i--) + heapify(arr, n, i); + + // One by one extract an element from heap + for (int i=n-1; i>=0; i--) + { + // Move current root to end + int temp = arr[0]; + arr[0] = arr[i]; + arr[i] = temp; + + // call max heapify on the reduced heap + heapify(arr, i, 0); + } + } + + + void heapify(int arr[], int n, int i) + { + int largest = i; + int l = 2*i + 1; + int r = 2*i + 2; + + + if (l < n && arr[l] > arr[largest]) + largest = l; + + + if (r < n && arr[r] > arr[largest]) + largest = r; + + // If largest is not root + if (largest != i) + { + int swap = arr[i]; + arr[i] = arr[largest]; + arr[largest] = swap; + + + heapify(arr, n, largest); + } + } + + static void printArray(int arr[]) + { + int n = arr.length; + for (int i=0; i2){ + li[a]=n; + } + li1=new int[li.length]; + for(int i=0; i9){ + while(li[i]!=0){ + int rem=li[i]%10; + sum+=rem; + li[i]/=10; + } + } + else { + sum += li[i]; + } + } + } + return sum; + } + +} + +public class Hoax_No { + public static void main(String[] args) { + int a; + Scanner sc=new Scanner(System.in); + a= sc.nextInt(); + Hoax s=new Hoax(a); +// int[] li=s.factors(); +// for(int i=0; i0) + { + Scanner meet = new Scanner(System.in); + + System.out.print("Enter Bowler Player Type (Fast / Spin / Medium) : "); + role = meet.next(); + } + + } +} + +class batsman extends CricketPlayer +{ + void getCar() + { + Scanner meet = new Scanner(System.in); + + System.out.print("Enter Player Carrer Total Match : "); + total = meet.nextInt(); + + } + + void print1() + { + System.out.println("Player Type : " + type); + System.out.println("Carrer Total Match : " + total); + } + +} + +class Bowler extends CricketPlayer +{ + + void print() + { + System.out.println("Player Name : " + name); + System.out.println("Player Age : " + age); + + if(c == 1) + { + System.out.println("Player Boling Type : " + role); + } + + } + +} + +class Inheri { + + public static void main(String arr[]) + { + Bowler b1 = new Bowler(); + batsman c1 = new batsman(); + + b1.getData(); + c1.getCar(); + b1.Bowler_Info(); + + System.out.print("\n------------------------------------------------\n"); + + b1.print(); + c1.print1(); + + System.out.println("------------------------------------------------"); + + } + +} diff --git a/Insertion Sort b/Insertion Sort new file mode 100644 index 0000000..d1940b4 --- /dev/null +++ b/Insertion Sort @@ -0,0 +1,30 @@ +public class InsertionSortExample { + public static void insertionSort(int array[]) { + int n = array.length; + for (int j = 1; j < n; j++) { + int key = array[j]; + int i = j-1; + while ( (i > -1) && ( array [i] > key ) ) { + array [i+1] = array [i]; + i--; + } + array[i+1] = key; + } + } + + public static void main(String a[]){ + int[] arr1 = {9,14,3,2,43,11,58,22}; + System.out.println("Before Insertion Sort"); + for(int i:arr1){ + System.out.print(i+" "); + } + System.out.println(); + + insertionSort(arr1);//sorting array using insertion sort + + System.out.println("After Insertion Sort"); + for(int i:arr1){ + System.out.print(i+" "); + } + } +} diff --git a/InsertionSort.java b/InsertionSort.java index ad17d3e..c30fc08 100644 --- a/InsertionSort.java +++ b/InsertionSort.java @@ -1,38 +1,42 @@ -import java.util.Arrays; - -public class InsertionSort { - - //Função para o Insertion Sort - public static void sort(int[] vetor) { - int aux, j; - //Laço de repetição para percorrer a lista - for (int i = 1; i < vetor.length; i++) { - //Auxiliar para melhor leitura - aux = vetor[i]; - //Indice do vetor - j = i - 1; - - //Enquanto as 2 opções forem Verdadeiras - while(j >= 0 && aux < vetor[j]) { - //O num q estava na posição j+1 vai ocupar a posição j - vetor[j+1] = vetor[j]; - //Caso o aux precise andar mais de uma casa para esquerda - j--; - } - vetor[j+1] = aux; - } - } - - - //Função Principal - public static void main(String[] args) { - //Criação lista 0 1 2 3 4 - int[] vetor = { 3, 4, 1, 2, 5 }; - - //Função para ordenar a lista - sort(vetor); - - //Imprimindo a lista Ordenada - System.out.println(Arrays.toString(vetor)); - } -} +// Java program for implementation of Insertion Sort +class InsertionSort { + /*Function to sort array using insertion sort*/ + void sort(int arr[]) + { + int n = arr.length; + for (int i = 1; i < n; ++i) { + int key = arr[i]; + int 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 array of size n*/ + static void printArray(int arr[]) + { + int n = arr.length; + for (int i = 0; i < n; ++i) + System.out.print(arr[i] + " "); + + System.out.println(); + } + + // Driver method + public static void main(String args[]) + { + int arr[] = { 12, 11, 13, 5, 6 }; + + InsertionSort ob = new InsertionSort(); + ob.sort(arr); + + printArray(arr); + } +} \ No newline at end of file diff --git a/Intersection of Two Arrays II.java b/Intersection of Two Arrays II.java new file mode 100644 index 0000000..23f9897 --- /dev/null +++ b/Intersection of Two Arrays II.java @@ -0,0 +1,15 @@ + +public class Solution{ + + public static void intersections(int arr1[], int arr2[]) { + for (int i = 0; i < arr1.length; i++){ + for (int j = 0; j < arr2.length; j++){ + if (arr1[i] == arr2[j]){ + System.out.print(arr1[i] + " "); + arr2[j] = Integer.MIN_VALUE; + break; + } + } + } + } +} diff --git a/Java program to find maximum product of.java b/Java program to find maximum product of.java new file mode 100644 index 0000000..b61b9f7 --- /dev/null +++ b/Java program to find maximum product of.java @@ -0,0 +1,78 @@ +// Java program to find maximum product of +// a subset. +class Array { + + static int minProductSubset(int a[], int n) + { + if (n == 1) + return a[0]; + + // Find count of negative numbers, + // count of zeros, maximum valued + // negative number, minimum valued + // positive number and product of + // non-zero numbers + int negmax = Integer.MIN_VALUE; + int posmin = Integer.MAX_VALUE; + int count_neg = 0, count_zero = 0; + int product = 1; + + for (int i = 0; i < n; i++) { + + // if number is zero,count it + // but dont multiply + if (a[i] == 0) { + count_zero++; + continue; + } + + // count the negative numbers + // and find the max negative number + if (a[i] < 0) { + count_neg++; + negmax = Math.max(negmax, a[i]); + } + + // find the minimum positive number + if (a[i] > 0 && a[i] < posmin) + posmin = a[i]; + + product *= a[i]; + } + + // if there are all zeroes + // or zero is present but no + // negative number is present + if (count_zero == n + || (count_neg == 0 && count_zero > 0)) + return 0; + + // If there are all positive + if (count_neg == 0) + return posmin; + + // If there are even number except + // zero of negative numbers + if (count_neg % 2 == 0 && count_neg != 0) { + + // Otherwise result is product of + // all non-zeros divided by maximum + // valued negative. + product = product / negmax; + } + + return product; + } + + // main function + public static void main(String[] args) + { + + int a[] = { -1, -1, -2, 4, 3 }; + int n = 5; + + System.out.println(minProductSubset(a, n)); + } +} + +// This code is contributed by Arnab Kundu. diff --git a/JavaAlgo.java b/JavaAlgo.java new file mode 100644 index 0000000..743d671 --- /dev/null +++ b/JavaAlgo.java @@ -0,0 +1,35 @@ +public class JumpSearchAlgorithm { + + public static void main(String[] args) { + int[] arr = {10, 20, 30, 40, 50, 60, 70, 80, 90}; + int ele = 60; + + int foundIndex = jumpSearch(arr, ele); + System.out.println(foundIndex > 0 ? "Found at index : " + foundIndex : "Element Not Found"); + } + + public static int jumpSearch(int[] arr, int ele) { + + int prev = 0; + int n = arr.length; + int step = (int) Math.floor(Math.sqrt(n)); + + //loop until current element is less than the given search element + while (arr[Math.min(step, n) - 1] < ele) { + prev = step; + step += (int) Math.floor(Math.sqrt(n)); + if (prev >= n) return -1; + } + + //perform linear search prev index element to given element + while (arr[prev] < ele) { + prev++; + if (prev == Math.min(step, n)) return -1; + } + + // Return index if element is found + if (arr[prev] == ele) return prev; + + return -1; + } +} diff --git a/JavaAlgo4 b/JavaAlgo4 new file mode 100644 index 0000000..56dfae1 --- /dev/null +++ b/JavaAlgo4 @@ -0,0 +1,23 @@ +#include +using namespace std; + +int factorial(int n); + +int main() { + + int n; + + cout << "Enter a positive integer: "; + cin >> n; + + cout << "Factorial of " << n << " = " << factorial(n); + + return 0; +} + +int factorial(int n) { + if(n > 1) + return n * factorial(n - 1); + else + return 1; +} diff --git a/K closest elements b/K closest elements new file mode 100644 index 0000000..2d0ee55 --- /dev/null +++ b/K closest elements @@ -0,0 +1,25 @@ +class Solution { + public List findClosestElements(int[] arr, int k, int x) { + Map> map = new TreeMap<>(); + List result = new ArrayList<>(); + + for(int i=0; i vals = map.getOrDefault(diff,new ArrayList<>()); + vals.add(arr[i]); + map.put(diff,vals); + } + + + for(Map.Entry> entry : map.entrySet()){ + for(Integer num : entry.getValue()){ + if(k>0){ + result.add(num); + k--; + } + } + } + Collections.sort(result); + return result; + } +} diff --git a/Kadane.java b/Kadane.java new file mode 100644 index 0000000..261aae7 --- /dev/null +++ b/Kadane.java @@ -0,0 +1,24 @@ + +public class Kadane { + public static void main(String[] args) { + System.out.println(kadaneAlgo(new int[]{1,2,3,4,-10, 11, -1})); + } + + public static int kadaneAlgo(int[] arr){ + int max = arr[0], sum = 0; + int len = 0; + for (int i = 0; i < arr.length; i++) { + + sum+=arr[i]; + len++; + if (sum > max) { + max = sum; + } + if (sum <= 0) { + sum = 0; + len = 0; + } + } + return max; + } +} diff --git a/Kadane_Algorithm.java b/Kadane_Algorithm.java new file mode 100644 index 0000000..fc3b9e3 --- /dev/null +++ b/Kadane_Algorithm.java @@ -0,0 +1,30 @@ +// Java program to print largest contiguous array sum +import java.io.*; +import java.util.*; + +class Kadane_Algorithm { + // Driver Code + public static void main(String[] args) + { + int[] a = { -2, -3, 4, -1, -2, 1, 5, -3 }; + System.out.println("Maximum contiguous sum is " + + maxSubArraySum(a)); + } + + // Function Call + static int maxSubArraySum(int a[]) + { + int size = a.length; + int max_so_far = Integer.MIN_VALUE, max_ending_here + = 0; + + for (int i = 0; i < size; i++) { + max_ending_here = max_ending_here + a[i]; + if (max_so_far < max_ending_here) + max_so_far = max_ending_here; + if (max_ending_here < 0) + max_ending_here = 0; + } + return max_so_far; + } +} diff --git a/Keshavg.cpp b/Keshavg.cpp new file mode 100644 index 0000000..17a4da1 --- /dev/null +++ b/Keshavg.cpp @@ -0,0 +1,25 @@ +// Factorial of n = 1*2*3*...*n + +#include +using namespace std; + +int factorial(int); + +int main() { + int n, result; + + cout << "Enter a non-negative number: "; + cin >> n; + + result = factorial(n); + cout << "Factorial of " << n << " = " << result; + return 0; +} + +int factorial(int n) { + if (n > 1) { + return n * factorial(n - 1); + } else { + return 1; + } +} diff --git a/Krushkal-Algorithm.java b/Krushkal-Algorithm.java new file mode 100644 index 0000000..a56c411 --- /dev/null +++ b/Krushkal-Algorithm.java @@ -0,0 +1,198 @@ +// Java program for Kruskal's algorithm to +// find Minimum Spanning Tree of a given +// connected, undirected and weighted graph + +import java.io.*; +import java.lang.*; +import java.util.*; + +class Graph { + + // A class to represent a graph edge + class Edge implements Comparable { + int src, dest, weight; + + // Comparator function used for + // sorting edgesbased on their weight + public int compareTo(Edge compareEdge) + { + return this.weight - compareEdge.weight; + } + }; + + // A class to represent a subset for + // union-find + class subset { + int parent, rank; + }; + + int V, E; // V-> no. of vertices & E->no.of edges + Edge edge[]; // collection of all edges + + // Creates a graph with V vertices and E edges + Graph(int v, int e) + { + V = v; + E = e; + edge = new Edge[E]; + for (int i = 0; i < e; ++i) + edge[i] = new Edge(); + } + + // A utility function to find set of an + // element i (uses path compression technique) + int find(subset subsets[], int i) + { + // find root and make root as parent of i + // (path compression) + if (subsets[i].parent != i) + subsets[i].parent + = find(subsets, subsets[i].parent); + + return subsets[i].parent; + } + + // A function that does union of two sets + // of x and y (uses union by rank) + void Union(subset subsets[], int x, int y) + { + int xroot = find(subsets, x); + int yroot = find(subsets, y); + + // Attach smaller rank tree under root + // of high rank tree (Union by Rank) + if (subsets[xroot].rank < subsets[yroot].rank) + subsets[xroot].parent = yroot; + else if (subsets[xroot].rank > subsets[yroot].rank) + subsets[yroot].parent = xroot; + + // If ranks are same, then make one as + // root and increment its rank by one + else { + subsets[yroot].parent = xroot; + subsets[xroot].rank++; + } + } + + // The main function to construct MST using Kruskal's + // algorithm + void KruskalMST() + { + // This will store the resultant MST + Edge result[] = new Edge[V]; + + // An index variable, used for result[] + int e = 0; + + // An index variable, used for sorted edges + int i = 0; + for (i = 0; i < V; ++i) + result[i] = new Edge(); + + // Step 1: Sort all the edges in non-decreasing + // order of their weight. If we are not allowed to + // change the given graph, we can create a copy of + // array of edges + Arrays.sort(edge); + + // Allocate memory for creating V subsets + subset subsets[] = new subset[V]; + for (i = 0; i < V; ++i) + subsets[i] = new subset(); + + // Create V subsets with single elements + for (int v = 0; v < V; ++v) { + subsets[v].parent = v; + subsets[v].rank = 0; + } + + i = 0; // Index used to pick next edge + + // Number of edges to be taken is equal to V-1 + while (e < V - 1) { + // Step 2: Pick the smallest edge. And increment + // the index for next iteration + Edge next_edge = edge[i++]; + + int x = find(subsets, next_edge.src); + int y = find(subsets, next_edge.dest); + + // If including this edge doesn't cause cycle, + // include it in result and increment the index + // of result for next edge + if (x != y) { + result[e++] = next_edge; + Union(subsets, x, y); + } + // Else discard the next_edge + } + + // print the contents of result[] to display + // the built MST + System.out.println("Following are the edges in " + + "the constructed MST"); + int minimumCost = 0; + for (i = 0; i < e; ++i) { + System.out.println(result[i].src + " -- " + + result[i].dest + + " == " + result[i].weight); + minimumCost += result[i].weight; + } + System.out.println("Minimum Cost Spanning Tree " + + minimumCost); + } + + // Driver's Code + public static void main(String[] args) + { + + /* Let us create following weighted graph + 10 + 0--------1 + | \ | + 6| 5\ |15 + | \ | + 2--------3 + 4 */ + int V = 4; // Number of vertices in graph + int E = 5; // Number of edges in graph + Graph graph = new Graph(V, E); + + // add edge 0-1 + graph.edge[0].src = 0; + graph.edge[0].dest = 1; + graph.edge[0].weight = 10; + + // add edge 0-2 + graph.edge[1].src = 0; + graph.edge[1].dest = 2; + graph.edge[1].weight = 6; + + // add edge 0-3 + graph.edge[2].src = 0; + graph.edge[2].dest = 3; + graph.edge[2].weight = 5; + + // add edge 1-3 + graph.edge[3].src = 1; + graph.edge[3].dest = 3; + graph.edge[3].weight = 15; + + // add edge 2-3 + graph.edge[4].src = 2; + graph.edge[4].dest = 3; + graph.edge[4].weight = 4; + + // Function call + graph.KruskalMST(); + } +} +// OutPut +""" +Following are the edges in the constructed MST +2 -- 3 == 4 +0 -- 3 == 5 +0 -- 1 == 10 +Minimum Cost Spanning Tree: 19 + +""" \ No newline at end of file diff --git a/Kth Element using HEAP (Priority queue).java b/Kth Element using HEAP (Priority queue).java new file mode 100644 index 0000000..2e7ad92 --- /dev/null +++ b/Kth Element using HEAP (Priority queue).java @@ -0,0 +1,80 @@ +// Java code for k largest/ smallest elements in an array +import java.util.*; + +class GFG { + + // Function to find k largest array element + static void kLargest(int a[], int n, int k) + { + // Implementation using + // a Priority Queue + PriorityQueue pq + = new PriorityQueue(); + + for (int i = 0; i < n; ++i) { + + // Insert elements into + // the priority queue + pq.add(a[i]); + + // If size of the priority + // queue exceeds k + if (pq.size() > k) { + pq.poll(); + } + } + + // Print the k largest element + while (!pq.isEmpty()) { + System.out.print(pq.peek() + " "); + pq.poll(); + } + System.out.println(); + } + + // Function to find k smallest array element + static void kSmallest(int a[], int n, int k) + { + // Implementation using + // a Priority Queue + PriorityQueue pq + = new PriorityQueue( + Collections.reverseOrder()); + + for (int i = 0; i < n; ++i) { + + // Insert elements into + // the priority queue + pq.add(a[i]); + + // If size of the priority + // queue exceeds k + if (pq.size() > k) { + pq.poll(); + } + } + + // Print the k largest element + while (!pq.isEmpty()) { + System.out.print(pq.peek() + " "); + pq.poll(); + } + } + + // Driver Code + public static void main(String[] args) + { + int a[] + = { 11, 3, 2, 1, 15, 5, 4, 45, 88, 96, 50, 45 }; + int n = a.length; + int k = 3; + System.out.print(k + " largest elements are : "); + // Function Call + kLargest(a, n, k); + System.out.print(k + " smallest elements are : "); + // Function Call + kSmallest(a, n, k); + } +} + +// This code is contributed by Harsh diff --git a/Lab4ComplexNum.cpp b/Lab4ComplexNum.cpp new file mode 100644 index 0000000..c11fce3 --- /dev/null +++ b/Lab4ComplexNum.cpp @@ -0,0 +1,81 @@ +/* Implement a class complex which represent the complex number data type.Implement the following operations: +1)Default Constuctor (including a default constuctor which creates the complex number 0+0i) +2)Paramatrised Constuctor (3+5i) +3)Copy Constuctor : use this to display the same complex number as of part 2 */ + +#include +using namespace std; +class complex +{ + int real,imaginary; + public: + complex() + { + real=imaginary=0; + } + void display() + { + cout< +using namespace std; +class complex +{ + int real,imaginary; + public: + complex(int r,int i) + { + real=3; + imaginary=5; + } + void display() + { + cout< +using namespace std; +class complex +{ + int real,imaginary; + public: + complex(int r,int i) + { + real=r; + imaginary=i; + } + complex(complex &c) + { + real=c.real; + imaginary=c.imaginary; + } + void display() + { + cout< ll = new LinkedList<>(); + Scanner sc = new Scanner(System.in); + + // Add elements to LinkedList + System.out.println("Options:"); + System.out.println("1. Enter element.\n2. Exit."); + System.out.println("Enter choice: "); + int ch = 1; + ch = Integer.parseInt(sc.nextLine()); + do{ + switch(ch){ + case 1: + //insert the element. + System.out.println("Enter the element: "); + String element = sc.nextLine(); + ll.add(element); + break; + + case 2: + //exit the loop, + ch=2; + System.out.println("Ending insertion into linked list..."); + break; + + default: + //invalid choice: + System.out.println("Enter a valid input!"); + break; + } + System.out.println("Enter choice: "); + ch = Integer.parseInt(sc.nextLine()); + }while(ch!=2); + System.out.println("LinkedList: " + ll); + } +} \ No newline at end of file diff --git a/Maximum_product_subarray.cpp b/Maximum_product_subarray.cpp new file mode 100644 index 0000000..e31bd11 --- /dev/null +++ b/Maximum_product_subarray.cpp @@ -0,0 +1,13 @@ +class Solution { +public: + int maxProduct(vector& nums) { + int max_pro=1; + int curr_pro=1; + for(int i=0;i Right -> Up -> Left, if the path doesn't work, then backtrack + /** + * + * @Description + * @author OngLipWei + * @date Jun 23, 202111:36:14 AM + * @param map The maze + * @param i x coordinate of your ball(target) + * @param j y coordinate of your ball(target) + * @return If we did find a path for the ball，return true，else false + */ + public static boolean setWay(int[][] map, int i, int j) { + if (map[6][5] == 2) {// means the ball find its path, ending condition + return true; + } + if (map[i][j] == 0) { // if the ball haven't gone through this point + // then the ball follows the move strategy : down -> right -> up -> left + map[i][j] = 2; // we assume that this path is feasible first, set the current point to 2 first。 + if (setWay(map, i + 1, j)) { // go down + return true; + } else if (setWay(map, i, j + 1)) { // go right + return true; + } else if (setWay(map, i - 1, j)) { // go up + return true; + } else if (setWay(map, i, j - 1)) { // go left + return true; + } else { + // means that the current point is the dead end, the ball cannot proceed, set + // the current point to 3 and return false, the backtraking will start, it will + // go to the previous step and check for feasible path again + map[i][j] = 3; + return false; + } + + } else { // if the map[i][j] != 0 , it will probably be 1,2,3, return false because the + // ball cannot hit the wall, cannot go to the path that has gone though before, + // and cannot head to deadend. + return false; + } + + } + + // Here is another move strategy for the ball: up->right->down->left + public static boolean setWay2(int[][] map, int i, int j) { + if (map[6][5] == 2) {// means the ball find its path, ending condition + return true; + } + if (map[i][j] == 0) { // if the ball haven't gone through this point + // then the ball follows the move strategy : up->right->down->left + map[i][j] = 2; // we assume that this path is feasible first, set the current point to 2 first。 + if (setWay2(map, i - 1, j)) { // go up + return true; + } else if (setWay2(map, i, j + 1)) { // go right + return true; + } else if (setWay2(map, i + 1, j)) { // go down + return true; + } else if (setWay2(map, i, j - 1)) { // go left + return true; + } else { + // means that the current point is the dead end, the ball cannot proceed, set + // the current point to 3 and return false, the backtraking will start, it will + // go to the previous step and check for feasible path again + map[i][j] = 3; + return false; + } + + } else { // if the map[i][j] != 0 , it will probably be 1,2,3, return false because the + // ball cannot hit the wall, cannot go to the path that has gone though before, + // and cannot head to deadend. + return false; + } + + } + +} diff --git a/MergeSort.java b/MergeSort.java deleted file mode 100644 index 3afd59b..0000000 --- a/MergeSort.java +++ /dev/null @@ -1,50 +0,0 @@ -import java.util.Scanner; - -public class MergeSort{ - public static void main(String[] args) { - Scanner sc = new Scanner(System.in); - int n = sc.nextInt(); - int[] arr = new int[n]; - for(int i=0;i heap; + public int size; + + public MinHeap() { + this.heap = new ArrayList(); + this.heap.add(null); + this.size = 0; + } + + public void add(int value) { + this.heap.add(value); + this.size += 1; + System.out.println("Adding: " + value); + System.out.println(this.heap); + this.bubbleUp(); + } + + public int popMin() { + if (this.size == 0) { + throw new Error("Heap is empty!"); + } + System.out.println("Swap min element " + this.heap.get(1) + " and last element " + this.heap.get(this.size)); + this.swap(1, this.size); + int min = this.heap.remove(this.size); + System.out.println("Removed from the heap: " + min); + System.out.println(this.heap); + this.size--; + this.heapify(); + return min; + } + + + private void bubbleUp() { + int current = this.size; + while (current > 1 && this.heap.get(this.getParent(current)) > this.heap.get(current)) { + System.out.println("Swap index " + current + " with index " + this.getParent(current)); + System.out.println(this.heap); + this.swap(current, this.getParent(current)); + current = this.getParent(current); + } + } + + private void heapify() { + int current = 1; + int leftChild = this.getLeft(current); + int rightChild = this.getRight(current); + while (this.canSwap(current, leftChild, rightChild)) { + if (this.exists(leftChild) && this.exists(rightChild)) { + if (this.heap.get(leftChild) < this.heap.get(rightChild)) { + this.swap(current, leftChild); + current = leftChild; + } else { + this.swap(current, rightChild); + current = rightChild; + } + } else { + this.swap(current, leftChild); + current = leftChild; + } + leftChild = this.getLeft(current); + rightChild = this.getRight(current); + + } + } + + + + private void swap(int a, int b) { + int temp = this.heap.get(b); + this.heap.set(b, this.heap.get(a)); + this.heap.set(a, temp); + } + + private boolean exists(int index) { + return index <= this.size; + } + + private boolean canSwap(int current, int leftChild, int rightChild) { + return (this.exists(leftChild) && (this.heap.get(current) > this.heap.get(leftChild))) + || (this.exists(rightChild) && (this.heap.get(current) > this.heap.get(rightChild))); + } + + public int getParent(int current) { + return (int) Math.floor(current / 2); + } + + public int getLeft(int current) { + return current * 2; + } + + public int getRight(int current) { + return (current * 2) + 1; + } + + + public static void main(String[] args) { + MinHeap minHeap = new MinHeap(); + Random r = new Random(); + for (int i = 0; i < 6; i++) { + int int_random = r.nextInt(40); + minHeap.add(int_random); + } + System.out.println("--------------"); + System.out.println("BUBBLED UP: " + minHeap.heap); + + // Remove minimum value multiple times + for (int i = 0; i < 6; i++) { + System.out.println("--------------"); + minHeap.popMin(); + System.out.println("HEAPIFIED: " + minHeap.heap); + } + } +} \ No newline at end of file diff --git a/MinimumSumPartition.java b/MinimumSumPartition.java new file mode 100644 index 0000000..fc0d87a --- /dev/null +++ b/MinimumSumPartition.java @@ -0,0 +1,89 @@ +package com.thealgorithms.dynamicprogramming; + +// Partition a set into two subsets such that the difference of subset sums is minimum + +/* +Input: arr[] = {1, 6, 11, 5} +Output: 1 +Explanation: +Subset1 = {1, 5, 6}, sum of Subset1 = 12 +Subset2 = {11}, sum of Subset2 = 11 + +Input: arr[] = {36, 7, 46, 40} +Output: 23 +Explanation: +Subset1 = {7, 46} ; sum of Subset1 = 53 +Subset2 = {36, 40} ; sum of Subset2 = 76 + */ +public class MinimumSumPartition { + + public static int subSet(int[] arr) { + int n = arr.length; + int sum = getSum(arr); + boolean[][] dp = new boolean[n + 1][sum + 1]; + for (int i = 0; i <= n; i++) { + dp[i][0] = true; + } + for (int j = 0; j <= sum; j++) { + dp[0][j] = false; + } + + // fill dp array + for (int i = 1; i <= n; i++) { + for (int j = 1; j <= sum; j++) { + if (arr[i - 1] < j) { + dp[i][j] = dp[i - 1][j - arr[i - 1]] || dp[i - 1][j]; + } else if (arr[i - 1] == j) { + dp[i][j] = true; + } else { + dp[i][j] = dp[i - 1][j]; + } + } + } + + // fill the index array + int[] index = new int[sum]; + int p = 0; + for (int i = 0; i <= sum / 2; i++) { + if (dp[n][i]) { + index[p++] = i; + } + } + + return getMin(index, sum); + } + + /** + * Calculate sum of array elements + * + * @param arr the array + * @return sum of given array + */ + public static int getSum(int[] arr) { + int sum = 0; + for (int temp : arr) { + sum += temp; + } + return sum; + } + + public static int getMin(int[] arr, int sum) { + if (arr.length == 0) { + return 0; + } + int min = Integer.MAX_VALUE; + for (int temp : arr) { + min = Math.min(min, sum - 2 * temp); + } + return min; + } + + /** + * Driver Code + */ + public static void main(String[] args) { + assert subSet(new int[] { 1, 6, 11, 5 }) == 1; + assert subSet(new int[] { 36, 7, 46, 40 }) == 23; + assert subSet(new int[] { 1, 2, 3, 9 }) == 3; + } +} \ No newline at end of file diff --git a/NMS-python.py b/NMS-python.py new file mode 100644 index 0000000..1ec51fa --- /dev/null +++ b/NMS-python.py @@ -0,0 +1,21 @@ +import telepot +import pyping + + +def ping_server(ip): + response = pyping.ping(ip) + if response.ret_code == 0: + send_telegram('Server {} up!'.format(ip)) + else: + send_telegram('Server {} down!'.format(ip)) + + +def send_telegram(pesan): + telegram_token = 'your_telegram_token' + chat_id = 'your_chat_id' + bot = telepot.Bot(telegram_token) + bot.sendMessage(chat_id, pesan) + + +if __name__ == '__main__': + ping_server('your_server') \ No newline at end of file diff --git a/NQueens.java b/NQueens.java new file mode 100644 index 0000000..fb0138d --- /dev/null +++ b/NQueens.java @@ -0,0 +1,111 @@ +package com.thealgorithms.backtracking; + +import java.util.ArrayList; +import java.util.List; + +/** + * Problem statement: Given a N x N chess board. Return all arrangements in + * which N queens can be placed on the board such no two queens attack each + * other. Ex. N = 6 Solution= There are 4 possible ways Arrangement: 1 ".Q....", + * "...Q..", ".....Q", "Q.....", "..Q...", "....Q." + *

+ * Arrangement: 2 "..Q...", ".....Q", ".Q....", "....Q.", "Q.....", "...Q.." + *

+ * Arrangement: 3 "...Q..", "Q.....", "....Q.", ".Q....", ".....Q", "..Q..." + *

+ * Arrangement: 4 "....Q.", "..Q...", "Q.....", ".....Q", "...Q..", ".Q...." + * + * Solution: Brute Force approach: + * + * Generate all possible arrangement to place N queens on N*N board. Check each + * board if queens are placed safely. If it is safe, include arrangement in + * solution set. Otherwise ignore it + * + * Optimized solution: This can be solved using backtracking in below steps + * + * Start with first column and place queen on first row Try placing queen in a + * row on second column If placing second queen in second column attacks any of + * the previous queens, change the row in second column otherwise move to next + * column and try to place next queen In case if there is no rows where a queen + * can be placed such that it doesn't attack previous queens, then go back to + * previous column and change row of previous queen. Keep doing this until last + * queen is not placed safely. If there is no such way then return an empty list + * as solution + */ +public class NQueens { + + public static void main(String[] args) { + placeQueens(1); + placeQueens(2); + placeQueens(3); + placeQueens(4); + placeQueens(5); + placeQueens(6); + } + + public static void placeQueens(final int queens) { + List> arrangements = new ArrayList>(); + getSolution(queens, arrangements, new int[queens], 0); + if (arrangements.isEmpty()) { + System.out.println("There is no way to place " + queens + " queens on board of size " + queens + "x" + queens); + } else { + System.out.println("Arrangement for placing " + queens + " queens"); + } + arrangements.forEach(arrangement -> { + arrangement.forEach(row -> System.out.println(row)); + System.out.println(); + }); + } + + /** + * This is backtracking function which tries to place queen recursively + * + * @param boardSize: size of chess board + * @param solutions: this holds all possible arrangements + * @param columns: columns[i] = rowId where queen is placed in ith column. + * @param columnIndex: This is the column in which queen is being placed + */ + private static void getSolution(int boardSize, List> solutions, int[] columns, int columnIndex) { + if (columnIndex == boardSize) { + // this means that all queens have been placed + List sol = new ArrayList(); + for (int i = 0; i < boardSize; i++) { + StringBuilder sb = new StringBuilder(); + for (int j = 0; j < boardSize; j++) { + sb.append(j == columns[i] ? "Q" : "."); + } + sol.add(sb.toString()); + } + solutions.add(sol); + return; + } + + // This loop tries to place queen in a row one by one + for (int rowIndex = 0; rowIndex < boardSize; rowIndex++) { + columns[columnIndex] = rowIndex; + if (isPlacedCorrectly(columns, rowIndex, columnIndex)) { + // If queen is placed successfully at rowIndex in column=columnIndex then try placing queen in next column + getSolution(boardSize, solutions, columns, columnIndex + 1); + } + } + } + + /** + * This function checks if queen can be placed at row = rowIndex in column = + * columnIndex safely + * + * @param columns: columns[i] = rowId where queen is placed in ith column. + * @param rowIndex: row in which queen has to be placed + * @param columnIndex: column in which queen is being placed + * @return true: if queen can be placed safely false: otherwise + */ + private static boolean isPlacedCorrectly(int[] columns, int rowIndex, int columnIndex) { + for (int i = 0; i < columnIndex; i++) { + int diff = Math.abs(columns[i] - rowIndex); + if (diff == 0 || columnIndex - i == diff) { + return false; + } + } + return true; + } +} diff --git a/Number is Palindrome or Not.java b/Number is Palindrome or Not.java new file mode 100644 index 0000000..395b5fa --- /dev/null +++ b/Number is Palindrome or Not.java @@ -0,0 +1,26 @@ +import java.util.Scanner; + class expalindrome +{ +public static void main(String args[]) +{ +int x,number, y=0,temp=0; +Scanner s=new Scanner(System.in); +System.out.println("Enter any number: "); +number=s.nextInt(); +x=number; +while(number>0) +{ +x=number%10; +number=number/10; +temp=temp*10+x; +} +if(temp==y) +{ +System.out.println("Number is Palindrome"); +} +else +{ +System.out.println("not Palindrome"); +} +} +} diff --git a/NumberFrequencyofArray.java b/NumberFrequencyofArray.java new file mode 100644 index 0000000..b28a969 --- /dev/null +++ b/NumberFrequencyofArray.java @@ -0,0 +1,30 @@ +public class Frequency { + public static void main(String[] args) { + //Initialize array + int [] arr = new int [] {1, 2, 8, 3, 2, 2, 2, 5, 1}; + //Array fr will store frequencies of element + int [] fr = new int [arr.length]; + int visited = -1; + for(int i = 0; i < arr.length; i++){ + int count = 1; + for(int j = i+1; j < arr.length; j++){ + if(arr[i] == arr[j]){ + count++; + //To avoid counting same element again + fr[j] = visited; + } + } + if(fr[i] != visited) + fr[i] = count; + } + + + System.out.println("---------------------------------------"); + System.out.println(" Element | Frequency"); + System.out.println("---------------------------------------"); + for(int i = 0; i < fr.length; i++){ + if(fr[i] != visited) + System.out.println(" " + arr[i] + " | " + fr[i]); + } + System.out.println("----------------------------------------"); + }} diff --git a/Number_guessing_game.java b/Number_guessing_game.java new file mode 100644 index 0000000..fca0218 --- /dev/null +++ b/Number_guessing_game.java @@ -0,0 +1,66 @@ +import java.util.Scanner; + +public class GFG { + + public static void + guessingNumberGame() + { + Scanner sc = new Scanner(System.in); + + int number = 1 + (int)(100 + * Math.random()); + + int K = 5; + + int i, guess; + + System.out.println( + "A number is chosen" + + " between 1 to 100." + + "Guess the number" + + " within 5 trials."); + + for (i = 0; i < K; i++) { + + System.out.println( + "Guess the number:"); + + guess = sc.nextInt(); + + if (number == guess) { + System.out.println( + "Congratulations!" + + " You guessed the number."); + break; + } + else if (number > guess + && i != K - 1) { + System.out.println( + "The number is " + + "greater than " + guess); + } + else if (number < guess + && i != K - 1) { + System.out.println( + "The number is" + + " less than " + guess); + } + } + + if (i == K) { + System.out.println( + "You have exhausted" + + " K trials."); + + System.out.println( + "The number was " + number); + } + } + + public static void + main(String arg[]) + { + + guessingNumberGame(); + } +} diff --git a/OccuranceOfEachCharacter.java b/OccuranceOfEachCharacter.java new file mode 100644 index 0000000..781c1f4 --- /dev/null +++ b/OccuranceOfEachCharacter.java @@ -0,0 +1,70 @@ +package coding; + +import java.util.HashMap; +import java.util.LinkedHashMap; +import java.util.Map; + +import org.testng.annotations.Test; + +public class OccuranceOfEachCharacter extends BaseTestNg{ + String str = "welcome to automation"; + int count =0; + + @Test(priority=1) + public void main() { + char[] char_array =str.toCharArray(); + Map charCounter=new HashMap(); + for (char ch : char_array) { + if(charCounter.containsKey(ch)){ + charCounter.put(ch, charCounter.get(ch)+1); + } + else{ + charCounter.put(ch, 1); + } + } + System.out.println(charCounter); + } + + @Test(priority=2) + public void occurance() { + String string=""; + int temp =0; + Map map =new LinkedHashMap(); + for (int i = 0; i < str.length(); i++) { + map.put(temp, ""+str.charAt(i)); + temp++; + } + for (int eachChar : map.keySet()) { + count=0; + string =map.get(eachChar); + for (Integer eachKey : map.keySet()) { + if (string.equals(map.get(eachKey))) { + count++; + } + } + System.out.println(map.get(eachChar)+"-->"+count); + } + } + + @Test(priority=3) + public void occuranceOfString() { + for (int j = 0; j < str.length(); j++) { + count = 0; + char c = str.charAt(j); + for (int i = 0; i < str.length(); i++) { + if (c == str.charAt(i)) { + count++; + } + } + System.out.println(c + " occurs " + count + " times in " + str); // you can store this in Map and print for better solution + } + } + + + +} + + + + + diff --git a/OopsConcept.java b/OopsConcept.java new file mode 100644 index 0000000..5902834 --- /dev/null +++ b/OopsConcept.java @@ -0,0 +1,21 @@ +class Student{ + int rollno; + String name; + float fee; + Student(int roll,String names,float fees){ + rollno=roll; + name=names; + fee=fees; + } + void display(){ + System.out.println(rollno+" "+name+" "+fee); + } +} +class OopsConcept{ + public static void main(String args[]){ + Student s1=new Student(111,"ankit",5000f); + Student s2=new Student(112,"sumit",6000f); + s1.display(); + s2.display(); + } +} diff --git a/PalindromeNumber.java b/PalindromeNumber.java new file mode 100644 index 0000000..dc3ad55 --- /dev/null +++ b/PalindromeNumber.java @@ -0,0 +1,17 @@ +class PalindromeExample{ + public static void main(String args[]){ + int r,sum=0,temp; + int n=454;//It is the number variable to be checked for palindrome + + temp=n; + while(n>0){ + r=n%10; //getting remainder + sum=(sum*10)+r; + n=n/10; + } + if(temp==sum) + System.out.println("palindrome number "); + else + System.out.println("not palindrome"); +} +} diff --git a/Pattern.java b/Pattern.java new file mode 100644 index 0000000..bc9dd90 --- /dev/null +++ b/Pattern.java @@ -0,0 +1,35 @@ +import java.util.Scanner; +public class MainClass +{ + public static void main(String[] args) + { + Scanner sc = new Scanner(System.in); + + //Taking rows value from the user + + System.out.println("How many rows you want in this pattern?"); + + int rows = sc.nextInt(); + + System.out.println("Here is your pattern....!!!"); + + for (int i=1; i<= rows ; i++) + { + for (int j = i; j < rows ; j++) { + System.out.print(" "); + } + for (int k = 1; k <= (2*i -1) ;k++) { + if( k==1 || i == rows || k==(2*i-1)) { + System.out.print("*"); + } + else { + System.out.print(" "); + } + } + System.out.println(""); + } + + //Close the resources + sc.close(); + } +} diff --git a/Patterns.cpp b/Patterns.cpp new file mode 100644 index 0000000..bafbad8 --- /dev/null +++ b/Patterns.cpp @@ -0,0 +1,193 @@ +/* +Approach method : - +1. No of lines = No of rows = No of times outer loop will run +2. Identify for every row no + *How many columns are there + *Types of elements in columns +3. What do you need to print +*/ + +#include +using namespace std; + +void pattern1(int noOfLines){ + for(int row = 0; row < noOfLines; row++){ + for (int column = 0; column < noOfLines; column++) + { + cout<<"*"; + } + cout<= row; column-- + { + cout<<"*"; + } + cout<>noOfLines; + cout<<"\n"<<" Patterns are "<0; i--){ + for (int j = 0; j=18)&&(age<=100)) + { + System.out.println("Congratulation "+name+", You are eligible for Voting"); + } + else + { + System.out.println("Sorry "+name+", You are not eligible for voting"); + } + } +} diff --git a/Project1.py b/Project1.py new file mode 100644 index 0000000..5254641 --- /dev/null +++ b/Project1.py @@ -0,0 +1,34 @@ +import random +print("\n\t\t\t******* Game of Snake, Water and Gun *******\n") +print(" There are some rules in this game.These are:-") +print("\tRule no.1:- You need to choose snake, water or gun") +print('\tRule no.2:- To choose snake type 1, to choose water type 2 and to choose gun type 3') +print("\tRule no.3:- If you want to quit type 5") +print("\n\t\t\t Ok then, Have fun!") + +a = True +while a == True: + def game(comp,user): + if comp == 3 and user == 2: + print(f"You win because the computer choose Gun") + elif comp == 2 and user == 3: + print(f"You lose because the computer choose Water") + elif comp == 3 and user == 1: + print(f"You Lose because the computer choose gun") + elif comp == 1 and user == 3: + print(f"You Win because the computer choose Snake") + elif comp == 1 and user == 2: + print(f"You Lose because the computer choose Snake") + elif comp == 2 and user == 1: + print(f"You Win because the computer choose Water") + elif user == 5: + print("\n\t\tYou quit the game.Thanks for Playing this game!") + quit() + elif user == comp : + print("The game is draw") + else: + print("Warring: Donot enter any wrong number.Please check the rules again") + + comp = random.randint(1, 3) + user = int(input('Your turn: ')) + game(comp, user) \ No newline at end of file diff --git a/Queue.java b/Queue.java new file mode 100644 index 0000000..1e5d11b --- /dev/null +++ b/Queue.java @@ -0,0 +1,121 @@ +public class Queue { + int SIZE = 5; + int items[] = new int[SIZE]; + int front, rear; + + Queue() { + front = -1; + rear = -1; + } + + // check if the queue is full + boolean isFull() { + if (front == 0 && rear == SIZE - 1) { + return true; + } + return false; + } + + // check if the queue is empty + boolean isEmpty() { + if (front == -1) + return true; + else + return false; + } + + // insert elements to the queue + void enQueue(int element) { + + // if queue is full + if (isFull()) { + System.out.println("Queue is full"); + } + else { + if (front == -1) { + // mark front denote first element of queue + front = 0; + } + + rear++; + // insert element at the rear + items[rear] = element; + System.out.println("Insert " + element); + } + } + + // delete element from the queue + int deQueue() { + int element; + + // if queue is empty + if (isEmpty()) { + System.out.println("Queue is empty"); + return (-1); + } + else { + // remove element from the front of queue + element = items[front]; + + // if the queue has only one element + if (front >= rear) { + front = -1; + rear = -1; + } + else { + // mark next element as the front + front++; + } + System.out.println( element + " Deleted"); + return (element); + } + } + + // display element of the queue + void display() { + int i; + if (isEmpty()) { + System.out.println("Empty Queue"); + } + else { + // display the front of the queue + System.out.println("\nFront index-> " + front); + + // display element of the queue + System.out.println("Items -> "); + for (i = front; i <= rear; i++) + System.out.print(items[i] + " "); + + // display the rear of the queue + System.out.println("\nRear index-> " + rear); + } + } + + public static void main(String[] args) { + + // create an object of Queue class + Queue q = new Queue(); + + // try to delete element from the queue + // currently queue is empty + // so deletion is not possible + q.deQueue(); + + // insert elements to the queue + for(int i = 1; i < 6; i ++) { + q.enQueue(i); + } + + // 6th element can't be added to queue because queue is full + q.enQueue(6); + + q.display(); + + // deQueue removes element entered first i.e. 1 + q.deQueue(); + + // Now we have just 4 elements + q.display(); + + } +} diff --git a/Queue_ll.java b/Queue_ll.java new file mode 100644 index 0000000..30ac5a3 --- /dev/null +++ b/Queue_ll.java @@ -0,0 +1,52 @@ +public class Queue_ll { + static class Node{ + Node next; + int data; + Node(int data){ + this.data=data; + this.next=null;}} + + static class Queue{ + static Node head=null,tail=null; + static boolean isEmpty() { + return head==null & tail==null;} + + static void add(int data) { + Node p=new Node(data); + if(tail==null) { + tail=head=p; + return;} + tail.next=p; + tail=p;} + + static int rem() { + if(isEmpty()) { + System.out.println("empty"); + return -1;} + int front=head.data; + if(head==null) + tail=null; + head=head.next; + return front;} + + static int print() { + if(head==null) { + System.out.println("empty"); + System.exit(0);} + return head.data;} + + + public static void main(String[] args) { + Queue q=new Queue(); + q.add(5); + q.add(6); + q.add(2); + q.add(78); + + while(!q.isEmpty()) { + System.out.println(q.print()); + q.rem(); } + } + + } +} \ No newline at end of file diff --git a/QuickSort.java b/QuickSort.java new file mode 100644 index 0000000..4ff9d78 --- /dev/null +++ b/QuickSort.java @@ -0,0 +1,85 @@ +// Java implementation of QuickSort +import java.io.*; + +class GFG { + + // A utility function to swap two elements + static void swap(int[] arr, int i, int j) + { + int temp = arr[i]; + arr[i] = arr[j]; + arr[j] = temp; + } + + /* This function takes last element as pivot, places + the pivot element at its correct position in sorted + array, and places all smaller (smaller than pivot) + to left of pivot and all greater elements to right + of pivot */ + static int partition(int[] arr, int low, int high) + { + + // pivot + int pivot = arr[high]; + + // Index of smaller element and + // indicates the right position + // of pivot found so far + int i = (low - 1); + + for (int j = low; j <= high - 1; j++) { + + // If current element is smaller + // than the pivot + if (arr[j] < pivot) { + + // Increment index of + // smaller element + i++; + swap(arr, i, j); + } + } + swap(arr, i + 1, high); + return (i + 1); + } + + /* The main function that implements QuickSort + arr[] --> Array to be sorted, + low --> Starting index, + high --> Ending index + */ + static void quickSort(int[] arr, int low, int high) + { + if (low < high) { + + // pi is partitioning index, arr[p] + // is now at right place + int pi = partition(arr, low, high); + + // Separately sort elements before + // partition and after partition + quickSort(arr, low, pi - 1); + quickSort(arr, pi + 1, high); + } + } + + // Function to print an array + static void printArray(int[] arr, int size) + { + for (int i = 0; i < size; i++) + System.out.print(arr[i] + " "); + + System.out.println(); + } + + // Driver Code + public static void main(String[] args) + { + int[] arr = { 10, 7, 8, 9, 1, 5 }; + int n = arr.length; + + quickSort(arr, 0, n - 1); + System.out.println("Sorted array: "); + printArray(arr, n); + } +} \ No newline at end of file diff --git a/QuickSortJava.java b/QuickSortJava.java new file mode 100644 index 0000000..6addca5 --- /dev/null +++ b/QuickSortJava.java @@ -0,0 +1,67 @@ + static int partition(int[] arr, int low, int high) + { + + // pivot + int pivot = arr[high]; + + // Index of smaller element and + // indicates the right position + // of pivot found so far + int i = (low - 1); + + for (int j = low; j <= high - 1; j++) { + + // If current element is smaller + // than the pivot + if (arr[j] < pivot) { + + // Increment index of + // smaller element + i++; + swap(arr, i, j); + } + } + swap(arr, i + 1, high); + return (i + 1); + } + + /* The main function that implements QuickSort + arr[] --> Array to be sorted, + low --> Starting index, + high --> Ending index + */ + static void quickSort(int[] arr, int low, int high) + { + if (low < high) { + + // pi is partitioning index, arr[p] + // is now at right place + int pi = partition(arr, low, high); + + // Separately sort elements before + // partition and after partition + quickSort(arr, low, pi - 1); + quickSort(arr, pi + 1, high); + } + } + + // Function to print an array + static void printArray(int[] arr, int size) + { + for (int i = 0; i < size; i++) + System.out.print(arr[i] + " "); + + System.out.println(); + } + + // Driver Code + public static void main(String[] args) + { + int[] arr = { 10, 7, 8, 9, 1, 5 }; + int n = arr.length; + + quickSort(arr, 0, n - 1); + System.out.println("Sorted array: "); + printArray(arr, n); + } +} diff --git a/README.md b/README.md index 37c9895..2db23e2 100644 --- a/README.md +++ b/README.md @@ -1 +1,28 @@ -# 🅰️ java-algorithms +# Hacktoberfest-2022🔥 +![image](https://user-images.githubusercontent.com/70385488/192114009-0830321a-d227-4a4d-8411-6c03b54d7ce6.png) + +

+ +[![Open Source Love](https://firstcontributions.github.io/open-source-badges/badges/open-source-v1/open-source.svg)](https://github.com/kishanrajput23/Hacktoberfest-2022) +Hacktober Badge +Star Badge +Contributions + +
+ + +### This repository aims to help code beginners with their first successful pull request and open-source contribution. :partying_face: + +:star: Feel free to use this project to make your first contribution to an open-source project on GitHub. Practice making your first pull request to a public repository before doing the real thing! + +:star: Make sure to grab some cool swags during Hacktoberfest by getting involved in the open-source community. + +### This repository is open to all members of the GitHub community. Any member can contribute to this project! The only thing which you need to keep in mind is that it should be genuine PR :grin: + +## What is Hacktoberfest? :thinking: +A month-long celebration from October 1st to October 31st presented by [Digital Ocean](https://hacktoberfest.digitalocean.com/) and [DEV Community](https://dev.to/) collaborated with [GitHub](https://github.com/blog/2433-celebrate-open-source-this-october-with-hacktoberfest) to get people involved in [Open Source](https://github.com/open-source). Create your very first pull request to any public repository on GitHub and contribute to the open-source developer community. + +[https://hacktoberfest.digitalocean.com/](https://hacktoberfest.digitalocean.com/) + +## Rules :fire: +To qualify for the __official limited edition Hacktoberfest shirt__, you must register [here](https://hacktoberfest.digitalocean.com/) and make four Pull Requests (PRs) between October 1-31, 2022 (in any time zone). PRs can be made to any public repo on GitHub, not only the ones with issues labeled Hacktoberfest. This year, the __first 40,000__ participants who complete the challenge will earn a T-shirt. diff --git a/RadixSort.java b/RadixSort.java new file mode 100644 index 0000000..7667727 --- /dev/null +++ b/RadixSort.java @@ -0,0 +1,80 @@ +// Radix sort Java implementation + +import java.io.*; +import java.util.*; + +class Radix { + + // A utility function to get maximum value in arr[] + static int getMax(int arr[], int n) + { + int mx = arr[0]; + for (int i = 1; i < n; i++) + if (arr[i] > mx) + mx = arr[i]; + return mx; + } + + // A function to do counting sort of arr[] according to + // the digit represented by exp. + static void countSort(int arr[], int n, int exp) + { + int output[] = new int[n]; // output array + int i; + int count[] = new int[10]; + Arrays.fill(count, 0); + + // Store count of occurrences in count[] + for (i = 0; i < n; i++) + count[(arr[i] / exp) % 10]++; + + // Change count[i] so that count[i] now contains + // actual position of this digit in output[] + for (i = 1; i < 10; i++) + count[i] += count[i - 1]; + + // Build the output array + for (i = n - 1; i >= 0; i--) { + output[count[(arr[i] / exp) % 10] - 1] = arr[i]; + count[(arr[i] / exp) % 10]--; + } + + // Copy the output array to arr[], so that arr[] now + // contains sorted numbers according to current + // digit + for (i = 0; i < n; i++) + arr[i] = output[i]; + } + + // The main function to that sorts arr[] of + // size n using Radix Sort + static void radixsort(int arr[], int n) + { + // Find the maximum number to know number of digits + int m = getMax(arr, n); + + // Do counting sort for every digit. Note that + // instead of passing digit number, exp is passed. + // exp is 10^i where i is current digit number + for (int exp = 1; m / exp > 0; exp *= 10) + countSort(arr, n, exp); + } + + // A utility function to print an array + static void print(int arr[], int n) + { + for (int i = 0; i < n; i++) + System.out.print(arr[i] + " "); + } + + // Main driver method + public static void main(String[] args) + { + int arr[] = { 170, 45, 75, 90, 802, 24, 2, 66 }; + int n = arr.length; + + // Function Call + radixsort(arr, n); + print(arr, n); + } +} diff --git a/RatMaze.java b/RatMaze.java new file mode 100644 index 0000000..07935d0 --- /dev/null +++ b/RatMaze.java @@ -0,0 +1,85 @@ + + +public class RatMaze { + + + static int N; + + + void printSolution(int sol[][]) + { + for (int i = 0; i < N; i++) { + for (int j = 0; j < N; j++) + System.out.print( + " " + sol[i][j] + " "); + System.out.println(); + } + } + + + boolean isSafe( + int maze[][], int x, int y) + { + + return (x >= 0 && x < N && y >= 0 + && y < N && maze[x][y] == 1); + } + + + boolean solveMaze(int maze[][]) + { + int sol[][] = new int[N][N]; + + if (solveMazeUtil(maze, 0, 0, sol) == false) { + System.out.print("Solution doesn't exist"); + return false; + } + + printSolution(sol); + return true; + } + + + boolean solveMazeUtil(int maze[][], int x, int y, + int sol[][]) + { + + if (x == N - 1 && y == N - 1 + && maze[x][y] == 1) { + sol[x][y] = 1; + return true; + } + + if (isSafe(maze, x, y) == true) { + if (sol[x][y] == 1) + return false; + + sol[x][y] = 1; + + if (solveMazeUtil(maze, x + 1, y, sol)) + return true; + + + if (solveMazeUtil(maze, x, y + 1, sol)) + return true; + + + sol[x][y] = 0; + return false; + } + + return false; + } + + public static void main(String args[]) + { + RatMaze rat = new RatMaze(); + int maze[][] = { { 1, 0, 0, 0 }, + { 1, 1, 0, 1 }, + { 0, 1, 0, 0 }, + { 1, 1, 1, 1 } }; + + N = maze.length; + rat.solveMaze(maze); + } +} diff --git a/Reverse a Number using a while loop.java b/Reverse a Number using a while loop.java new file mode 100644 index 0000000..a443512 --- /dev/null +++ b/Reverse a Number using a while loop.java @@ -0,0 +1,21 @@ +class Main { + public static void main(String[] args) { + + int num = 1234, reversed = 0; + + System.out.println("Original Number: " + num); + + // run loop until num becomes 0 + while(num != 0) { + + // get last digit from num + int digit = num % 10; + reversed = reversed * 10 + digit; + + // remove the last digit from num + num /= 10; + } + + System.out.println("Reversed Number: " + reversed); + } +} diff --git a/Reverse-words-in-string.java b/Reverse-words-in-string.java new file mode 100644 index 0000000..840625a --- /dev/null +++ b/Reverse-words-in-string.java @@ -0,0 +1,18 @@ +class Solution { + public String reverseWords(String s) { + String resp = ""; + List list = Arrays.asList(s.split(" ")); + for(String word : list){ + resp += reverseIt(word); + resp += " "; + } + return resp.trim(); + } + + String reverseIt(String word){ + StringBuilder input = new StringBuilder(); + input.append(word); + input.reverse(); + return input.toString(); + } +} diff --git a/ReverseNumberPrint.java b/ReverseNumberPrint.java new file mode 100644 index 0000000..6bdf4a1 --- /dev/null +++ b/ReverseNumberPrint.java @@ -0,0 +1,13 @@ +public class ReverseNumber{ +public static void main(String[] args) +{ +int number = 987654, reverse = 0; +while(number != 0) +{ +int remainder = number % 10; +reverse = reverse * 10 + remainder; +number = number/10; +} +System.out.println("The reverse of the given number is: " + reverse); +} +} diff --git a/Right Triangle pattern program b/Right Triangle pattern program new file mode 100644 index 0000000..80dc029 --- /dev/null +++ b/Right Triangle pattern program @@ -0,0 +1,21 @@ + class RightTrianglePattern +{ +public static void main(String args[]) +{ +//i for rows and j for columns +//n denotes the number of rows you want to print +int i, j, n=6; +//outer loop for rows +for(i=0; i numbers = new ArrayList<>(); + numbers.add(1); + numbers.add(2); + numbers.add(3); + + // Using binarySearch() + int pos = Collections.binarySearch(numbers, 3); + System.out.println("The position of 3 is " + pos); + } +} diff --git a/SearchBinaryTree.java b/SearchBinaryTree.java new file mode 100644 index 0000000..bd98f34 --- /dev/null +++ b/SearchBinaryTree.java @@ -0,0 +1,68 @@ +public class SearchBinaryTree { + + //Represent a node of binary tree + public static class Node{ + int data; + Node left; + Node right; + + public Node(int data){ + //Assign data to the new node, set left and right children to null + this.data = data; + this.left = null; + this.right = null; + } + } + + //Represent the root of binary tree + public Node root; + + public static boolean flag = false; + + public SearchBinaryTree(){ + root = null; + } + + //searchNode() will search for the particular node in the binary tree + public void searchNode(Node temp, int value){ + //Check whether tree is empty + if(root == null){ + System.out.println("Tree is empty"); + } + else{ + //If value is found in the given binary tree then, set the flag to true + if(temp.data == value){ + flag = true; + return; + } + //Search in left subtree + if(flag == false && temp.left != null){ + searchNode(temp.left, value); + } + //Search in right subtree + if(flag == false && temp.right != null){ + searchNode(temp.right, value); + } + } + } + + public static void main(String[] args) { + + SearchBinaryTree bt = new SearchBinaryTree(); + //Add nodes to the binary tree + bt.root = new Node(1); + bt.root.left = new Node(2); + bt.root.right = new Node(3); + bt.root.left.left = new Node(4); + bt.root.right.left = new Node(5); + bt.root.right.right = new Node(6); + + //Search for node 5 in the binary tree + bt.searchNode(bt.root, 5); + + if(flag) + System.out.println("Element is present in the binary tree"); + else + System.out.println("Element is not present in the binary tree"); + } + } \ No newline at end of file diff --git a/Selection Sort.java b/Selection Sort.java new file mode 100644 index 0000000..cd2e69a --- /dev/null +++ b/Selection Sort.java @@ -0,0 +1,27 @@ +import java.util.* ; +import java.io.*; +public class Solution { + public static void selectionSort(int arr[], int n) { + + for(int i = 0; i < arr.length - 1; i++){ + int minIndex = i; + for (int j = i+1; j < arr.length; j++){ + if (arr[j] < arr[minIndex]){ + minIndex = j; + } + + } + int temp = arr[i]; + arr[i] = arr[minIndex]; + arr[minIndex] = temp; + + + + + } + + + + + } +} diff --git a/SelectionSortpro.java b/SelectionSortpro.java new file mode 100644 index 0000000..6dce585 --- /dev/null +++ b/SelectionSortpro.java @@ -0,0 +1,36 @@ +public class SelectionSortpro +{ + public static void main(String[] args) { + // This is unsorted array + Integer[] array = new Integer[] { 12, 13, 24, 10, 3, 6, 90, 70 }; + + // Let's sort using selection sort + selectionSort(array, 0, array.length); + + // Verify sorted array + System.out.println(Arrays.toString(array)); + } + + @SuppressWarnings({ "rawtypes", "unchecked" }) + public static void selectionSort(Object[] array, int fromIndex, int toIndex) + { + Object d; + for (int currentIndex = fromIndex; currentIndex < toIndex; currentIndex++) + { + int indexToMove = currentIndex; + for (int tempIndexInLoop = currentIndex + 1; tempIndexInLoop < toIndex; tempIndexInLoop++) + { + if (((Comparable) array[indexToMove]).compareTo(array[tempIndexInLoop]) > 0) + { + //Swapping + indexToMove = tempIndexInLoop; + } + } + d = array[currentIndex]; + array[currentIndex] = array[indexToMove]; + array[indexToMove] = d; + } + } +} + +Output: [3, 6, 10, 12, 13, 24, 70, 90] \ No newline at end of file diff --git a/Shell_Sort.java b/Shell_Sort.java new file mode 100644 index 0000000..15c1589 --- /dev/null +++ b/Shell_Sort.java @@ -0,0 +1,47 @@ +package Sorting; + +public class shell { + + public static void main(String args[]) + { + int[] a={9, 8, 3, 56, 5, 6, 4, 1}; + int length=a.length; + + + int gap=length/2; + // System.out.println(gap); + while(gap>0) + { + for(int i=gap;i=gap && a[j-gap]>temp) + { + // System.out.println(a[j]); + a[j]=a[j-gap]; + // System.out.println(a[j]); + j=j-gap; + + a[j]=temp; + // System.out.println(a[j]); + + } + + + } + + gap=gap/2; + + + } + for(int i=0;i 0; gap /= 2) + { + // Do a gapped insertion sort for this gap size. + // The first gap elements a[0..gap-1] are already + // in gapped order keep adding one more element + // until the entire array is gap sorted + for (int i = gap; i < n; i += 1) + { + // add a[i] to the elements that have been gap + // sorted save a[i] in temp and make a hole at + // position i + int temp = arr[i]; + + // shift earlier gap-sorted elements up until + // the correct location for a[i] is found + int j; + for (j = i; j >= gap && arr[j - gap] > temp; j -= gap) + arr[j] = arr[j - gap]; + + // put temp (the original a[i]) in its correct + // location + arr[j] = temp; + } + } + return 0; + } + + // Driver method + public static void main(String args[]) + { + int arr[] = {12, 34, 54, 2, 3}; + System.out.println("Array before sorting"); + printArray(arr); + + ShellSort ob = new ShellSort(); + ob.sort(arr); + + System.out.println("Array after sorting"); + printArray(arr); + } +} +/*This code is contributed by Rajat Mishra */ diff --git a/Shuffling Using shuffle() b/Shuffling Using shuffle() new file mode 100644 index 0000000..e05e4cb --- /dev/null +++ b/Shuffling Using shuffle() @@ -0,0 +1,21 @@ +import java.util.ArrayList; +import java.util.Collections; + +class Main { + public static void main(String[] args) { + + // Creating an array list + ArrayList numbers = new ArrayList<>(); + + // Add elements + numbers.add(1); + numbers.add(2); + numbers.add(3); + System.out.println("Sorted ArrayList: " + numbers); + + // Using the shuffle() method + Collections.shuffle(numbers); + System.out.println("ArrayList using shuffle: " + numbers); + + } +} diff --git a/Sierpinski.java b/Sierpinski.java new file mode 100644 index 0000000..557297f --- /dev/null +++ b/Sierpinski.java @@ -0,0 +1,45 @@ +// Java program to print +// sierpinski triangle. +import java.util.*; +import java.io.*; + +class Sierpinski +{ + static void printSierpinski(int n) + { + for (int b = n - 1; b >= 0; b--) { + + // printing space till + // the value of y + for (int i = 0; i < b; i++) { + System.out.print(" "); + } + + // printing '*' + for (int a = 0; a + b < n; a++) { + + // printing '*' at the appropriate + // position is done by the and + // value of x and y wherever value + // is 0 we have printed '*' + if ((a & b) != 0) + System.out.print(" " + + " "); + else + System.out.print("* "); + } + + System.out.print("\n"); + } + } + + // Driver code + public static void main(String args[]) + { + int n = 16; + + // Function calling + printSierpinski(n); + } +} + diff --git a/SieveOfEratosthenes.java b/SieveOfEratosthenes.java new file mode 100644 index 0000000..c2e4a2b --- /dev/null +++ b/SieveOfEratosthenes.java @@ -0,0 +1,42 @@ +import java.util.*; +public class SieveOfEratosthenes { + + + static boolean[] sieveOfEr(int n) + { + boolean isPrime[]=new boolean[n+1]; + Arrays.fill(isPrime,true); + for(int i=2;i*i<=n;i++) + { for(int j=2;j<=n;j=j+i) + { +isPrime[j]=false; + } + + } + return isPrime; + } + + public static void main (String args[]) +{ + Scanner sc=new Scanner(System.in); + + int n=sc.nextInt(); + boolean iPrime[]=sieveOfEr(n); + for(int i=2;i +#include + +void main() +{ + FILE *fp; + char ch; + int size = 0; + + fp = fopen("MyFile.txt", "r"); + if (fp == NULL) + { + printf("\nFile unable to open..."); + } + else + { + printf("\nFile opened..."); + } + fseek(fp, 0, 2); /* File pointer at the end of file */ + size = ftell(fp); /* Take a position of file pointer in size variable */ + printf("The size of given file is: %d\n", size); + fclose(fp); +} diff --git a/Solution.java b/Solution.java new file mode 100644 index 0000000..5becba6 Binary files /dev/null and b/Solution.java differ diff --git a/Spiral_Matrix.cpp b/Spiral_Matrix.cpp new file mode 100644 index 0000000..053dd25 --- /dev/null +++ b/Spiral_Matrix.cpp @@ -0,0 +1,37 @@ + vector spiralOrder(vector>& matrix) { + + int count=0; + vector ans; + int startingrow=0,startingcol=0,endingrow=matrix.size(),endingcol=matrix[0].size(); + int total=endingrow*endingcol; + endingrow=matrix.size()-1; + endingcol=endingcol-1; + + while(count=startingcol&&count=startingrow&&count +// Given an integer number n, return the difference between the product of its digits and the sum of its digits. + +/* +Sample: +Input: n = 234 +Output: 15 +Explanation: +Product of digits = 2 * 3 * 4 = 24 +Sum of digits = 2 + 3 + 4 = 9 +Result = 24 - 9 = 15 +*/ + +//code +class Solution { + public int subtractProductAndSum(int n) { + int reverse=0,sum=0,product=1; + int temp=n; + //for sum + while(temp>0) { + reverse=temp%10; + sum+=reverse; + temp/=10; + } + //for multiply + + while(n>0) { + reverse=n%10; + product*=reverse; + n/=10; + } + //returning the difference + return (product-sum); + + } + +} diff --git a/Sudoku Solver b/Sudoku Solver new file mode 100644 index 0000000..90b2cd3 --- /dev/null +++ b/Sudoku Solver @@ -0,0 +1,95 @@ +/** + * Most Optimized Backtracking solution using Bit Manipulation + * + * Time Complexity: T(N) = 9 * T(N-1) + O(9) ==> TC = (9^N). Also, O(9*9) is + * required for checking validity and finding blanks. + * + * Space Complexity: O(3*9 + 2*N). 3*9 for rows, cols and boxes int array. N for + * blanks list. N will be the recursion depth. + * + * N = Number of blank spaces. In worst case it can be 9*9 = 81. + */ +class Solution1 { + public void solveSudoku(char[][] board) { + if (board == null || board.length != 9 || board[0].length != 9) { + throw new IllegalArgumentException("Input is invalid"); + } + + int[] rows = new int[9]; + int[] cols = new int[9]; + int[] boxes = new int[9]; + List blanks = new ArrayList<>(); + + for (int i = 0; i < 9; i++) { + for (int j = 0; j < 9; j++) { + char c = board[i][j]; + // To Blanks List + if (c == '.') { + blanks.add(new int[] { i, j }); + continue; + } + + // Check for Invalid Chars + if (c < '1' || c > '9') { + throw new IllegalArgumentException("Invalid sudoku board"); + } + + int b = 3 * (i / 3) + (j / 3); + int mask = 1 << (c - '1'); + + // Check for unsolvable board + if (((rows[i] & mask) != 0) || ((cols[j] & mask) != 0) || ((boxes[b] & mask) != 0)) { + throw new IllegalArgumentException("Invalid sudoku board"); + } + + // Add the cell to rows, cols and boxes. + rows[i] |= mask; + cols[j] |= mask; + boxes[b] |= mask; + } + } + + if (!solveSudokuHelper(board, rows, cols, boxes, blanks, 0)) { + throw new RuntimeException("Input sudoku does not have a valid solution"); + } + } + + private boolean solveSudokuHelper(char[][] board, int[] rows, int[] cols, int[] boxes, List blanks, + int idx) { + if (idx == blanks.size()) { + return true; + } + + int[] cell = blanks.get(idx); + int i = cell[0]; + int j = cell[1]; + int b = 3 * (i / 3) + (j / 3); + + for (char c = '1'; c <= '9'; c++) { + int mask = 1 << (c - '1'); + + // Check if the number already used in row, column and sub-box. + if (((rows[i] & mask) != 0) || ((cols[j] & mask) != 0) || ((boxes[b] & mask) != 0)) { + continue; + } + + // Add the cell to rows, cols and boxes. + rows[i] |= mask; + cols[j] |= mask; + boxes[b] |= mask; + board[i][j] = c; + + if (solveSudokuHelper(board, rows, cols, boxes, blanks, idx + 1)) { + return true; + } + + // Backtrack + // Remove the cell to rows, cols and boxes. + rows[i] &= ~mask; + cols[j] &= ~mask; + boxes[b] &= ~mask; + } + + return false; + } +} diff --git a/Swap Numbers b/Swap Numbers new file mode 100644 index 0000000..ff675de --- /dev/null +++ b/Swap Numbers @@ -0,0 +1,24 @@ +public class SwapNumbers { + + public static void main(String[] args) { + + float first = 1.20f, second = 2.45f; + + System.out.println("--Before swap--"); + System.out.println("First number = " + first); + System.out.println("Second number = " + second); + + // Value of first is assigned to temporary + float temporary = first; + + // Value of second is assigned to first + first = second; + + // Value of temporary (which contains the initial value of first) is assigned to second + second = temporary; + + System.out.println("--After swap--"); + System.out.println("First number = " + first); + System.out.println("Second number = " + second); + } +} diff --git a/Swap.cpp b/Swap.cpp new file mode 100644 index 0000000..6053852 --- /dev/null +++ b/Swap.cpp @@ -0,0 +1,36 @@ +#include + +int main() { + + double first, second, temp; + + printf("Enter first number: "); + + scanf("%lf", &first); + + printf("Enter second number: "); + + scanf("%lf", &second); + + // value of first is assigned to temp + + temp = first; + + // value of second is assigned to first + + first = second; + + // value of temp (initial value of first) is assigned to second + + second = temp; + + // %.2lf displays number up to 2 decimal points + + printf("\nAfter swapping, first number = %.2lf\n", first); + + printf("After swapping, second number = %.2lf", second); + + return 0; + +} + diff --git a/Tallest Billboard [naive depth first search] b/Tallest Billboard [naive depth first search] new file mode 100644 index 0000000..5223731 --- /dev/null +++ b/Tallest Billboard [naive depth first search] @@ -0,0 +1,19 @@ +class Solution { + public int tallestBillboard(int[] rods) { + int[] result = new int[1]; + dfs(rods, 0, 0, 0, rods.length, result); + return result[0]; + } + private void dfs(int[] rods, int left, int right, int level, int n, int[] result) { + if (level == n) { + if (left == right) { + result[0] = Math.max(left, result[0]); + } + return; + } + + dfs(rods, left, right, level + 1, n, result); + dfs(rods, left + rods[level], right, level + 1, n, result); + dfs(rods, left, right + rods[level], level + 1, n, result); + } +} diff --git a/TestStack.java b/TestStack.java new file mode 100644 index 0000000..84354e0 --- /dev/null +++ b/TestStack.java @@ -0,0 +1,58 @@ + +import java.io.*; +import java.util.*; + +class Test +{ + // Pushing element on the top of the stack + static void stack_push(Stack stack) + { + for(int i = 0; i < 5; i++) + { + stack.push(i); + } + } + + + static void stack_pop(Stack stack) + { + System.out.println("Pop Operation:"); + + for(int i = 0; i < 5; i++) + { + Integer y = (Integer) stack.pop(); + System.out.println(y); + } + } + + + static void stack_peek(Stack stack) + { + Integer element = (Integer) stack.peek(); + System.out.println("Element on stack top: " + element); + } + + + static void stack_search(Stack stack, int element) + { + Integer pos = (Integer) stack.search(element); + + if(pos == -1) + System.out.println("Element not found"); + else + System.out.println("Element is found at position: " + pos); + } + + + public static void main (String[] args) + { + Stack stack = new Stack(); + + stack_push(stack); + stack_pop(stack); + stack_push(stack); + stack_peek(stack); + stack_search(stack, 2); + stack_search(stack, 6); + } +} diff --git a/TestTwoMethods.java b/TestTwoMethods.java new file mode 100644 index 0000000..d663522 --- /dev/null +++ b/TestTwoMethods.java @@ -0,0 +1,11 @@ +package demoTest; + +public class TestTwoMethods { + public String checkMood(String message){ + return "Happy"; + } + + public static String displayStudentName(String firstName, String lastName) { + return firstName + " "+lastName; + } +} diff --git a/Tic Tac Toe/README.md b/Tic Tac Toe/README.md new file mode 100644 index 0000000..2a52649 --- /dev/null +++ b/Tic Tac Toe/README.md @@ -0,0 +1,3 @@ +# Tic-Tac-Toe Game in Java + +The task is to create a Java program to implement a 3×3 Tic-Tac-Toe game for two players. diff --git a/Tic Tac Toe/tic-tac-toe.java b/Tic Tac Toe/tic-tac-toe.java new file mode 100644 index 0000000..584c42f --- /dev/null +++ b/Tic Tac Toe/tic-tac-toe.java @@ -0,0 +1,173 @@ +// A simple program to demonstrate +// Tic-Tac-Toe Game. +import java.util.*; + +public class solution { + + static String[] board; + static String turn; + + + // CheckWinner method will + // decide the combination + // of three box given below. + static String checkWinner() + { + for (int a = 0; a < 8; a++) { + String line = null; + + switch (a) { + case 0: + line = board[0] + board[1] + board[2]; + break; + case 1: + line = board[3] + board[4] + board[5]; + break; + case 2: + line = board[6] + board[7] + board[8]; + break; + case 3: + line = board[0] + board[3] + board[6]; + break; + case 4: + line = board[1] + board[4] + board[7]; + break; + case 5: + line = board[2] + board[5] + board[8]; + break; + case 6: + line = board[0] + board[4] + board[8]; + break; + case 7: + line = board[2] + board[4] + board[6]; + break; + } + //For X winner + if (line.equals("XXX")) { + return "X"; + } + + // For O winner + else if (line.equals("OOO")) { + return "O"; + } + } + + for (int a = 0; a < 9; a++) { + if (Arrays.asList(board).contains( + String.valueOf(a + 1))) { + break; + } + else if (a == 8) { + return "draw"; + } + } + + // To enter the X Or O at the exact place on board. + System.out.println( + turn + "'s turn; enter a slot number to place " + + turn + " in:"); + return null; + } + + // To print out the board. + /* |---|---|---| + | 1 | 2 | 3 | + |-----------| + | 4 | 5 | 6 | + |-----------| + | 7 | 8 | 9 | + |---|---|---|*/ + + static void printBoard() + { + System.out.println("|---|---|---|"); + System.out.println("| " + board[0] + " | " + + board[1] + " | " + board[2] + + " |"); + System.out.println("|-----------|"); + System.out.println("| " + board[3] + " | " + + board[4] + " | " + board[5] + + " |"); + System.out.println("|-----------|"); + System.out.println("| " + board[6] + " | " + + board[7] + " | " + board[8] + + " |"); + System.out.println("|---|---|---|"); + } + + public static void main(String[] args) + { + Scanner in = new Scanner(System.in); + board = new String[9]; + turn = "X"; + String winner = null; + + for (int a = 0; a < 9; a++) { + board[a] = String.valueOf(a + 1); + } + + System.out.println("Welcome to 3x3 Tic Tac Toe."); + printBoard(); + + System.out.println( + "X will play first. Enter a slot number to place X in:"); + + while (winner == null) { + int numInput; + + // Exception handling. + // numInput will take input from user like from 1 to 9. + // If it is not in range from 1 to 9. + // then it will show you an error "Invalid input." + try { + numInput = in.nextInt(); + if (!(numInput > 0 && numInput <= 9)) { + System.out.println( + "Invalid input; re-enter slot number:"); + continue; + } + } + catch (InputMismatchException e) { + System.out.println( + "Invalid input; re-enter slot number:"); + continue; + } + + // This game has two player x and O. + // Here is the logic to decide the turn. + if (board[numInput - 1].equals( + String.valueOf(numInput))) { + board[numInput - 1] = turn; + + if (turn.equals("X")) { + turn = "O"; + } + else { + turn = "X"; + } + + printBoard(); + winner = checkWinner(); + } + else { + System.out.println( + "Slot already taken; re-enter slot number:"); + } + } + + // If no one win or lose from both player x and O. + // then here is the logic to print "draw". + if (winner.equalsIgnoreCase("draw")) { + System.out.println( + "It's a draw! Thanks for playing."); + } + + // For winner -to display Congratulations! message. + else { + System.out.println( + "Congratulations! " + winner + + "'s have won! Thanks for playing."); + } + } +} diff --git a/Tic-tac-toe java program.java b/Tic-tac-toe java program.java new file mode 100644 index 0000000..04abd22 --- /dev/null +++ b/Tic-tac-toe java program.java @@ -0,0 +1,176 @@ +import java.util.Scanner; + + +public class TicTacToe +{ + private int counter; + private char posn[]=new char[10]; + private char player; + + + public static void main(String args[]) + { + String ch; + TicTacToe Toe=new TicTacToe(); + do{ + Toe.newBoard(); + Toe.play(); + System.out.println ("Would you like to play again (Enter 'yes')? "); + Scanner in =new Scanner(System.in); + ch=in.nextLine(); + System.out.println("ch value is "+ch); + }while (ch.equals("yes")); + + + } + public void newBoard() + { + + char posndef[] = {'0','1', '2', '3', '4', '5', '6', '7', '8', '9'}; + int i; + counter = 0; + player = 'X'; + for (i=1; i<10; i++) posn[i]=posndef[i]; + currentBoard(); + + + } + public String currentBoard() + { + System.out.println( "\n\n" ); + System.out.println( "\n\n" ); + System.out.println( "\n\n\t\t" + posn [1] + " | " +posn [2]+ " | " +posn [3]); + System.out.println( " \t\t | | " ); + System.out.println( " \t\t ___|____|___ " ); + System.out.println( "\n\n\t\t" +posn [4]+ " | " +posn [5]+ " | " +posn [6]); + System.out.println( " \t\t | | " ); + System.out.println( " \t\t ___|____|___ " ); + System.out.println( "\n\n\t\t" +posn [7]+ " | " +posn [8]+ " | " +posn [9]); + System.out.println( " \t\t | | " ); + System.out.println( " \t\t | | " ); + System.out.println( "\n\n" ); + return "currentBoard"; + } + + public void play() + { + int spot; + char blank = ' '; + + System.out.println( "Player " + getPlayer() +" will go first and be the letter 'X'" ); + + do { + currentBoard(); // display current board + + System.out.println( "\n\n Player " + getPlayer() +" choose a posn." ); + + boolean posTaken = true; + while (posTaken) { + // System.out.println( "position is taken, please enter a valid space"); + Scanner in =new Scanner (System.in); + spot=in.nextInt(); + posTaken = checkPosn(spot); + if(posTaken==false) + posn[spot]=getPlayer(); + } + + System.out.println( "Nice move." ); + + currentBoard(); // display current board + + nextPlayer(); + }while ( checkWinner() == blank ); + + } + + public char checkWinner() + { + char Winner = ' '; + + // Check if X wins + if (posn[1] == 'X' && posn[2] == 'X' && posn[3] == 'X') Winner = 'X'; + if (posn[4] == 'X' && posn[5] == 'X' && posn[6] == 'X') Winner = 'X'; + if (posn[7] == 'X' && posn[8] == 'X' && posn[9] == 'X') Winner = 'X'; + if (posn[1] == 'X' && posn[4] == 'X' && posn[7] == 'X') Winner = 'X'; + if (posn[2] == 'X' && posn[5] == 'X' && posn[8] == 'X') Winner = 'X'; + if (posn[3] == 'X' && posn[6] == 'X' && posn[9] == 'X') Winner = 'X'; + if (posn[1] == 'X' && posn[5] == 'X' && posn[9] == 'X') Winner = 'X'; + if (posn[3] == 'X' && posn[5] == 'X' && posn[7] == 'X') Winner = 'X'; + if (Winner == 'X' ) + {System.out.println("Player1 wins the game." ); + return Winner; + } + + // Check if O wins + if (posn[1] == 'O' && posn[2] == 'O' && posn[3] == 'O') Winner = 'O'; + if (posn[4] == 'O' && posn[5] == 'O' && posn[6] == 'O') Winner = 'O'; + if (posn[7] == 'O' && posn[8] == 'O' && posn[9] == 'O') Winner = 'O'; + if (posn[1] == 'O' && posn[4] == 'O' && posn[7] == 'O') Winner = 'O'; + if (posn[2] == 'O' && posn[5] == 'O' && posn[8] == 'O') Winner = 'O'; + if (posn[3] == 'O' && posn[6] == 'O' && posn[9] == 'O') Winner = 'O'; + if (posn[1] == 'O' && posn[5] == 'O' && posn[9] == 'O') Winner = 'O'; + if (posn[3] == 'O' && posn[5] == 'O' && posn[7] == 'O') Winner = 'O'; + if (Winner == 'O' ) + { + System.out.println( "Player2 wins the game." ); + return Winner; } + + // check for Tie + for(int i=1;i<10;i++) + { + if(posn[i]=='X' || posn[i]=='O') + { + if(i==9) + { + char Draw='D'; + System.out.println(" Game is stalemate "); + return Draw; + } + continue; + } + else + break; + + } + + return Winner; + } + + public boolean checkPosn(int spot) + { + + + if (posn[spot] == 'X' || posn[spot] == 'O') + { + System.out.println("That posn is already taken, please choose another"); + return true; + } + else { + return false; + } + + // counter++; + // return false; + } + + + + public void nextPlayer() + { + if (player == 'X') + player = 'O'; + else player = 'X'; + + } + + public String getTitle() + { + return "Tic Tac Toe" ; + } + + public char getPlayer() + { + return player; + } + +} diff --git a/TimSort.java b/TimSort.java new file mode 100644 index 0000000..f4d00b9 --- /dev/null +++ b/TimSort.java @@ -0,0 +1,84 @@ +import java.util.Arrays; +public final class TimSort { + + static int RUN = 32; + public static void insertionSort(int[] arr, int left, int right) { + for (int i = left + 1; i <= right; i++) { + int temp = arr[i]; + int j = i - 1; + while (j >= 0 && arr[j] > temp && j >= left) { + arr[j + 1] = arr[j]; + j--; + } + arr[j + 1] = temp; + } + } + + public static void merge(int[] arr, int left, int mid, int right) { + + int leftArryLen = mid - left + 1, rightArrLen = right - mid; + int[] leftArr = new int[leftArryLen]; + int[] rightArr = new int[rightArrLen]; + + for (int x = 0; x < leftArryLen; x++) { + leftArr[x] = arr[left + x]; + } + + for (int x = 0; x < rightArrLen; x++) { + rightArr[x] = arr[mid + 1 + x]; + } + + int i = 0; + int j = 0; + int k = left; + + while (i < leftArryLen && j < rightArrLen) { + if (leftArr[i] <= rightArr[j]) { + arr[k] = leftArr[i]; + i++; + } else { + arr[k] = rightArr[j]; + j++; + } + k++; + } + + while (i < leftArryLen) { + arr[k] = leftArr[i]; + k++; + i++; + } + + while (j < rightArrLen) { + arr[k] = rightArr[j]; + k++; + j++; + } + } + + public static void timSort(int[] arr) { + int length = arr.length; + + // Sort individual subarrays of size THRESHOLD + for (int i = 0; i < length; i += RUN) { + // perform insertion sort + insertionSort(arr, i, Math.min((i + 31), (length - 1))); + } + + for (int size = RUN; size < length; size = 2 * size) { + for (int left = 0; left < length; left += 2 * size) { + int mid = left + size - 1; + int right = Math.min((left + 2 * size - 1), (length - 1)); + // perform merge sort + merge(arr, left, mid, right); + } + } + } + + public static void main(String[] args) { + int[] arr = { 10, 3, 2, 19, 7, 15, 23, 13, 1 }; + System.out.println(Arrays.toString(arr)); + timSort(arr); + System.out.println(Arrays.toString(arr)); + } +} diff --git a/Timesort.java b/Timesort.java new file mode 100644 index 0000000..f638dd1 --- /dev/null +++ b/Timesort.java @@ -0,0 +1,142 @@ + +class GFG +{ + + static int MIN_MERGE = 32; + + public static int minRunLength(int n) + { + assert n >= 0; + + // Becomes 1 if any 1 bits are shifted off + int r = 0; + while (n >= MIN_MERGE) + { + r |= (n & 1); + n >>= 1; + } + return n + r; + } + + + public static void insertionSort(int[] arr, int left, + int right) + { + for (int i = left + 1; i <= right; i++) + { + int temp = arr[i]; + int j = i - 1; + while (j >= left && arr[j] > temp) + { + arr[j + 1] = arr[j]; + j--; + } + arr[j + 1] = temp; + } + } + + // Merge function merges the sorted runs + public static void merge(int[] arr, int l, + int m, int r) + { + // Original array is broken in two parts + // left and right array + int len1 = m - l + 1, len2 = r - m; + int[] left = new int[len1]; + int[] right = new int[len2]; + for (int x = 0; x < len1; x++) + { + left[x] = arr[l + x]; + } + for (int x = 0; x < len2; x++) + { + right[x] = arr[m + 1 + x]; + } + + int i = 0; + int j = 0; + int k = l; + + while (i < len1 && j < len2) + { + if (left[i] <= right[j]) + { + arr[k] = left[i]; + i++; + } + else { + arr[k] = right[j]; + j++; + } + k++; + } + + while (i < len1) + { + arr[k] = left[i]; + k++; + i++; + } + + while (j < len2) + { + arr[k] = right[j]; + k++; + j++; + } + } + + public static void timSort(int[] arr, int n) + { + int minRun = minRunLength(MIN_MERGE); + + // Sort individual subarrays of size RUN + for (int i = 0; i < n; i += minRun) + { + insertionSort(arr, i, + Math.min((i + MIN_MERGE - 1), (n - 1))); + } + + + for (int size = minRun; size < n; size = 2 * size) + { + for (int left = 0; left < n; + left += 2 * size) + { + + int mid = left + size - 1; + int right = Math.min((left + 2 * size - 1), + (n - 1)); + + if(mid < right) + merge(arr, left, mid, right); + } + } + } + + // Utility function to print the Array + public static void printArray(int[] arr, int n) + { + for (int i = 0; i < n; i++) { + System.out.print(arr[i] + " "); + } + System.out.print("\n"); + } + + // Driver code + public static void main(String[] args) + { + int[] arr = { -2, 7, 15, -14, 0, 15, 0, 7, + -7, -4, -13, 5, 8, -14, 12 }; + int n = arr.length; + System.out.println("Given Array is"); + printArray(arr, n); + + timSort(arr, n); + + System.out.println("After Sorting Array is"); + printArray(arr, n); + } +} + + diff --git a/Tower_Of_Hanoi.c b/Tower_Of_Hanoi.c new file mode 100644 index 0000000..9c45caf --- /dev/null +++ b/Tower_Of_Hanoi.c @@ -0,0 +1,26 @@ +//program for tower of hanoi +#include +#include +void main() +{ + int n; + char A='A',B='B',C='C'; + void hanoi(int,char,char,char); + printf("Enter the number of disks : "); + scanf("%d",&n); + printf("\n\n Tower of Hanoi problem with %d disks\n",n); + printf("Sequence of moves :\n"); + hanoi(n,A,B,C); + getch(); +} +void hanoi(int n,char A,char B,char C) +{ + if(n==1) + printf("\n Move disk 1 from rod %c to rod %c",A,C); + else + { + hanoi(n-1,A,C,B); + printf("\n Move disk %d from rod %c to rod %c",n,A,C); + hanoi(n-1,B,A,C); + } +} diff --git a/Transpose_of_Matrix.java b/Transpose_of_Matrix.java new file mode 100644 index 0000000..0cc2dcc --- /dev/null +++ b/Transpose_of_Matrix.java @@ -0,0 +1,30 @@ +public class MatrixTransposeExample{ +public static void main(String args[]){ +//creating a matrix +int original[][]={{1,3,4},{2,4,3},{3,4,5}}; + +//creating another matrix to store transpose of a matrix +int transpose[][]=new int[3][3]; //3 rows and 3 columns + +//Code to transpose a matrix +for(int i=0;i<3;i++){ +for(int j=0;j<3;j++){ +transpose[i][j]=original[j][i]; +} +} + +System.out.println("Printing Matrix without transpose:"); +for(int i=0;i<3;i++){ +for(int j=0;j<3;j++){ +System.out.print(original[i][j]+" "); +} +System.out.println();//new line +} +System.out.println("Printing Matrix After Transpose:"); +for(int i=0;i<3;i++){ +for(int j=0;j<3;j++){ +System.out.print(transpose[i][j]+" "); +} +System.out.println();//new line +} +}} diff --git a/Tree/TreeImplementationLinkedList.java b/Tree/TreeImplementationLinkedList.java new file mode 100644 index 0000000..93304d8 --- /dev/null +++ b/Tree/TreeImplementationLinkedList.java @@ -0,0 +1,67 @@ +package Tree; + +import java.util.Scanner; + +public class TreeImplementationLinkedList { + + static Scanner sc=null; + public static void main(String[] args) { + + sc=new Scanner(System.in); + + Node root= createTree(); + inOrder(root); + + } + + static Node createTree() + { + Node root = null; + System.out.println("Enter Data:- "); + int data= sc.nextInt(); + + if (data==-1) return null; + + root=new Node(data); + + System.out.println("Enter Left for " + data ); + root.left=createTree(); + + System.out.println("Enter Right for " + data ); + root.right=createTree(); + + return root; + } + + static void inOrder(Node root) { + if(root == null) return; + + inOrder(root.left); + System.out.print(root.data+" "); + inOrder(root.right); + } + + static void preOrder(Node root) { + if(root == null) return; + System.out.print(root.data+" "); + preOrder(root.left); + preOrder(root.right); + } + + static void postOrder(Node root) { + if(root == null) return; + + postOrder(root.left); + postOrder(root.right); + System.out.print(root.data+" "); + } +} +class Node{ + Node left,right; + int data; + + public Node(int data) + { + this.data=data; + } +} \ No newline at end of file diff --git a/Tree/treeds b/Tree/treeds new file mode 100644 index 0000000..a803c64 --- /dev/null +++ b/Tree/treeds @@ -0,0 +1,165 @@ +import java.util.*; + +class Tree{ + static node create(){ + Scanner sc=new Scanner(System.in); + node root=null; + System.out.println("Enter the data "); + int data=sc.nextInt(); + if(data==-1){ + return null; + } + root=new node(data); + System.out.println("enter data to left of root "+root.data); + root.left=create(); + System.out.println("enter data to right of root "+root.data); + root.right=create(); + return root; + } + public static int height(node root){ + if(root==null){ + return 0; + } + return Math.max(height(root.left),height(root.right))+1; + } + public static class node{ + node left,right; + int data; + node(int data){ + this.data=data; + left=null; + right=null; + } + } + //preorder traversal in tree data structure + public static void preoder(node root){ + if(root==null){ + return; + } + System.out.print(root.data+" "); + preoder(root.left); + preoder(root.right); + } + //finding maximum in tree + public static int maximum(node root){ + if(root==null) + return Integer.MIN_VALUE; + return Math.max(root.data,Math.max(maximum(root.left),maximum(root.right))); + } + //finding minimum in tree + public static int minimum(node root){ + if(root==null) + return Integer.MAX_VALUE; + return Math.min(root.data,Math.min(minimum(root.left),minimum(root.right))); + } + //postorder traversal in tree + public static void postorder(node root){ + if(root==null){ + return; + } + postorder(root.left); + postorder(root.right); + System.out.print(root.data+" "); + } + //inoreder traveral in tree + public static void inorder(node root){ + if(root==null){ + return; + } + inorder(root.left); + System.out.print(root.data+" "); + inorder(root.right); + } + //level order traversal in tree + public static void levelorder(node root){ + Queue q=new LinkedList<>(); + q.add(root); + while(!q.isEmpty()){ + node cur=q.poll(); + System.out.print(cur.data+" "); + if(cur.left!=null){ + q.add(cur.left); + } + if(cur.right!=null){ + q.add(cur.right); + } + } + } + //int size of tree + public static int size(node root) { + if(root == null) + return 0; + return size(root.left)+size(root.right)+1; + } + public static void printleftview(node root){ + ArrayList list=new ArrayList<>(); + printviewleft(root, list, 0); + for(node cur: list){ + System.out.print(cur.data+" "); + } + } + public static void printviewleft(node root,ArrayList list,int level){ + if(root==null){ + return; + } + if(list.get(level)==null){ + list.set(level,root); + } + printviewleft(root.left, list, level+1); + printviewleft(root.right, list, level+1); + } + + public static void levelordernextlevel(node root){ + Queue q1=new LinkedList<>(); + q1.add(root); + q1.add(null); + while(!q1.isEmpty()){ + node cur=q1.poll(); + if(cur==null){ + if(q1.isEmpty()){ + return; + } + q1.add(null); + System.out.println(); + continue; + } + System.out.print(cur.data+" "); + + if(cur.left!=null){ + q1.add(cur.left); + } + if(cur.right!=null){ + q1.add(cur.right); + } + } + } + + + public static void main(String [] args){ + node root=create(); + System.out.print("preorder:-"); + preoder(root); + System.out.println(); + System.out.print("inorder:-"); + inorder(root); + System.out.println(); + System.out.print("postorder:-"); + postorder(root); + System.out.println(); + System.out.print("levelorder:-"); + levelorder(root); + System.out.println(); + System.out.print("levelorder next line:-"); + levelordernextlevel(root); + System.out.println(); + System.out.print("height of tree is "+ height(root)); + System.out.println(); + System.out.print("size of tree is "+ size(root)); + System.out.println(); + System.out.print("maximum of tree is "+ maximum(root)); + System.out.println(); + System.out.print("minimum of tree is "+ minimum(root)); + System.out.println(); + printleftview(root); + } +} diff --git a/Tree_traversal.java b/Tree_traversal.java new file mode 100644 index 0000000..33bede1 --- /dev/null +++ b/Tree_traversal.java @@ -0,0 +1,75 @@ +class Node { + public int value; + public Node left, right; + + public Node(int element) + { + value = element; + left = right = null; + } +} + +class Tree { + Node root; /* root of the tree */ + + Tree() { root = null; } + /*function to print the nodes of given binary in Preorder*/ + void traversePreorder(Node node) + { + if (node == null) + return; + System.out.print(node.value + " "); + traversePreorder(node.left); + traversePreorder(node.right); + } + /*function to print the nodes of given binary in Inorder*/ + void traverseInorder(Node node) + { + if (node == null) + return; + traverseInorder(node.left); + System.out.print(node.value + " "); + traverseInorder(node.right); + } + /*function to print the nodes of given binary in Postorder*/ + void traversePostorder(Node node) + { + if (node == null) + return; + traversePostorder(node.left); + traversePostorder(node.right); + System.out.print(node.value + " "); + } + + + void traversePreorder() { traversePreorder(root); } + void traverseInorder() { traverseInorder(root); } + void traversePostorder() { traversePostorder(root); } + + public static void main(String args[]) + { + Tree pt = new Tree(); + pt.root = new Node(36); + pt.root.left = new Node(26); + pt.root.right = new Node(46); + pt.root.left.left = new Node(21); + pt.root.left.right = new Node(31); + pt.root.left.left.left = new Node(11); + pt.root.left.left.right = new Node(24); + pt.root.right.left = new Node(41); + pt.root.right.right = new Node(56); + pt.root.right.right.left = new Node(51); + pt.root.right.right.right = new Node(66); + + System.out.println(); + System.out.println("The Preorder traversal of given binary tree is - "); + pt.traversePreorder(); + System.out.println("\n"); + System.out.println("The Inorder traversal of given binary tree is - "); + pt.traverseInorder(); + System.out.println("\n"); + System.out.println("The Postorder traversal of given binary tree is - "); + pt.traversePostorder(); + System.out.println(); + } +} \ No newline at end of file diff --git a/TripletSumProgramUsingHashing.java b/TripletSumProgramUsingHashing.java new file mode 100644 index 0000000..1c50c01 --- /dev/null +++ b/TripletSumProgramUsingHashing.java @@ -0,0 +1,42 @@ +import java.util.*; + +class GFG { + + static boolean find3Numbers(int A[],int arr_size, int sum) + { + + for (int i = 0; i < arr_size - 2; i++) { + + // Find pair in subarray A[i+1..n-1] + // with sum equal to sum - A[i] + HashSet s = new HashSet(); + int curr_sum = sum - A[i]; + for (int j = i + 1; j < arr_size; j++) + { + if (s.contains(curr_sum - A[j])) + { + System.out.printf("Triplet is %d, + %d, %d", A[i], + A[j], curr_sum - A[j]); + return true; + } + s.add(A[j]); + } + } + + + return false; + } + + /* Driver code */ + public static void main(String[] args) + { + int A[] = { 1, 4, 45, 6, 10, 8 }; + int sum = 22; + int arr_size = A.length; + + find3Numbers(A, arr_size, sum); + } +} + + diff --git a/Vowel or Consonant b/Vowel or Consonant new file mode 100644 index 0000000..2dad978 --- /dev/null +++ b/Vowel or Consonant @@ -0,0 +1,7 @@ +ch = input("Enter a character: ") + +if(ch=='A' or ch=='a' or ch=='E' or ch =='e' or ch=='I' + or ch=='i' or ch=='O' or ch=='o' or ch=='U' or ch=='u'): + print(ch, "is a Vowel") +else: + print(ch, "is a Consonant") diff --git a/Zig-Zag_tree_traversal.java b/Zig-Zag_tree_traversal.java new file mode 100644 index 0000000..fb30027 --- /dev/null +++ b/Zig-Zag_tree_traversal.java @@ -0,0 +1,104 @@ +// Java implementation of a O(n) time method for +// Zigzag order traversal +import java.util.*; +public class Main { + // Class containing left and + // right child of current + // node and key value + static class Node { + + public int data; + public Node left, right; + + public Node(int data) + { + this.data = data; + left = right = null; + } + } + + // A utility function to create a new node + static Node newNode(int data) + { + Node node = new Node(data); + return node; + } + + // Function to print the zigzag traversal + static ArrayList zigZagTraversal(Node root) + { + + ArrayList ans = new ArrayList(); + // if there is no element in the tree,return empty + // arraylist + if (root == null) + return ans; + Queue q = new LinkedList(); + q.add(root); + // this variable helps to check if elements are to + // be added from left to right or right to left + boolean leftToRight = true; + while (q.size() > 0) { + int size = q.size(); + // this arraylist is used to store element at + // current level + ArrayList temp = new ArrayList<>(); + for (int i = 0; i < size; i++) { + Node curr = q.poll(); + if (curr.left != null) + q.add(curr.left); + if (curr.right != null) + q.add(curr.right); + temp.add(curr.data); + } + if (leftToRight) // at current level,add element + // from left to right to our + // answer + { + // do nothing + } + // we have to add element from to right to left + // and this can be done by reversing our temp + // arraylist + else { + Collections.reverse(temp); + } + // add element form temp arraylist to our ans + // arraylist + for (int i = 0; i < temp.size(); i++) { + ans.add(temp.get(i)); + } + // change the value of leftToRight from true to + // false or false to true for next iteration. + leftToRight = !(leftToRight); + } + // return our ans arraylist + return ans; + } + + public static void main(String[] args) + { + + // Arraylist to store the traversal order. + ArrayList ans; + + // create tree + Node root = newNode(1); + root.left = newNode(2); + root.right = newNode(3); + root.left.left = newNode(7); + root.left.right = newNode(6); + root.right.left = newNode(5); + root.right.right = newNode(4); + System.out.println( + "ZigZag Order traversal of binary tree is"); + + ans = zigZagTraversal(root); + + for (int i = 0; i < ans.size(); + i++) { // to print the order + System.out.print(ans.get(i) + " "); + } + } +} +// this is contributed by harsh diff --git a/_5factorial.java b/_5factorial.java new file mode 100644 index 0000000..ce4ea9f --- /dev/null +++ b/_5factorial.java @@ -0,0 +1,21 @@ +import java.util.Scanner; + +public class _5factorial { + + public static void main(String[] args) { + + Scanner reader = new Scanner(System.in); + + System.out.println("Enter a number 1: "); + int n1 = reader.nextInt(); + int fact = 1; + + for (int i = 1; i <= n1; i++) { + + fact = fact * i; + } + System.out.println("Factorial value is " + fact); + + reader.close(); + } +} \ No newline at end of file diff --git a/abstract_class/Base.class b/abstract_class/Base.class new file mode 100644 index 0000000..ba8d285 Binary files /dev/null and b/abstract_class/Base.class differ diff --git a/abstract_class/Derived.class b/abstract_class/Derived.class new file mode 100644 index 0000000..4a876c8 Binary files /dev/null and b/abstract_class/Derived.class differ diff --git a/abstract_class/Main.class b/abstract_class/Main.class new file mode 100644 index 0000000..468c728 Binary files /dev/null and b/abstract_class/Main.class differ diff --git a/abstract_class/abstract.java b/abstract_class/abstract.java new file mode 100644 index 0000000..8e0b80c --- /dev/null +++ b/abstract_class/abstract.java @@ -0,0 +1,29 @@ +abstract class Base { + abstract void fun(); +} + +// Class 2 +class Derived extends Base { + void fun() + { + System.out.println("Derived fun() called"); + } +} + +// Class 3 +// Main class +class Main { + + // Main driver method + public static void main(String args[]) + { + + // Uncommenting the following line will cause + // compiler error as the line tries to create an + // instance of abstract class. Base b = new Base(); + + // We can have references of Base type. + Base b = new Derived(); + b.fun(); + } +} \ No newline at end of file diff --git a/abstract_method.txt b/abstract_method.txt new file mode 100644 index 0000000..11fe1a2 --- /dev/null +++ b/abstract_method.txt @@ -0,0 +1,36 @@ + /* Abstact Method in Java */ + +abstact class A //Superclass +{ + public abstract void Car(); +} + +class B extends A +{ + @Override + public void Car() + { + System.out.println("Anuj has Audi"); + } +} + +class C extends A +{ + @Override + public void Car() + { + System.out.println("Spandan has BMW"); + } +} + +class abstact_method +{ + public static void main(String[] a){ + A B_obj=new B(); // Reference of object class + B B_obj=new B(); // Instance of Class B + C C_obj=new C(); // Instance of Class C + B_obj.Car(); + C_obj.Car(); + } + +} \ No newline at end of file diff --git a/addTwoNumber.java b/addTwoNumber.java new file mode 100644 index 0000000..7fa0a47 --- /dev/null +++ b/addTwoNumber.java @@ -0,0 +1,16 @@ +import java.util.*; +import java.util.Scanner; +public class addTwoNumber { +public static void main (String[] args) { + + /* code */ + int a = 5; + int b = 10; + Scanner s = new Scanner(System.in); +int a = s.nextInt(); +int b = s.nextInt(); +System.out.println(a+b); + +} + +} \ No newline at end of file diff --git a/addstring.java b/addstring.java new file mode 100644 index 0000000..604e823 --- /dev/null +++ b/addstring.java @@ -0,0 +1,47 @@ +// Source : https://leetcode.com/problems/add-strings/ +// Author : mohit parmar + +/*************************************************************************************** + * + * Given two non-negative numbers num1 and num2 represented as string, return the sum + * of num1 and num2. + * + * Note: + * + * The length of both num1 and num2 is + * Both num1 and num2 contains only digits 0-9. + * Both num1 and num2 does not contain any leading zero. + * You must not use any built-in BigInteger library or convert the inputs to integer + * directly. + ***************************************************************************************/ + +class Solution { +public: + string addStrings(string num1, string num2) { + string& longstr = ( num1.size() >= num2.size() ? num1 : num2 ); + string& shortstr = ( num1.size() < num2.size() ? num1 : num2 ); + + int longlen = longstr.size(); + int shortlen = shortstr.size(); + + char carry = 0; + int i, j; + + string result; + for (i = longlen-1, j=shortlen-1; i>=0; i--, j--) { + int add = 0; + if (j>=0) { + add = longstr[i] + shortstr[j] - 2 * '0' + carry; + }else{ + add = longstr[i] - '0' + carry; + } + carry = add/10; + result = char('0' + add % 10) + result; + } + + if (carry) { + result = '1' + result; + } + return result; + } +}; \ No newline at end of file diff --git a/aeonvdedn.c b/aeonvdedn.c new file mode 100644 index 0000000..c8acb99 --- /dev/null +++ b/aeonvdedn.c @@ -0,0 +1,14 @@ +#include +int main() { + int num; + printf("Enter an integer: "); + scanf("%d", &num); + + // true if num is perfectly divisible by 2 + if(num % 2 == 0) + printf("%d is even.", num); + else + printf("%d is odd.", num); + + return 0; +} diff --git a/armstrong.java b/armstrong.java new file mode 100644 index 0000000..3302f71 --- /dev/null +++ b/armstrong.java @@ -0,0 +1,31 @@ +class Main { + public static void main(String[] args) { + + int low = 999, high = 99999; + + for(int number = low + 1; number < high; ++number) { + int digits = 0; + int result = 0; + int originalNumber = number; + + // number of digits calculation + while (originalNumber != 0) { + originalNumber /= 10; + ++digits; + } + + originalNumber = number; + + // result contains sum of nth power of its digits + while (originalNumber != 0) { + int remainder = originalNumber % 10; + result += Math.pow(remainder, digits); + originalNumber /= 10; + } + + if (result == number) { + System.out.print(number + " "); + } + } + } +} diff --git a/armstrongCheck.java b/armstrongCheck.java new file mode 100644 index 0000000..f9ef4c0 --- /dev/null +++ b/armstrongCheck.java @@ -0,0 +1,24 @@ +import java.util.Scanner; +public class JavaExample { + + public static void main(String[] args) { + + int num, number, temp, total = 0; + System.out.println("Enter 3 Digit Number"); + Scanner scanner = new Scanner(System.in); + num = scanner.nextInt(); + scanner.close(); + number = num; + + for( ;number!=0;number /= 10) + { + temp = number % 10; + total = total + temp*temp*temp; + } + + if(total == num) + System.out.println(num + " is an Armstrong number"); + else + System.out.println(num + " is not an Armstrong number"); + } +} diff --git a/bestTimeToBuyAndSellStock b/bestTimeToBuyAndSellStock new file mode 100644 index 0000000..acbf2bd --- /dev/null +++ b/bestTimeToBuyAndSellStock @@ -0,0 +1,82 @@ +public class bestTimeToBuyAndSellStock2 { +// driver code + public static void main(String[] args) { + + int[] Arr = {7, 1, 5, 3, 6, 4}; + System.out.println(maxProfit_start(Arr)); + + } + + static int maxProfit_start(int[] prices) { + int n = prices.length; + int[][] dp = new int[n][2]; + for (int[] row : dp) { + Arrays.fill(row, -1); + } + + return maxprofit(0, 0, n, prices,dp); + + + } + //recursion + + static int maxprofit(int ind, int buy, int n, int[] prices) { + if (ind == n) return 0; + + int profit = 0; + // we can by the stock + if (buy == 0) { + profit = Math.max(0 + maxprofit(ind + 1, 0, n, prices), maxprofit(ind + 1, 1, n, prices) - prices[ind]); + } + if (buy == 1) { + // we can sell the stock + profit = Math.max(0 + maxprofit(ind + 1, 1, n, prices), maxprofit(ind + 1, 0, n, prices) + prices[ind]); + } + return profit; + } + + // memorazation + static int maxprofit(int ind, int buy, int n, int[] prices, int[][] dp) { + if (ind == n) return 0; + if (dp[ind][buy] != -1) return dp[ind][buy]; + + int profit = 0; + // we can by the stock + if (buy == 0) { + profit = Math.max(0 + maxprofit(ind + 1, 0, n, prices), maxprofit(ind + 1, 1, n, prices) - prices[ind]); + } + if (buy == 1) { + // we can sell the stock + profit = Math.max(0 + maxprofit(ind + 1, 1, n, prices), maxprofit(ind + 1, 0, n, prices) + prices[ind]); + } + return dp[ind][buy] = profit; + } +} +// Tabulation + + + public int maxProfit(int[] prices){ + int n = prices.length; + int dp[][] = new int[n+1][2]; + for (int row[]:dp){ + Arrays.fill(row,-1); + } + //base condation + dp[n][0] = dp[n][1] = 0; + int profit = 0 ; + for (int ind = n-1; ind >=0 ; ind--) { + for (int buy = 0; buy <=1 ; buy++) { + if (buy == 0){ + // we can buy stock + profit = Math.max(0+dp[ind+1][0],dp[ind+1][1] -prices[ind]); + } + if (buy ==1 ){ + profit = Math.max(0+dp[ind+1][1],dp[ind+1][0] +prices[ind]); + } + dp[ind][buy] = profit; + + } + + } + return dp[0][0]; + } diff --git a/binary_search.java b/binary_search.java new file mode 100644 index 0000000..d670065 --- /dev/null +++ b/binary_search.java @@ -0,0 +1,25 @@ +class BinarySearchExample{ + public static void binarySearch(int arr[], int first, int last, int key){ + int mid = first + (last-first)/2; + while( first <= last ){ + if ( arr[mid] < key ){ + first = mid + 1; + }else if ( arr[mid] == key ){ + System.out.println("Element is found at index: " + mid); + break; + }else{ + last = mid - 1; + } + mid = (first + last)/2; + } + if ( first > last ){ + System.out.println("Element is not found!"); + } + } + public static void main(String args[]){ + int arr[] = {10,20,30,40,50}; + int key = 30; + int last=arr.length-1; + binarySearch(arr,0,last,key); + } +} diff --git a/bmiCalculator.html b/bmiCalculator.html new file mode 100644 index 0000000..4a63d74 --- /dev/null +++ b/bmiCalculator.html @@ -0,0 +1,15 @@ + + + + + BMI Cakculator + + +

BMI Calculator

+
+ + + +
+ + diff --git a/bouncynumber.java b/bouncynumber.java new file mode 100644 index 0000000..1d22fef --- /dev/null +++ b/bouncynumber.java @@ -0,0 +1,62 @@ +import java.util.*; +public class BouncyNumberExample1 +{ +public static void main(String args[]) +{ +Scanner scan = new Scanner(System.in); +System.out.print("Enter any number you want to check: "); +//reading an integer from the user +int inputNumber = scan.nextInt(); +//if any of the following condition returns true, the number id not bouncy +if (isIncreasing(inputNumber) || isDecreasing(inputNumber) || inputNumber < 101) +//prints if the number is not bouncy +System.out.println(inputNumber+" not a bouncy number."); +else +//prints if the number is bouncy +System.out.println(inputNumber+" is a bouncy number."); +} +//function that checks if the number is an increasing number or not +public static boolean isIncreasing(int inputNumber) +{ +//converts the number into string +String str = Integer.toString(inputNumber); +char digit; +//flag set to true +boolean flag = true; +//iterates over the string up to length-1 +for(int i=0;i < str.length()-1;i++) +{ +digit = str.charAt(i); +//if any digit is greater than check next digit, it will not check further +if(digit > str.charAt(i+1)) +{ +//flag set to false if the condition returns true +flag = false; +break; +} +} +return flag; +} +//function that checks if the number is a decreasing number or not +public static boolean isDecreasing(int inputNumber) +{ +//converts the number into string +String str = Integer.toString(inputNumber); +char digit; +//flag set to true +boolean flag = true; +//iterates over the string up to length-1 +for(int i=0;i < str.length()-1;i++) +{ +digit = str.charAt(i); +//if any digit is less than the next digit, it will not check further +if(digit < str.charAt(i+1)) +{ +//flag set to false if the condition returns true +flag = false; +break; +} +} +return flag; +} +} diff --git a/boxmodel.html b/boxmodel.html new file mode 100644 index 0000000..4fdf4fb --- /dev/null +++ b/boxmodel.html @@ -0,0 +1,67 @@ + + + + + + + Box Model + + + +
+

This is my heading

+

Lorem ipsum dolor sit amet consectetur, adipisicing elit. Incidunt harum quis, quibusdam, minima molestiae tempore vel magni, repellendus doloribus debitis rerum tenetur eveniet.

+
+ +
+

This is my heading

+

Lorem ipsum dolor sit amet consectetur, adipisicing elit. Incidunt harum quis, quibusdam, minima molestiae tempore vel magni, repellendus doloribus debitis rerum tenetur eveniet.

+
+ +
+

This is my heading

+

Lorem ipsum dolor sit amet consectetur, adipisicing elit. Incidunt harum quis, quibusdam, minima molestiae tempore vel magni, repellendus doloribus debitis rerum tenetur eveniet.

+
+ + diff --git a/bubble.java b/bubble.java new file mode 100644 index 0000000..4d6b7d6 --- /dev/null +++ b/bubble.java @@ -0,0 +1,58 @@ +// Java program to sort an array +// using bucket sort +import java.util.*; +import java.util.Collections; + +class GFG { + + // Function to sort arr[] of size n + // using bucket sort + static void bucketSort(float arr[], int n) + { + if (n <= 0) + return; + + // 1) Create n empty buckets + @SuppressWarnings("unchecked") + Vector[] buckets = new Vector[n]; + + for (int i = 0; i < n; i++) { + buckets[i] = new Vector(); + } + + // 2) Put array elements in different buckets + for (int i = 0; i < n; i++) { + float idx = arr[i] * n; + buckets[(int)idx].add(arr[i]); + } + + // 3) Sort individual buckets + for (int i = 0; i < n; i++) { + Collections.sort(buckets[i]); + } + + // 4) Concatenate all buckets into arr[] + int index = 0; + for (int i = 0; i < n; i++) { + for (int j = 0; j < buckets[i].size(); j++) { + arr[index++] = buckets[i].get(j); + } + } + } + + // Driver code + public static void main(String args[]) + { + float arr[] = { (float)0.897, (float)0.565, + (float)0.656, (float)0.1234, + (float)0.665, (float)0.3434 }; + + int n = arr.length; + bucketSort(arr, n); + + System.out.println("Sorted array is "); + for (float el : arr) { + System.out.print(el + " "); + } + } +} diff --git a/bubble_sort.java b/bubble_sort.java new file mode 100644 index 0000000..ff0f385 --- /dev/null +++ b/bubble_sort.java @@ -0,0 +1,62 @@ +public class BubbleSortExample { + /*worst case of this code is O(n2).*/ + static void bubbleSort(int[] arr) { + int n = arr.length; + int temp = 0; + for(int i=0; i < n; i++){ + for(int j=1; j < (n-i); j++){ + if(arr[j-1] > arr[j]){ + //swap elements + temp = arr[j-1]; + arr[j-1] = arr[j]; + arr[j] = temp; + } + + } + } + + + } + /* An optimized version of Bubble Sort + worst case of this code is O(n).*/ + + static void optimizedbubbleSort(int arr[], int n) + { + int i, j, temp; + boolean swapped; + for (i = 0; i < n - 1; i++) + { + swapped = false; + for (j = 0; j < n - i - 1; j++) + { + if (arr[j] > arr[j + 1]) + { + temp = arr[j]; + arr[j] = arr[j + 1]; + arr[j + 1] = temp; + swapped = true; + } + } + if (swapped == false) + break; + } + } + public static void main(String[] args) { + int arr[] ={3,60,35,2,45,320,5}; + + System.out.println("Array Before Bubble Sort"); + for(int i=0; i < arr.length; i++){ + System.out.print(arr[i] + " "); + } + System.out.println(); + + bubbleSort(arr);/*sorting array elements using bubble sort */ + + System.out.println("Array After Bubble Sort"); + for(int i=0; i < arr.length; i++){ + System.out.print(arr[i] + " "); + } + + } +} +//THIS CODE IS UPDATED BY BATRAKESHAV10 diff --git a/bubble_sortnew.java b/bubble_sortnew.java new file mode 100644 index 0000000..436662e --- /dev/null +++ b/bubble_sortnew.java @@ -0,0 +1,35 @@ +public class BubbleSortExample { + static void bubbleSort(int[] arr) { + int n = arr.length; + int temp = 0; + for(int i=0; i < n; i++){ + for(int j=1; j < (n-i); j++){ + if(arr[j-1] > arr[j]){ + //swap elements + temp = arr[j-1]; + arr[j-1] = arr[j]; + arr[j] = temp; + } + + } + } + + } + public static void main(String[] args) { + int arr[] ={3,60,35,2,45,320,5}; + + System.out.println("Array Before Bubble Sort"); + for(int i=0; i < arr.length; i++){ + System.out.print(arr[i] + " "); + } + System.out.println(); + + bubbleSort(arr);//sorting array elements using bubble sort + + System.out.println("Array After Bubble Sort"); + for(int i=0; i < arr.length; i++){ + System.out.print(arr[i] + " "); + } + + } +} diff --git a/bubblesort.java b/bubblesort.java index 436662e..ae1ceaa 100644 --- a/bubblesort.java +++ b/bubblesort.java @@ -1,35 +1,35 @@ -public class BubbleSortExample { - static void bubbleSort(int[] arr) { - int n = arr.length; - int temp = 0; - for(int i=0; i < n; i++){ - for(int j=1; j < (n-i); j++){ - if(arr[j-1] > arr[j]){ - //swap elements - temp = arr[j-1]; - arr[j-1] = arr[j]; - arr[j] = temp; - } - - } - } - - } - public static void main(String[] args) { - int arr[] ={3,60,35,2,45,320,5}; - - System.out.println("Array Before Bubble Sort"); - for(int i=0; i < arr.length; i++){ - System.out.print(arr[i] + " "); - } - System.out.println(); - - bubbleSort(arr);//sorting array elements using bubble sort - - System.out.println("Array After Bubble Sort"); - for(int i=0; i < arr.length; i++){ - System.out.print(arr[i] + " "); - } - - } -} +public class BubbleSortExample { + static void bubbleSort(int[] arr) { + int n = arr.length; + int temp = 0; + for(int i=0; i < n; i++){ + for(int j=1; j < (n-i); j++){ + if(arr[j-1] > arr[j]){ + //swap elements + temp = arr[j-1]; + arr[j-1] = arr[j]; + arr[j] = temp; + } + + } + } + + } + public static void main(String[] args) { + int arr[] ={3,60,35,2,45,320,5}; + + System.out.println("Array Before Bubble Sort"); + for(int i=0; i < arr.length; i++){ + System.out.print(arr[i] + " "); + } + System.out.println(); + + bubbleSort(arr);//sorting array elements using bubble sort + + System.out.println("Array After Bubble Sort"); + for(int i=0; i < arr.length; i++){ + System.out.print(arr[i] + " "); + } + + } +} \ No newline at end of file diff --git a/bubblesorthacktoberfest.java b/bubblesorthacktoberfest.java new file mode 100644 index 0000000..24119cf --- /dev/null +++ b/bubblesorthacktoberfest.java @@ -0,0 +1,31 @@ +package Sorting; + +public class bubblesort { + + public static void main(String args[]) + { + int a[]={3,4,5,2,1,87,45} + + for(int i=1;i=0 && a[hole]>key) + { + a[hole+1]=a[hole]; + hole=hole-1; + + a[hole+1]=key; + } + } + + for(int i=0;i arr[j + 1]) + { + temp = arr[j]; + arr[j] = arr[j + 1]; + arr[j + 1] = temp; + swapped = true; + } + } + if (swapped == false) + break; + } + } + public static void main(String[] args) { + int arr[] ={3,60,35,2,45,320,5}; + + System.out.println("Array Before Bubble Sort"); + for(int i=0; i < arr.length; i++){ + System.out.print(arr[i] + " "); + } + System.out.println(); + + bubbleSort(arr);//sorting array elements using bubble sort + + System.out.println("Array After Bubble Sort"); + for(int i=0; i < arr.length; i++){ + System.out.print(arr[i] + " "); + } + + } +} diff --git a/buzznumber.java b/buzznumber.java new file mode 100644 index 0000000..e9cdbc2 --- /dev/null +++ b/buzznumber.java @@ -0,0 +1,47 @@ +import Java.util.*; +import java.io.*; +import java.util.Scanner; + +//create BuzzNumberExample class to check whether the given number is Buzz number or not +class BuzzNumberExample { + + // create checkNumber() method that returns true when it founds number Buzz + static boolean checkNumber(int number) + { + // check whether the number ends with 7, is divisible by 7 or not + if(number % 10 == 7 || number % 7 == 0) + return true; //returns true when the number is Buzz + else + return false; //returns flase when the number is not Buzz + } + + // main() method start + public static void main(String args[]) + { + int n1, n2; + + //create scanner class object to get input from user + Scanner sc=new Scanner(System.in); + + //show custom message + System.out.println("Enter first number"); + + //store user entered value into variable n1 + n1 = sc.nextInt(); + + //show custom message + System.out.println("Enter second number"); + + //store user entered value into variable n2 + n2 = sc.nextInt(); + + if (checkNumber(n1)) + System.out.println(n1 + " is a Buzz number"); + else + System.out.println(n1 + " is not a Buzz number"); + if (checkNumber(n2)) + System.out.println(n2 + " is a Buzz number"); + else + System.out.println(n2 + " is not a Buzz number"); + } +} diff --git a/bytearraytohex.java b/bytearraytohex.java new file mode 100644 index 0000000..a47c44a --- /dev/null +++ b/bytearraytohex.java @@ -0,0 +1,12 @@ +public class ByteHex { + + public static void main(String[] args) { + + byte[] bytes = {10, 2, 15, 11}; + + for (byte b : bytes) { + String st = String.format("%02X", b); + System.out.print(st); + } + } +} diff --git a/c++ structure.cpp b/c++ structure.cpp new file mode 100644 index 0000000..c28a4fc --- /dev/null +++ b/c++ structure.cpp @@ -0,0 +1,28 @@ +#include +using namespace std; + +struct Person +{ + char name[50]; + int age; + float salary; +}; + +int main() +{ + Person p1; + + cout << "Enter Full name: "; + cin.get(p1.name, 50); + cout << "Enter age: "; + cin >> p1.age; + cout << "Enter salary: "; + cin >> p1.salary; + + cout << "\nDisplaying Information." << endl; + cout << "Name: " << p1.name << endl; + cout <<"Age: " << p1.age << endl; + cout << "Salary: " << p1.salary; + + return 0; +} \ No newline at end of file diff --git a/c++001.cpp b/c++001.cpp new file mode 100644 index 0000000..5cfdd45 --- /dev/null +++ b/c++001.cpp @@ -0,0 +1,29 @@ +// Program to compute absolute value +// Works for both int and float + +#include +using namespace std; + +// function with float type parameter +float absolute(float var){ + if (var < 0.0) + var = -var; + return var; +} + +// function with int type parameter +int absolute(int var) { + if (var < 0) + var = -var; + return var; +} + +int main() { + + // call function with int type parameter + cout << "Absolute value of -5 = " << absolute(-5) << endl; + + // call function with float type parameter + cout << "Absolute value of 5.5 = " << absolute(5.5f) << endl; + return 0; +} diff --git a/c++3,cpp b/c++3,cpp new file mode 100644 index 0000000..17a4da1 --- /dev/null +++ b/c++3,cpp @@ -0,0 +1,25 @@ +// Factorial of n = 1*2*3*...*n + +#include +using namespace std; + +int factorial(int); + +int main() { + int n, result; + + cout << "Enter a non-negative number: "; + cin >> n; + + result = factorial(n); + cout << "Factorial of " << n << " = " << result; + return 0; +} + +int factorial(int n) { + if (n > 1) { + return n * factorial(n - 1); + } else { + return 1; + } +} diff --git a/c++3.cpp b/c++3.cpp new file mode 100644 index 0000000..17a4da1 --- /dev/null +++ b/c++3.cpp @@ -0,0 +1,25 @@ +// Factorial of n = 1*2*3*...*n + +#include +using namespace std; + +int factorial(int); + +int main() { + int n, result; + + cout << "Enter a non-negative number: "; + cin >> n; + + result = factorial(n); + cout << "Factorial of " << n << " = " << result; + return 0; +} + +int factorial(int n) { + if (n > 1) { + return n * factorial(n - 1); + } else { + return 1; + } +} diff --git a/c++400.cpp b/c++400.cpp new file mode 100644 index 0000000..17a4da1 --- /dev/null +++ b/c++400.cpp @@ -0,0 +1,25 @@ +// Factorial of n = 1*2*3*...*n + +#include +using namespace std; + +int factorial(int); + +int main() { + int n, result; + + cout << "Enter a non-negative number: "; + cin >> n; + + result = factorial(n); + cout << "Factorial of " << n << " = " << result; + return 0; +} + +int factorial(int n) { + if (n > 1) { + return n * factorial(n - 1); + } else { + return 1; + } +} diff --git a/calculator.java b/calculator.java new file mode 100644 index 0000000..8f81a7b --- /dev/null +++ b/calculator.java @@ -0,0 +1,56 @@ +import java.util.Scanner; + +class Main { + public static void main(String[] args) { + + char operator; + Double number1, number2, result; + + // create an object of Scanner class + Scanner input = new Scanner(System.in); + + // ask users to enter operator + System.out.println("Choose an operator: +, -, *, or /"); + operator = input.next().charAt(0); + + // ask users to enter numbers + System.out.println("Enter first number"); + number1 = input.nextDouble(); + + System.out.println("Enter second number"); + number2 = input.nextDouble(); + + switch (operator) { + + // performs addition between numbers + case '+': + result = number1 + number2; + System.out.println(number1 + " + " + number2 + " = " + result); + break; + + // performs subtraction between numbers + case '-': + result = number1 - number2; + System.out.println(number1 + " - " + number2 + " = " + result); + break; + + // performs multiplication between numbers + case '*': + result = number1 * number2; + System.out.println(number1 + " * " + number2 + " = " + result); + break; + + // performs division between numbers + case '/': + result = number1 / number2; + System.out.println(number1 + " / " + number2 + " = " + result); + break; + + default: + System.out.println("Invalid operator!"); + break; + } + + input.close(); + } +} \ No newline at end of file diff --git a/ceilingNum.java b/ceilingNum.java new file mode 100644 index 0000000..ca365cc --- /dev/null +++ b/ceilingNum.java @@ -0,0 +1,37 @@ +public class CeilingNum { + public static void main(String[] args) { + int[] arr={2,3,5,9,14,16,18}; + int num = 5; + int ans=Ceilingnum(arr,num); + System.out.println(ans); + } + + public static int Ceilingnum(int arr[],int target) + { + if(target>arr[arr.length-1]) + { + return -1; + } + + int start=0,end=arr.length-1; + while(start<=end) + { + int mid=(start+end)/2; + if(targetarr[mid]) + { + start=mid+1; + } + else + { + return arr[mid]; + } + } + return arr[start]; // for floor value start will be replaced with end + } + +} + diff --git a/challenge.txt b/challenge.txt new file mode 100644 index 0000000..17d7f59 --- /dev/null +++ b/challenge.txt @@ -0,0 +1,72 @@ +# Hacktoberfest2022 +[![Typing SVG](https://readme-typing-svg.demolab.com/?lines=Hey+boss+Hactoberfest+2022+is+here;hurry+up+and+join+now)](https://git.io/typing-svg) +# ✨Hacktoberfest 2022✨ + +## Hello security geeks, I'm Shiva + +Contribute to start your journey with hacktoberfest. Happy Hacking💻!!! (*Required) + +# 🌟Languages +- 💻 HTML +- 💻 PHP +- 💻 Python +- 💻 Java +- 💻 Javascript +- 💻 Dart +- 💻 C language +- 💻 Go lang + +# ❄Programs +- ⚡Print 1 to 100 without using numbers +- ⚡Make calculator without using operators in program +- ⚡Create any pattern +- ⚡Make any algorithm +- ⚡Add webpage parts. +- ⚡Calculate fibonacci series with classes +- ⚡Calculate factorial with classes +- ⚡Print IP Address and Hostname +- ⚡Any Game +- ⚡Any Other Codes +- ⚡Payloads + +# ⚡️Swags of Hacktoberfest: +- Participants are required to make four (4) successfull pull request for the hacktoberfest2022, So that you will be eligible to get the swags from the Hacktoberfest. +- Swags: +- 1. Hactoberfest T-Shirt +- 2. Cool Stickers for your Tech accessories + +

  • tshirt image

    stickers image

    +
    • + +# ✡What to do ? +1. Create a new README.md file or add any programming language codes of any projects, creating games, payloads, scripts in the given area. +2. You can also download this README.md file, edit and upload it here. + +# ✨Getting started: +```text +1. Create a github account +2. Register for hacktoberfest 2022 +3. Come here and edit this file +4. Edit any 2 line code then click on **Propose Changes** +5. Then save your edit and go to pull request on the up +6. You'll see **Merge and create pull request option** +7. Click on it and save it +8. The main developer will accept it +9. DONE, now you created one successfull pull request +10. REPEAT ALL STEPS 4 times to complete all the task +``` + +# Contribution rules📚: +```text +- The project must work when opening Contributors.html +- You are allowed to make pull requests that break the rules. We just merge it ;) +- Do NOT add any build steps e.g npm install (we want to keep this a simple static site) +- Do NOT remove other content. +- Styling/code can be pretty, ugly or stupid, big or small as long as it works +- Add your name to the Contributors.html file +- Try to keep pull requests small to minimize merge conflicts +``` + +```text +**Make this README FILE MORE PROFESSIONAL AND ATTRACTIVE** +``` diff --git a/checkstringisnumeric.java b/checkstringisnumeric.java new file mode 100644 index 0000000..c932183 --- /dev/null +++ b/checkstringisnumeric.java @@ -0,0 +1,19 @@ +public class Numeric { + + public static void main(String[] args) { + + String string = "12345.15"; + boolean numeric = true; + + try { + Double num = Double.parseDouble(string); + } catch (NumberFormatException e) { + numeric = false; + } + + if(numeric) + System.out.println(string + " is a number"); + else + System.out.println(string + " is not a number"); + } +} diff --git a/code1 b/code1 new file mode 100644 index 0000000..7aaa3da --- /dev/null +++ b/code1 @@ -0,0 +1,36 @@ +// Code to understand the working of the copy constructor. +#include +using namespace std; +class person +{ +private: + string name; + int age; + +public: + person(string person_name, int person_age) + { + cout << "Constructor for both name and age is called" << endl; + name = person_name; + age = person_age; + } + person(const person &obj) + { + cout << "Copy constructor is called" << endl; + name = obj.name; + age = obj.age; + } + void display() + { + cout << "Name of current object : " << name << endl; + cout << "Age of current object : " << age << endl; + cout << endl; + } +}; +int main() +{ + person obj1("First person", 25); + obj1.display(); + person obj2(obj1); + obj2.display(); +}; diff --git a/comparetwoobjects.java b/comparetwoobjects.java new file mode 100644 index 0000000..5c0302f --- /dev/null +++ b/comparetwoobjects.java @@ -0,0 +1,13 @@ +public class ObjectComparisonExample +{ +public static void main(String[] args) +{ +//creating constructor of the Double class +Double x = new Double(123.45555); +//creating constructor of the Long class +Long y = new Long(9887544); +//invoking the equals() method +System.out.println("Objects are not equal, hence it returns " + x.equals(y)); +System.out.println("Objects are equal, hence it returns " + x.equals(123.45555)); +} +} diff --git a/countSort.java b/countSort.java new file mode 100644 index 0000000..332a4bb --- /dev/null +++ b/countSort.java @@ -0,0 +1,23 @@ +public class countSort { + public static void main(String[] args) { + int[] arr = {5,4,3,3,2,1}; //created array + int k = 5; + int n = arr.length; + int[] countArr = new int[k+1]; + for(int i=1;i<=k;i++) countArr[i] = 0; + + for(int i=0;i +using namespace std; + +void checkPalindrome(const char* p){ + + const char* pnew = p; + + for(p;*p != '\0';p++); + // p--; + while (*pnew++ == *--p); + + if(pnew>p) cout<<"is"; + + else cout<<"isnot"; + + +} +int main() +{ + int x; + cout<<"enter the size of the string "; + cin>>x; + + char* str = new char[x]; + + for(int i = 0; i>str[i] ; + } + + const char* pointer; + + pointer = str; + + checkPalindrome(pointer); + + delete [] str; + + + +} diff --git a/currentdirectory.java b/currentdirectory.java new file mode 100644 index 0000000..3d2bb11 --- /dev/null +++ b/currentdirectory.java @@ -0,0 +1,10 @@ +public class CurrDirectory { + + public static void main(String[] args) { + + String path = System.getProperty("user.dir"); + + System.out.println("Working Directory = " + path); + + } +} diff --git a/diamond.java b/diamond.java new file mode 100644 index 0000000..f4fdc17 --- /dev/null +++ b/diamond.java @@ -0,0 +1,27 @@ +import java.util.*; +public class Main +{ + public static void main(String[] args) + { + Scanner sc=new Scanner(System.in); + System.out.println("Enter the length of the diamond"); + int num=sc.nextInt(); + int j,k; + for(j=1;j<=num;j++) + { + for(k=1;k<=num-j;k++) + System.out.print(" "); + for(k=1;k<=j*2-1;k++) + System.out.print("*"); + System.out.println(); + } + for(j=num-1;j>0;j--) + { + for(k=1;k<=num-j;k++) + System.out.print(" "); + for(k=1;k<=j*2-1;k++) + System.out.print("*"); + System.out.println(); + } + } +} \ No newline at end of file diff --git a/dijkstra-algorithm.java b/dijkstra-algorithm.java new file mode 100644 index 0000000..1306c5f --- /dev/null +++ b/dijkstra-algorithm.java @@ -0,0 +1,115 @@ +import java.util.*; +class Graph_pq { + int dist[]; + Set visited; + PriorityQueue pqueue; + int V; // Number of vertices + List > adj_list; + //class constructor + public Graph_pq(int V) { + this.V = V; + dist = new int[V]; + visited = new HashSet(); + pqueue = new PriorityQueue(V, new Node()); + } + + // Dijkstra's Algorithm implementation + public void algo_dijkstra(List > adj_list, int src_vertex) + { + this.adj_list = adj_list; + + for (int i = 0; i < V; i++) + dist[i] = Integer.MAX_VALUE; + + // first add source vertex to PriorityQueue + pqueue.add(new Node(src_vertex, 0)); + + // Distance to the source from itself is 0 + dist[src_vertex] = 0; + while (visited.size() != V) { + + // u is removed from PriorityQueue and has min distance + int u = pqueue.remove().node; + + // add node to finalized list (visited) + visited.add(u); + graph_adjacentNodes(u); + } + } + // this methods processes all neighbours of the just visited node + private void graph_adjacentNodes(int u) { + int edgeDistance = -1; + int newDistance = -1; + + // process all neighbouring nodes of u + for (int i = 0; i < adj_list.get(u).size(); i++) { + Node v = adj_list.get(u).get(i); + + // proceed only if current node is not in 'visited' + if (!visited.contains(v.node)) { + edgeDistance = v.cost; + newDistance = dist[u] + edgeDistance; + + // compare distances + if (newDistance < dist[v.node]) + dist[v.node] = newDistance; + + // Add the current vertex to the PriorityQueue + pqueue.add(new Node(v.node, dist[v.node])); + } + } + } +} +class Main{ + public static void main(String arg[]) { + int V = 6; + int source = 0; + // adjacency list representation of graph + List > adj_list = new ArrayList >(); + // Initialize adjacency list for every node in the graph + for (int i = 0; i < V; i++) { + List item = new ArrayList(); + adj_list.add(item); + } + + + // Input graph edges + adj_list.get(0).add(new Node(1, 5)); + adj_list.get(0).add(new Node(2, 3)); + adj_list.get(0).add(new Node(3, 2)); + adj_list.get(0).add(new Node(4, 3)); + adj_list.get(0).add(new Node(5, 3)); + adj_list.get(2).add(new Node(1, 2)); + adj_list.get(2).add(new Node(3, 3)); + // call Dijkstra's algo method + Graph_pq dpq = new Graph_pq(V); + dpq.algo_dijkstra(adj_list, source); + + // Print the shortest path from source node to all the nodes + System.out.println("The shorted path from source node to other nodes:"); + System.out.println("Source\t\t" + "Node#\t\t" + "Distance"); + for (int i = 0; i < dpq.dist.length; i++) + System.out.println(source + " \t\t " + i + " \t\t " + dpq.dist[i]); + } +} + +// Node class +class Node implements Comparator { + public int node; + public int cost; + public Node() { } //empty constructor + + public Node(int node, int cost) { + this.node = node; + this.cost = cost; + } + @Override + public int compare(Node node1, Node node2) + { + if (node1.cost < node2.cost) + return -1; + if (node1.cost > node2.cost) + return 1; + return 0; + } +} diff --git a/disjoint set.java b/disjoint set.java new file mode 100644 index 0000000..d1405b3 --- /dev/null +++ b/disjoint set.java @@ -0,0 +1,118 @@ +// A Java program to implement Disjoint Set Data +// Structure. +import java.io.*; +import java.util.*; + +class DisjointUnionSets { + int[] rank, parent; + int n; + + // Constructor + public DisjointUnionSets(int n) + { + rank = new int[n]; + parent = new int[n]; + this.n = n; + makeSet(); + } + + // Creates n sets with single item in each + void makeSet() + { + for (int i = 0; i < n; i++) { + // Initially, all elements are in + // their own set. + parent[i] = i; + } + } + + // Returns representative of x's set + int find(int x) + { + // Finds the representative of the set + // that x is an element of + if (parent[x] != x) { + // if x is not the parent of itself + // Then x is not the representative of + // his set, + parent[x] = find(parent[x]); + + // so we recursively call Find on its parent + // and move i's node directly under the + // representative of this set + } + + return parent[x]; + } + + // Unites the set that includes x and the set + // that includes x + void union(int x, int y) + { + // Find representatives of two sets + int xRoot = find(x), yRoot = find(y); + + // Elements are in the same set, no need + // to unite anything. + if (xRoot == yRoot) + return; + + // If x's rank is less than y's rank + if (rank[xRoot] < rank[yRoot]) + + // Then move x under y so that depth + // of tree remains less + parent[xRoot] = yRoot; + + // Else if y's rank is less than x's rank + else if (rank[yRoot] < rank[xRoot]) + + // Then move y under x so that depth of + // tree remains less + parent[yRoot] = xRoot; + + else // if ranks are the same + { + // Then move y under x (doesn't matter + // which one goes where) + parent[yRoot] = xRoot; + + // And increment the result tree's + // rank by 1 + rank[xRoot] = rank[xRoot] + 1; + } + } +} + +// Driver code +public class Main { + public static void main(String[] args) + { + // Let there be 5 persons with ids as + // 0, 1, 2, 3 and 4 + int n = 5; + DisjointUnionSets dus = + new DisjointUnionSets(n); + + // 0 is a friend of 2 + dus.union(0, 2); + + // 4 is a friend of 2 + dus.union(4, 2); + + // 3 is a friend of 1 + dus.union(3, 1); + + // Check if 4 is a friend of 0 + if (dus.find(4) == dus.find(0)) + System.out.println("Yes"); + else + System.out.println("No"); + + // Check if 1 is a friend of 0 + if (dus.find(1) == dus.find(0)) + System.out.println("Yes"); + else + System.out.println("No"); + } +} diff --git a/division.c b/division.c new file mode 100644 index 0000000..5cfba9b --- /dev/null +++ b/division.c @@ -0,0 +1,14 @@ +#include +int main() +{ + int num1,num2,div; + printf("\tEnter Two Numbers\n"); + printf("---------------------------\n"); + printf("Enter First Number : "); + scanf("%d", &num1); + printf("\nEnter Second Number : "); + scanf("%d",&num2); + div=num1/num2; + printf("\nDivision of %d & %d is = %d",num1,num2,div); + return 0; +} diff --git a/doublyLinkedList.cpp b/doublyLinkedList.cpp new file mode 100644 index 0000000..fa1a262 --- /dev/null +++ b/doublyLinkedList.cpp @@ -0,0 +1,40 @@ +#include +using namespace std; +struct Node{ +int data; +Node *next; +Node *prev; +}; +void insertAtHead(Node **head_ref ,int mydata) +{ + Node* temp=new Node(); + temp->data=mydata; + temp->next=*head_ref; + temp->prev=NULL; + if(*head_ref!=NULL) + { + (*head_ref)->prev=temp; + } + + (*head_ref)=temp; + +} +void print(Node*head) +{ + Node*temp=head; + while(temp!=NULL) + { + cout<data<<" "; + temp=temp->next; + } +} +int main(){ + Node*head=NULL; + insertAtHead(&head,2); + insertAtHead(&head,5); + insertAtHead(&head,7); + insertAtHead(&head,11); + print(head); + + return 0; +} \ No newline at end of file diff --git a/duck_number.java b/duck_number.java new file mode 100644 index 0000000..2f93589 --- /dev/null +++ b/duck_number.java @@ -0,0 +1,27 @@ +import java.util.*; +public class Main +{ + public static boolean duck(String num,int len) + { + int i=0; + while (i +using namespace std; + +class Encapsulation +{ + private: + // data hidden from outside world + int x; + + public: + // function to set value of + // variable x + void set(int a) + { + x =a; + } + + // function to return value of + // variable x + int get() + { + return x; + } +}; + +// main function +int main() +{ + Encapsulation obj; + + obj.set(5); + + cout< +#include +#include +int main() +{ + + // make two process which run same + // program after this instruction + fork(); + + printf("Hello world!\n"); + return 0; +} + diff --git a/factorial.java b/factorial.java new file mode 100644 index 0000000..bf0bda2 --- /dev/null +++ b/factorial.java @@ -0,0 +1,14 @@ +class FactorialExample2{ + static int factorial(int n){ + if (n == 0) + return 1; + else + return(n * factorial(n-1)); + } + public static void main(String args[]){ + int i,fact=1; + int number=4;//It is the number to calculate factorial + fact = factorial(number); + System.out.println("Factorial of "+number+" is: "+fact); + } +} \ No newline at end of file diff --git a/factorial3.cpp b/factorial3.cpp new file mode 100644 index 0000000..17a4da1 --- /dev/null +++ b/factorial3.cpp @@ -0,0 +1,25 @@ +// Factorial of n = 1*2*3*...*n + +#include +using namespace std; + +int factorial(int); + +int main() { + int n, result; + + cout << "Enter a non-negative number: "; + cin >> n; + + result = factorial(n); + cout << "Factorial of " << n << " = " << result; + return 0; +} + +int factorial(int n) { + if (n > 1) { + return n * factorial(n - 1); + } else { + return 1; + } +} diff --git a/fibonacci.java b/fibonacci.java new file mode 100644 index 0000000..cc4f405 --- /dev/null +++ b/fibonacci.java @@ -0,0 +1,15 @@ +public class fibonacci +{ + public static void main(String[] args) + { + int n1=0,n2=1,n3=0,i; + System.out.print(n1 + " " +n2); + for(i=2;i<=10;++i) + { + n3=n1+n2; + System.out.print("\t" +n3); + n1=n2; + n2=n3; + } + } +} diff --git a/fileHandler.java b/fileHandler.java new file mode 100644 index 0000000..362bb9e --- /dev/null +++ b/fileHandler.java @@ -0,0 +1,36 @@ +package gomes.fernando.robson; + +import java.io.BufferedReader; +import java.io.BufferedWriter; +import java.io.FileReader; +import java.io.FileWriter; +import java.io.IOException; +import java.util.Scanner; + +public class ManipuladorArquivo { + + public static void leitor(String path) throws IOException { + BufferedReader buffRead = new BufferedReader(new FileReader(path)); + String linha = ""; + while (true) { + if (linha != null) { + System.out.println(linha); + + } else + break; + linha = buffRead.readLine(); + } + buffRead.close(); + } + + public static void escritor(String path) throws IOException { + BufferedWriter buffWrite = new BufferedWriter(new FileWriter(path)); + String linha = ""; + Scanner in = new Scanner(System.in); + System.out.println("Escreva algo: "); + linha = in.nextLine(); + buffWrite.append(linha + "\n"); + buffWrite.close(); + } + +} \ No newline at end of file diff --git a/fileextension.java b/fileextension.java new file mode 100644 index 0000000..30b18e4 --- /dev/null +++ b/fileextension.java @@ -0,0 +1,17 @@ +import java.io.File; + +class Main { + + public static void main(String[] args) { + File file = new File("Test.java"); + + // convert the file name into string + String fileName = file.toString(); + + int index = fileName.lastIndexOf('.'); + if(index > 0) { + String extension = fileName.substring(index + 1); + System.out.println("File extension is " + extension); + } + } +} diff --git a/findduplicate.java b/findduplicate.java new file mode 100644 index 0000000..2d72782 --- /dev/null +++ b/findduplicate.java @@ -0,0 +1,25 @@ +public class DuplicateCharacters { + public static void main(String[] args) { + String string1 = "Great responsibility"; + int count; + + //Converts given string into character array + char string[] = string1.toCharArray(); + + System.out.println("Duplicate characters in a given string: "); + //Counts each character present in the string + for(int i = 0; i 1 && string[i] != '0') + System.out.println(string[i]); + } + } +} diff --git a/fizzbuzz.java b/fizzbuzz.java new file mode 100644 index 0000000..1e4c61f --- /dev/null +++ b/fizzbuzz.java @@ -0,0 +1,22 @@ +import java.util.*; +public class Main +{ + public static void main(String args[]) + { + Scanner sc=new Scanner(System.in); + int n,i; + System.out.println("Enter the range"); + n=sc.nextInt(); + for (i=1;i<=n;i++) + { + if (i%15==0) + System.out.println("FizzBuzz"); + else if (i%5==0) + System.out.println("Buzz"); + else if (i%3==0) + System.out.println("Fizz"); + else + System.out.println(i); + } + } +} \ No newline at end of file diff --git a/geekandnumberstrings.java b/geekandnumberstrings.java new file mode 100644 index 0000000..d455ca3 --- /dev/null +++ b/geekandnumberstrings.java @@ -0,0 +1,20 @@ +class Solution { + public int minLength(String s, int n) { + // code here + Stackst=new Stack<>(); + int pair[]=new int[]{9,2,1,4,3,6,5,8,7,0}; + for(char ch:s.toCharArray()){ + int key=ch-'0'; + if(st.size()==0){ + st.push(key); + }else{ + if(st.peek()==pair[key]){ + st.pop(); + }else{ + st.push(key); + } + } + } + return st.size(); + } +} diff --git a/giftallocation.c b/giftallocation.c new file mode 100644 index 0000000..78a348a --- /dev/null +++ b/giftallocation.c @@ -0,0 +1,27 @@ +#include +int main() +//gift allocation +{ + int maths,science; + printf(" maths and science" ); + scanf("%d %d",&maths,&science); + printf("marks obtained in maths=%d and marks obtained in science=%d\n",maths,science ); + if(maths==30 && science==30) + { + printf("you get a gift of $45"); + } + else if(maths==30 && science<30) + { + printf("you get a gift of $15"); + + } + else if(maths<30 && science==30) + { + printf("you get a gift of $15"); + } + else + { + printf("not eligible for gift"); + } + return 0; +} diff --git a/hacktoberfest-2022 b/hacktoberfest-2022 new file mode 100644 index 0000000..8b13789 --- /dev/null +++ b/hacktoberfest-2022 @@ -0,0 +1 @@ + diff --git a/hactoberfest 1.html b/hactoberfest 1.html new file mode 100644 index 0000000..a26e691 --- /dev/null +++ b/hactoberfest 1.html @@ -0,0 +1,31 @@ +• +• +• +• Hacktoberfest 2022 +• +• +• +•
    +•

    +• Figma +•

    +•

    +• UI/UX +•

    +•

    +• Canva +•

    +•
    +•
    +•

    +• ReactJs +•

    +•

    +• Django +•

    +•

    +• Flask +•

    +•
    +• + diff --git a/harsh 1.txt b/harsh 1.txt new file mode 100644 index 0000000..4b778a5 --- /dev/null +++ b/harsh 1.txt @@ -0,0 +1,50 @@ +#include +using namespace std; + +int main(){ + + int n; + + cin>>n; + + int b[n]; + + int max=b[0]; + + for(int i=0;i>b[i]; + } + + for(int i=1;imax){ + max=b[i]; + } + } + cout< +using namespace std; + +int main(){ + + int n; + + cin>>n; + + int b[n]; + + int max=b[0]; + + for(int i=0;i>b[i]; + } + + for(int i=1;imax){ + max=b[i]; + } + } + cout<= 0; i--) + heapify(arr, n, i); + + // One by one extract an element from heap + for (int i=n-1; i>=0; i--) + { + // Move current root to end + int temp = arr[0]; + arr[0] = arr[i]; + arr[i] = temp; + + // call max heapify on the reduced heap + heapify(arr, i, 0); + } + } + + // To heapify a subtree rooted with node i which is + // an index in arr[]. n is size of heap + void heapify(int arr[], int n, int i) + { + int largest = i; // Initialize largest as root + int l = 2*i + 1; // left = 2*i + 1 + int r = 2*i + 2; // right = 2*i + 2 + + // If left child is larger than root + if (l < n && arr[l] > arr[largest]) + largest = l; + + // If right child is larger than largest so far + if (r < n && arr[r] > arr[largest]) + largest = r; + + // If largest is not root + if (largest != i) + { + int swap = arr[i]; + arr[i] = arr[largest]; + arr[largest] = swap; + + // Recursively heapify the affected sub-tree + heapify(arr, n, largest); + } + } + + /* A utility function to print array of size n */ + static void printArray(int arr[]) + { + int n = arr.length; + for (int i=0; i + + + + + + + FOODIEZ + + + + + + + +
    + + + +
    + + +

    Best Food In Town

    +

    Lahore might be nicknamed the city of love, + but it could easily be called the city of + food. And while it's easy to associate + Paris with fancy, fine dining —
    a hub of Michelin-starred eateries — + there's SO much more to this culinary city

    +Visit for More.
    + +
    + +
    +
    +
    + +
    +
    +
    +
    +
    +

    Islamabad:
    The City of Peace is Famous for it's Natural views full of life

    + +
    +
    +
    +
    +
    +
    +

    Karachi:
    The City of lights Occupy most of the industrial business in pakistan

    + +
    +
    +
    + +
    +

    Food We Offer

    +

    Healthy food keeps children fresh and rejuvenated. + Food, when eaten in proper intervals and in the right amount, can make children fitter. + Healhy food is delicious. + Kids must be told and trained on how to eat healthily

    +
    +
    +

    Burger

    + It's All That only juicier. One thinks he's + all that. The other's not all there. + The best burgers offer a combination of tastes + and textures – sweet, + sour, salt – with a bit of crunch. +
    +
    +

    Pizza

    + + "Pizza is not a 'trend' it's a way of life" + Pizza is my favourite food because it tastes + and smells fabulous. The pizza + itself looks so yummy, crispy and so cheesy +
    +
    +

    Pasta

    + + Dying for a bowl of pasta. + Good pasta will have a chewy texture that + has a bounce to it when chewed. These are + qualities that you cannot determine until + the pasta has been cooked. +
    +
    +
    + + +
    +

    Our Locations to Visit

    +

    Gulberg| Johar Town| Badshahi Mosque| MM Alam Road

    + +
    + +
    + +
    +

    GULBERG

    +
    +
    +
    + +
    +

    JOHAR TOWN

    +
    +
    +
    + +
    +

    MM ALAM ROAD

    +
    +
    +
    +
    + + + +
    +

    Our Menu

    +

    Gulberg| Johar Town| Badshahi Mosque| MM Alam Road

    +
    +
    + +

    Desi Food

    +

    Descriptioon about food

    +
    +
    + +

    Thai Food

    +

    Descriptioon about food

    +
    +
    + +

    Junk Food

    +

    Descriptioon about food

    +
    +
    +
    +

    + +
    +
    +

    Reviews

    +

    Gulberg| Johar Town| Badshahi Mosque| MM Alam Road

    +
    +
    + +
    +

    Staff and speed of service was extremely good. + It is very clean, calm and has a nice ambiance. + Thai pizzas are delicious and of good quality. + You can also choose steak, as I prefered, it's also really good. + I definetely recommend this restaurant in Lahore.

    +

    Ayesha Farooqi

    + + + + + +
    +
    + + +
    + +
    +

    Delicious food, good service, and great hygiene + mixed with the atmosphere is all that a good + restaurant needs and Napoli almost fulfilled + every single one of them. The food and service + was great and made me want to go there again + but the atmosphere was the only thing that was + a bit off which kind of makes me skeptical about visiting it again.

    +

    Nayab Ejaz

    + + + + + +
    +
    +
    +
    + +
    +

    About Us

    +

    Lorem ipsum dolor sit amet consectetur adipisicing elit. + Eos debitis possimus ratione doloremque,
    + totam sit sapiente ipsa necessitatibus perferendis nostrum minima Aipsam voluptatibus +
    consequuntur beatae corrupti incidunt praesentium officia.

    +
    + + + + + +
    + +
    +

    Contact Us for more Details

    + CONTACT US +
    + pro_dog + +
    +
    + +
    +
    +
    +
    +
    + azna +
    +

    AZNA IJAZ

    +

    Raiwind Road Mughalpura, Lahore.

    +

    090878601 +

    +

    B-24684@usa.edu.pk

    +

    +
    +
    +
    +
    +

    NEWSLETTER

    +
    + +
    +
    + + +
    +
    + +
    +
    +
    +
    +
    +
    +
    +

    Copyright ©Azna Ijaz 2021 All right reserved | Azna Ijaz

    + + + + + + + \ No newline at end of file diff --git a/insertAtMiddle.cpp b/insertAtMiddle.cpp new file mode 100644 index 0000000..0ef2acc --- /dev/null +++ b/insertAtMiddle.cpp @@ -0,0 +1,53 @@ +#include +using namespace std; + +struct Node{ +int data; +Node *next; +Node *prev; +}; +void insertAtHead(Node **head_ref ,int mydata) +{ + Node* temp=new Node(); + temp->data=mydata; + temp->next=*head_ref; + temp->prev=NULL; + if(*head_ref!=NULL) + { + (*head_ref)->prev=temp; + } + + (*head_ref)=temp; + +} +void insertAtMiddle(Node *previous,int mydata) +{ + Node *temp=new Node(); + temp->data=mydata; + temp->next=previous->next; + + temp->prev=previous; + previous->next=temp; + if(temp->next!=NULL) + { + temp->next->prev=temp; + } +} +void print(Node *head) +{ + Node*temp=head; + while( temp!=NULL) + { + cout<data<<" "; + temp=temp->next; + } +} +int main(){ + Node *head=NULL; + insertAtHead(&head,2); + insertAtHead(&head,5); + insertAtHead(&head,8); + insertAtMiddle(head->next,10); + print(head); + return 0; +} \ No newline at end of file diff --git a/insertion.java b/insertion.java new file mode 100644 index 0000000..a3659bb --- /dev/null +++ b/insertion.java @@ -0,0 +1,20 @@ +import java.util.*; +public class Main { +public static void main(String[] args) { + //declare an array and print the original contents + int[] numArray = {10,6,15,4,1,45}; + System.out.println("Original Array:" + Arrays.toString(numArray)); + //apply insertion sort algorithm on the array + for(int k=1; k=0 && temp <= numArray[j]) { + numArray[j+1] = numArray[j]; + j = j-1; + } + numArray[j+1] = temp; + } + //print the sorted array + System.out.println("Sorted Array:" + Arrays.toString(numArray)); +} +} \ No newline at end of file diff --git a/insertion_sort.java b/insertion_sort.java new file mode 100644 index 0000000..8e90f82 --- /dev/null +++ b/insertion_sort.java @@ -0,0 +1,41 @@ +class InsertionSort { + /*Function to sort array using insertion sort*/ + void sort(int arr[]) + { + int n = arr.length; + for (int i = 1; i < n; ++i) { + int key = arr[i]; + int 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 array of size n*/ + static void printArray(int arr[]) + { + int n = arr.length; + for (int i = 0; i < n; ++i) + System.out.print(arr[i] + " "); + + System.out.println(); + } + + // Driver method + public static void main(String args[]) + { + int arr[] = { 12, 11, 13, 5, 6 }; + + InsertionSort ob = new InsertionSort(); + ob.sort(arr); + + printArray(arr); + } +} diff --git a/java b/java new file mode 100644 index 0000000..f0f7b29 --- /dev/null +++ b/java @@ -0,0 +1,25 @@ +class BinarySearchExample{ + public static void binarySearch(int arr[], int first, int last, int key){ + int mid = (first + last)/2; + while( first <= last ){ + if ( arr[mid] < key ){ + first = mid + 1; + }else if ( arr[mid] == key ){ + System.out.println("Element is found at index: " + mid); + break; + }else{ + last = mid - 1; + } + mid = (first + last)/2; + } + if ( first > last ){ + System.out.println("Element is not found!"); + } + } + public static void main(String args[]){ + int arr[] = {10,20,30,40,50}; + int key = 30; + int last=arr.length-1; + binarySearch(arr,0,last,key); + } +} diff --git a/javaAlgo.java b/javaAlgo.java new file mode 100644 index 0000000..a6a49c0 --- /dev/null +++ b/javaAlgo.java @@ -0,0 +1,19 @@ +public class PrimeExample{ + public static void main(String args[]){ + int i,m=0,flag=0; + int n=3;//it is the number to be checked + m=n/2; + if(n==0||n==1){ + System.out.println(n+" is not prime number"); + }else{ + for(i=2;i<=m;i++){ + if(n%i==0){ + System.out.println(n+" is not prime number"); + flag=1; + break; + } + } + if(flag==0) { System.out.println(n+" is prime number"); } + }//end of else +} +} diff --git a/javabook.java b/javabook.java new file mode 100644 index 0000000..3edcc77 --- /dev/null +++ b/javabook.java @@ -0,0 +1,26 @@ +// A Java program to demonstrate +// working of recursion + +class GFG { + static void printFun(int test) + { + if (test < 1) + return; + + else { + System.out.printf("%d ", test); + + // Statement 2 + printFun(test - 1); + + System.out.printf("%d ", test); + return; + } + } + + public static void main(String[] args) + { + int test = 3; + printFun(test); + } +} diff --git a/javaiterator.java b/javaiterator.java new file mode 100644 index 0000000..7acd9fe --- /dev/null +++ b/javaiterator.java @@ -0,0 +1,19 @@ +import java.util.ArrayList; +import java.util.Iterator; + +public class Main { + public static void main(String[] args) { + + // Make a collection + ArrayList animes = new ArrayList(); + animes.add("Fullmetal Alchemist: Brotherhood"); + animes.add("Gintama"); + animes.add("Mushoku Tensei"); + + // Get the iterator + Iterator it = animes.iterator(); + + // Print the first item + System.out.println(it.next()); + } +} diff --git a/javaoperators.java b/javaoperators.java new file mode 100644 index 0000000..d697e92 --- /dev/null +++ b/javaoperators.java @@ -0,0 +1,42 @@ +public class Main { + public static void main(String[] args) { + // Adding + int a = 1; + int b = 99; + int c = a + b; + System.out.println(c); + + // Subtracting + int d = 100; + int e = 99; + int f = d - e; + System.out.println(f); + + // Multiplying + int g = 20; + int h = 5; + int i = g * h; + System.out.println(i); + + // Increment and Decrement + int j = 2; + j++; + int k = 4; + k--; + int l = i + k; + System.out.println(l); + + // Dividing + int m = 100; + int n = 10; + int o = m / n; + System.out.println(o); + + // Remainder + int p = 10; + int q = 2; + int r = p % q; + System.out.println(r); + + } +} diff --git a/javasubstring.java b/javasubstring.java new file mode 100644 index 0000000..68bac97 --- /dev/null +++ b/javasubstring.java @@ -0,0 +1,17 @@ +package day3; + +import java.util.*; + +class javasubstring { + + public static void main(String[] args) { + Scanner in = new Scanner(System.in); + System.out.println("Enter any String value = "); + String S = in.nextLine(); + System.out.println("Enter the start point = "); + int start = in.nextInt(); + System.out.println("Enter the end point = "); + int end = in.nextInt(); + System.out.println(S.substring(start, end)); + } +} diff --git a/jobSequencing.java b/jobSequencing.java new file mode 100644 index 0000000..b0b36fd --- /dev/null +++ b/jobSequencing.java @@ -0,0 +1,130 @@ +// This is Job Sequencing Problem using Greedy Method + +import java.util.*; + +public class jobSequencing +{ + public static void main(String args[]) + { + Scanner sc=new Scanner(System.in); + System.out.println("Enter the number of Jobs"); + int n=sc.nextInt(); + String a[]=new String[n]; + int b[]=new int[n]; + int c[]=new int[n]; + for(int i=0;imax) + { + max=c[i]; + } + } + String x[]=new String[max]; + int m[]=new int[max]; + int profit=0; + for(int i=0;i"); + } + + } + System.out.println("\n"); + System.out.print("Profit Earned "+profit); // printing total profit + } +} \ No newline at end of file diff --git a/kmp_algorithm.java b/kmp_algorithm.java new file mode 100644 index 0000000..6cb3d5e --- /dev/null +++ b/kmp_algorithm.java @@ -0,0 +1,77 @@ +public class Main +{ + public static void main(String[] args) { + String txt = "ABABDABACDABABCABAB"; + String pat = "ABABCABAB"; + new KMP_String_Matching().KMPSearch(pat, txt); + + } +} + +class KMP_String_Matching { + void KMPSearch(String path, String txt) + { + int M = path.length(); + int N = txt.length(); + + // create lps array that will hold the longest prefix suffix values for pattern + + int lps[] = new int[M]; + int j = 0; // index for path[] + + // Preprocess the pattern (calculate lps[] array) + computeLPSArray(path, M, lps); + + int i = 0; // index for txt[] + while ((N - i) >= (M - j)) { + if (path.charAt(j) == txt.charAt(i)) { + j++; + i++; + } + if (j == M) { + System.out.println("Found pattern " + + "at index " + (i - j)); + j = lps[j - 1]; + } + + // mismatch after j matches + else if (i < N && path.charAt(j) != txt.charAt(i)) { + // Do not match lps[0..lps[j-1]] characters, + // they will match anyway + if (j != 0) + j = lps[j - 1]; + else + i = i + 1; + } + } + } + + void computeLPSArray(String path, int M, int lps[]) + { + // length of the previous longest prefix suffix + int len = 0; + int i = 1; + lps[0] = 0; // lps[0] is always 0 + + // the loop calculates lps[i] for i = 1 to M-1 + while (i < M) { + if (path.charAt(i) == path.charAt(len)) { + len++; + lps[i] = len; + i++; + } + else // (path[i] != path[len]) + { + if (len != 0) { + len = lps[len - 1]; + + } + else // if (len == 0) + { + lps[i] = len; + i++; + } + } + } + } +} \ No newline at end of file diff --git a/knapsack.java b/knapsack.java new file mode 100644 index 0000000..c54b2d3 --- /dev/null +++ b/knapsack.java @@ -0,0 +1,29 @@ +class Knapsack { + + + static int max(int a, int b) { return (a > b) ? a : b; } + + static int knapSack(int W, int wt[], int val[], int n) + { + // Base Case + if (n == 0 || W == 0) + return 0; + + if (wt[n - 1] > W) + return knapSack(W, wt, val, n - 1); + + else + return max(val[n - 1] + knapSack(W - wt[n - 1], wt, val, n - 1), + knapSack(W, wt, val, n - 1)); + } + + + public static void main(String args[]) + { + int val[] = new int[] { 60, 100, 120 }; + int wt[] = new int[] { 10, 20, 30 }; + int W = 50; + int n = val.length; + System.out.println(knapSack(W, wt, val, n)); + } +} diff --git a/knapsack_problem.java b/knapsack_problem.java new file mode 100644 index 0000000..e0993a6 --- /dev/null +++ b/knapsack_problem.java @@ -0,0 +1,28 @@ + +class Knapsack { + static int max(int a, int b) { return (a > b) ? a : b; } + + static int knapSack(int W, int wt[], int val[], int n) + { + + if (n == 0 || W == 0) + return 0; + + if (wt[n - 1] > W) + return knapSack(W, wt, val, n - 1); + + else + return max(val[n - 1] + knapSack(W - wt[n - 1], wt, val, n - 1), + knapSack(W, wt, val, n - 1)); + } + + public static void main(String args[]) + { + int val[] = new int[] { 60, 100, 120 }; + int wt[] = new int[] { 10, 20, 30 }; + int W = 50; + int n = val.length; + System.out.println(knapSack(W, wt, val, n)); + } +} + diff --git a/kruskal.java b/kruskal.java new file mode 100644 index 0000000..1fcaeb1 --- /dev/null +++ b/kruskal.java @@ -0,0 +1,190 @@ +// Java program for Kruskal's algorithm to +// find Minimum Spanning Tree of a given +// connected, undirected and weighted graph + +import java.io.*; +import java.lang.*; +import java.util.*; + +class Graph { + + // A class to represent a graph edge + class Edge implements Comparable { + int src, dest, weight; + + // Comparator function used for + // sorting edgesbased on their weight + public int compareTo(Edge compareEdge) + { + return this.weight - compareEdge.weight; + } + }; + + // A class to represent a subset for + // union-find + class subset { + int parent, rank; + }; + + int V, E; // V-> no. of vertices & E->no.of edges + Edge edge[]; // collection of all edges + + // Creates a graph with V vertices and E edges + Graph(int v, int e) + { + V = v; + E = e; + edge = new Edge[E]; + for (int i = 0; i < e; ++i) + edge[i] = new Edge(); + } + + // A utility function to find set of an + // element i (uses path compression technique) + int find(subset subsets[], int i) + { + // find root and make root as parent of i + // (path compression) + if (subsets[i].parent != i) + subsets[i].parent + = find(subsets, subsets[i].parent); + + return subsets[i].parent; + } + + // A function that does union of two sets + // of x and y (uses union by rank) + void Union(subset subsets[], int x, int y) + { + int xroot = find(subsets, x); + int yroot = find(subsets, y); + + // Attach smaller rank tree under root + // of high rank tree (Union by Rank) + if (subsets[xroot].rank < subsets[yroot].rank) + subsets[xroot].parent = yroot; + else if (subsets[xroot].rank > subsets[yroot].rank) + subsets[yroot].parent = xroot; + + // If ranks are same, then make one as + // root and increment its rank by one + else { + subsets[yroot].parent = xroot; + subsets[xroot].rank++; + } + } + + // The main function to construct MST using Kruskal's + // algorithm + void KruskalMST() + { + // This will store the resultant MST + Edge result[] = new Edge[V]; + + // An index variable, used for result[] + int e = 0; + + // An index variable, used for sorted edges + int i = 0; + for (i = 0; i < V; ++i) + result[i] = new Edge(); + + // Step 1: Sort all the edges in non-decreasing + // order of their weight. If we are not allowed to + // change the given graph, we can create a copy of + // array of edges + Arrays.sort(edge); + + // Allocate memory for creating V subsets + subset subsets[] = new subset[V]; + for (i = 0; i < V; ++i) + subsets[i] = new subset(); + + // Create V subsets with single elements + for (int v = 0; v < V; ++v) { + subsets[v].parent = v; + subsets[v].rank = 0; + } + + i = 0; // Index used to pick next edge + + // Number of edges to be taken is equal to V-1 + while (e < V - 1) { + // Step 2: Pick the smallest edge. And increment + // the index for next iteration + Edge next_edge = edge[i++]; + + int x = find(subsets, next_edge.src); + int y = find(subsets, next_edge.dest); + + // If including this edge doesn't cause cycle, + // include it in result and increment the index + // of result for next edge + if (x != y) { + result[e++] = next_edge; + Union(subsets, x, y); + } + // Else discard the next_edge + } + + // print the contents of result[] to display + // the built MST + System.out.println("Following are the edges in " + + "the constructed MST"); + int minimumCost = 0; + for (i = 0; i < e; ++i) { + System.out.println(result[i].src + " -- " + + result[i].dest + + " == " + result[i].weight); + minimumCost += result[i].weight; + } + System.out.println("Minimum Cost Spanning Tree " + + minimumCost); + } + + // Driver's Code + public static void main(String[] args) + { + + /* Let us create following weighted graph + 10 + 0--------1 + | \ | + 6| 5\ |15 + | \ | + 2--------3 + 4 */ + int V = 4; // Number of vertices in graph + int E = 5; // Number of edges in graph + Graph graph = new Graph(V, E); + + // add edge 0-1 + graph.edge[0].src = 0; + graph.edge[0].dest = 1; + graph.edge[0].weight = 10; + + // add edge 0-2 + graph.edge[1].src = 0; + graph.edge[1].dest = 2; + graph.edge[1].weight = 6; + + // add edge 0-3 + graph.edge[2].src = 0; + graph.edge[2].dest = 3; + graph.edge[2].weight = 5; + + // add edge 1-3 + graph.edge[3].src = 1; + graph.edge[3].dest = 3; + graph.edge[3].weight = 15; + + // add edge 2-3 + graph.edge[4].src = 2; + graph.edge[4].dest = 3; + graph.edge[4].weight = 4; + + // Function call + graph.KruskalMST(); + } +} +// This code is contributed by Aakash Hasija diff --git a/kthLargestElement.java b/kthLargestElement.java new file mode 100644 index 0000000..e36c6e0 --- /dev/null +++ b/kthLargestElement.java @@ -0,0 +1,19 @@ +class Solution { + public int findKthLargest(int[] nums, int k) { + + PriorityQueue pq = new PriorityQueue<>(Collections.reverseOrder()); + + for(int i : nums){ + pq.add(i); + } + + int res = 0; + + while(k-- > 0){ + res = pq.poll(); + } + + + return res; + } +} diff --git a/leap_year.java b/leap_year.java new file mode 100644 index 0000000..17c1925 --- /dev/null +++ b/leap_year.java @@ -0,0 +1,15 @@ +import java.util.*; +public class Main +{ + public static void main(String args[]) + { + int year; + Scanner sc=new Scanner(System.in); + System.out.println("Enter the year"); + year=sc.nextInt(); + if (((year % 4 == 0)&&(year % 100!= 0))||(year%400 == 0)) + System.out.println("Leap Year"); + else + System.out.println("Not a Leap Year"); + } +} diff --git a/linearsearch.java b/linearsearch.java new file mode 100644 index 0000000..2eb303c --- /dev/null +++ b/linearsearch.java @@ -0,0 +1,34 @@ +public class Main +{ + + public static int linearSearch (int[]arr, int key) + { + + for (int i = 0; i < arr.length; i++) + { + + if (arr[i] == key) + { + + return i; + + } + + } + + return -1; + + } + + public static void main (String a[]) + { + + int[] a1 = { 11, 22, 33, 45, 76, 98 }; + + int key = 33; + + System.out.println (key + " is found at index: " + + linearSearch (a1, key)); + + } +} diff --git a/linked list b/linked list new file mode 100644 index 0000000..5dd0f42 --- /dev/null +++ b/linked list @@ -0,0 +1,37 @@ +import java.util.LinkedList; + +public class HelloLinkedList { + + public static void main(String[] args) { + LinkedList list = new LinkedList(); + + list.add("F"); + list.add("B"); + list.add("D"); + list.add("E"); + list.addLast("Z"); + list.addFirst("A"); + list.add(1, "A2"); + + System.out.println("Original contents of list: " + list); + + list.remove("F"); + list.remove(2); + + + System.out.println("Contents of list after deletion: " + list); + + + list.removeFirst(); + list.removeLast(); + + + System.out.println("List after deleting first and last: " + list); + + Object val = list.get(2); + + list.set(2, (String) val + " Changed"); + System.out.println("List after change: " + list); + } + +} diff --git a/linked.cpp b/linked.cpp new file mode 100644 index 0000000..f9a8a1e --- /dev/null +++ b/linked.cpp @@ -0,0 +1,46 @@ +#include +using namespace std; +struct Node { + int data; + Node* next; +}; +struct Node* newNode(int data) { + Node* node = new Node; + node->data = data; + node->next = NULL; + return node; +} +void insertNewNode(Node** root, int data) { + Node* node = newNode(data); + Node* ptr; + if (*root == NULL) { + *root = node; + } + else { + ptr = *root; + while (ptr->next != NULL) { + ptr = ptr->next; + } + ptr->next = node; + } +} +void printLinkedList(Node* root) { + while (root != NULL) { + cout << root->data << " -> "; + root = root->next; + } + cout << "NULL" << endl; +} +Node* createLinkedList(int arr[], int n) { + Node *root = NULL; + for (int i = 0; i < n; i++) { + insertNewNode(&root, arr[i]); + } + return root; +} +int main() { + int arr[] = { 1, 2, 3, 4, 5 }, n = 5; + Node* root = createLinkedList(arr, n); + printLinkedList(root); + return 0; +} diff --git a/linked_list/AppendLastToFirst.java b/linked_list/AppendLastToFirst.java new file mode 100644 index 0000000..ce399f1 --- /dev/null +++ b/linked_list/AppendLastToFirst.java @@ -0,0 +1,37 @@ +package linked_list; + +import java.util.Scanner; + +public class AppendLastToFirst { + public static void main(String[] args) { + Scanner scanner = new Scanner(System.in); + Node head = LinkedList.takeInput(); + int n = scanner.nextInt(); + head = appendLastNToFirst(head, n); + LinkedList.printLL(head); + } + + static Node appendLastNToFirst(Node head, int n){ + if (n == 0 || head == null){ + return head; + } + Node fast = head; + Node slow = head; + Node initialHead = head; + + for (int i = 0; i < n; i++){ + fast = fast.next; + } + while (fast.next != null){ + slow = slow.next; + fast = fast.next; + } + + Node temp = slow.next; + slow.next = null; + fast.next = initialHead; + head = temp; + + return head; + } +} diff --git a/linked_list/DeleteNodeRecursively.java b/linked_list/DeleteNodeRecursively.java new file mode 100644 index 0000000..705b815 --- /dev/null +++ b/linked_list/DeleteNodeRecursively.java @@ -0,0 +1,26 @@ +package linked_list; + +public class DeleteNodeRecursively { + public static void main(String[] args) { + Node head = LinkedList.takeInput(); + LinkedList.printLL(head); + System.out.println(); + head = deleteNode(head, 4); + LinkedList.printLL(head); + } + + static Node deleteNode(Node head, int pos){ + if (head == null && pos > 0){ + return head; + } + + if (pos == 0){ + assert head != null; + head = head.next; + } else { + Node newNode = deleteNode(head.next, pos - 1); + head.next = newNode; + } + return head; + } +} diff --git a/linked_list/EliminateConsDuplicates.java b/linked_list/EliminateConsDuplicates.java new file mode 100644 index 0000000..b4ec11f --- /dev/null +++ b/linked_list/EliminateConsDuplicates.java @@ -0,0 +1,28 @@ +package linked_list; + +import java.util.Objects; + +public class EliminateConsDuplicates { + public static void main(String[] args) { + Node head = LinkedList.takeInput(); + LinkedList.printLL(head); + System.out.println(); + removeDuplicates(head); + LinkedList.printLL(head); + } + static Node removeDuplicates(Node head){ + if (head == null){ + return null; + } + Node currNode = head; + while (currNode.next != null){ + if (currNode.data.equals(currNode.next.data)) { + // remove node + currNode.next = currNode.next.next; + } else { + currNode = currNode.next; + } + } + return head; + } +} diff --git a/linked_list/FindNode.java b/linked_list/FindNode.java new file mode 100644 index 0000000..4054245 --- /dev/null +++ b/linked_list/FindNode.java @@ -0,0 +1,25 @@ +package linked_list; + +import java.util.Scanner; + +public class FindNode { + public static void main(String[] args) { + Node head = LinkedList.takeInput(); + Scanner scanner = new Scanner(System.in); + int n = scanner.nextInt(); + System.out.println("Index of given value in the linked list is: " + findNode(head, n)); + } + + static int findNode(Node head, int data){ + Node temp = head; + int pos = 0; + while (temp != null){ + if (temp.data == data){ + return pos; + } + pos++; + temp = temp.next; + } + return -1; + } +} diff --git a/linked_list/InsertNodeRecursively.java b/linked_list/InsertNodeRecursively.java new file mode 100644 index 0000000..e5b8a98 --- /dev/null +++ b/linked_list/InsertNodeRecursively.java @@ -0,0 +1,28 @@ +package linked_list; + +public class InsertNodeRecursively { + public static void main(String[] args) { + Node head = LinkedList.takeInput(); + LinkedList.printLL(head); + System.out.println(); + head = insert(head, 20, 8); + LinkedList.printLL(head); + } + + static Node insert(Node head, int data, int pos){ + Node newNode; + if (head == null && pos > 0){ + return head; + } + if (pos == 0){ + newNode = new Node<>(data); + newNode.next = head; + head = newNode; + } else { + assert head != null; + newNode = insert(head.next, data, pos - 1); + head.next = newNode; + } + return head; + } +} diff --git a/linked_list/LinkedList.java b/linked_list/LinkedList.java new file mode 100644 index 0000000..b556dac --- /dev/null +++ b/linked_list/LinkedList.java @@ -0,0 +1,140 @@ +package linked_list; + +import java.util.Scanner; + +public class LinkedList { + public static void main(String[] args) { + Scanner scanner = new Scanner(System.in); + Node head = takeInput(); + printLL(head); + System.out.println(); + /** + // the value of head is incremented + increment(head); + System.out.println(head.data); + */ +// System.out.println(lengthOfLL(head)); + printIthNode(head, 0); + + int pos = scanner.nextInt(); +// int data = scanner.nextInt(); +// head = insertNode(head, data, pos); + head = deleteNode(head, pos); + printLL(head); + } + + static int lengthOfLL(Node head) { + Node temp = head; + int len = 0; + while (temp != null) { + len++; + temp = temp.next; + } + return len; + } + + static void printLL(Node head) { + Node temp = head; + while (temp != null) { + System.out.print(temp.data + " "); + temp = temp.next; + } + } + + static void increment(Node head) { + head.data++; + } + + static void printIthNode(Node head, int i) { + Node temp = head; + int j = 0; + while (temp != null && j < i) { + temp = temp.next; + j++; + } + if (temp != null) { + System.out.println(temp.data); + } else { + System.out.println("Index out of bounds"); + } + } + + static Node takeInput() { + Scanner scanner = new Scanner(System.in); + int data = scanner.nextInt(); + Node head = null; + Node tail = null; + while (data != -1) { + Node currentNode = new Node<>(data); + if (head == null) { + head = currentNode; + tail = head; + } else { + tail.next = currentNode; + tail = tail.next; + } + data = scanner.nextInt(); + } + return head; + } + + static Node insertNode(Node head, int data, int pos) { + int currPos = 0; + Node temp = head; + Node newNode = new Node<>(data); + // case 1: insertion at head/beginning + if (pos == 0) { + newNode.next = head; + head = newNode; + return head; + } + + while (temp != null && currPos < (pos - 1)) { + temp = temp.next; + currPos++; + } + if (temp == null) { + return head; + } + + newNode.next = temp.next; + temp.next = newNode; + return head; + } + + static Node deleteNode(Node head, int pos) { + int currPos = 0; + Node temp = head; + if (pos == 0) { + head = head.next; + return head; + } + while (temp != null && currPos < pos - 1) { + temp = temp.next; + currPos++; + } + if (temp == null) { + return head; + } + temp.next = temp.next.next; + return head; + } + + static Node createLinkedList() { + Node n1 = new Node<>(3); + Node n2 = new Node<>(4); + Node n3 = new Node<>(5); + Node n4 = new Node<>(2); + Node n5 = new Node<>(6); + Node n6 = new Node<>(1); + Node n7 = new Node<>(9); + n1.next = n2; + n2.next = n3; + n3.next = n4; + n4.next = n5; + n5.next = n6; + n6.next = n7; + + return n1; + } +} diff --git a/linked_list/MergeTwoSortedLists.java b/linked_list/MergeTwoSortedLists.java new file mode 100644 index 0000000..0fbbb6d --- /dev/null +++ b/linked_list/MergeTwoSortedLists.java @@ -0,0 +1,50 @@ +package linked_list; + +public class MergeTwoSortedLists { + public static void main(String[] args) { + + } + + private Node solve(Node list1, Node list2){ + if(list1.next == null){ + list1.next = list2; + } else { + Node curr1 = list1; + Node next1 = curr1.next; + Node curr2 = list2; + Node next2; + + while (next1 != null && curr2 != null){ + if (curr2.data >= curr1.data && curr2.data <= next1.data){ + curr1.next = curr2; + next2 = curr2.next; + curr2.next = next1; + curr1 = curr2; + curr2 = next2; + } else { + curr1 = next1; + next1 = next1.next; + if (next1 == null){ + curr1.next = curr2; + return list1; + } + } + } + } + return list1; + } + + Node merge(Node list1, Node list2){ + if (list1 == null){ + return list2; + } + if (list2 == null){ + return list1; + } + if (list1.data <= list2.data){ + return solve(list1, list2); + } else { + return solve(list2, list1); + } + } +} diff --git a/linked_list/MidPointLinkedList.java b/linked_list/MidPointLinkedList.java new file mode 100644 index 0000000..8059c42 --- /dev/null +++ b/linked_list/MidPointLinkedList.java @@ -0,0 +1,19 @@ +package linked_list; + +public class MidPointLinkedList { + public static void main(String[] args) { + Node head = LinkedList.takeInput(); + System.out.println(midPoint(head).data); + } + + static Node midPoint(Node head){ + // We use Floyd's Tortoise and Hare algorithm to solve this problem (a cycle detection algo) + Node fast = head; + Node slow = head; + while (fast != null && fast.next != null){ + fast = fast.next.next; + slow = slow.next; + } + return slow; + } +} diff --git a/linked_list/Node.java b/linked_list/Node.java new file mode 100644 index 0000000..5e6501b --- /dev/null +++ b/linked_list/Node.java @@ -0,0 +1,11 @@ +package linked_list; + +public class Node { + public T data; + public Node next; + + public Node(T data){ + this.data = data; + next = null; + } +} diff --git a/linked_list/PalindromeList.java b/linked_list/PalindromeList.java new file mode 100644 index 0000000..4b85dba --- /dev/null +++ b/linked_list/PalindromeList.java @@ -0,0 +1,68 @@ +package linked_list; + +public class PalindromeList { + public static void main(String[] args) { + Node head = LinkedList.takeInput(); + LinkedList.printLL(head); + System.out.println(); + System.out.println(Solution.isPalindrome(head)); + } +} + +class Solution{ + // method to reverse the linked list + private static Node reverseList(Node head){ + if (head == null || head.next == null){ + return head; + } + Node currNode = head; + Node prevNode = null; + while (currNode != null){ + Node tempNode = currNode.next; + currNode.next = prevNode; + prevNode = currNode; + currNode = tempNode; + } + return prevNode; + } + + // method to check palindrome + public static Boolean isPalindrome(Node head){ + if (head == null || head.next == null){ + return true; + } + + Node fast = head; + // this pointer will reach the middle of the list + Node slow = head; + + while (fast != null && fast.next != null){ + fast = fast.next.next; + slow = slow.next; + } + + // reverse the list + slow = reverseList(slow); + Node tempNode = head; + + while (slow != null){ + if (slow.data == tempNode.data){ + slow = slow.next; + tempNode = tempNode.next; + } else { + return false; + } + } + return true; + } + + /* + A non-optimised solution could be using a stack to store all the elements of the list and then popping the + elements one by one and comparing to the elements of the list. + This would take O(n) space and time complexity + + Whereas here I have coded the optimised solution which uses a space complexity of O(1) and time complexity of + O(n). Here we use the Hare - Tortoise approach to get to the middle of the list and then reverse the list in + order to compare the last elements to the starting elements of the list. + */ +} diff --git a/linked_list/PrintReverseLL.java b/linked_list/PrintReverseLL.java new file mode 100644 index 0000000..d5da81b --- /dev/null +++ b/linked_list/PrintReverseLL.java @@ -0,0 +1,38 @@ +package linked_list; + +public class PrintReverseLL { + public static void main(String[] args) { + Node head = LinkedList.takeInput(); + LinkedList.printLL(head); + System.out.println(); + head = printReverse(head); + LinkedList.printLL(head); + System.out.println(); + head = printReverseIterative(head); + LinkedList.printLL(head); + } + + // recursive approach has more complexity + static Node printReverse(Node head){ + if (head == null || head.next == null){ + return head; + } + Node newHead = printReverse(head.next); + head.next.next = head; + head.next = null; + return newHead; + } + + // iterative approach + static Node printReverseIterative(Node head){ + Node currNode = head; + Node prevNode = null; + while (currNode != null){ + Node tempNode = currNode.next; + currNode.next = prevNode; + prevNode = currNode; + currNode = tempNode; + } + return prevNode; + } +} diff --git a/linkedlist_Implementatino.java b/linkedlist_Implementatino.java new file mode 100644 index 0000000..87c7f3c --- /dev/null +++ b/linkedlist_Implementatino.java @@ -0,0 +1,84 @@ +import java.io.*; + +public class LinkedList { + + Node head; // head of list + + static class Node { + + int data; + Node next; + + // Constructor + Node(int d) + { + data = d; + next = null; + } + } + + // Method to insert a new node + public static LinkedList insert(LinkedList list, int data) + { + // Create a new node with given data + Node new_node = new Node(data); + + + // If the Linked List is empty, + // then make the new node as head + if (list.head == null) { + list.head = new_node; + } + else { + // Else traverse till the last node + // and insert the new_node there + Node last = list.head; + while (last.next != null) { + last = last.next; + } + + // Insert the new_node at last node + last.next = new_node; + } + + // Return the list by head + return list; + } + + // Method to print the LinkedList. + public static void printList(LinkedList list) + { + Node currNode = list.head; + + System.out.print("LinkedList: "); + + // Traverse through the LinkedList + while (currNode != null) { + // Print the data at current node + System.out.print(currNode.data + " "); + + // Go to next node + currNode = currNode.next; + } + } + + // Driver code + public static void main(String[] args) + { + /* Start with the empty list. */ + LinkedList list = new LinkedList(); + + // Insert the values + list = insert(list, 1); + list = insert(list, 2); + list = insert(list, 3); + list = insert(list, 4); + list = insert(list, 5); + list = insert(list, 6); + list = insert(list, 7); + list = insert(list, 8); + + // Print the LinkedList + printList(list); + } +} diff --git a/linkes_45.cpp b/linkes_45.cpp new file mode 100644 index 0000000..1af04a7 --- /dev/null +++ b/linkes_45.cpp @@ -0,0 +1,76 @@ +// Iterative C++ program to reverse a linked list +#include +using namespace std; + +/* Link list node */ +struct Node { + int data; + struct Node* next; + Node(int data) + { + this->data = data; + next = NULL; + } +}; + +struct LinkedList { + Node* head; + LinkedList() { head = NULL; } + + /* Function to reverse the linked list */ + void reverse() + { + // Initialize current, previous and next pointers + Node* current = head; + Node *prev = NULL, *next = NULL; + + while (current != NULL) { + // Store next + next = current->next; + // Reverse current node's pointer + current->next = prev; + // Move pointers one position ahead. + prev = current; + current = next; + } + head = prev; + } + + /* Function to print linked list */ + void print() + { + struct Node* temp = head; + while (temp != NULL) { + cout << temp->data << " "; + temp = temp->next; + } + } + + void push(int data) + { + Node* temp = new Node(data); + temp->next = head; + head = temp; + } +}; + +/* Driver code*/ +int main() +{ + /* Start with the empty list */ + LinkedList ll; + ll.push(20); + ll.push(4); + ll.push(15); + ll.push(85); + + cout << "Given linked list\n"; + ll.print(); + + ll.reverse(); + + cout << "\nReversed Linked list \n"; + ll.print(); + return 0; +} + diff --git a/linklist_implementation.java b/linklist_implementation.java new file mode 100644 index 0000000..885617b --- /dev/null +++ b/linklist_implementation.java @@ -0,0 +1,289 @@ +/** + * LinkedList class implements a doubly-linked list. + */ +public class MyLinkedList implements Iterable +{ + /** + * Construct an empty LinkedList. + */ + public MyLinkedList( ) + { + doClear( ); + } + + private void clear( ) + { + doClear( ); + } + + /** + * Change the size of this collection to zero. + */ + public void doClear( ) + { + beginMarker = new Node<>( null, null, null ); + endMarker = new Node<>( null, beginMarker, null ); + beginMarker.next = endMarker; + + theSize = 0; + modCount++; + } + + /** + * Returns the number of items in this collection. + * @return the number of items in this collection. + */ + public int size( ) + { + return theSize; + } + + public boolean isEmpty( ) + { + return size( ) == 0; + } + + /** + * Adds an item to this collection, at the end. + * @param x any object. + * @return true. + */ + public boolean add( AnyType x ) + { + add( size( ), x ); + return true; + } + + /** + * Adds an item to this collection, at specified position. + * Items at or after that position are slid one position higher. + * @param x any object. + * @param idx position to add at. + * @throws IndexOutOfBoundsException if idx is not between 0 and size(), inclusive. + */ + public void add( int idx, AnyType x ) + { + addBefore( getNode( idx, 0, size( ) ), x ); + } + + /** + * Adds an item to this collection, at specified position p. + * Items at or after that position are slid one position higher. + * @param p Node to add before. + * @param x any object. + * @throws IndexOutOfBoundsException if idx is not between 0 and size(), inclusive. + */ + private void addBefore( Node p, AnyType x ) + { + Node newNode = new Node<>( x, p.prev, p ); + newNode.prev.next = newNode; + p.prev = newNode; + theSize++; + modCount++; + } + + + /** + * Returns the item at position idx. + * @param idx the index to search in. + * @throws IndexOutOfBoundsException if index is out of range. + */ + public AnyType get( int idx ) + { + return getNode( idx ).data; + } + + /** + * Changes the item at position idx. + * @param idx the index to change. + * @param newVal the new value. + * @return the old value. + * @throws IndexOutOfBoundsException if index is out of range. + */ + public AnyType set( int idx, AnyType newVal ) + { + Node p = getNode( idx ); + AnyType oldVal = p.data; + + p.data = newVal; + return oldVal; + } + + /** + * Gets the Node at position idx, which must range from 0 to size( ) - 1. + * @param idx index to search at. + * @return internal node corresponding to idx. + * @throws IndexOutOfBoundsException if idx is not between 0 and size( ) - 1, inclusive. + */ + private Node getNode( int idx ) + { + return getNode( idx, 0, size( ) - 1 ); + } + + /** + * Gets the Node at position idx, which must range from lower to upper. + * @param idx index to search at. + * @param lower lowest valid index. + * @param upper highest valid index. + * @return internal node corresponding to idx. + * @throws IndexOutOfBoundsException if idx is not between lower and upper, inclusive. + */ + private Node getNode( int idx, int lower, int upper ) + { + Node p; + + if( idx < lower || idx > upper ) + throw new IndexOutOfBoundsException( "getNode index: " + idx + "; size: " + size( ) ); + + if( idx < size( ) / 2 ) + { + p = beginMarker.next; + for( int i = 0; i < idx; i++ ) + p = p.next; + } + else + { + p = endMarker; + for( int i = size( ); i > idx; i-- ) + p = p.prev; + } + + return p; + } + + /** + * Removes an item from this collection. + * @param idx the index of the object. + * @return the item was removed from the collection. + */ + public AnyType remove( int idx ) + { + return remove( getNode( idx ) ); + } + + /** + * Removes the object contained in Node p. + * @param p the Node containing the object. + * @return the item was removed from the collection. + */ + private AnyType remove( Node p ) + { + p.next.prev = p.prev; + p.prev.next = p.next; + theSize--; + modCount++; + + return p.data; + } + + /** + * Returns a String representation of this collection. + */ + public String toString( ) + { + StringBuilder sb = new StringBuilder( "[ " ); + + for( AnyType x : this ) + sb.append( x + " " ); + sb.append( "]" ); + + return new String( sb ); + } + + /** + * Obtains an Iterator object used to traverse the collection. + * @return an iterator positioned prior to the first element. + */ + public java.util.Iterator iterator( ) + { + return new LinkedListIterator( ); + } + + /** + * This is the implementation of the LinkedListIterator. + * It maintains a notion of a current position and of + * course the implicit reference to the MyLinkedList. + */ + private class LinkedListIterator implements java.util.Iterator + { + private Node current = beginMarker.next; + private int expectedModCount = modCount; + private boolean okToRemove = false; + + public boolean hasNext( ) + { + return current != endMarker; + } + + public AnyType next( ) + { + if( modCount != expectedModCount ) + throw new java.util.ConcurrentModificationException( ); + if( !hasNext( ) ) + throw new java.util.NoSuchElementException( ); + + AnyType nextItem = current.data; + current = current.next; + okToRemove = true; + return nextItem; + } + + public void remove( ) + { + if( modCount != expectedModCount ) + throw new java.util.ConcurrentModificationException( ); + if( !okToRemove ) + throw new IllegalStateException( ); + + MyLinkedList.this.remove( current.prev ); + expectedModCount++; + okToRemove = false; + } + } + + /** + * This is the doubly-linked list node. + */ + private static class Node + { + public Node( AnyType d, Node p, Node n ) + { + data = d; prev = p; next = n; + } + + public AnyType data; + public Node prev; + public Node next; + } + + private int theSize; + private int modCount = 0; + private Node beginMarker; + private Node endMarker; +} + +class TestLinkedList +{ + public static void main( String [ ] args ) + { + MyLinkedList lst = new MyLinkedList<>( ); + + for( int i = 0; i < 10; i++ ) + lst.add( i ); + for( int i = 20; i < 30; i++ ) + lst.add( 0, i ); + + lst.remove( 0 ); + lst.remove( lst.size( ) - 1 ); + + System.out.println( lst ); + + java.util.Iterator itr = lst.iterator( ); + while( itr.hasNext( ) ) + { + itr.next( ); + itr.remove( ); + System.out.println( lst ); + } + } +} \ No newline at end of file diff --git a/main54.c b/main54.c new file mode 100644 index 0000000..3c5f47e --- /dev/null +++ b/main54.c @@ -0,0 +1,15 @@ +#include +void main() +{ //6 11 8 13 10 15 12 + int a=6; + printf("%d ",a); + label: + a=a+5; + printf("%d ",a); + a=a-3; + printf("%d ",a); + if(a<12) + { + goto label; + } +} diff --git a/marksToPercent.java b/marksToPercent.java new file mode 100644 index 0000000..9d5a9a5 --- /dev/null +++ b/marksToPercent.java @@ -0,0 +1,27 @@ +import java.util.Scanner; + +public class marksToPercent { + public static void main(String[] args) { + Scanner sc = new Scanner(System.in); + System.out.println("Enter marks of hindi"); + float marks1 = sc.nextFloat(); + System.out.println("Enter marks of english"); + float marks2 = sc.nextFloat(); + System.out.println("Enter marks of mathematics"); + float marks3 = sc.nextFloat(); + System.out.println("Enter marks of science"); + float marks4 = sc.nextFloat(); + System.out.println("Enter marks of SST"); + float marks5 = sc.nextFloat(); + + float total = marks1 + marks2 + marks3 + marks4 + marks5; + System.out.println("Total marks = "); + System.out.println(total); + float average = (total / 5.0f); + System.out.println("Average marks = "); + System.out.println(average); + float percentage = (total / 500.0f) * 100; + System.out.print("Percentage = " + percentage); + System.out.println(percentage); + } +} \ No newline at end of file diff --git a/matrixTranspose.java b/matrixTranspose.java new file mode 100644 index 0000000..7c72e6e --- /dev/null +++ b/matrixTranspose.java @@ -0,0 +1,33 @@ +package ArrayQuestions.src; + +import java.util.Arrays; + +public class matrixTranspose { + public static void main(String[] args) { + int[][] matrix = { + {1,2,3}, + {4,5,6}, + + }; + + System.out.println(Arrays.toString((transpose(matrix)))); + } + static int[][] transpose(int[][] matrix) { + int[][] temp = matrix; + int[][] res = new int [matrix[0].length][matrix.length]; + + for (int i = 0; i < res.length; i++) { + for(int j = 0; j < matrix.length; j++){ + res[i][j] = matrix[j][i]; + + } + } + + for(int i = 0; i < res.length; i++){ + System.out.println(Arrays.toString(res[i])); + } + return res; + } + + } + diff --git a/merge-sort.java b/merge-sort.java new file mode 100644 index 0000000..f417242 --- /dev/null +++ b/merge-sort.java @@ -0,0 +1,77 @@ +/* Java program for Merge Sort */ +class MergeSort { + + void merge(int arr[], int l, int m, int r) + { + int n1 = m - l + 1; + int n2 = r - m; + int L[] = new int[n1]; + int R[] = new int[n2]; + for (int i = 0; i < n1; ++i) + L[i] = arr[l + i]; + for (int j = 0; j < n2; ++j) + R[j] = arr[m + 1 + j]; + int i = 0, j = 0; + int k = l; + while (i < n1 && j < n2) { + if (L[i] <= R[j]) { + arr[k] = L[i]; + i++; + } + else { + arr[k] = R[j]; + j++; + } + k++; + } + while (i < n1) { + arr[k] = L[i]; + i++; + k++; + } + while (j < n2) { + arr[k] = R[j]; + j++; + k++; + } + } + + + void sort(int arr[], int l, int r) + { + if (l < r) { + + int m = l + (r - l) / 2; + + sort(arr, l, m); + sort(arr, m + 1, r); + + + merge(arr, l, m, r); + } + } + + + static void printArray(int arr[]) + { + int n = arr.length; + for (int i = 0; i < n; ++i) + System.out.print(arr[i] + " "); + System.out.println(); + } + + public static void main(String args[]) + { + int arr[] = { 12, 11, 13, 5, 6, 7 }; + + System.out.println("Given Array"); + printArray(arr); + + MergeSort ob = new MergeSort(); + ob.sort(arr, 0, arr.length - 1); + + System.out.println("\nSorted array"); + printArray(arr); + } +} + diff --git a/merge.c b/merge.c new file mode 100644 index 0000000..45622c6 --- /dev/null +++ b/merge.c @@ -0,0 +1,101 @@ + + +#include +#include + + + + +void merge(int arr[], int l, int m, int r) +{ + int i, j, k; + int n1 = m - l + 1; + int n2 = r - m; + + + int L[n1], R[n2]; + + + for (i = 0; i < n1; i++) + L[i] = arr[l + i]; + for (j = 0; j < n2; j++) + R[j] = arr[m + 1 + j]; + + + i = 0; + j = 0; + k = l; + while (i < n1 && j < n2) { + if (L[i] <= R[j]) { + arr[k] = L[i]; + i++; + } + else { + arr[k] = R[j]; + j++; + } + k++; + } + + + while (i < n1) { + arr[k] = L[i]; + i++; + k++; + } + + + while (j < n2) { + arr[k] = R[j]; + j++; + k++; + } +} + + +void mergeSort(int arr[], int l, int r) +{ + if (l < r) { + + int m = l + (r - l) / 2; + + + mergeSort(arr, l, m); + mergeSort(arr, m + 1, r); + + merge(arr, l, m, r); + } +} + + +void printArray(int A[], int size) +{ + int i; + for (i = 0; i < size; i++) + printf("%d ", A[i]); + printf("\n"); +} + + +int main() +{ + printf("enter size"); + int s; + scanf("%d",&s); + + int arr[s]; + for(int jj=0;jj m - 1) + { + nums[i] = nums2[j]; + j = +1; + } else { + nums[i] = nums1[i]; + } + + } + System.out.println(Arrays.toString(nums)); + + int temp; + for(int k=0;k= 0) { + MinHeapify(i); + i--; + } + } + + // A recursive method to heapify a subtree + // with the root at given index This method + // assumes that the subtrees are already heapified + void MinHeapify(int i) + { + int l = left(i); + int r = right(i); + int smallest = i; + + if (l < heap_size + && harr[l].element < harr[i].element) + smallest = l; + + if (r < heap_size + && harr[r].element < harr[smallest].element) + smallest = r; + + if (smallest != i) { + swap(harr, i, smallest); + MinHeapify(smallest); + } + } + + // to get index of left child of node at index i + int left(int i) { return (2 * i + 1); } + + // to get index of right child of node at index i + int right(int i) { return (2 * i + 2); } + + // to get the root + MinHeapNode getMin() + { + if (heap_size <= 0) { + System.out.println("Heap underflow"); + return null; + } + return harr[0]; + } + + // to replace root with new node + // "root" and heapify() new root + void replaceMin(MinHeapNode root) + { + harr[0] = root; + MinHeapify(0); + } + + // A utility function to swap two min heap nodes + void swap(MinHeapNode[] arr, int i, int j) + { + MinHeapNode temp = arr[i]; + arr[i] = arr[j]; + arr[j] = temp; + } + + // A utility function to print array elements + static void printArray(int[] arr) + { + for (int i : arr) + System.out.print(i + " "); + System.out.println(); + } + + // This function takes an array of + // arrays as an argument and All + // arrays are assumed to be sorted. + // It merges them together and + // prints the final sorted output. + static void mergeKSortedArrays(int[][] arr, int K) + { + MinHeapNode[] hArr = new MinHeapNode[K]; + int resultSize = 0; + for (int i = 0; i < arr.length; i++) { + MinHeapNode node + = new MinHeapNode(arr[i][0], i, 1); + hArr[i] = node; + resultSize += arr[i].length; + } + + // Create a min heap with k heap nodes. Every heap + // node has first element of an array + MinHeap mh = new MinHeap(hArr, K); + + int[] result + = new int[resultSize]; // To store output array + + // Now one by one get the minimum element from min + // heap and replace it with next element of its + // array + for (int i = 0; i < resultSize; i++) { + + // Get the minimum element and store it in + // result + MinHeapNode root = mh.getMin(); + result[i] = root.element; + + // Find the next element that will replace + // current root of heap. The next element + // belongs to same array as the current root. + if (root.j < arr[root.i].length) + root.element = arr[root.i][root.j++]; + // If root was the last element of its array + else + root.element = Integer.MAX_VALUE; + + // Replace root with next element of array + mh.replaceMin(root); + } + + printArray(result); + } + + // Driver's code + public static void main(String args[]) + { + int[][] arr = { { 2, 6, 12, 34 }, + { 1, 9, 20, 1000 }, + { 23, 34, 90, 2000 } }; + + System.out.println("Merged array is :"); + + // Function call + mergeKSortedArrays(arr, arr.length); + } +}; + +// This code is contributed by harsh diff --git a/mergesort.java b/mergesort.java new file mode 100644 index 0000000..091010c --- /dev/null +++ b/mergesort.java @@ -0,0 +1,77 @@ +public class MergeSort { + + public static void main(String[] args) { + + int[] arr = { 70, 50, 30, 10, 20, 40, 60 }; + + int[] merged = mergeSort(arr, 0, arr.length - 1); + + for (int val : merged) { + System.out.print(val + " "); + } + + } + + public static int[] mergeTwoSortedArrays(int[] one, int[] two) { + + int[] sorted = new int[one.length + two.length]; + + int i = 0; + int j = 0; + int k = 0; + + while (i < one.length && j < two.length) { + + if (one[i] < two[j]) { + sorted[k] = one[i]; + k++; + i++; + } else { + sorted[k] = two[j]; + k++; + j++; + } + } + + if (i == one.length) { + + while (j < two.length) { + sorted[k] = two[j]; + k++; + j++; + } + } + + if (j == two.length) { + + while (i < one.length) { + sorted[k] = one[i]; + k++; + i++; + } + } + + return sorted; + + } + + public static int[] mergeSort(int[] arr, int lo, int hi) { + + if (lo == hi) { + int[] br = new int[1]; + br[0] = arr[lo]; + + return br; + } + + int mid = (lo + hi) / 2; + + int[] fh = mergeSort(arr, lo, mid); + int[] sh = mergeSort(arr, mid + 1, hi); + + int[] merged = mergeTwoSortedArrays(fh, sh); + + return merged; + } + +} diff --git a/netconf-server-mr.py b/netconf-server-mr.py new file mode 100644 index 0000000..c8eeb4a --- /dev/null +++ b/netconf-server-mr.py @@ -0,0 +1,239 @@ +from __future__ import absolute_import, division, unicode_literals, print_function, nested_scopes +import io +import logging +import os +import sys +import threading +import paramiko as ssh +from lxml import etree +import sshutil.server + +from netconf import base +import netconf.error as ncerror +from netconf import NSMAP +from netconf import qmap +from netconf import util + +if sys.platform == 'win32' and sys.version_info < (3, 5): + import backports.socketpair # pylint: disable=E0401,W0611 + +logger = logging.getLogger(__name__) + +try: + import pam + have_pam = True +except ImportError: + have_pam = False + + +class SSHAuthorizedKeysController(ssh.ServerInterface): + """An implementation of paramiko `ServerInterface` that utilizes users + authorized keys file for authentication. + :param users: A list of usernames whose authorized keys will allow access. + """ + def __init__(self, users=None): + self.event = threading.Event() + self.users = users + self.users_keys = {} + if have_pam: + self.pam = pam.pam() + else: + self.pam = None + + def get_user_auth_keys(self, username): + """Parse the users's authorized_keys file if any to look for authorized keys""" + if username in self.users_keys: + return self.users_keys[username] + + self.users_keys[username] = [] + + userdir = os.path.expanduser("~" + username) + if not userdir: + return self.users_keys[username] + + keyfile = os.path.join(userdir, ".ssh/authorized_keys") + if not keyfile or not os.path.exists(keyfile): + return self.users_keys[username] + + with open(keyfile) as f: + for line in f.readlines(): + line = line.strip() + if not line or line.startswith("#"): + continue + values = [x.strip() for x in line.split()] + + exp = None + try: + int(values[0]) # bits value? + except ValueError: + # Type 1 or type 2, type 1 is bits in second value + options_ktype = values[0] + try: + int(values[1]) # bits value? + except ValueError: + # type 2 with options + ktype = options_ktype + data = values[1] + else: + # Type 1 no options. + exp = int(values[1]) + data = values[2] + else: + # Type 1 no options. + exp = int(values[1]) + data = values[2] + + # XXX For now skip type 1 keys + if exp is not None: + continue + + if data: + import base64 + if ktype == "ssh-rsa": + key = ssh.RSAKey(data=base64.decodebytes(data.encode('ascii'))) + elif ktype == "ssh-dss": + key = ssh.DSSKey(data=base64.decodebytes(data.encode('ascii'))) + else: + key = None + if key: + self.users_keys[username].append(key) + return self.users_keys[username] + + def get_allowed_auths(self, username): + # This is only called after the user fails some other authentication type. + if self.users is None: + users = [username] + else: + users = self.users + allowed = [] + if username in users: + if self.pam: + allowed.append("password") + + if self.get_user_auth_keys(username): + allowed.append("publickey") + + allowed = ",".join(allowed) + logger.debug("Allowed methods for user %s: %s", str(username), allowed) + return allowed + + def check_auth_none(self, unused_username): + return ssh.AUTH_FAILED + + def check_auth_publickey(self, username, key): + if not self.get_user_auth_keys(username): + return ssh.AUTH_FAILED + for ukey in self.users_keys[username]: + if ukey == key: + return ssh.AUTH_SUCCESSFUL + return ssh.AUTH_FAILED + + def check_auth_password(self, username, password): + # Don't allow empty user or empty passwords + if not username or not password: + return ssh.AUTH_FAILED + if self.pam and self.pam.authenticate(username, password): + return ssh.AUTH_SUCCESSFUL + return ssh.AUTH_FAILED + + def check_channel_request(self, kind, chanid): + if kind == "session": + return ssh.OPEN_SUCCEEDED + return ssh.OPEN_FAILED_ADMINISTRATIVELY_PROHIBITED + + def check_channel_subsystem_request(self, channel, name): + self.event.set() + return name == "netconf" + + +# Backward compat +SSHAuthController = SSHAuthorizedKeysController + + +class SSHUserPassController(ssh.ServerInterface): + """An implementation of paramiko `ServerInterface` that authorizes a single user + and password. + :param username: The username to allow. + :param password: The password to allow. + """ + def __init__(self, username=None, password=None): + self.username = username + self.password = password + self.event = threading.Event() + + def get_allowed_auths(self, username): + del username # unused + return "password" + + def check_auth_none(self, username): + del username # unused + return ssh.AUTH_FAILED + + def check_auth_password(self, username, password): + if self.username == username and self.password == password: + return ssh.AUTH_SUCCESSFUL + return ssh.AUTH_FAILED + + def check_channel_request(self, kind, chanid): + if kind == "session": + return ssh.OPEN_SUCCEEDED + return ssh.OPEN_FAILED_ADMINISTRATIVELY_PROHIBITED + + def check_channel_subsystem_request(self, channel, name): + self.event.set() + return name == "netconf" + + +class NetconfServerSession(base.NetconfSession): + """Netconf Server-side session with a client. + This object will be passed to a the server RPC methods. + """ + handled_rpc_methods = set(["close-session", "lock", "kill-session", "unlock"]) + + def __init__(self, channel, server, unused_extra_args, debug): + self.server = server + + sid = self.server._allocate_session_id() + if debug: + logger.debug("NetconfServerSession: Creating session-id %s", str(sid)) + + self.methods = server.server_methods + super(NetconfServerSession, self).__init__(channel, debug, sid) + super(NetconfServerSession, self)._open_session(True) + + if self.debug: + logger.debug("%s: Client session-id %s created", str(self), str(sid)) + + def __del__(self): + self.close() + super(NetconfServerSession, self).__del__() + + def __str__(self): + return "NetconfServerSession(sid:{})".format(self.session_id) + + def close(self): + """Close the servers side of the session.""" + # XXX should be invoking a method in self.methods? + if self.debug: + logger.debug("%s: Closing.", str(self)) + + # Cleanup any locks + locked = self.server.unlock_target_any(self) + method = getattr(self.methods, "rpc_unlock", None) + if method is not None: + try: + # Let the user know. + for target in locked: + method(self, None, target) + except Exception as ex: + if self.debug: + logger.debug("%s: Ignoring exception in rpc_unlock during close: %s", str(self), + str(ex)) + try: + super(NetconfServerSession, self).close() + except EOFError: + if self.debug: + logger.debug("%s: EOF error while closing", str(self)) + + if self.debug: + logger.debug("%s: Closed.", str(self)) \ No newline at end of file diff --git a/netconf-static-route b/netconf-static-route new file mode 100644 index 0000000..6601e10 --- /dev/null +++ b/netconf-static-route @@ -0,0 +1,35 @@ +from ncclient import manager +import xmltodict +import json +import yaml +from jinja2 import Template + +with open('inventory.yml') as f: + inventory = f.read() + +inventory_dict = yaml.load(inventory) +# print(json.dumps(inventory_dict,indent=4)) + +device_list = inventory_dict['CORE'] + +netconf_template = Template(open('static_route_template.xml').read()) + +for device in device_list: + host = device['host'] + route_list = device['static_route'] + + print('----------------------------------------') + print(f'Configuring Static Route on {host}') + print('----------------------------------------') + + netconf_payload = netconf_template.render(route_list=route_list) + + # print(netconf_payload) + + # send the payload to the host + with manager.connect(host=host, port='830', + username='cisco', password='cisco', + hostkey_verify=False) as m: + + netconf_reply = m.edit_config(netconf_payload, target='running') + print(netconf_reply) \ No newline at end of file diff --git a/netmiko-ospf.py b/netmiko-ospf.py new file mode 100644 index 0000000..a57f800 --- /dev/null +++ b/netmiko-ospf.py @@ -0,0 +1,79 @@ +import yaml +from pprint import pprint +from netmiko import ConnectHandler + + +def read_yaml(yaml_file): + with open(yaml_file) as f: + inventory = f.read() + + inventory_dict = yaml.load(inventory) + return inventory_dict + +def device_connection(router_ip): + device = { + "device_type" : "cisco_ios", + "ip" : router_ip, + "username" : "cisco", + "password" : "cisco" + } + + conn = ConnectHandler(**device) + return conn + +def conf_ip(conn, ip_config): + interface = ip_config['interface'] + ip_addr = ip_config['ip_address'] + config_list = ['interface {}'.format(interface), + 'ip address {}'.format(ip_addr), + 'no shutdown'] + print conn.send_config_set(config_list) + +def conf_dhcp(conn, dhcp_config): + pool = dhcp_config['pool'] + network = dhcp_config['network'] + gateway = dhcp_config['gateway'] + config_list = ['ip dhcp pool {}'.format(pool), + 'network {}'.format(network), + 'default-router {}'.format(gateway)] + print conn.send_config_set(config_list) + +def conf_ospf(conn, ospf_config): + area = ospf_config['area'] + network_list = ospf_config['network'] + config_list = ['router ospf 1'] + for network in network_list: + config_list.append('network {} area {}'.format(network, area)) + + print conn.send_config_set(config_list) + +def main(): + yaml_file = 'inventory.yaml' + inventory_dict = read_yaml(yaml_file) + pprint(inventory_dict) + + for router in inventory_dict['CORE']: + + router_ip = router['host'] + print "-------------------------------" + print "Configuring {}".format(router_ip) + print "-------------------------------" + #connection + conn = device_connection(router_ip) + + #configure ip address + ip_config = router['int_config'] + for conf in ip_config: + conf_ip(conn, conf) + + #configure dhcp + dhcp_config = router['dhcp_config'] + for config in dhcp_config: + conf_dhcp(conn, config) + + #configure ospf + ospf_config = router['ospf_config'] + for config in ospf_config: + conf_ospf(conn, config) + +main() \ No newline at end of file diff --git a/newbubblesort.java b/newbubblesort.java new file mode 100644 index 0000000..436662e --- /dev/null +++ b/newbubblesort.java @@ -0,0 +1,35 @@ +public class BubbleSortExample { + static void bubbleSort(int[] arr) { + int n = arr.length; + int temp = 0; + for(int i=0; i < n; i++){ + for(int j=1; j < (n-i); j++){ + if(arr[j-1] > arr[j]){ + //swap elements + temp = arr[j-1]; + arr[j-1] = arr[j]; + arr[j] = temp; + } + + } + } + + } + public static void main(String[] args) { + int arr[] ={3,60,35,2,45,320,5}; + + System.out.println("Array Before Bubble Sort"); + for(int i=0; i < arr.length; i++){ + System.out.print(arr[i] + " "); + } + System.out.println(); + + bubbleSort(arr);//sorting array elements using bubble sort + + System.out.println("Array After Bubble Sort"); + for(int i=0; i < arr.length; i++){ + System.out.print(arr[i] + " "); + } + + } +} diff --git a/oddOrEvenNumber.java b/oddOrEvenNumber.java new file mode 100644 index 0000000..b856cce --- /dev/null +++ b/oddOrEvenNumber.java @@ -0,0 +1,21 @@ +import java.util.Scanner; + +public class oddOrEvenNumber { + public static void main(String[] args) throws Exception { + + Scanner inputNumber = new Scanner(System.in); + + // Check whether a number is even or odd using if else statement + System.out.print("Enter a number:\t"); + int num = inputNumber.nextInt(); + + if (num % 2 == 0) { + System.out.print(num + " is even"); + } else { + System.out.print(num + " is odd"); + } + + inputNumber.close(); + } + +} diff --git a/overidding_MR.java b/overidding_MR.java new file mode 100644 index 0000000..2a6e0c9 --- /dev/null +++ b/overidding_MR.java @@ -0,0 +1,62 @@ + +//example of the overriding method +//return type and signature(parameter) same means the overriding method + +class a1 +{ + void hell() + { + System.out.println("hello i am from i1"); + } +} + +class b1 extends a1 +{ + void hell() + { + + System.out.println("hello i am from i1"); + } +} + +class c1 extends b1{ + void hell() + { + System.out.println("hello i am from i1"); + } +} + +public class polymorph { + + public static void main(String[] args) + { + //where c1 is called reference + // where c1() is called instance + + + //c1 obj1=new c1(); + // obj1.hell(); + + // now we take the reference of b1 and instance c1 as same + + // b1 obj1=new c1(); + // obj1.hell(); + + //it's means that if we change the instance than automatically + //sentence will be changed or method /function will be change + + //reference is a1 and instance c1 + //output is of c1 method is display + + // a1 obj1=new c1(); + //obj1.hell(); + + //reference is a1 and instance b1 + //output is of b1 method is display + + // a1 obj1=new b1(); + // obj1.hell(); + + + } +} diff --git a/palindrome.java b/palindrome.java new file mode 100644 index 0000000..61b2f1b --- /dev/null +++ b/palindrome.java @@ -0,0 +1,27 @@ +import java.util.*; +public class Main +{ + public static void palindrome(int n) + { + int d,sum=0; + int copy=n; + while(n>0) + { + d=n%10; + sum=sum*10+d; + n/=10; + } + if(copy==sum) + System.out.println("Palindrome Number"); + else + System.out.println("Not a Palindrome Number"); + } + public static void main(String args[]) + { + int num; + Scanner sc=new Scanner(System.in); + System.out.println("Enter the number"); + num=sc.nextInt(); + palindrome(num); + } +} diff --git a/palindrome1.java b/palindrome1.java new file mode 100644 index 0000000..c3e6080 --- /dev/null +++ b/palindrome1.java @@ -0,0 +1,31 @@ +import java.util.*; +public class Main +{ + public static void main(String[] args) { + Scanner sc=new Scanner(System.in); + System.out.println("check palindrome"); + System.out.println("enter n"); + int nn=sc.nextInt(); + for(int i=1;i<=nn;i++){ + System.out.println("Enter number"); + int num=sc.nextInt(); + String newnum=""; + int n=num; + int d; + while(n!=0){ + d=n%10; + n=n/10; + newnum = newnum+d; + } + if(num==0 || num/10==0){ + System.out.println("not palindrome"); + } + else if(Integer.valueOf(newnum) == num){ + System.out.println("Palindrome"); + } + else{ + System.out.println("not palindrome"); + } + } + } +} diff --git a/palindromenumber.java b/palindromenumber.java new file mode 100644 index 0000000..eeae7a5 --- /dev/null +++ b/palindromenumber.java @@ -0,0 +1,9 @@ +public boolean isPalindrome(int x) { + if (x<0 || (x!=0 && x%10==0)) return false; + int rev = 0; + while (x>rev){ + rev = rev*10 + x%10; + x = x/10; + } + return (x==rev || x==rev/10); +} diff --git a/parameterized_recursion.java b/parameterized_recursion.java new file mode 100644 index 0000000..e6f4dc1 --- /dev/null +++ b/parameterized_recursion.java @@ -0,0 +1,28 @@ + +//sum of n numbers + + + +public class parameterized_recursion { + + static int f(int i, int sum){ + if(i<0){ + System.out.println(sum); + return 0; + + } + f(i-1,sum+i); + return 0; + + } + + public static void main(String[] args){ + + int n =5; + int sum =0; + f(n,sum); + + + + } +} diff --git a/parentComponent.html b/parentComponent.html new file mode 100644 index 0000000..cad8b58 --- /dev/null +++ b/parentComponent.html @@ -0,0 +1,10 @@ + \ No newline at end of file diff --git a/pascal triangle in c.c b/pascal triangle in c.c new file mode 100644 index 0000000..ce7ad9b --- /dev/null +++ b/pascal triangle in c.c @@ -0,0 +1,19 @@ +#include +int main() { + int rows, coef = 1, space, i, j; + printf("Enter the number of rows: "); + scanf("%d", &rows); + for (i = 0; i < rows; i++) { + for (space = 1; space <= rows - i; space++) + printf(" "); + for (j = 0; j <= i; j++) { + if (j == 0 || i == 0) + coef = 1; + else + coef = coef * (i - j + 1) / j; + printf("%4d", coef); + } + printf("\n"); + } + return 0; +} diff --git a/permutation.java b/permutation.java new file mode 100644 index 0000000..67c9a03 --- /dev/null +++ b/permutation.java @@ -0,0 +1,39 @@ +public class PermuteString { + //Function for swapping the characters at position I with character at position j + public static String swapString(String a, int i, int j) { + char[] b =a.toCharArray(); + char ch; + ch = b[i]; + b[i] = b[j]; + b[j] = ch; + return String.valueOf(b); + } + + public static void main(String[] args) + { + String str = "ABC"; + int len = str.length(); + System.out.println("All the permutations of the string are: "); + generatePermutation(str, 0, len); + } + + //Function for generating different permutations of the string + public static void generatePermutation(String str, int start, int end) + { + //Prints the permutations + if (start == end-1) + System.out.println(str); + else + { + for (int i = start; i < end; i++) + { + //Swapping the string by fixing a character + str = swapString(str,start,i); + //Recursively calling function generatePermutation() for rest of the characters + generatePermutation(str,start+1,end); + //Backtracking and swapping the characters again. + str = swapString(str,start,i); + } + } + } +} diff --git a/polymorphism.java b/polymorphism.java new file mode 100644 index 0000000..d8d78b9 --- /dev/null +++ b/polymorphism.java @@ -0,0 +1,70 @@ +package vid24oops; + +//Method Overloading or Run time Polymorphism (Functions can be called as per required in any type of Polymorphism) +// class Student{ +// String name; +// int age; + +// public void displayInfo(String name) { +// System.out.println(name); +// } + +// public void displayInfo(int age) { +// System.out.println(age); +// } + +// public void displayInfo(String name, int age) { +// System.out.println(name); +// System.out.println(age); +// } +// } + +// public class polymorphism { +// public static void main(String[] args) { +// Student s1 = new Student(); + +// s1.name = "Adi"; +// s1.age= 21; + +// s1.displayInfo(s1.name); //If we want only name to display + +// s1.displayInfo(s1.age); //If we want only age to display + +// s1.displayInfo(s1.name,s1.age); //If we want name and age to display +// } +// } + +//Run time polymorphism +// abstract class Animal { +// abstract void walk(); +// void breathe() { +// System.out.println("This animal breathes air"); +// } + +// Animal() { +// System.out.println("You are about to create an Animal."); +// } +// } + +// class Horse extends Animal { +// void walk() { +// System.out.println("Horse walks on 4 legs"); +// } +// } + +// class Chicken extends Animal { +// void walk() { +// System.out.println("Chicken walks on 2 legs"); +// } +// } + +// public class polymorphism { +// public static void main(String args[]) { +// Horse horse = new Horse(); +// horse.walk(); +// horse.breathe(); + +// Animal animal = new Animal(); +// animal.walk(); //Gives error when you run, but not when you compile +// } +// } diff --git a/primenumber.java b/primenumber.java new file mode 100644 index 0000000..356b605 --- /dev/null +++ b/primenumber.java @@ -0,0 +1,19 @@ +public class PrimeExample{ + public static void main(String args[]){ + int i,m=0,flag=0; + int n=3;//it is the number to be checked + m=n/2; + if(n==0||n==1){ + System.out.println(n+" is not prime number"); + }else{ + for(i=2;i<=m;i++){ + if(n%i==0){ + System.out.println(n+" is not prime number"); + flag=1; + break; + } + } + if(flag==0) { System.out.println(n+" is prime number"); } + }//end of else +} +} \ No newline at end of file diff --git a/printASCIIvalue.java b/printASCIIvalue.java new file mode 100644 index 0000000..73c0778 --- /dev/null +++ b/printASCIIvalue.java @@ -0,0 +1,14 @@ +public class PrintAsciiValueExample1 +{ +public static void main(String[] args) +{ +// character whose ASCII value to be found +char ch1 = 'a'; +char ch2 = 'b'; +// variable that stores the integer value of the character +int asciivalue1 = ch1; +int asciivalue2 = ch2; +System.out.println("The ASCII value of " + ch1 + " is: " + asciivalue1); +System.out.println("The ASCII value of " + ch2 + " is: " + asciivalue2); +} +} diff --git a/printarray.java b/printarray.java new file mode 100644 index 0000000..1dd91a1 --- /dev/null +++ b/printarray.java @@ -0,0 +1,10 @@ +public class Array { + + public static void main(String[] args) { + int[] array = {1, 2, 3, 4, 5}; + + for (int element: array) { + System.out.println(element); + } + } +} diff --git a/priya.html b/priya.html new file mode 100644 index 0000000..f75ba5c --- /dev/null +++ b/priya.html @@ -0,0 +1,97 @@ + +
    +
    +!DOCTYPE html> + + + + +

    GeeksforGeeks

    + +

    It is a Computer Science portal For Geeks

    + + + + + + +
  • Works
    • +
  • Contact
    • +
    +
    +
    97%
    +
    + Adobe Photoshop +
    +
    +
    +
    + These tutorials are excellent. I've learned so much. I can't wait to try more! +
    +
    + testimonial author avatar + Mark Johnson + Envato Tuts+ user +
    +
    +
    + +html> + + + + HTML table border Attribute + + + + +

    GeeksforGeeks

    + +

    HTML table border Attribute

    + + + + + + + + + + + + + + + + + + + + +
    Author Details
    NAMEAGEBRANCH
    BITTU22CSE
    RAMRAM21ECE
    + + + diff --git a/program to add two numbers b/program to add two numbers new file mode 100644 index 0000000..5fcf93a --- /dev/null +++ b/program to add two numbers @@ -0,0 +1,15 @@ +class Main { + + public static void main(String[] args) { + + System.out.println("Enter two numbers"); + int first = 10; + int second = 20; + + System.out.println(first + " " + second); + + // add two numbers + int sum = first + second; + System.out.println("The sum is: " + sum); + } +} diff --git a/puzzleGame.java b/puzzleGame.java new file mode 100644 index 0000000..8a4c161 --- /dev/null +++ b/puzzleGame.java @@ -0,0 +1,178 @@ +import java.awt.*; +import java.awt.event.*; +import javax.swing.JOptionPane; +public class Puzzle extends Frame implements ActionListener{ +Button b1,b2,b3,b4,b5,b6,b7,b8,b9; +Puzzle(){ + super("Puzzle - JavaTpoint"); + b1=new Button("1"); + b1.setBounds(50,100,40,40); + b2=new Button("2"); + b2.setBounds(100,100,40,40); + b3=new Button("3"); + b3.setBounds(150,100,40,40); + b4=new Button("4"); + b4.setBounds(50,150,40,40); + b5=new Button("5"); + b5.setBounds(100,150,40,40); + b6=new Button("6"); + b6.setBounds(150,150,40,40); + b7=new Button("7"); + b7.setBounds(50,200,40,40); + b8=new Button(""); + b8.setBounds(100,200,40,40); + b9=new Button("8"); + b9.setBounds(150,200,40,40); + + b1.addActionListener(this); + b2.addActionListener(this); + b3.addActionListener(this); + b4.addActionListener(this); + b5.addActionListener(this); + b6.addActionListener(this); + b7.addActionListener(this); + b8.addActionListener(this); + b9.addActionListener(this); + + add(b1);add(b2);add(b3);add(b4);add(b5);add(b6);add(b7);add(b8);add(b9); + setSize(400,400); + setLayout(null); + setVisible(true); +} +public void actionPerformed(ActionEvent e){ + if(e.getSource()==b1){ + String label=b1.getLabel(); + if(b2.getLabel().equals("")){ + b2.setLabel(label); + b1.setLabel(""); + } + if(b4.getLabel().equals("")){ + b4.setLabel(label); + b1.setLabel(""); + } + } + if(e.getSource()==b2){ + String label=b2.getLabel(); + if(b1.getLabel().equals("")){ + b1.setLabel(label); + b2.setLabel(""); + } + if(b3.getLabel().equals("")){ + b3.setLabel(label); + b2.setLabel(""); + } + if(b5.getLabel().equals("")){ + b5.setLabel(label); + b2.setLabel(""); + } + } + if(e.getSource()==b3){ + String label=b3.getLabel(); + if(b2.getLabel().equals("")){ + b2.setLabel(label); + b3.setLabel(""); + } + if(b6.getLabel().equals("")){ + b6.setLabel(label); + b3.setLabel(""); + } + } + if(e.getSource()==b4){ + String label=b4.getLabel(); + if(b1.getLabel().equals("")){ + b1.setLabel(label); + b4.setLabel(""); + } + if(b7.getLabel().equals("")){ + b7.setLabel(label); + b4.setLabel(""); + } + if(b5.getLabel().equals("")){ + b5.setLabel(label); + b4.setLabel(""); + } + } + if(e.getSource()==b5){ + String label=b5.getLabel(); + if(b2.getLabel().equals("")){ + b2.setLabel(label); + b5.setLabel(""); + } + if(b6.getLabel().equals("")){ + b6.setLabel(label); + b5.setLabel(""); + } + if(b4.getLabel().equals("")){ + b4.setLabel(label); + b5.setLabel(""); + } + if(b8.getLabel().equals("")){ + b8.setLabel(label); + b5.setLabel(""); + } + } + if(e.getSource()==b6){ + String label=b6.getLabel(); + if(b9.getLabel().equals("")){ + b9.setLabel(label); + b6.setLabel(""); + } + if(b3.getLabel().equals("")){ + b3.setLabel(label); + b6.setLabel(""); + } + if(b5.getLabel().equals("")){ + b5.setLabel(label); + b6.setLabel(""); + } + } + if(e.getSource()==b7){ + String label=b7.getLabel(); + if(b4.getLabel().equals("")){ + b4.setLabel(label); + b7.setLabel(""); + } + if(b8.getLabel().equals("")){ + b8.setLabel(label); + b7.setLabel(""); + } + } + if(e.getSource()==b8){ + String label=b8.getLabel(); + if(b9.getLabel().equals("")){ + b9.setLabel(label); + b8.setLabel(""); + } + if(b7.getLabel().equals("")){ + b7.setLabel(label); + b8.setLabel(""); + } + if(b5.getLabel().equals("")){ + b5.setLabel(label); + b8.setLabel(""); + } + } + if(e.getSource()==b9){ + String label=b9.getLabel(); + if(b6.getLabel().equals("")){ + b6.setLabel(label); + b9.setLabel(""); + } + if(b8.getLabel().equals("")){ + b8.setLabel(label); + b9.setLabel(""); + } + } + + //congrats code + if(b1.getLabel().equals("1")&&b2.getLabel().equals("2")&&b3.getLabel() + .equals("3")&&b4.getLabel().equals("4")&&b5.getLabel().equals("5") + &&b6.getLabel().equals("6")&&b7.getLabel().equals("7")&&b8.getLabel() + .equals("8")&&b9.getLabel().equals("")){ + JOptionPane.showMessageDialog(this,"Congratulations! You won."); + } +} +public static void main(String[] args) { + new Puzzle(); +} +} diff --git a/pyramid.java b/pyramid.java new file mode 100644 index 0000000..0dd55c6 --- /dev/null +++ b/pyramid.java @@ -0,0 +1,19 @@ +import java.util.*; +public class Pyramid +{ + public static void main(String args[]) + { + int rows,i,k,j; + Scanner sc=new Scanner(System.in); + System.out.println("Enter the no. of rows"); + rows=sc.nextInt(); + for(i=0;i<=rows;i++) + { + for(j=0;j +using namespace std; +void swap(int *a, int *b) +{ + int temp = *a; + *a = *b; + *b = temp; + return; +} +int partition(int arr[], int start, int end) +{ + int pivot = arr[end]; + int i = start - 1; + for (int j = start; j < end; j++) + { + if (arr[j] <= pivot) + { + i++; + swap(arr[i], arr[j]); + } + } + i++; + swap(arr[i], arr[end]); + return i; +} + +void quickSort(int arr[], int start, int end) +{ + if (start < end) + { + int part = partition(arr, start, end); + quickSort(arr, start, part - 1); + quickSort(arr, part + 1, end); + } +} + +int main() +{ + int size; + cout << "Enter size: "; + cin >> size; + int arr[size]; + cout << "Enter array: "; + for (int i = 0; i < size; i++) + { + cin >> arr[i]; + } + + quickSort(arr, 0, size - 1); + + cout << "Sorted array is: "; + for (int i = 0; i < size; i++) + { + cout << arr[i] << " "; + } + cout << endl; +} \ No newline at end of file diff --git a/quick_sort.java b/quick_sort.java new file mode 100644 index 0000000..8732663 --- /dev/null +++ b/quick_sort.java @@ -0,0 +1,58 @@ +public class Quick +{ + /* function that consider last element as pivot, +place the pivot at its exact position, and place +smaller elements to left of pivot and greater +elements to right of pivot. */ +int partition (int a[], int start, int end) +{ + int pivot = a[end]; // pivot element + int i = (start - 1); + + for (int j = start; j <= end - 1; j++) + { + // If current element is smaller than the pivot + if (a[j] < pivot) + { + i++; // increment index of smaller element + int t = a[i]; + a[i] = a[j]; + a[j] = t; + } + } + int t = a[i+1]; + a[i+1] = a[end]; + a[end] = t; + return (i + 1); +} + +/* function to implement quick sort */ +void quick(int a[], int start, int end) /* a[] = array to be sorted, start = Starting index, end = Ending index */ +{ + if (start < end) + { + int p = partition(a, start, end); //p is partitioning index + quick(a, start, p - 1); + quick(a, p + 1, end); + } +} + +/* function to print an array */ +void printArr(int a[], int n) +{ + int i; + for (i = 0; i < n; i++) + System.out.print(a[i] + " "); +} + public static void main(String[] args) { + int a[] = { 13, 18, 27, 2, 19, 25 }; + int n = a.length; + System.out.println("\nBefore sorting array elements are - "); + Quick q1 = new Quick(); + q1.printArr(a, n); + q1.quick(a, 0, n - 1); + System.out.println("\nAfter sorting array elements are - "); + q1.printArr(a, n); + System.out.println(); + } +} \ No newline at end of file diff --git a/rabin-karp.java b/rabin-karp.java new file mode 100644 index 0000000..44d898a --- /dev/null +++ b/rabin-karp.java @@ -0,0 +1,69 @@ +// Rabin Karp Algo - string pattern matching + +public class Main { + // d is the number of characters in the input alphabet + public final static int d = 256; + + /* pat -> pattern + txt -> text + q -> A prime number + */ + static void search(String pat, String txt, int q) + { + int M = pat.length(); + int N = txt.length(); + int i, j; + int p = 0; // hash value for pattern + int t = 0; // hash value for txt + int h = 1; + + // The value of h would be "pow(d, M-1)%q" + for (i = 0; i < M - 1; i++) + h = (h * d) % q; + + // Calculate the hash value of pattern and first + // window of text + for (i = 0; i < M; i++) { + p = (d * p + pat.charAt(i)) % q; + t = (d * t + txt.charAt(i)) % q; + } + + // Slide the pattern over text one by one + for (i = 0; i <= N - M; i++) { + + // Check the hash values of current window of text + // and pattern. If the hash values match then only + // check for characters on by one + if (p == t) { + /* Check for characters one by one */ + for (j = 0; j < M; j++) { + if (txt.charAt(i + j) != pat.charAt(j)) + break; + } + + // if p == t and pat[0...M-1] = txt[i, i+1, ...i+M-1] + if (j == M) + System.out.println("Pattern found at index " + i); + } + + // Calculate hash value for next window of text: Remove + // leading digit, add trailing digit + if (i < N - M) { + t = (d * (t - txt.charAt(i) * h) + txt.charAt(i + M)) % q; + + // We might get negative value of t, converting it + // to positive + if (t < 0) + t = (t + q); + } + } + } + + public static void main(String[] args) + { + String txt = "Yash Seth"; + String pat = "Seth"; + int q = 101; // A prime number + search(pat, txt, q); + } +} diff --git a/radix.java b/radix.java new file mode 100644 index 0000000..c19a396 --- /dev/null +++ b/radix.java @@ -0,0 +1,80 @@ +// Radix sort Java implementation + +import java.io.*; +import java.util.*; + +class Radix { + + // A utility function to get maximum value in arr[] + static int getMax(int arr[], int n) + { + int mx = arr[0]; + for (int i = 1; i < n; i++) + if (arr[i] > mx) + mx = arr[i]; + return mx; + } + + // A function to do counting sort of arr[] according to + // the digit represented by exp. + static void countSort(int arr[], int n, int exp) + { + int output[] = new int[n]; // output array + int i; + int count[] = new int[10]; + Arrays.fill(count, 0); + + // Store count of occurrences in count[] + for (i = 0; i < n; i++) + count[(arr[i] / exp) % 10]++; + + // Change count[i] so that count[i] now contains + // actual position of this digit in output[] + for (i = 1; i < 10; i++) + count[i] += count[i - 1]; + + // Build the output array + for (i = n - 1; i >= 0; i--) { + output[count[(arr[i] / exp) % 10] - 1] = arr[i]; + count[(arr[i] / exp) % 10]--; + } + + // Copy the output array to arr[], so that arr[] now + // contains sorted numbers according to current + // digit + for (i = 0; i < n; i++) + arr[i] = output[i]; + } + + // The main function to that sorts arr[] of + // size n using Radix Sort + static void radixsort(int arr[], int n) + { + // Find the maximum number to know number of digits + int m = getMax(arr, n); + + // Do counting sort for every digit. Note that + // instead of passing digit number, exp is passed. + // exp is 10^i where i is current digit number + for (int exp = 1; m / exp > 0; exp *= 10) + countSort(arr, n, exp); + } + + // A utility function to print an array + static void print(int arr[], int n) + { + for (int i = 0; i < n; i++) + System.out.print(arr[i] + " "); + } + + // Main driver method + public static void main(String[] args) + { + int arr[] = { 170, 45, 75, 90, 802, 24, 2, 66 }; + int n = arr.length; + + // Function Call + radixsort(arr, n); + print(arr, n); + } +} diff --git a/radix_Sort.java b/radix_Sort.java new file mode 100644 index 0000000..8c1316f --- /dev/null +++ b/radix_Sort.java @@ -0,0 +1,70 @@ + +import java.io.*; +import java.util.*; + +class Radix { + + + static int getMax(int arr[], int n) + { + int mx = arr[0]; + for (int i = 1; i < n; i++) + if (arr[i] > mx) + mx = arr[i]; + return mx; + } + + static void countSort(int arr[], int n, int exp) + { + int output[] = new int[n]; // output array + int i; + int count[] = new int[10]; + Arrays.fill(count, 0); + + // Store count of occurrences in count[] + for (i = 0; i < n; i++) + count[(arr[i] / exp) % 10]++; + + + for (i = 1; i < 10; i++) + count[i] += count[i - 1]; + + // Build the output array + for (i = n - 1; i >= 0; i--) { + output[count[(arr[i] / exp) % 10] - 1] = arr[i]; + count[(arr[i] / exp) % 10]--; + } + + + for (i = 0; i < n; i++) + arr[i] = output[i]; + } + + static void radixsort(int arr[], int n) + { + // Find the maximum number to know number of digits + int m = getMax(arr, n); + + + for (int exp = 1; m / exp > 0; exp *= 10) + countSort(arr, n, exp); + } + + // A utility function to print an array + static void print(int arr[], int n) + { + for (int i = 0; i < n; i++) + System.out.print(arr[i] + " "); + } + + // Main driver method + public static void main(String[] args) + { + int arr[] = { 170, 45, 75, 90, 802, 24, 2, 66 }; + int n = arr.length; + + // Function Call + radixsort(arr, n); + print(arr, n); + } +} diff --git a/raghav1.cpp b/raghav1.cpp new file mode 100644 index 0000000..17a4da1 --- /dev/null +++ b/raghav1.cpp @@ -0,0 +1,25 @@ +// Factorial of n = 1*2*3*...*n + +#include +using namespace std; + +int factorial(int); + +int main() { + int n, result; + + cout << "Enter a non-negative number: "; + cin >> n; + + result = factorial(n); + cout << "Factorial of " << n << " = " << result; + return 0; +} + +int factorial(int n) { + if (n > 1) { + return n * factorial(n - 1); + } else { + return 1; + } +} diff --git a/recursion.java b/recursion.java new file mode 100644 index 0000000..3edcc77 --- /dev/null +++ b/recursion.java @@ -0,0 +1,26 @@ +// A Java program to demonstrate +// working of recursion + +class GFG { + static void printFun(int test) + { + if (test < 1) + return; + + else { + System.out.printf("%d ", test); + + // Statement 2 + printFun(test - 1); + + System.out.printf("%d ", test); + return; + } + } + + public static void main(String[] args) + { + int test = 3; + printFun(test); + } +} diff --git a/rev_arr_recursion.java b/rev_arr_recursion.java new file mode 100644 index 0000000..d4d9ca7 --- /dev/null +++ b/rev_arr_recursion.java @@ -0,0 +1,35 @@ +public class rev_arr_recursion { + + static void printArr(int arr[],int n){ + System.out.println("new array is: \n"); + for (int i =0; i Optional[ListNode]: + prev, curr = None, head + + while curr: + nxt = curr.next + curr.next = prev + prev = curr + curr = nxt + + return prev + + + diff --git a/reverseString.java b/reverseString.java new file mode 100644 index 0000000..44d8752 --- /dev/null +++ b/reverseString.java @@ -0,0 +1,10 @@ +class Solution { + public void reverseString(char[] s) { + char temp; + for(int i=0;i None: + """ + Do not return anything, modify s in-place instead. + """ + for i in range(len(s)//2): + s[i], s[len(s)-1-i] = s[len(s)-1-i], s[i] + diff --git a/reversestringusingloop.java b/reversestringusingloop.java new file mode 100644 index 0000000..f764ccf --- /dev/null +++ b/reversestringusingloop.java @@ -0,0 +1,16 @@ +import java.util.Scanner; +class ReverseStringExample1 +{ +public static void main(String args[]) +{ +String s; +Scanner sc=new Scanner(System.in); +System.out.print("Enter a String: "); +s=sc.nextLine(); //reading string from user +System.out.print("After reverse string is: "); +for(int i=s.length();i>0;--i) //i is the length of the string +{ +System.out.print(s.charAt(i-1)); //printing the character at index i-1 +} +} +} diff --git a/reversing arry.java b/reversing arry.java new file mode 100644 index 0000000..e95e4d1 --- /dev/null +++ b/reversing arry.java @@ -0,0 +1,28 @@ +// Basic Java program that reverses an array + +public class reverseArray { + + // function that reverses array and stores it + // in another array + static void reverse(int a[], int n) + { + int[] b = new int[n]; + int j = n; + for (int i = 0; i < n; i++) { + b[j - 1] = a[i]; + j = j - 1; + } + + // printing the reversed array + System.out.println("Reversed array is: \n"); + for (int k = 0; k < n; k++) { + System.out.println(b[k]); + } + } + + public static void main(String[] args) + { + int [] arr = {10, 20, 30, 40, 50}; + reverse(arr, arr.length); + } +} diff --git a/righttrianglepatter.java b/righttrianglepatter.java new file mode 100644 index 0000000..cf49bd5 --- /dev/null +++ b/righttrianglepatter.java @@ -0,0 +1,21 @@ +public class RightTrianglePattern +{ +public static void main(String args[]) +{ +//i for rows and j for columns +//row denotes the number of rows you want to print +int i, j, row=6; +//outer loop for rows +for(i=0; i= s2) { + res = res + s1; + } + else { + res = res + s2 - s1; + i++; + } + } + else { + res = res + s1; + } + } + return res; + } + int value(char r) + { + if (r == 'I') + return 1; + if (r == 'V') + return 5; + if (r == 'X') + return 10; + if (r == 'L') + return 50; + if (r == 'C') + return 100; + if (r == 'D') + return 500; + if (r == 'M') + return 1000; + return -1; + } + public static void main(String args[]){ + Solution ob=new Solution(); + Scanner sc=new Scanner(System.in); + System.out.println("Enter a roman number"); + String x=sc.nextLine(); + int a=ob.romanToInt(x); + System.out.println(a); + + } +} \ No newline at end of file diff --git a/seaching.cpp b/seaching.cpp new file mode 100644 index 0000000..b2673e0 --- /dev/null +++ b/seaching.cpp @@ -0,0 +1,38 @@ +#include +using namespace std; + + +int binarySearch(int arr[], int start, int end, int ele) +{ + if (end >= start) { + int mid = (start+end)/2; + + if (arr[mid] == ele) + return mid; + if (arr[mid] > x) + return binarySearch(arr, l, mid - 1, x); + + return binarySearch(arr, mid + 1, r, x); + } + return -1; +} + +int main(void) +{ + int n; + cout<<"Enter the size of Array: "; + cin>>n; + int A[n]; + cout<<" Enter the Array: "; + for(int i=0;i> A[i]; + + int ele; + cout<<"Enter the element you wants to search: "; + cin>>ele; + int result = binarySearch(arr, 0, n - 1, ele); + (result == -1) + ? cout << "Element is not present in array" + : cout << "Element is present at index " << result; + return 0; +} diff --git a/searching2dArray.java b/searching2dArray.java new file mode 100644 index 0000000..8da7838 --- /dev/null +++ b/searching2dArray.java @@ -0,0 +1,29 @@ +import java.util.Arrays; + +public class Searchin2D { + public static void main(String[] args) { + int[][] arr = { + {12, 34, 65, 87, 12, 32}, + {65, 347, 52, 6, 1, 35}, + {56, 1, 23, 10, 1, 2} + }; + int[] ans=Searchin2d(arr,1); + System.out.println(Arrays.toString(ans)); + } + + public static int[] Searchin2d(int[][] arr,int target) + { + for(int i=0;i< arr.length;i++) + { + for(int j=0;j< arr[i].length;j++) + { + if(arr[i][j]==target) + { + return new int[]{i,j}; + } + } + } + return new int[]{-1,-1}; + } +} + diff --git a/selection-sort.java b/selection-sort.java new file mode 100644 index 0000000..44b9d5e --- /dev/null +++ b/selection-sort.java @@ -0,0 +1,42 @@ + +// SelectionSort + +import java.util.*; + +public class SelectionSort { + public static void main(String[] args) { + Scanner sc = new Scanner(System.in); + System.out.println("enter length"); + int n = sc.nextInt(); + int[] arr = new int[n]; + for (int i = 0; i < n; i++) { + arr[i] = sc.nextInt(); + } + selection(arr); + System.out.println(Arrays.toString(arr)); + } + + static void selection(int[] arr) { + for(int i = 0; i < arr.length; ++i) { + int last = arr.length - i - 1; + int maxIndex = getMaxIndex(arr, 0, last); + swap(arr, maxIndex, last); + } + } + + static void swap(int[] arr, int first, int second) { + int temp = arr[first]; + arr[first] = arr[second]; + arr[second] = temp; + } + + static int getMaxIndex(int[] arr, int start, int end) { + int max = start; + for(int i = start; i <= end; ++i) { + if (arr[max] < arr[i]) { + max = i; + } + } + return max; + } +} diff --git a/selection_sort.java b/selection_sort.java new file mode 100644 index 0000000..6bd2284 --- /dev/null +++ b/selection_sort.java @@ -0,0 +1,32 @@ +public class SelectionSortExample { + public static void selectionSort(int[] arr){ + for (int i = 0; i < arr.length - 1; i++) + { + int index = i; + for (int j = i + 1; j < arr.length; j++){ + if (arr[j] < arr[index]){ + index = j;//searching for lowest index + } + } + int smallerNumber = arr[index]; + arr[index] = arr[i]; + arr[i] = smallerNumber; + } + } + + public static void main(String a[]){ + int[] arr1 = {9,14,3,2,43,11,58,22}; + System.out.println("Before Selection Sort"); + for(int i:arr1){ + System.out.print(i+" "); + } + System.out.println(); + + selectionSort(arr1);//sorting array using selection sort + + System.out.println("After Selection Sort"); + for(int i:arr1){ + System.out.print(i+" "); + } + } +} diff --git a/shortest_common_supersequence.java b/shortest_common_supersequence.java new file mode 100644 index 0000000..a0a3e9a --- /dev/null +++ b/shortest_common_supersequence.java @@ -0,0 +1,61 @@ +module hactoberfest { + // Java program to find length of + // the shortest supersequence + class Solution { + + static int shortestSuperSequence(String X, String Y) + { + int m = X.length(); + int n = Y.length(); + + // find lcs + int l = lcs(X, Y, m, n); + + // Result is sum of input string + // lengths - length of lcs + return (m + n - l); + } + + // Returns length of LCS + // for X[0..m - 1], Y[0..n - 1] + static int lcs(String X, String Y, int m, int n) + { + int[][] L = new int[m + 1][n + 1]; + int i, j; + + // Following steps build L[m + 1][n + 1] + // in bottom up fashion. Note that + // L[i][j] contains length of LCS + // of X[0..i - 1]and Y[0..j - 1] + for (i = 0; i <= m; i++) { + for (j = 0; j <= n; j++) { + if (i == 0 || j == 0) + L[i][j] = 0; + + else if (X.charAt(i - 1) == Y.charAt(j - 1)) + L[i][j] = L[i - 1][j - 1] + 1; + + else + L[i][j] = Math.max(L[i - 1][j], + L[i][j - 1]); + } + } + + // L[m][n] contains length of LCS + // for X[0..n - 1] and Y[0..m - 1] + return L[m][n]; + } + public static void main(String args[]) + { + String X = "AGGTAB"; + String Y = "GXTXAYB"; + + System.out.println("Length of the shortest " + + "supersequence is " + + shortestSuperSequence(X, Y)); + } + } + + + +} \ No newline at end of file diff --git a/showroom.java b/showroom.java new file mode 100644 index 0000000..f852647 --- /dev/null +++ b/showroom.java @@ -0,0 +1,36 @@ +class car +{ + int tire; + String name; + String color; + void naming(String name) + { + System.out.println("Name:"+name); + } +} +//Inherit property of car class +class sports extends car +{ + void tire(int tire) + { + System.out.println("tire is:" +tire); + } +} +//inherit property of sports class +class Luxury extends sports +{ + void colur(String black) + { + System.out.println("colur:"+black); + } +} +class showroom +{ + public static void main(String arg[]) + { + Luxury L = new Luxury(); + L.naming("Audi"); + L.tire(4); + L.colur("black"); + } +} \ No newline at end of file diff --git a/shuffling.java b/shuffling.java new file mode 100644 index 0000000..e05e4cb --- /dev/null +++ b/shuffling.java @@ -0,0 +1,21 @@ +import java.util.ArrayList; +import java.util.Collections; + +class Main { + public static void main(String[] args) { + + // Creating an array list + ArrayList numbers = new ArrayList<>(); + + // Add elements + numbers.add(1); + numbers.add(2); + numbers.add(3); + System.out.println("Sorted ArrayList: " + numbers); + + // Using the shuffle() method + Collections.shuffle(numbers); + System.out.println("ArrayList using shuffle: " + numbers); + + } +} diff --git a/sierpinski.java b/sierpinski.java new file mode 100644 index 0000000..acc74e6 --- /dev/null +++ b/sierpinski.java @@ -0,0 +1,28 @@ +import java.util.*; +import java.io.*; +class sierpinski +{ + static void printSierpinski(int n) + { + for (int i = n - 1; i >= 0; i--) { + for (int j = 0; j < i; j++) { + System.out.print(" "); + } + for (int k = 0; k + i < n; k++) { + if ((k & i) != 0) + System.out.print(" "+" "); + else + System.out.print("* "); + } + System.out.print("\n"); + } + } + public static void main(String args[]) + { + int n; + Scanner s= new Scanner(System.in); + n= s.nextInt(); + printSierpinski(n); + } +} + \ No newline at end of file diff --git a/snake.java b/snake.java new file mode 100644 index 0000000..f7dfd8f --- /dev/null +++ b/snake.java @@ -0,0 +1,33 @@ +package com.zetcode; + +import java.awt.EventQueue; +import javax.swing.JFrame; + +public class Snake extends JFrame { + + public Snake() { + + initUI(); + } + + private void initUI() { + + add(new Board()); + + setResizable(false); + pack(); + + setTitle("Snake"); + setLocationRelativeTo(null); + setDefaultCloseOperation(JFrame.EXIT_ON_CLOSE); + } + + + public static void main(String[] args) { + + EventQueue.invokeLater(() -> { + JFrame ex = new Snake(); + ex.setVisible(true); + }); + } +} \ No newline at end of file diff --git a/soortarray.java b/soortarray.java new file mode 100644 index 0000000..3eadbd8 --- /dev/null +++ b/soortarray.java @@ -0,0 +1,17 @@ +import java.util.Arrays; +public class SortArrayExample1 +{ +public static void main(String[] args) +{ +//defining an array of integer type +int [] array = new int [] {90, 23, 5, 109, 12, 22, 67, 34}; +//invoking sort() method of the Arrays class +Arrays.sort(array); +System.out.println("Elements of array sorted in ascending order: "); +//prints array using the for loop +for (int i = 0; i < array.length; i++) +{ +System.out.println(array[i]); +} +} +} diff --git a/sortingUsingsort.java b/sortingUsingsort.java new file mode 100644 index 0000000..0bfebd0 --- /dev/null +++ b/sortingUsingsort.java @@ -0,0 +1,21 @@ +import java.util.ArrayList; +import java.util.Collections; + +class Main { + public static void main(String[] args) { + + // Creating an array list + ArrayList numbers = new ArrayList<>(); + + // Add elements + numbers.add(4); + numbers.add(2); + numbers.add(3); + System.out.println("Unsorted ArrayList: " + numbers); + + // Using the sort() method + Collections.sort(numbers); + System.out.println("Sorted ArrayList: " + numbers); + + } +} diff --git a/sortmapbyvalue.java b/sortmapbyvalue.java new file mode 100644 index 0000000..c35e534 --- /dev/null +++ b/sortmapbyvalue.java @@ -0,0 +1,41 @@ +import java.util.*; +import java.util.Map.Entry; + +class Main { + + public static void main(String[] args) { + + // create a map and store elements to it + LinkedHashMap capitals = new LinkedHashMap(); + capitals.put("Nepal", "Kathmandu"); + capitals.put("India", "New Delhi"); + capitals.put("United States", "Washington"); + capitals.put("England", "London"); + capitals.put("Australia", "Canberra"); + + // call the sortMap() method to sort the map + Map result = sortMap(capitals); + + for (Map.Entry entry : result.entrySet()) { + System.out.print("Key: " + entry.getKey()); + System.out.println(" Value: " + entry.getValue()); + } + } + + public static LinkedHashMap sortMap(LinkedHashMap map) { + List > capitalList = new LinkedList<>(map.entrySet()); + + // call the sort() method of Collections + Collections.sort(capitalList, (l1, l2) -> l1.getValue().compareTo(l2.getValue())); + + // create a new map + LinkedHashMap result = new LinkedHashMap(); + + // get entry from list to the map + for (Map.Entry entry : capitalList) { + result.put(entry.getKey(), entry.getValue()); + } + + return result; + } +} diff --git a/stack_usingarrays.java b/stack_usingarrays.java new file mode 100644 index 0000000..dbe78b8 --- /dev/null +++ b/stack_usingarrays.java @@ -0,0 +1,47 @@ +import java.util.Stack; + +public class stack_usingarrays { + static int push(int k,int []arr,int i){ + int temp=i; + temp=temp+1; + arr[temp]=k; + + return temp; + } + static int pop(int []arr,int i){ + int temp=i; + temp=temp-1; + arr[i]=0; + return temp; + } + static int top(int arr[],int temp){ + return arr[temp+1]; + } + static boolean empty(int temp){ + boolean flags=false; + //if temp is pointing at imagnary point , i.e, -1 + if (temp==-1){ + flags=true; + } + + return flags; + } + + + + public static void main(String[] args) { + int[] arr=new int[4]; + //pushing the first + var temp=-1; + + //printing the array + + + System.out.println( push(3,arr,temp)); + System.out.println(push(4,arr,temp)); + + push(4,arr,temp); + push(4,arr,temp); + System.out.println( empty(temp));// + } +} diff --git a/stacqueuek.cpp b/stacqueuek.cpp new file mode 100644 index 0000000..0118966 --- /dev/null +++ b/stacqueuek.cpp @@ -0,0 +1,70 @@ +/* Program to implement a stack using +two queue */ +#include + +using namespace std; + +class Stack { + // Two inbuilt queues + queue q1, q2; + +public: + void push(int x) + { + // Push x first in empty q2 + q2.push(x); + + // Push all the remaining + // elements in q1 to q2. + while (!q1.empty()) { + q2.push(q1.front()); + q1.pop(); + } + + // swap the names of two queues + queue q = q1; + q1 = q2; + q2 = q; + } + + void pop() + { + // if no elements are there in q1 + if (q1.empty()) + return; + q1.pop(); + } + + int top() + { + if (q1.empty()) + return -1; + return q1.front(); + } + + int size() + { + return q1.size(); + } +}; + +// Driver code +int main() +{ + Stack s; + s.push(1); + s.push(2); + s.push(3); + + cout << "current size: " << s.size() + << endl; + cout << s.top() << endl; + s.pop(); + cout << s.top() << endl; + s.pop(); + cout << s.top() << endl; + + cout << "current size: " << s.size() + << endl; + return 0; +} diff --git a/stringpalindrome.java b/stringpalindrome.java new file mode 100644 index 0000000..e756f96 --- /dev/null +++ b/stringpalindrome.java @@ -0,0 +1,71 @@ +/*package whatever //do not write package name here */ + + + +import java.io.*; + + + +class GFG { + + public static boolean isPalindrome(String str) + + { + + // Initializing an empty string to store the reverse + + // of the original str + + String rev = ""; + + + + // Initializing a new boolean variable for the + + // answer + + boolean ans = false; + + + + for (int i = str.length() - 1; i >= 0; i--) { + + rev = rev + str.charAt(i); + + } + + + + // Checking if both the strings are equal + + if (str.equals(rev)) { + + ans = true; + + } + + return ans; + + } + + public static void main(String[] args) + + { + + // Input string + + String str = "geeks"; + + + + // Convert the string to lowercase + + str = str.toLowerCase(); + + boolean A = isPalindrome(str); + + System.out.println(A); + + } + +} diff --git a/style.css b/style.css new file mode 100644 index 0000000..5e00837 --- /dev/null +++ b/style.css @@ -0,0 +1,640 @@ +*{ + margin: 0; + padding: 0; + font-family: 'Noto Serif', serif; +} +.header{ + min-height: 100vh; + width:100% ; + background-image: linear-gradient(rgba(4,9,30,0.7),rgba(4,9,30,0.7)),url(food/background.jpg); +background-position: center; +background-size: cover; +} +nav{ + display: flex; + padding: 2% 6%; + justify-content: space-between; + align-items: center; + font-weight: bold; +} +nav img{ + width: 100px; +} +.nav-links{ + flex:1 ; + text-align: right; +} + +.nav-links ul li{ + list-style:none; +display:inline-block; +padding: 8px 12px; +position: relative; +} +.nav-links ul li a{ + color: azure; + text-decoration: none; + font-size: 13px; + } + + .nav-links ul li::after + { + content: ''; + width: 0%; + height: 2px; + background: #263063; + display: block; + margin: auto; + transition: 1.5s; + } + .nav-links ul li:hover::after + { + width: 100%; + } + + .text-box{ + width: 90%; + color: #ccc; + position: absolute; + top:43%; + left: 50%; + transform: translate(-50%,-50%); + text-align: center; + } +.text-box h1{ + font-size: 62px; +} +.text-box p{ + margin: 10px 0 40px; + font-size: 14px; + color: whitesmoke; +} +.hero-btn{ + display: inline-block; + text-decoration: none; + border: 1px solid #7f5e8f; + color: #f9f9f9; + padding: 12px 34px; + font-size: 13px; + background: transparent; + position: relative; + cursor: pointer; +} +.hero-btn:hover{ + background: rgb(26, 26, 110); + border:1px solid rgba(4,9,30,0.7);; + transition: 1s; +} +h2{ + color: #eee7e7; +} + + .Hot_Sale{ + display: flex; + width: auto; + height: 360px; + background-color: rgba(4,9,30,0.7); + position: relative; + top: 280px; + justify-content: space-around; + } + + .burger{ + background-image: url(food/burger.jpg); + background-size: 300px 300px; + background-repeat: no-repeat; + background-position: center; + width: 300px; + height: 300px; + } + + .Pizza{ + background-image: url(food/pizza.jpg); + background-size: 300px 300px; + background-repeat: no-repeat; + background-position: center; + width: 300px; + height: 300px; + + } + + .burger2{ + background-image: url(food/burger\ 2.jpg); + background-size: 300px 300px; + background-repeat: no-repeat; + background-position: center; + width: 300px; + height: 300px; + + } + .Cateogry{ + position: relative; + background-color: White; + top: 50px; + color: Black; + width: 300px; + height: 300px; + border: 1px solid white; + } + + .Hidden{ + position: relative; + + bottom: 100px; + display: none; + padding-left: 5px; + width: auto; + height: 100px; + font-family: 'Times New Roman'; + background: linear-gradient(360deg, rgba(4,9,30,0.7),rgba(4,9,30,0.7)); + } + + .burger:hover + .Hidden{ + display: flex; + color: black; + } + + .Hidden2{ + position: relative; + bottom: 100px; + font-family: 'Times New Roman', Times, serif; + display: none; + padding-left: 5px; + width: auto; + height: 100px; + background: linear-gradient(360deg, rgba(4,9,30,0.7),rgba(4,9,30,0.7)); + } + + .Pizza:hover + .Hidden2{ + display: flex; + color: black; + } + + .Hidden3{ + position: relative; + bottom: 100px; + display: none; + padding-left: 5px; + width: auto; + height: 100px; + background: linear-gradient(360deg, rgba(4,9,30,0.7),rgba(4,9,30,0.7)); + } + + .burger2:hover + .Hidden3{ + display: flex; + color: black; + } + + + + +.doggy img{ + width: 120px; height: 190px; + position: absolute; + left: 160px; + top: 560%; + animation-name: doggy; + animation-duration: s; + animation-timing-function: linear; + animation-iteration-count: 0; +} + +@keyframes doggy{ + + 0%{left: 70px} + 100%{ left: 700% } +} + + +/*food*/ +.food +{ + width: 80%; + margin: auto; + text-align: center; + padding-top:290px ; +} +h1{ + color: #ccc; + font-size: 36px; + font-weight: 600; +} +p{ + color: #ccc; + font-size: 14px; + font-weight: 300; + line-height: 22px; + padding: 10px; +} + +.row +{ + margin-top: 1%; + display: flex; + justify-content: space-between; +} +.food-col{ + flex-basis: 32%; + background: rgba(24, 41, 112, 0.7); + border-radius: 10px; + margin-bottom: 5%; + padding: 20px 12px; + box-sizing: border-box; +} + +h3{ + text-align: center; + color: #ccc; + font-weight:600 ; + margin: 10px 0; +} +.food-col:hover +{ + box-shadow: 0 0 20px 0px rgba(29, 63, 114, 0.4); +} +@media(max-width:700px){ +.row +{ + flex-direction:column; +} +} + + +/*Locations*/ +.location{ + width: 80%; + margin: auto; + text-align: center; + padding-top: 1waq0px; +} +.location-col{ + flex-basis: 32%; + border-radius: 10px; + margin-bottom:30px ; + position: relative; + overflow:hidden; +} + +.location-col img { + width: 100%; +} +.layer +{ + background: transparent; + height: 100%; + width:100%; + position: absolute; + top: 0; + left:0; + transition: 0.5s; + +} + +.layer:hover{ + + background:rgba(110, 83, 83, 0.7); +} + +.layer h3{ + color: #eee7e7; + bottom: 0; + left: 50%; + position: absolute; + width: 100%; + font-weight: 500; + font-size:26px; + transform: translateX(-50%); + opacity: 0; + transition: 0.5s; + +} +.layer:hover h3{ + bottom: 49%; + opacity: 1; +} + +/* menu*/ + +.menu{ + width: 80%; + margin:auto; + text-align: center; + padding-top: 5px; +} +.menu-col{ + flex-basis:31%; +border-radius: 10px; +margin-bottom:5%; +position: relative; + overflow:hidden; +} +.menu-col img{ + width: 100%; + border-radius: 10px; +} +.menu-col p{ + padding: 0; +} +.menu-col h3{ + margin-top: 16px; + margin-bottom: 15px; + text-align: left; +} +.testimonials{ + width: 92%; + margin: auto; + padding-top: 1px; + text-align: center; +} +.testimonials-col{ + flex-basis: 44%; + border-radius: 12px; + margin-bottom:5% ; + text-align: left; + background: #5b5269; + padding: 25px; + cursor: pointer; + display: flex; +} +.testimonials-col img +{ + height: 40px; + margin-left: 2px; + margin-right: 30px; + border-radius: 50%; +} + +.testimonials-col p{ + margin-top: 15px; +} + +.cta{ + margin:100px auto ; + width:80% ; + top: 80px; + background-image: linear-gradient(rgba(0,0,0,0.7),rgba(0,0,0,0.7)),url(images/banner2.jpg); + background-position:center ; + background-size: cover; + border-radius: 10px; + text-align: center ; + padding: 100px 0; +} +.cta h1{ + color: #fff; + margin-bottom: 40px; + padding: 0; +} +@media(max-width:700px){ + .cta h1{ + font-size: 24px; + } +} + + +.footer{ + width: 100%; + text-align: center; + padding: 30px 0; +} +.footer h4{ + margin-bottom: 25px; + margin-top: 20px; + font-weight: 600; +} +.icons .fa{ + color: #f44336; + margin: 0 13px; + cursor: pointer; + padding: 18px 0; +} +.fa-heart-o{ + color: #f44336; +} + + .signupbtn { + float: left; + width: 50%; + background-color: #04AA6D; + color: white; + padding: 10px 10px; + margin: 1px 0; + border: none; + cursor: pointer; + width: 100%; + opacity: 0.9; + } + .signupbtn:hover { + opacity: 2; + } + .azna2 { + height: 400px; + width: 650px; + padding-top: 20px; + background-color: maroon; + border-style: double; + border-color: white; + margin-right: 90px; + /* padding-left: 20px; */ + /* margin-left: 50px; + margin-top: 5px; */ + /* justify-content: space-between; */ + } + + +#azna-6 input[type="text"], +#azna-6 input[type="email"] +{ + width: 100%; + border: 1px solid #ccc; + background: #fff; + margin: 0 0 5px; + padding: 10px; + border-radius: 25px; +} + +#azna-6 input[type="text"]:hover, +#azna-6 input[type="email"]:hover +{ + transition: border-color 0.3s ease-in-out; + border: 1px solid #8a8989; +} + +#azna-6 button[type="submit"] { + cursor: pointer; + width: 100%; + border: none; + background: #6b188b; + color: #fff; + margin: 0 0 5px; + padding: 10px; + font-size: 15px; + margin-top: 10px; +} + +#azna-6 button[type="submit"]:hover { + background: #752196; +} +#azna-6 button[type="submit"]:active { + box-shadow: inset 0 1px 3px rgba(0, 0, 0, 0.5); +} +#azna-6 input:focus +{ + outline: 0; + border: 1px solid #aaa; +} + +.aznafooter +{ + background-color: orange; + text-align: center; + margin-top: 1px; +} + + +.azna-1 { + width: 100%; + height: auto; + overflow: hidden; + } + + .azna-2 { + width: 500px; + height: 300px; + float: left; + margin-left: 10px; + } + + .azna-2 img { + width: 250px; + height: 250px; + position: absolute; + left: 100px; + } + + .azna-3 { + width: 300px; + height: 300px; + margin-left: 270px; + margin-top: 30px; + } + + .azna-3 img { + width: 20px; + height: 20px; + position: relative; + left: -215px; + } + + .azna-5 { + float: right; + width: 350px; + margin-bottom:80px; + margin-right: 200px; + } + + .azna-5 h2 { + margin-bottom: 10px; + margin-left: 70px; + } + + #azna-6 { + background: #f9f9f9; + padding: 25px; + margin: 50px 0; + border-radius: 20px; + margin-bottom: 5px; + box-shadow: 0 0 20px 0 rgba(0, 0, 0, 0.2), 0 5px 5px 0 ; + } + + fieldset { + border: medium none !important; + margin: 0 0 10px; + min-width: 100%; + padding: 0; + width: 100%; + } + + #azna-6 input[type="text"], + #azna-6 input[type="email"] + { + width: 100%; + border: 1px solid #ccc; + background: #fff; + margin: 0 0 5px; + padding: 10px; + border-radius: 25px; + } + + #azna-6 input[type="text"]:hover, + #azna-6 input[type="email"]:hover + { + transition: border-color 0.3s ease-in-out; + border: 1px solid #8a8989; + } + + #azna-6 button[type="submit"] { + cursor: pointer; + width: 100%; + border: none; + background: #4e2177; + color: lightgray; + margin: 0 0 5px; + padding: 10px; + font-size: 15px; + margin-top: 10px; + } + + #azna-6 button[type="submit"]:hover { + background: #752196; + } + #azna-6 button[type="submit"]:active { + box-shadow: inset 0 1px 3px rgba(0, 0, 0, 0.5); + } + #azna-6 input:focus + { + outline: 0; + border: 1px solid #aaa; + } + + .aznafooter + { + background-color: #7f5e8f; + text-align: center; + margin-top: 1px; + } + +nav .fa{ + display: none ; +} + @media screen and (max-width: 400px) + { + .text-box h1{ + font-size: 20px; + } + .nav-links ul { + display: block; + } + .nav-links{ + position: absolute; + height: 100vh; + width: 200px; + top: 0; + right: -200px; + text-align: left; + z-index: 2; + transition: 1s; + } + .nav .fa{ + display: block; + color: #fff; + margin: 10px; + font-size: 22px; + cursor:pointer; + } + .nav-links ul { + padding: 30px; + } + + } + + \ No newline at end of file diff --git a/subscribe.java b/subscribe.java new file mode 100644 index 0000000..8484c95 --- /dev/null +++ b/subscribe.java @@ -0,0 +1,204 @@ +// import java.util.Scanner; +// public class subscribe{ +// public static void main(String[] args){ + +// int age; +// System.out.println("Enter your age"); +// Scanner sc =new Scanner(System.in); +// age = sc.nextInt(); +// // if(age>56){ +// // System.out.println("you are experienced"); +// // } +// // else if(age>46){ +// // System.out.println("You are semi experienced"); +// // } +// // else{ +// // System.out.println("you are not experienced"); +// // } +// switch(age){ +// case 18: +// System.out.println("you are going to be an adult"); +// break; +// case 23: +// System.out.println("you are going to be young"); +// break; +// case 60: +// System.out.println("you are going to be old"); +// break; +// default: +// System.out.println("enjoy life"); +// break; +// } +// } +// } +// import java.util.Scanner; +// public class subscribe{ +// public static void main(String[] args){ +// int x=2; +// int y; +// System.out.println("Enter value of y:"); +// Scanner sc = new Scanner(System.in); +// y = sc.nextInt(); +// switch(y){ +// case 0 : +// System.out.println('1'); +// break; +// case 1 : +// System.out.println(x); +// break; +// case 2 : +// System.out.println( x * x); +// break; +// case 3 : +// System.out.println( x * x * x ); +// break; +// case 4 : +// System.out.println( x * x * x * x); +// break; +// default : +// System.out.println("No match exists."); +// } +// } +// } +// import java.util.Scanner; +// public class subscribe{ +// char LetterGrade; +// public static void main(String[] args){ +// System.out.println("Enter lettergrade"); +// Scanner sc = new Scanner(System.in); +// char LetterGrade = sc.next().charAt(0); +// switch (LetterGrade) { +// case 'a' : +// case 'A' : System.out.print( "Excellent"); +// break; +// case 'b' : +// case 'B' : System.out.print("Superior"); +// break; +// case 'C' : +// case 'c' : System.out.print("Average"); +// break; case 'd' : +// case 'D' : System.out.print(" Poor"); +// break; +// case 'f' : +// case 'F' : System.out.print( " Try again"); +// break; +// default : System.out.print("This is not a recognized letter grade."); +// } +// } +// } +// import java.util.Scanner; +// public class subscribe{ +// public static void main(String[] args){ +// char What; +// System.out.println("Enter lettergrade"); +// Scanner sc = new Scanner(System.in); +// What = sc.next().charAt(0); +// switch (What) { +// case 'c' : +// case 'C' : System.out.print(" Bobo "); +// case 'y' : +// case 'P' : System.out.print(" Is a Dog "); +// break; +// case 'x' : +// case 'X' : System.out.print(" Try But "); +// case 'z' : +// case 'Z' : System.out.print(" Cannot"); +// default : System.out.print(" Help You."); +// } +// } +// } +// import java.util.Scanner; +// public class subscribe{ +// public static void main(String[] args){ +// int Year; +// System.out.println("Enter your age"); +// Scanner sc =new Scanner(System.in); +// Year = sc.nextInt(); +// // if (Year == 1) +// // System.out.print(" Freshman "); else if (Year == 2) +// // System.out.print(" Sophomore "); +// // else if (Year == 3) +// // System.out.print(" Junior "); +// // else if (Year == 4) +// // System.out.print(" Senior "); +// // else +// // System.out.print(" Graduate "); +// switch(Year){ +// case 1: +// System.out.println("Freshman"); +// break; +// case 2: +// System.out.println("Sophomore"); +// break; +// case 3: +// System.out.println("Junior"); +// break; +// case 4: +// System.out.println("Senior"); +// break; +// default: +// System.out.println("Graduate"); +// } +// } +// } +// import java.util.Scanner; +// public class subscribe{ +// static void gp(int a,int r,int n){ +// int current_term; +// for(int i=0;i +using namespace std; + +int main() +{ + int n,i,sum=0; + cout<<"the value of n is : "; + cin>>n; + for(i=1;i<=n;i++) + { + sum+=i; + } + cout<<"sum="< j) { + System.out.println(count); + return 0; + + } else { + count=count+i; + i++; + f(i,j,count); + + } + + return 0; + } + + + + public static void main(String[] args){ + Scanner sc= new Scanner(System.in); + int inp = sc.nextInt(); + int i = 0; int j=inp; + int count = 0; + f(i,j,count); + + } +} diff --git a/swapoftwonumber.java b/swapoftwonumber.java new file mode 100644 index 0000000..ff675de --- /dev/null +++ b/swapoftwonumber.java @@ -0,0 +1,24 @@ +public class SwapNumbers { + + public static void main(String[] args) { + + float first = 1.20f, second = 2.45f; + + System.out.println("--Before swap--"); + System.out.println("First number = " + first); + System.out.println("Second number = " + second); + + // Value of first is assigned to temporary + float temporary = first; + + // Value of second is assigned to first + first = second; + + // Value of temporary (which contains the initial value of first) is assigned to second + second = temporary; + + System.out.println("--After swap--"); + System.out.println("First number = " + first); + System.out.println("Second number = " + second); + } +} diff --git a/time.java b/time.java new file mode 100644 index 0000000..c8bbe69 --- /dev/null +++ b/time.java @@ -0,0 +1,9 @@ +// Calculate milliseconds in a year +const minute = 1000 * 60; +const hour = minute * 60; +const day = hour * 24; +const year = day * 365; + +// Divide Time with a year +const d = new Date(); +let years = Math.round(d.getTime() / year); \ No newline at end of file diff --git a/towerofhanoi.java b/towerofhanoi.java new file mode 100644 index 0000000..636d3a5 --- /dev/null +++ b/towerofhanoi.java @@ -0,0 +1,26 @@ +import java.util.Scanner; +public class TowersofHanoi { + public static final String SOURCE_PEG = "Source"; + public static final String TARGET_PEG = "Target"; + public static final String SPARE_PEG = "Spare"; + + public static void main(String[] args) { + Scanner scanner = new Scanner(System.in); + System.out.println("Please enter number of discs:"); + int numberOfDiscs = scanner.nextInt(); + solveTowersOfHanoi(numberOfDiscs, SOURCE_PEG, TARGET_PEG, SPARE_PEG); + scanner.close(); + } + + + private static void solveTowersOfHanoi(int numberOfDiscs, String sourcePeg, String targetPeg, String sparePeg) { + if (numberOfDiscs == 1) { + System.out.println(sourcePeg + " => " + targetPeg); + } else { + solveTowersOfHanoi(numberOfDiscs - 1, sourcePeg, sparePeg, targetPeg); + System.out.println(sourcePeg + " => " + targetPeg); + solveTowersOfHanoi(numberOfDiscs - 1, sparePeg, targetPeg, sourcePeg); + } + + } +} \ No newline at end of file diff --git a/transpose.java b/transpose.java new file mode 100644 index 0000000..d86ccf1 --- /dev/null +++ b/transpose.java @@ -0,0 +1,31 @@ +public class Transpose { + + public static void main(String[] args) { + int row = 2, column = 3; + int[][] matrix = { {2, 3, 4}, {5, 6, 4} }; + + // Display current matrix + display(matrix); + + // Transpose the matrix + int[][] transpose = new int[column][row]; + for(int i = 0; i < row; i++) { + for (int j = 0; j < column; j++) { + transpose[j][i] = matrix[i][j]; + } + } + + // Display transposed matrix + display(transpose); + } + + public static void display(int[][] matrix) { + System.out.println("The matrix is: "); + for(int[] row : matrix) { + for (int column : row) { + System.out.print(column + " "); + } + System.out.println(); + } + } +} diff --git a/trapping_rainwater.java b/trapping_rainwater.java new file mode 100644 index 0000000..efca76c --- /dev/null +++ b/trapping_rainwater.java @@ -0,0 +1,40 @@ +class Test { + static int arr[] + = new int[] { 0, 1, 0, 2, 1, 0, 1, 3, 2, 1, 2, 1 }; + + + static int findWater(int n) + { + + int left[] = new int[n]; + + + int right[] = new int[n]; + + + int water = 0; + + + left[0] = arr[0]; + for (int i = 1; i < n; i++) + left[i] = Math.max(left[i - 1], arr[i]); + + + right[n - 1] = arr[n - 1]; + for (int i = n - 2; i >= 0; i--) + right[i] = Math.max(right[i + 1], arr[i]); + + + for (int i = 0; i < n; i++) + water += Math.min(left[i], right[i]) - arr[i]; + + return water; + } + + + public static void main(String[] args) + { + + System.out.println(findWater(arr.length)); + } +} \ No newline at end of file diff --git a/triangle.py b/triangle.py new file mode 100644 index 0000000..5ba10fd --- /dev/null +++ b/triangle.py @@ -0,0 +1,6 @@ +rows = int(input("Enter number of rows: ")) + +for i in range(rows): + for j in range(i+1): + print(j+1, end=" ") + print("\n") \ No newline at end of file diff --git a/tsp.java b/tsp.java new file mode 100644 index 0000000..619c58c --- /dev/null +++ b/tsp.java @@ -0,0 +1,73 @@ +// import required classes and packages +import Java.util.*; +import java.io.*; +import java.util.Scanner; + +// create TSPExample class to implement TSP code in Java +class TSPExample +{ + // create findHamiltonianCycle() method to get minimum weighted cycle + static int findHamiltonianCycle(int[][] distance, boolean[] visitCity, int currPos, int cities, int count, int cost, int hamiltonianCycle) + { + + if (count == cities && distance[currPos][0] > 0) + { + hamiltonianCycle = Math.min(hamiltonianCycle, cost + distance[currPos][0]); + return hamiltonianCycle; + } + + // BACKTRACKING STEP + for (int i = 0; i < cities; i++) + { + if (visitCity[i] == false && distance[currPos][i] > 0) + { + + // Mark as visited + visitCity[i] = true; + hamiltonianCycle = findHamiltonianCycle(distance, visitCity, i, cities, count + 1, cost + distance[currPos][i], hamiltonianCycle); + + // Mark ith node as unvisited + visitCity[i] = false; + } + } + return hamiltonianCycle; + } + + // main() method start + public static void main(String[] args) + { + int cities; + + //create scanner class object to get input from user + Scanner sc = new Scanner(System.in); + + // get total number of cities from the user + System.out.println("Enter total number of cities "); + cities = sc.nextInt(); + + + //get distance of cities from the user + int distance[][] = new int[cities][cities]; + for( int i = 0; i < cities; i++){ + for( int j = 0; j < cities; j++){ + System.out.println("Distance from city"+ (i+1) +" to city"+ (j+1) +": "); + distance[i][j] = sc.nextInt(); + } + } + + // create an array of type boolean to check if a node has been visited or not + boolean[] visitCity = new boolean[cities]; + + // by default, we make the first city visited + visitCity[0] = true; + + + int hamiltonianCycle = Integer.MAX_VALUE; + + // call findHamiltonianCycle() method that returns the minimum weight Hamiltonian Cycle + hamiltonianCycle = findHamiltonianCycle(distance, visitCity, 0, cities, 1, 0, hamiltonianCycle); + + // print the minimum weighted Hamiltonian Cycle + System.out.println(hamiltonianCycle); + } +} diff --git a/tut4.html.html b/tut4.html.html new file mode 100644 index 0000000..e69de29 diff --git a/union of arrays.cpp b/union of arrays.cpp new file mode 100644 index 0000000..d152643 --- /dev/null +++ b/union of arrays.cpp @@ -0,0 +1,41 @@ +#include +#include +using namespace std; +void unionofArrays(int arr[],int arr2[], int size, int size1){ + set s; + + + for(int i=0;i::iterator it; + +// print the contents of our set +for (it=s.begin(); it!=s.end(); ++it) + cout << ' ' << *it; +cout << '\n'; + +} +int main(){ + int arr[]={1,2,3,4}; + int arr2[]={3,4,5,6}; + int size=4; + int size1=4; + unionofArrays(arr,arr2,size,size1); + + + return 0; +} diff --git a/user-manual.pdf b/user-manual.pdf new file mode 100644 index 0000000..0d4754f Binary files /dev/null and b/user-manual.pdf differ diff --git a/water_trap.java b/water_trap.java new file mode 100644 index 0000000..74b917f --- /dev/null +++ b/water_trap.java @@ -0,0 +1,35 @@ +public class water_trap { + + static int trap(int[]arr){ + int trapW=0; + + int n=arr.length; + for (int i=0;i=0){ + lm=Math.max(lm,arr[j]); + j--; + } + j=i; + while(j + + WEB DESIGNING + + +

    BLOCK LEVEL

    +

    there are two categories of block level. + block level elements or tags create largest structure then inline elements genrally block level elements may contain inline elements and + other blocks levels elements

    +
    +

    SOME EXAMPLE OF BLOCK LEVEL

    +
      +
    1. heading tag
      2. +
    2. table tag
      3. +
    3. paragraph tag
      4. +
    4. form tag
      5. +
    5. text level
      6. +
    +

    TEXT LEVEL ELEMENTS

    +

    inline elements create smaller srtucture than block level elements genrally inline elements may contain only data + and other inline elements. + inline elements do not begin on new line

    +

    some example of inline elements

    + this tag is in text level +
    + underline tag used in inline tag +
    + italic tag is used in inline tag +
    + small tag is used to small the tha character and it is used in inline tag +
    + big tag is used for big the character and also used in inline tag +
    + a2+b2 +

    this tag is used superscript like a power 2 + b power 2

    +
    + h2o +

    this tag is show subscript command and from above example

    +
    +
    +
    + hello sir + + + \ No newline at end of file diff --git a/webpage.html b/webpage.html new file mode 100644 index 0000000..957aed9 --- /dev/null +++ b/webpage.html @@ -0,0 +1,39 @@ + + + + + + + + PROFILE + + + The image is no longer available + +
    +

    NAME : Arpit Gupta

    +

    INSTA I'D : arpitg913

    +

    LINKEDIN I'D : Arpit gupta

    +
    +

    QUALIFICATIONS

    + + + + + + + + + + + + + + + + +
    CLASSBOARDPERCENTAGE
    XU.P. Board76%
    XIIU.P. Board 73%
    + + + \ No newline at end of file diff --git a/ytviddownloader.py b/ytviddownloader.py new file mode 100644 index 0000000..beab1a4 --- /dev/null +++ b/ytviddownloader.py @@ -0,0 +1,30 @@ +from tkinter import * +from pytube import YouTube + +window = Tk() +window.geometry("600x700") +window.config(bg="red") +window.title("Youtube Video Downloader by Tharuka") + +youtube_logo = PhotoImage(file="yt.png") +window.iconphoto(False, youtube_logo) + +Label(window, text="Video Downloader", font=("Arial 30 bold"), bg="lightgreen").pack(padx=5, pady=50) + +video_link = StringVar() + +Label(window, text="Enter the Link : ", font=("Arial",25,"bold")).place(x=170, y=150) + +Entry_link = Entry(window, width=50, font=35 , textvariable=video_link, bd=4).place(x=60, y=200) + +def video_download(): + video_url = YouTube(str(video_link.get())) + videos = video_url.streams.first() + videos.download() + + Label(window, text="Download Completed !!!", font=("Arial",35,"bold"),bg="lightpink",fg="Black").place(x=60, y=350) + Label(window, text="Check out Download Folder", font=("Arial", 30, "bold"), bg="yellow").place(x=60, y=400) + +Button(window, text=".DOWNLOAD.", font=("Arial", 25, "bold"), bg="lightblue", command=video_download).place(x=180, y=300) + +window.mainloop()