{children}
;
3 | };
4 |
5 | export default CartLayout;
6 |
--------------------------------------------------------------------------------
/React Machine Coding/Stop Watch/Button.js:
--------------------------------------------------------------------------------
1 | export default function Button({ label, buttonHandler }) {
2 | return (
3 |
6 | );
7 | }
8 |
--------------------------------------------------------------------------------
/BigFrontEnd/DSA /Must Do DSA/Fibonacci.js:
--------------------------------------------------------------------------------
1 | function fibonacci(n) {
2 | const fib = [0, 1];
3 | for( let i = 2; i < n; i++){
4 | fib[i] = fib[i - 1] + fib[i - 2];
5 | }
6 | return fib
7 | }
8 |
9 | console.log(fibonacci(5))
--------------------------------------------------------------------------------
/HackerRank/README.md:
--------------------------------------------------------------------------------
1 | Solutions to problems on [HackerRanK](https://www.hackerrank.com/)
2 |
3 |
4 | 
5 |
6 |
7 |
--------------------------------------------------------------------------------
/React Machine Coding/Redux Ecommerce Store/pages/ProductListing.jsx:
--------------------------------------------------------------------------------
1 | import Products from '../components/Products';
2 |
3 | export default function ProductListing() {
4 | return (
5 |
5 |
6 |
8 | );
9 | }
10 |
--------------------------------------------------------------------------------
/BigFrontEnd/DSA /Must Do DSA/Factorial.js:
--------------------------------------------------------------------------------
1 | function factorial(n) {
2 | let result = 1;
3 |
4 | for( let i = 2; i <= n; i++){
5 | result = result * i;
6 | }
7 |
8 | return result;
9 | }
10 |
11 | console.log(factorial(5));
--------------------------------------------------------------------------------
/BigFrontEnd/DSA /0053_Max_SubArray.js:
--------------------------------------------------------------------------------
1 | var maxSubArray = function(nums) {
2 | mx = nums[0]
3 | sm = 0;
4 | nums.forEach((n) => {
5 | sm += n
6 | mx = Math.max(sm, mx);
7 | if(sm < 0) sm = 0;
8 | })
9 | return mx;
10 | };
--------------------------------------------------------------------------------
/LeetCode/389-Find_The_Difference.java:
--------------------------------------------------------------------------------
1 | class Solution {
2 | public char findTheDifference(String s, String t) {
3 | char c = 0;
4 | for(char cs : s.toCharArray()) c ^= cs;
5 | for(char ct : t.toCharArray()) c ^= ct;
6 | return c;
7 | }
8 | }
--------------------------------------------------------------------------------
/React Machine Coding/Product_Cart_Publicis_Sapient/App.js:
--------------------------------------------------------------------------------
1 | import "./styles.css";
2 | import CartPage from "./pages/CartPage";
3 |
4 | export default function App() {
5 | return (
6 |
7 |
9 | );
10 | }
11 |
--------------------------------------------------------------------------------
/React Machine Coding/Product_Cart_Publicis_Sapient/components/atoms/Typography.js:
--------------------------------------------------------------------------------
1 | const Typography = ({ variant = "p", children }) => {
2 | const Tag = variant;
3 | return
8 |
10 | );
11 | }
12 |
--------------------------------------------------------------------------------
/BigFrontEnd/BFE/JS/0023_create_sum.js:
--------------------------------------------------------------------------------
1 | function sum(num, currentSum = 0) {
2 | // your code here
3 | const newCurrentSum = num + currentSum
4 |
5 | const func = (arg) => {
6 | return sum(arg, num + currentSum)
7 | }
8 |
9 | func.valueOf = () => newCurrentSum
10 |
11 | return func
12 | }
--------------------------------------------------------------------------------
/BigFrontEnd/DSA /0141_Linked_List_Cycle.js:
--------------------------------------------------------------------------------
1 |
2 | var hasCycle = function(head) {
3 | let fast = head
4 | let slow = head
5 |
6 | while(fast && fast.next) {
7 | fast = fast.next.next
8 | slow = slow.next
9 |
10 | if (fast === slow) return true
11 | }
12 |
13 | return false
14 | };
--------------------------------------------------------------------------------
/BigFrontEnd/DSA /0206_Reverse_Linked_List.js:
--------------------------------------------------------------------------------
1 | var reverseList = function(head) {
2 | let prev = null
3 | let curr = head;
4 | while(curr){
5 | let next = curr.next;
6 | curr.next = prev;
7 | prev = curr
8 | curr = next;
9 | }
10 | head = prev
11 |
12 | return head
13 | };
--------------------------------------------------------------------------------
/React Machine Coding/Product_Cart_Publicis_Sapient/components/atoms/Button.js:
--------------------------------------------------------------------------------
1 | const Button = ({ children, onClick }) => (
2 |
8 | );
9 |
10 | export default Button;
11 |
--------------------------------------------------------------------------------
/BigFrontEnd/JS Interview Concept Snippets/Event_Delegration.js:
--------------------------------------------------------------------------------
1 | // Event Delegation Example
2 |
3 | const div = document.getElementById("div");
4 |
5 | div.addEventListener("click", (event) => {
6 | const target = event.target;
7 |
8 | if (target.tagName === "BUTTON") {
9 | console.log(target.innerHTML);
10 | }
11 | });
--------------------------------------------------------------------------------
/CodeForces/B-Lovely_Palindromes.java:
--------------------------------------------------------------------------------
1 | import java.util.Scanner;
2 |
3 | public class Main
4 | {
5 | public static void main(String[] args) {
6 | Scanner sc = new Scanner(System.in);
7 | StringBuilder number = new StringBuilder(sc.next());
8 | System.out.println(number.toString()+""+number.reverse());
9 | }
10 | }
--------------------------------------------------------------------------------
/React Machine Coding/Star Rating/style.css:
--------------------------------------------------------------------------------
1 | .App {
2 | font-family: sans-serif;
3 | text-align: center;
4 | }
5 |
6 | .star-rating {
7 | font-size: 24px;
8 | }
9 |
10 | .star {
11 | cursor: pointer;
12 | }
13 |
14 | .star.hover {
15 | color: gold;
16 | }
17 |
18 | .star.active {
19 | color: orange;
20 | }
21 |
--------------------------------------------------------------------------------
/BigFrontEnd/DSA /Must Do DSA/RecursiveFibonacci.js:
--------------------------------------------------------------------------------
1 | function recursiveFibonacci(n) {
2 | if (n < 2) {
3 | return n;
4 | }
5 | return recursiveFibonacci(n - 1) + recursiveFibonacci(n - 2);
6 | }
7 |
8 | console.log(recursiveFibonacci(0));
9 | console.log(recursiveFibonacci(1));
10 | console.log(recursiveFibonacci(4));
--------------------------------------------------------------------------------
/React Machine Coding/OTP Login/styles.css:
--------------------------------------------------------------------------------
1 | /* ----------------------Mobile Login------------------------ */
2 | .mobile__login {
3 | text-align: center;
4 | margin: auto;
5 | }
6 |
7 | .otpInput {
8 | width: 40px;
9 | height: 40px;
10 | margin: 5px;
11 | text-align: center;
12 | font-size: 1.2em;
13 | }
--------------------------------------------------------------------------------
/HackerRank/Problem Solving/102-Drawing_Book.cpp:
--------------------------------------------------------------------------------
1 | #include
10 |
12 | );
13 | }
14 |
--------------------------------------------------------------------------------
/React Machine Coding/Custom Hook/useToggle/useToggle.js:
--------------------------------------------------------------------------------
1 | import { useState } from "react";
2 |
3 | export default function useToggle(defaultValue = false) {
4 | const [value, setValue] = useState(defaultValue);
5 |
6 | function toggleValue(value) {
7 | setValue((currentValue) => {
8 | typeof value === "boolean" ? value : !currentValue;
9 | });
10 | }
11 |
12 | return [value, toggleValue];
13 | }
14 |
--------------------------------------------------------------------------------
/React Machine Coding/Product_Cart_Publicis_Sapient/pages/CartPage.js:
--------------------------------------------------------------------------------
1 | import CartLayout from "../components/templates/CartLayout";
2 | import CartList from "../components/organisms/CartList";
3 |
4 | const CartPage = () => {
5 | return (
6 | Your Cart
8 |LeetCode Problems and Challenges Solutions
2 | 3 | Remember solutions are only solutions to given problems. If you want full study checklist for code & whiteboard interview, please turn to [jwasham's coding-interview-university](https://github.com/jwasham/coding-interview-university). 4 | 5 | 6 |
7 |
--------------------------------------------------------------------------------
/BigFrontEnd/DSA /Interview Exp/MoveZeroes.js:
--------------------------------------------------------------------------------
1 | function moveZeroes(nums) {
2 | let insertPos = 0;
3 |
4 | for (let i = 0; i < nums.length; i++) {
5 | if (nums[i] !== 0) {
6 | nums[insertPos] = nums[i];
7 | insertPos += 1;
8 | }
9 | }
10 |
11 | while (insertPos < nums.length) {
12 | nums[insertPos] = 0;
13 | insertPos += 1;
14 | }
15 |
16 | return nums;
17 | }
18 |
19 | let nums = [0, 1, 2, 3, 0, 1, 2, 3, 5];
20 | console.log(moveZeroes(nums));
--------------------------------------------------------------------------------
/BigFrontEnd/DSA /Interview Exp/NonRepeatingChar.js:
--------------------------------------------------------------------------------
1 | function firstNonRepeatingChar(str) {
2 | const charCounts = new Map();
3 |
4 | for (const char of str) {
5 | charCounts.set(char, (charCounts.get(char) || 0) + 1);
6 | }
7 |
8 | for (const char of str) {
9 | if (charCounts.get(char) === 1) {
10 | return char;
11 | }
12 | }
13 |
14 | return null;
15 | }
16 |
17 | console.log(firstNonRepeatingChar("swiss")); // Output: "w"
18 |
19 |
--------------------------------------------------------------------------------
/Daily Bytes/009-Detect_Capital.java:
--------------------------------------------------------------------------------
1 | class Solution {
2 | public boolean detectCapitalUse(String word) {
3 | int count = 0;
4 |
5 | for(int i = 0; i < word.length(); i++){
6 | if(Character.isUpperCase(word.charAt(i))){
7 | count++;
8 | }
9 | }
10 |
11 | return count == word.length() || count == 0 || count == 1 && Character.isUpperCase(word.charAt(0));
12 |
13 | }
14 | }
--------------------------------------------------------------------------------
/LeetCode/520-Detect_Capital.java:
--------------------------------------------------------------------------------
1 | class Solution {
2 | public boolean detectCapitalUse(String word) {
3 | int count = 0;
4 |
5 | for(int i = 0; i < word.length(); i++){
6 | if(Character.isUpperCase(word.charAt(i))){
7 | count++;
8 | }
9 | }
10 |
11 | return count == word.length() || count == 0 || count == 1 && Character.isUpperCase(word.charAt(0));
12 |
13 | }
14 | }
--------------------------------------------------------------------------------
/Product_Prep_2024/LeetCode/0392_Is_Subsequence.java:
--------------------------------------------------------------------------------
1 | class Solution {
2 | public boolean isSubsequence(String s, String t) {
3 | int sIndex = 0;
4 | int tIndex = 0;
5 |
6 | while(sIndex < s.length() && tIndex < t.length()){
7 | if(s.charAt(sIndex) == t.charAt(tIndex)){
8 | sIndex++;
9 | }
10 |
11 | tIndex++;
12 | }
13 |
14 | return sIndex == s.length();
15 | }
16 | }
--------------------------------------------------------------------------------
/React Machine Coding/JS Machine Coding/Tabs/index.html:
--------------------------------------------------------------------------------
1 |
2 |
3 |
4 |
6 | {products.map((prod) => (
7 |
13 | );
14 | }
15 |
16 | const ProductWrapper = withProductFetch(ProductListing);
17 |
18 | export default ProductWrapper;
19 |
--------------------------------------------------------------------------------
/React Machine Coding/Pop Up/Pop.js:
--------------------------------------------------------------------------------
1 | export default function Pop(props) {
2 | return props.trigger ? (
3 |
8 |
11 | ))}
12 | {prod.name}
9 |{prod.desc}
10 |
4 |
14 | ) : (
15 | ""
16 | );
17 | }
18 |
--------------------------------------------------------------------------------
/HackerRank/Problem Solving/113-Birthday_Cake_Candles.py:
--------------------------------------------------------------------------------
1 | import math
2 | import os
3 | import random
4 | import re
5 | import sys
6 |
7 | # Complete the birthdayCakeCandles function below.
8 | def birthdayCakeCandles(ar,n):
9 | m = max(ar)
10 | count = 0
11 | for i in range(n):
12 | if(ar[i]==m):
13 | count+=1
14 | print (count)
15 |
16 |
17 |
18 | n = int(input())
19 |
20 | ar = list(map(int, input().rstrip().split()))
21 |
22 | birthdayCakeCandles(ar,n)
23 |
--------------------------------------------------------------------------------
/BigFrontEnd/DSA /Must Do DSA/SelectionSort.js:
--------------------------------------------------------------------------------
1 | let nums = [5, 7, 2, 3, 4, 20, 19, 11];
2 |
3 | function selectionSort(arr) {
4 | for (let i = 0; i < arr.length - 1; i++) {
5 | let minIndex = i;
6 | for (let j = i + 1; j < arr.length; j++) {
7 | if (nums[j] < nums[minIndex]) {
8 | minIndex = j;
9 | }
10 | }
11 |
12 | [nums[i], nums[minIndex]] = [nums[minIndex], nums[i]];
13 | }
14 |
15 | return arr;
16 | }
17 |
18 | console.log(selectionSort(nums));
19 |
--------------------------------------------------------------------------------
/LeetCode/066-Plus_One.java:
--------------------------------------------------------------------------------
1 | class Solution {
2 | public int[] plusOne(int[] digits) {
3 | int n = digits.length;
4 |
5 | for(int i = n -1; i >= 0; i--){
6 | if(digits[i] < 9){
7 | digits[i]++;
8 | return digits;
9 | }
10 |
11 | digits[i] = 0;
12 | }
13 |
14 | int[] new_number = new int[n+1];
15 | new_number[0] = 1;
16 | return new_number;
17 | }
18 | }
--------------------------------------------------------------------------------
/React Machine Coding/Custom Hook/useToggle/TogglePage.js:
--------------------------------------------------------------------------------
1 | import useToggle from "./useToggle";
2 |
3 | export default function TogglePage() {
4 | const [value, toggleValue] = useToggle(false);
5 |
6 | return (
7 |
5 |
11 | {props.children}
12 |
13 |
8 |
13 | );
14 | }
15 |
--------------------------------------------------------------------------------
/CodeForces/A-String_Task.cpp:
--------------------------------------------------------------------------------
1 | #include {value.toString()}
9 |
10 |
11 |
12 | Search with Debounce
11 | 12 |
17 |
19 | );
20 | }
21 |
--------------------------------------------------------------------------------
/Geeks For Geeks/DSA 450/002-Finding_Kth_Min_Element.java:
--------------------------------------------------------------------------------
1 | class Solution{
2 | public static int kthSmallest(int[] arr, int l, int r, int k)
3 | {
4 | //Your code here
5 | int n = l - r + 1;
6 |
7 | QueueCounter App
11 |
12 |
13 |
16 |
17 |
18 |
19 |
20 |
21 |
22 |
--------------------------------------------------------------------------------
/LeetCode/189-Rotate_Array.java:
--------------------------------------------------------------------------------
1 | class Solution {
2 | public void rotate(int[] nums, int k) {
3 | k = k % nums.length;
4 | reverse(nums, 0 , nums.length - 1);
5 | reverse(nums, 0 , k - 1);
6 | reverse(nums, k , nums.length - 1);
7 | }
8 |
9 | public void reverse(int[] nums, int start, int end){
10 | while(start < end){
11 | int temp = nums[start];
12 | nums[start] = nums[end];
13 | nums[end] = temp;
14 | start++;
15 | end--;
16 | }
17 | }
18 | }
--------------------------------------------------------------------------------
/Product_Prep_2024/LeetCode/0169_Majority_Element.java:
--------------------------------------------------------------------------------
1 | class Solution {
2 | public int majorityElement(int[] nums) {
3 | Integer candidate = null;
4 | int count = 0;
5 |
6 | for(int num : nums){
7 | if(count == 0){
8 | candidate = num;
9 | }
10 |
11 | if(num == candidate){
12 | count++;
13 | } else{
14 | count--;
15 | }
16 | }
17 |
18 | return candidate;
19 | }
20 | }
21 |
22 | // Boyer-Moore Voting Algorithm
--------------------------------------------------------------------------------
/Geeks For Geeks/Arrays/Searching/101-Linear_Search.cpp:
--------------------------------------------------------------------------------
1 | #include 0
14 |
15 | To-Do APP
10 | 11 | 15 | 16 |
8 |
24 | );
25 | }
26 |
--------------------------------------------------------------------------------
/LeetCode/278-First_Bad_Version.java:
--------------------------------------------------------------------------------
1 | public class Solution extends VersionControl {
2 | public int firstBadVersion(int n) {
3 | int left = 0;
4 | int right = n;
5 |
6 | while(left < right){
7 | int midpoint = left + (right - left)/2;
8 | if(isBadVersion(midpoint)){
9 | right = midpoint;
10 | } else {
11 | left = midpoint + 1;
12 | }
13 | }
14 |
15 | if(left == right && isBadVersion(left)){
16 | return left;
17 | }
18 |
19 | return -1;
20 | }
21 | }
--------------------------------------------------------------------------------
/LeetCode/118-Pascal_Triangle.java:
--------------------------------------------------------------------------------
1 | class Solution {
2 | public List
9 | setTitle(e.target.value)}
13 | />
14 |
22 |
23 |
11 |
19 |
20 |
21 |
22 |
23 |
--------------------------------------------------------------------------------
/LeetCode/283-Move_Zeroes.java:
--------------------------------------------------------------------------------
1 | class Solution {
2 | public void moveZeroes(int[] nums) {
3 | int n = nums.length;
4 |
5 | if(n == 0 || n == 1)
6 | return;
7 |
8 | int left = 0, right = 0;
9 | int temp;
10 |
11 | while(right < n){
12 | if(nums[right] == 0)
13 | ++right;
14 | else{
15 | temp = nums[left];
16 | nums[left] = nums[right];
17 | nums[right] = temp;
18 | ++left;
19 | ++right;
20 | }
21 | }
22 | }
23 | }
--------------------------------------------------------------------------------
/React Machine Coding/Star Rating/App.js:
--------------------------------------------------------------------------------
1 | import { useEffect, useMemo, useRef, useState } from "react";
2 | import StarRating from "./components/StarRating";
3 | import "./styles.css";
4 |
5 | export default function App() {
6 | const [currentRating, setCurrentRating] = useState(0);
7 |
8 | const handleRatingChange = (newRating) => {
9 | setCurrentRating(newRating);
10 | };
11 |
12 | return (
13 | Stopwatch
12 | 00:00:00 13 |
14 |
15 |
16 |
17 |
18 |
14 |
21 | );
22 | }
23 |
--------------------------------------------------------------------------------
/Geeks For Geeks/Arrays/Searching/103-Recursive_Sort.cpp:
--------------------------------------------------------------------------------
1 | #include Hello
15 |
19 |
20 |
22 |
23 | );
24 | }
25 |
--------------------------------------------------------------------------------
/LeetCode/125-Valid_Palindrom.java:
--------------------------------------------------------------------------------
1 | class Solution {
2 | public boolean isPalindrome(String s) {
3 |
4 | int st = 0, en = s.length() - 1;
5 |
6 | while(st <= en){
7 | while(st < en && !Character.isLetterOrDigit(s.charAt(st)))
8 | st++;
9 | while(st < en && !Character.isLetterOrDigit(s.charAt(en)))
10 | en--;
11 | if(st < en && Character.toLowerCase(s.charAt(st)) != Character.toLowerCase(s.charAt(en)))
12 | return false;
13 |
14 | st++;
15 | en--;
16 | }
17 | return true;
18 | }
19 | }
--------------------------------------------------------------------------------
/LeetCode/203-Remove_Linked_List_Elements.java:
--------------------------------------------------------------------------------
1 | class Solution {
2 | public ListNode removeElements(ListNode head, int val) {
3 | while(head != null && head.val == val){
4 | head = head.next;
5 | }
6 |
7 | ListNode current_node = head;
8 |
9 | while(current_node != null && current_node.next != null){
10 | if(current_node.next.val == val ){
11 | current_node.next = current_node.next.next;
12 | }
13 | else{
14 | current_node = current_node.next;
15 | }
16 | }
17 |
18 | return head;
19 | }
20 | }
--------------------------------------------------------------------------------
/Product_Prep_2024/LeetCode/0167_Two_Sum_II_Input_Array_Sorted.java:
--------------------------------------------------------------------------------
1 | class Solution {
2 | public int[] twoSum(int[] numbers, int target) {
3 | int left = 0;
4 | int right = numbers.length - 1;
5 |
6 | while(left < right){
7 | int sum = numbers[left] + numbers[right];
8 |
9 | if(sum == target){
10 | return new int[]{left+1, right+1};
11 | }
12 |
13 | if(sum < target){
14 | left++;
15 | }else{
16 | right--;
17 | }
18 |
19 |
20 | }
21 |
22 | return new int[]{-1,-1};
23 | }
24 | }
--------------------------------------------------------------------------------
/React Machine Coding/BreadCrumb Menu/styles.css:
--------------------------------------------------------------------------------
1 | .App {
2 | font-family: sans-serif;
3 | padding: 0 20px;
4 | }
5 |
6 | .prod-grid {
7 | display: grid;
8 | grid-template-columns: 1fr 1fr 1fr;
9 | grid-gap: 20px;
10 | text-align: center;
11 | }
12 |
13 | .prod-card a {
14 | text-decoration: none;
15 | color: #333;
16 | }
17 |
18 | .prod-card img {
19 | width: 100%;
20 | height: 250px;
21 | object-fit: contain;
22 | max-height: 200px;
23 | }
24 |
25 | .bread-crumbs a {
26 | text-decoration: none;
27 | color: #111;
28 | font-weight: 600;
29 | }
30 |
31 | .bread-crumbs span {
32 | color: #333;
33 | }
34 |
--------------------------------------------------------------------------------
/Daily Bytes/002-Valid_Palindrome.java:
--------------------------------------------------------------------------------
1 | class Solution {
2 | public boolean isPalindrome(String s) {
3 |
4 | int st = 0, en = s.length() - 1;
5 |
6 | while(st <= en){
7 | while(st < en && !Character.isLetterOrDigit(s.charAt(st)))
8 | st++;
9 | while(st < en && !Character.isLetterOrDigit(s.charAt(en)))
10 | en--;
11 | if(st < en && Character.toLowerCase(s.charAt(st)) != Character.toLowerCase(s.charAt(en)))
12 | return false;
13 |
14 | st++;
15 | en--;
16 | }
17 | return true;
18 |
19 | }
20 | }
--------------------------------------------------------------------------------
/LeetCode/116-Populating_Next_Right_Pointers_in_Each_Node.java:
--------------------------------------------------------------------------------
1 | class Solution {
2 | public Node connect(Node root) {
3 | if(root == null) return root;
4 |
5 | Node leftNode = root;
6 |
7 | while(leftNode.left != null){
8 | Node head = leftNode;
9 | while(head!=null){
10 | head.left.next = head.right;
11 | if(head.next != null){
12 | head.right.next = head.next.left;
13 | }
14 | head = head.next;
15 | }
16 | leftNode = leftNode.left;
17 | }
18 | return root;
19 | }
20 | }
--------------------------------------------------------------------------------
/BigFrontEnd/DSA /102_Binary_Tree_Level_Order_Traversal.js:
--------------------------------------------------------------------------------
1 | var levelOrder = function(root) {
2 | if (root === null) return []
3 |
4 | let res = []
5 | let queue = [root]
6 |
7 | while(queue.length) {
8 | let levelArr = []
9 | let levelSize = queue.length
10 |
11 | while (levelSize) {
12 | let current = queue.shift()
13 |
14 | if(current.left) queue.push(current.left)
15 | if(current.right) queue.push(current.right)
16 |
17 | levelArr.push(current.val)
18 | levelSize--
19 | }
20 |
21 | res.push(levelArr)
22 | }
23 |
24 | return res
25 | };
--------------------------------------------------------------------------------
/React Machine Coding/Progress Bar/style.css:
--------------------------------------------------------------------------------
1 | /* ----------------Progress Bar ----------------- */
2 |
3 | .progress {
4 | height: 20px;
5 | width: 500px;
6 | background-color: rgb(233, 236, 239);
7 | border: 1px solid black;
8 | border-radius: 15px;
9 | overflow: hidden;
10 | position: relative;
11 | }
12 |
13 | .progress span {
14 | position: absolute;
15 | width: 100%;
16 | display: flex;
17 | flex-direction: column;
18 | align-items: center;
19 | }
20 |
21 | .progress .color {
22 | height: 100%;
23 | /* width: 20%; */
24 | background-color: rgb(131, 207, 17);
25 | z-index: 5;
26 | }
--------------------------------------------------------------------------------
/HackerRank/JAVA/JavaLoopsII.java:
--------------------------------------------------------------------------------
1 | import java.util.*;
2 | import java.io.*;
3 |
4 | class Solution{
5 | public static void main(String []argh){
6 | Scanner in = new Scanner(System.in);
7 | int t=in.nextInt();
8 | for(int i=0;i
8 |
15 | );
16 | };
17 |
18 | export default ProductCard;
19 |
--------------------------------------------------------------------------------
/React Machine Coding/useContext/ThemeToggler.js:
--------------------------------------------------------------------------------
1 | import React, { useContext } from "react";
2 | import { ThemeContext } from "./ThemeContext";
3 |
4 | const ThemeToggler = () => {
5 | const { theme, toggleTheme } = useContext(ThemeContext);
6 |
7 | return (
8 |
10 | {product.title}
11 | ${product.price}
12 |
13 |
14 |
16 |
21 | );
22 | };
23 |
24 | export default ThemeToggler;
25 |
--------------------------------------------------------------------------------
/LeetCode/142-Linked_List_Cycle_II.java:
--------------------------------------------------------------------------------
1 | public class Solution {
2 | public ListNode detectCycle(ListNode head) {
3 | if(head == null || head.next == null)
4 | return null;
5 |
6 | ListNode slow = head;
7 | ListNode fast = head;
8 | ListNode entry = head;
9 |
10 | while(fast.next!=null && fast.next.next != null){
11 | slow = slow.next;
12 | fast = fast.next.next;
13 | if(slow == fast ){
14 | while(slow != entry){
15 | slow = slow.next;
16 | fast = fast.next;
17 | }
18 | return entry;
19 | }
20 | }
21 | return null;
22 | }
23 | }
--------------------------------------------------------------------------------
/CodeForces/A-Way_Too_Long_Words.java:
--------------------------------------------------------------------------------
1 | import java.util.Scanner;
2 |
3 | public class Way{
4 | public static void main(String[] args){
5 | Scanner sc = new Scanner(System.in);
6 | int n = sc.nextInt();
7 | sc.nextLine();
8 |
9 | int i;
10 | String[] arr = new String[n];
11 |
12 | for(i = 0 ; i < n ; i++){
13 | arr[i] = sc.nextLine();
14 | }
15 |
16 | for(i= 0 ; i < n ; i++){
17 | if(arr[i].length()>10){
18 | System.out.println(arr[i].charAt(0)+""+(arr[i].length()-2)+""+arr[i].charAt(arr[i].length()-1));
19 | }
20 | else
21 | System.out.println(arr[i]);
22 | }
23 | }
24 | }
--------------------------------------------------------------------------------
/Geeks For Geeks/DSA 450/004-Move_all_negative_elements_end.java:
--------------------------------------------------------------------------------
1 |
2 |
3 | //User function Template for Java
4 |
5 | class Solution {
6 |
7 | public void segregateElements(int arr[], int n)
8 | {
9 | // Your code goes here
10 | int a[] = new int[n];
11 | int k = 0;
12 | for(int i = 0; i < n ; i++){
13 | if(arr[i] >= 0){
14 | a[k] = arr[i];
15 | k++;
16 | }
17 | }
18 | for(int i = 0; i < n; i++){
19 | if(arr[i] < 0){
20 | a[k] = arr[i];
21 | k++;
22 | }
23 | }
24 | for(int i = 0; i < n; i++){
25 | arr[i] = a[i];
26 | }
27 | }
28 | }
--------------------------------------------------------------------------------
/LeetCode/067-Add_Binary.java:
--------------------------------------------------------------------------------
1 | class Solution {
2 | public String addBinary(String a, String b) {
3 | StringBuilder sb = new StringBuilder();
4 | int i = a.length() - 1;
5 | int j = b.length() - 1;
6 | int carry = 0;
7 |
8 | while(i >= 0 || j >= 0){
9 | int sum = carry;
10 | if(i >= 0){
11 | sum += a.charAt(i--) - '0';
12 | }
13 | if(j >= 0){
14 | sum += b.charAt(j--) - '0';
15 | }
16 |
17 | sb.insert(0, sum % 2);
18 | carry = sum / 2;
19 | }
20 |
21 | if(carry > 0){
22 | sb.insert(0, 1);
23 | }
24 | return sb.toString();
25 | }
26 | }
--------------------------------------------------------------------------------
/Daily Bytes/005-Add_Binary.java:
--------------------------------------------------------------------------------
1 | class Solution {
2 | public String addBinary(String a, String b) {
3 | StringBuilder sb = new StringBuilder();
4 | int i = a.length() - 1;
5 | int j = b.length() - 1;
6 | int carry = 0;
7 |
8 | while(i >= 0 || j >= 0){
9 | int sum = carry;
10 | if(i >= 0){
11 | sum += a.charAt(i--) - '0';
12 | }
13 | if(j >= 0){
14 | sum += b.charAt(j--) - '0';
15 | }
16 |
17 | sb.insert(0, sum % 2);
18 | carry = sum / 2;
19 | }
20 |
21 | if(carry > 0){
22 | sb.insert(0, 1);
23 | }
24 | return sb.toString();
25 | }
26 | }
--------------------------------------------------------------------------------
/LeetCode/349-Intersection_Of_Two_Arrays.java:
--------------------------------------------------------------------------------
1 | class Solution {
2 | public int[] intersection(int[] nums1, int[] nums2) {
3 | HashSet17 | The current theme is {theme}. 18 |
19 | 20 |
11 |
24 | );
25 | } else {
26 | return setExpand(!expand)} style={{ cursor: "pointer" }}>
12 | 🗂️ {explorer.name}
13 |
14 | {expand && (
15 |
16 | {explorer.items.map((exp) => (
17 |
22 | )}
23 |
18 |
20 | ))}
21 | 📒 {explorer.name}
;
27 | }
28 | }
29 |
--------------------------------------------------------------------------------
/Geeks For Geeks/Arrays/Rotation/101-Array_Rotation.cpp:
--------------------------------------------------------------------------------
1 | #include
18 | {product ? (
19 |
28 | );
29 | }
30 |
--------------------------------------------------------------------------------
/HackerRank/Problem Solving/105-Utopian_Tree.cpp:
--------------------------------------------------------------------------------
1 | #include
20 | 
21 |
24 | ) : (
25 | {product.description}
22 |{product.price}
23 |Loading...
26 | )} 27 |Week 2
2 | 3 | ### [Bubble Sort an Array](https://www.geeksforgeeks.org/bubble-sort/) 4 | 5 | ### [Selection Sort in an Array](https://www.geeksforgeeks.org/selection-sort/) 6 | 7 | 8 | ### [Insertion Sort in an Array](https://www.geeksforgeeks.org/insertion-sort/) 9 | 10 | ### [Merge Sort in An Array](https://www.geeksforgeeks.org/merge-sort/) 11 | 12 | ### [Quick Sort in an Array.](https://www.geeksforgeeks.org/quick-sort/) 13 | 14 | ### [Sorting of array consisting of Element 0s,1s,2s only](https://www.geeksforgeeks.org/sort-an-array-of-0s-1s-and-2s/) 15 | 16 | 17 | 18 | Medium 19 | Given an array which consists of 0,1 and 2 only. Sort the array wwithout any sorting algo. 20 | Move all the negative elements to one side of the array. 21 | Find the union and intersection of two sorted arrays. -------------------------------------------------------------------------------- /React Machine Coding/Custom Hook/useFetch/App.js: -------------------------------------------------------------------------------- 1 | import { useEffect, useState } from "react"; 2 | import useFetch from "./hooks/useFetch"; 3 | import "./styles.css"; 4 | 5 | export default function App() { 6 | const { data, loading, error } = useFetch("https://dummyjson.com/products"); 7 | 8 | if (loading) { 9 | returnloading...
; 10 | } 11 | 12 | if (error) { 13 | returnAn error occured : {error}
; 14 | } 15 | 16 | console.log(data); 17 | 18 | return ( 19 |
20 |
31 | );
32 | }
33 |
--------------------------------------------------------------------------------
/React Machine Coding/Custom Hook/useDebounce/App.js:
--------------------------------------------------------------------------------
1 | import { useEffect, useState } from "react";
2 | import useDebounce from "./hooks/useDebounce";
3 | import useFetch from "./hooks/useFetch";
4 | import "./styles.css";
5 |
6 | export default function App() {
7 | const [input, setInput] = useState();
8 |
9 | const handleChange = (e) => {
10 | setInput(e.target.value);
11 | };
12 |
13 | const deboucedValue = useDebounce(input, 2000, () => {
14 | // API call logic
15 | console.log("Event Debounced");
16 | });
17 |
18 | return (
19 | Posts
21 | 22 | {data && 23 | data.products?.map((d) => ( 24 |
25 | 
26 |
29 | ))}
30 | {d.title}
27 |{d.description}
28 |
20 |
30 | );
31 | }
32 |
--------------------------------------------------------------------------------
/React Machine Coding/Pop Up/PopUp.js:
--------------------------------------------------------------------------------
1 | import { useState, useEffect } from "react";
2 | import Pop from "./Pop";
3 |
4 | export default function PopUp() {
5 | const [btnPopUp, setBtnPopUp] = useState(false);
6 | const [timePopUp, setTimePopUp] = useState(false);
7 |
8 | useEffect(() => {
9 | setTimeout(() => {
10 | setTimePopUp(true);
11 | }, 3000);
12 | }, []);
13 |
14 | return (
15 | debouncing
21 |{deboucedValue}
22 | 23 | 29 |
16 |
17 |
20 | Hello from My Pop Up
21 |
22 |
23 |
24 | Hello from Timed Pop Up
25 |
26 |
27 |
28 | );
29 | }
30 |
--------------------------------------------------------------------------------
/BigFrontEnd/React JS Concept Snippets/react.memo.jsx:
--------------------------------------------------------------------------------
1 | import React, { useState } from "react";
2 |
3 | const Counter = ({ count }) => {
4 | console.log("Counter Re-rendered");
5 | return Count : {count}
; 6 | }; 7 | 8 | const MemoizedCounter = React.memo(Counter); 9 | 10 | const ReactMemo = () => { 11 | const [count, setCount] = useState(0); 12 | const [text, setText] = useState(""); 13 | 14 | return ( 15 |
16 | {/*
28 | );
29 | };
30 |
31 | export default ReactMemo;
32 |
--------------------------------------------------------------------------------
/LeetCode/021-Merge_Two_Sorted_Lists.java:
--------------------------------------------------------------------------------
1 | class Solution {
2 | public ListNode mergeTwoLists(ListNode l1, ListNode l2) {
3 | ListNode temp_node = new ListNode(0);
4 | ListNode current_node = temp_node;
5 |
6 | while(l1 != null && l2 != null){
7 | if(l1.val < l2.val){
8 | current_node.next = l1;
9 | l1 = l1.next;
10 | }
11 | else{
12 | current_node.next = l2;
13 | l2 = l2.next;
14 | }
15 | current_node = current_node.next;
16 | }
17 | if(l1 != null){
18 | current_node.next = l1;
19 | l1 = l1.next;
20 | }
21 | if(l2 != null){
22 | current_node.next = l2;
23 | l2 = l2.next;
24 | }
25 |
26 | return temp_node.next;
27 | }
28 | }
--------------------------------------------------------------------------------
/BigFrontEnd/DSA /0015_3Sum.js:
--------------------------------------------------------------------------------
1 | var threeSum = function(nums) {
2 | if(nums.length === 0) return [];
3 |
4 | nums = nums.sort((a, b) => a - b)
5 | let res = []
6 |
7 | for(let i = 0; i < nums.length - 2; i++){
8 | if(i>0 && nums[i]===nums[i-1]) continue
9 |
10 | let j = i + 1
11 | let k = nums.length - 1
12 |
13 | while( j < k){
14 | let sum = nums[i] + nums[j] + nums[k]
15 |
16 | if(sum === 0) {
17 | res.push([nums[i], nums[j], nums[k]])
18 |
19 | while(nums[j] === nums[j+1]) j++
20 | while(nums[k] === nums[k+1]) k--
21 |
22 | j++
23 | k--
24 | } else if (sum < 0) {
25 | j++
26 | } else {
27 | k--
28 | }
29 | }
30 | }
31 |
32 | return res
33 | };
34 |
--------------------------------------------------------------------------------
/HackerRank/Problem Solving/103-Cats_and_a_Mouse.cpp:
--------------------------------------------------------------------------------
1 | #include
9 | {pathnames.length > 0 && Home}
10 |
11 | {pathnames.map((name, index) => {
12 | breadcrumbpath += `/${name}`;
13 | const isLast = index === pathnames.length - 1;
14 |
15 | return isLast ? (
16 | / {name}
17 | ) : (
18 |
19 | / {name}
20 |
21 | );
22 | })}
23 |
24 | );
25 | }
26 |
--------------------------------------------------------------------------------
/BigFrontEnd/DSA /0023_Merge_k_Sorted_Lists.js:
--------------------------------------------------------------------------------
1 | function mergeList(a, b){
2 | let dummy = new ListNode(0)
3 | let current = dummy
4 |
5 | while(a !== null && b !== null){
6 | if(a.val < b.val){
7 | current.next = a;
8 | a = a.next
9 | } else {
10 | current.next = b;
11 | b = b.next;
12 | }
13 |
14 | current = current.next;
15 | }
16 |
17 | current.next = a || b;
18 |
19 | return dummy.next;
20 | }
21 |
22 |
23 | var mergeKLists = function(lists) {
24 | if(lists.length === 0){
25 | return null;
26 | }
27 |
28 | while(lists.length > 1){
29 | let a = lists.shift();
30 | let b = lists.shift();
31 |
32 | let mergeAB = mergeList(a , b)
33 | lists.push(mergeAB)
34 | }
35 |
36 | return lists[0];
37 | };
--------------------------------------------------------------------------------
/CodeForces/A-Cards_Of_Friends.java:
--------------------------------------------------------------------------------
1 | import java.util.Scanner;
2 |
3 | public class HelloWorld{
4 |
5 | public static void main(String []args){
6 | Scanner sc = new Scanner(System.in);
7 |
8 | int t = sc.nextInt();
9 |
10 | while(t-- >= 1){
11 | int w = sc.nextInt();
12 | int h = sc.nextInt();
13 | int n = sc.nextInt();
14 | int sheets = 1;
15 |
16 | while (w % 2 == 0) {
17 | w = w / 2;
18 | sheets = sheets * 2;
19 | }
20 | while (h % 2 == 0) {
21 | h = h/2;
22 | sheets = sheets*2;
23 | }
24 | if(sheets>=n){
25 | System.out.println("YES");
26 | }else{
27 | System.out.println("NO");
28 | }
29 | }
30 | }
31 | }
--------------------------------------------------------------------------------
/DSA SHEET Solution/GFG-Move_All_Negative_Elements_to_End.java:
--------------------------------------------------------------------------------
1 | // Problem URL - https://practice.geeksforgeeks.org/problems/move-all-negative-elements-to-end1813/1
2 | // Solution URL - https://www.geeksforgeeks.org/move-ve-elements-end-order-extra-space-allowed/
3 |
4 |
5 | class Solution {
6 |
7 | public void segregateElements(int arr[], int n)
8 | {
9 | int temp[] = new int[n];
10 | int j = 0;
11 |
12 | for(int i = 0; i < n; i++){
13 | if(arr[i]>=0)
14 | temp[j++] = arr[i];
15 | }
16 |
17 | if (j == n || j == 0)
18 | return;
19 |
20 | for(int i = 0; i < n; i++){
21 | if(arr[i]<0)
22 | temp[j++] = arr[i];
23 | }
24 |
25 | for (int i = 0; i < n; i++)
26 | arr[i] = temp[i];
27 | }
28 | }
--------------------------------------------------------------------------------
/HackerRank/Problem Solving/101-Migratory_Birds.cpp:
--------------------------------------------------------------------------------
1 | #include
17 |
28 | );
29 | }
30 |
--------------------------------------------------------------------------------
/React Machine Coding/File Manager/data/folderInfo.json:
--------------------------------------------------------------------------------
1 | {
2 | "id": "1",
3 | "name": "root",
4 | "isFolder": true,
5 | "items": [
6 | {
7 | "id": "2",
8 | "name": "public",
9 | "isFolder": true,
10 | "items": [
11 | {
12 | "id": "4",
13 | "name": "index.html",
14 | "isFolder": false
15 | },
16 | {
17 | "id": "5",
18 | "name": "index.css",
19 | "isFolder": false
20 | },
21 | {
22 | "id": "6",
23 | "name": "hello.html",
24 | "isFolder": false
25 | }
26 | ]
27 | },
28 | {
29 | "id": "3",
30 | "name": "images",
31 | "isFolder": true,
32 | "items": [
33 | {
34 | "id": "7",
35 | "name": "hey.html",
36 | "isFolder": false
37 | }
38 | ]
39 | }
40 | ]
41 | }
42 |
--------------------------------------------------------------------------------
/BigFrontEnd/DSA /0232_Implement_Queue_using_Stacks.js:
--------------------------------------------------------------------------------
1 | class MyQueue {
2 | constructor() {
3 | this.pushStack = [];
4 | this.popStack = [];
5 | }
6 |
7 | push(val) {
8 | this.pushStack.push(val)
9 | }
10 |
11 | pop() {
12 | if(!this.popStack.length){
13 | while(this.pushStack.length){
14 | this.popStack.push(this.pushStack.pop());
15 | }
16 | }
17 |
18 | return this.popStack.pop();
19 | }
20 |
21 | peek () {
22 | if (!this.popStack.length){
23 | while (this.pushStack.length){
24 | this.popStack.push(this.pushStack.pop())
25 | }
26 | }
27 |
28 | return this.popStack[this.popStack.length - 1];
29 | }
30 |
31 | empty() {
32 | return !this.pushStack.length && !this.popStack.length
33 | }
34 | }
--------------------------------------------------------------------------------
/Daily Bytes/004-Correct_Capitalization.java:
--------------------------------------------------------------------------------
1 | // This question is asked by Google. Given a string, return whether or not it uses capitalization correctly. A string correctly uses capitalization if all letters are capitalized, no letters are capitalized, or only the first letter is capitalized.
2 |
3 | // Ex: Given the following strings...
4 |
5 | // "USA", return true
6 | // "Calvin", return true
7 | // "compUter", return false
8 | // "coding", return true
9 |
10 |
11 | class Solution {
12 | public boolean detectCapitalUse(String word) {
13 | int count = 0;
14 |
15 | for(int i = 0; i < word.length(); i++){
16 | if(Character.isUpperCase(word.charAt(i))){
17 | count++;
18 | }
19 | }
20 |
21 | return count == word.length() || count == 0 || count == 1 && Character.isUpperCase(word.charAt(0));
22 |
23 | }
24 | }
--------------------------------------------------------------------------------
/React Machine Coding/Progress Bar/ProgressBar.js:
--------------------------------------------------------------------------------
1 | import { useEffect, useState } from "react";
2 |
3 | export default function ProgressBar({ value = 0 }) {
4 | const [percent, setPercent] = useState(value);
5 |
6 | useEffect(() => {
7 | setPercent(Math.min(100, Math.max(value, 0)));
8 | }, [value]);
9 |
10 | return (
11 |
18 | {products.map((prod) => (
19 |
27 |
20 |
21 | 
22 |
25 | ))}
26 | {prod.title}
23 | 24 |
12 | 49 ? "white" : "black" }}>
13 | {percent.toFixed()} %
14 |
15 |
27 |
28 | );
29 | }
30 |
--------------------------------------------------------------------------------
/React Machine Coding/BreadCrumb Menu/App.js:
--------------------------------------------------------------------------------
1 | import { useEffect, useMemo, useReducer, useRef, useState } from "react";
2 | import "./styles.css";
3 | import { BrowserRouter, Routes, Route } from "react-router-dom";
4 | import Home from "./pages/home";
5 | import ProductListing from "./pages/product-listing";
6 | import ProductDetail from "./pages/product-detail";
7 | import BreadCrumb from "../components/BreadCrumb";
8 |
9 | export default function App() {
10 | return (
11 |
13 | {/* bread crumbs */}
14 |
17 |
21 |
22 |
26 |
32 | );
33 | }
34 |
--------------------------------------------------------------------------------
/LeetCode/567-Permutation_in_String.java:
--------------------------------------------------------------------------------
1 | class Solution {
2 | public boolean checkInclusion(String s1, String s2) {
3 | int m = s1.length();
4 | int n = s2.length();
5 |
6 |
7 | if(n < m){
8 | return false;
9 | }
10 | int[] freq1 = new int[26];
11 | int[] freq2 = new int[26];
12 |
13 | for(int i=0; i < m; i++){
14 | freq1[s1.charAt(i) - 'a']++;
15 | freq2[s2.charAt(i) - 'a']++;
16 | }
17 |
18 | for(int i=m; i< n; i++){
19 | if(Arrays.equals(freq1, freq2)){
20 | return true;
21 | }
22 | freq2[s2.charAt(i) - 'a']++;
23 | freq2[s2.charAt(i-m) - 'a']--;
24 | }
25 | if(Arrays.equals(freq1, freq2)){
26 | return true;
27 | }
28 |
29 | return false;
30 | }
31 | }
--------------------------------------------------------------------------------
/Geeks For Geeks/Arrays/001-Find_the_repeating_and_the_missing.java:
--------------------------------------------------------------------------------
1 | // Link - https://www.geeksforgeeks.org/find-a-repeating-and-a-missing-number/
2 |
3 | import java.io.*;
4 |
5 | public class Solution{
6 |
7 |
8 | public static void main(String []args){
9 | int[] v = { 4, 3, 6, 2, 1, 6, 7 };
10 |
11 | int n = v.length;
12 |
13 | int sum = n * (n + 1) / 2;
14 | int sum_square = n * (n+1) * (2 * n + 1) / 6;
15 |
16 | for(int i = 0 ; i < n; i++){
17 | sum = sum - v[i];
18 | sum_square = sum_square - (v[i] * v[i]);
19 | }
20 |
21 | int missing = ((sum_square / sum) + sum) / 2;
22 | int repeating = missing - sum;
23 |
24 | System.out.println("Missing Number is "+ missing);
25 | System.out.println("Repeating Number is "+ repeating);
26 |
27 | }
28 | }
--------------------------------------------------------------------------------
/React Machine Coding/Custom Hook/React Hooks Polyfills/useMemo/App.js:
--------------------------------------------------------------------------------
1 | import { useEffect, useMemo, useRef, useState } from "react";
2 | import useCustomMemo from "../components/use-custom-memo";
3 | import "./styles.css";
4 |
5 | export default function App() {
6 | const [counter, setCounter] = useState(0);
7 | const [counter2, setCounter2] = useState(100);
8 |
9 | const square = () => {
10 | console.log("Expensive Calculation");
11 | return counter * counter;
12 | };
13 |
14 | const memoizedSquare = useCustomMemo(square, [counter]);
15 |
16 | return (
17 | {counter}
27 | 28 | 29 |{counter2}
30 | 31 |
18 |
24 | );
25 | }
26 |
--------------------------------------------------------------------------------
/LeetCode/075-Sort_Colors.java:
--------------------------------------------------------------------------------
1 | class Solution {
2 | public void sortColors(int[] nums) {
3 | int lo = 0;
4 | int hi = nums.length - 1;
5 | int mid = 0;
6 |
7 | int temp;
8 |
9 | while(mid <= hi){
10 | switch(nums[mid]){
11 | case 0 : {
12 | temp = nums[lo];
13 | nums[lo] = nums[mid];
14 | nums[mid] = temp;
15 | lo++;
16 | mid++;
17 | break;
18 | }
19 | case 1:
20 | mid++;
21 | break;
22 | case 2: {
23 | temp = nums[mid];
24 | nums[mid] = nums[hi];
25 | nums[hi] = temp;
26 | hi--;
27 | break;
28 | }
29 | }
30 | }
31 | }
32 | }
--------------------------------------------------------------------------------
/React Machine Coding/Custom Hook/React Hooks Polyfills/useEffect/useCustomEffect.js:
--------------------------------------------------------------------------------
1 | import { useRef } from "react";
2 |
3 | const useCustomHook = (cb, deps) => {
4 | const isFirstRender = useRef(true);
5 | const prevDeps = useRef([]);
6 |
7 | // First Render
8 | if (isFirstRender.current) {
9 | isFirstRender.current = false;
10 | const cleanup = cb();
11 |
12 | return () => {
13 | if (cleanup && typeof cleanup === "function") {
14 | cleanup();
15 | }
16 | };
17 | }
18 |
19 | // deps changes or No deps array
20 | const depsChanged = deps
21 | ? JSON.stringify(deps) !== JSON.stringify(prevDeps.current)
22 | : true;
23 |
24 | if (depsChanged) {
25 | const cleanup = cb();
26 | if (cleanup && typeof cleanup === "function") {
27 | cleanup();
28 | }
29 | }
30 |
31 | prevDeps.current = deps || [];
32 | };
33 |
34 | export default useCustomHook;
35 |
--------------------------------------------------------------------------------
/React Machine Coding/Custom Hook/useFetch/useFetch.js:
--------------------------------------------------------------------------------
1 | const { useState, useEffect } = require("react");
2 |
3 | const useFetch = (url) => {
4 | const [data, setData] = useState([]);
5 | const [loading, setLoading] = useState(false);
6 | const [error, setError] = useState(null);
7 |
8 | useEffect(() => {
9 | const fetchData = async () => {
10 | setLoading(true);
11 |
12 | try {
13 | const response = await fetch(url);
14 | if (!response.ok) {
15 | throw new Error("Server Response not OK");
16 | }
17 | const result = await response.json();
18 | setData(result);
19 | } catch (err) {
20 | setError(err);
21 | } finally {
22 | setLoading(false);
23 | }
24 | };
25 |
26 | if (url) {
27 | fetchData();
28 | }
29 | }, [url]);
30 |
31 | return { data, loading, error };
32 | };
33 |
34 | export default useFetch;
35 |
--------------------------------------------------------------------------------
/React Machine Coding/Infinite Scrolling/InfiniteScrolling.js:
--------------------------------------------------------------------------------
1 | // Reference - https://www.youtube.com/watch?v=Ckka1HhE2kM
2 |
3 | import { useEffect, useState } from "react";
4 |
5 | export default function InfiniteScroll() {
6 | const [count, setCount] = useState(50);
7 |
8 | useEffect(() => {
9 | const onScroll = () => {
10 | if (
11 | window.innerHeight + window.scrollY >=
12 | window.document.body.offsetHeight - 30
13 | ) {
14 | setCount(count + 50);
15 | }
16 | };
17 | window.addEventListener("scroll", onScroll);
18 |
19 | return () => window.removeEventListener("scroll", onScroll);
20 | }, [count]);
21 |
22 | const elements = [];
23 |
24 | for (let i = 0; i < count; i++) {
25 | elements.push(Square Value : {memoizedSquare}
19 |Counter 1 : {counter}
20 | 21 |Counter 2 : {counter2}
22 | 23 |{i + 1}
);
26 | }
27 |
28 | return (
29 |
30 | Hello from Infinite Scroll
31 | {elements}
32 |
33 | );
34 | }
35 |
--------------------------------------------------------------------------------
/Dot Net Repository /DSA C#/FactorialUsingRecursion.cs:
--------------------------------------------------------------------------------
1 | using System;
2 |
3 | public class FactorialCalculator
4 | {
5 | public static void Main(string[] args)
6 | {
7 | int number = 5;
8 |
9 | // Check for non-negative input
10 | if (number < 0)
11 | {
12 | Console.WriteLine("Factorial of a negative number does not exist.");
13 | }
14 | else
15 | {
16 | long result = Factorial(number);
17 | Console.WriteLine($"The factorial of {number} is {result}.");
18 | }
19 | }
20 |
21 | // Recursive function to calculate factorial
22 | public static long Factorial(int n)
23 | {
24 | // Base case: 0! and 1! are both 1
25 | if (n <= 1)
26 | {
27 | return 1;
28 | }
29 | // Recursive step: n * (n-1)!
30 | else
31 | {
32 | return n * Factorial(n - 1);
33 | }
34 | }
35 | }
--------------------------------------------------------------------------------
/DSA SHEET Solution/075-Sort_Colors.java:
--------------------------------------------------------------------------------
1 | class Solution {
2 | public void sortColors(int[] nums) {
3 | int lo = 0;
4 | int mid = 0;
5 | int hi = nums.length - 1;
6 | int temp;
7 | while(mid <= hi){
8 | switch(nums[mid]){
9 | case 0 : {
10 | temp = nums[lo];
11 | nums[lo] = nums[mid];
12 | nums[mid] = temp;
13 | lo++;
14 | mid++;
15 | break;
16 | }
17 | case 1: {
18 | mid++;
19 | break;
20 | }
21 | case 2: {
22 | temp = nums[mid];
23 | nums[mid] = nums[hi];
24 | nums[hi] = temp;
25 | hi--;
26 | break;
27 | }
28 | }
29 | }
30 | }
31 | }
--------------------------------------------------------------------------------
/Geeks For Geeks/Arrays/002-Leaders_In_Array.java:
--------------------------------------------------------------------------------
1 | public class LeadersInArray
2 | {
3 | /* Java Function to print leaders in an array */
4 | void printLeaders(int arr[], int size)
5 | {
6 | int max_from_right = arr[size-1];
7 |
8 | /* Rightmost element is always leader */
9 | System.out.print(max_from_right + " ");
10 |
11 | for (int i = size-2; i >= 0; i--)
12 | {
13 | if (max_from_right < arr[i])
14 | {
15 | max_from_right = arr[i];
16 | System.out.print(max_from_right + " ");
17 | }
18 | }
19 | }
20 |
21 | /* Driver program to test above functions */
22 | public static void main(String[] args)
23 | {
24 | LeadersInArray lead = new LeadersInArray();
25 | int arr[] = new int[]{16, 17, 4, 3, 5, 2};
26 | int n = arr.length;
27 | lead.printLeaders(arr, n);
28 | }
29 | }
--------------------------------------------------------------------------------
/BigFrontEnd/DSA /0016_3Sum.js:
--------------------------------------------------------------------------------
1 | var threeSum = function(nums) {
2 | let result = [];
3 |
4 | nums.sort((a,b) => a-b)
5 |
6 | for(let i = 0; i < nums.length - 2; i++){
7 | if(i > 0 && nums[i] === nums[i-1]) continue
8 |
9 | let left = i + 1;
10 | let right = nums.length - 1;
11 |
12 | while(left < right){
13 | const sum = nums[i] + nums[left] + nums[right];
14 |
15 | if(sum === 0){
16 | result.push([nums[i], nums[left], nums[right]])
17 |
18 | while(left < right && nums[left] == nums[left + 1]) left++;
19 | while(left < right && nums[right] == nums[right-1]) right--;
20 |
21 | left++
22 | right--
23 | }
24 | else if(sum < 0){
25 | left++
26 | } else {
27 | right--
28 | }
29 | }
30 | }
31 | return result
32 | };
--------------------------------------------------------------------------------
/CodeForces/B-Bad_Prices.java:
--------------------------------------------------------------------------------
1 | import java.util.Scanner;
2 |
3 | /**
4 | *
5 | */
6 | public class Problem1213B {
7 | public static void main(String[] args) {
8 | Scanner sc = new Scanner(System.in);
9 | int t = sc.nextInt();
10 | while(t-->=1){
11 | int n = sc.nextInt();
12 | int prices[] = new int[n];
13 | for(int i =0; i
23 |
33 | );
34 | }
35 |
--------------------------------------------------------------------------------
/CodeForces/A-Odd_Set.java:
--------------------------------------------------------------------------------
1 | import java.util.Scanner;
2 |
3 |
4 | public class OddSet{
5 |
6 | public static void main(String []args){
7 | Scanner sc = new Scanner(System.in);
8 |
9 | int t = sc.nextInt();
10 |
11 | while(t-- >= 1){
12 | int n = sc.nextInt();
13 | int size = 2 * n;
14 | int arr[] = new int[size];
15 |
16 | int odd = 0;
17 | int even = 0;
18 |
19 | for(int i = 0 ; i < size ; i++){
20 | arr[i] = sc.nextInt();
21 | if(arr[i] % 2 == 0){
22 | even++;
23 | }
24 | else{
25 | odd++;
26 | }
27 | }
28 |
29 | if(even == odd){
30 | System.out.println("Yes");
31 | }
32 | else
33 | System.out.println("No");
34 |
35 | }
36 | }
37 | }
--------------------------------------------------------------------------------
/BigFrontEnd/DSA /0784_Letter_Case_Permutation.js:
--------------------------------------------------------------------------------
1 | /**
2 | * @param {string} s
3 | * @return {string[]}
4 | */
5 | var letterCasePermutation = function(S) {
6 | const result = [];
7 |
8 | const dfs = (i, S, slate) => {
9 | // base case
10 | if (i === S.length){
11 | result.push(slate.join(''));
12 | return;
13 | }
14 |
15 | // dfs recursive case
16 | let char = S[i]
17 |
18 | if(!Number.isInteger(parseInt(char))) {
19 | // uppercase
20 | slate.push(char.toUpperCase());
21 | dfs(i + 1, S, slate);
22 | slate.pop()
23 |
24 | // lowercase
25 | slate.push(char.toLowerCase());
26 | dfs(i + 1, S, slate);
27 | slate.pop()
28 | } else {
29 | slate.push(char)
30 | dfs(i + 1, S, slate)
31 | slate.pop();
32 | }
33 | }
34 |
35 | dfs(0, S, []);
36 | return result;
37 | };
--------------------------------------------------------------------------------
/BigFrontEnd/JS Interview Concept Snippets/PromiseAllPolyfill.js:
--------------------------------------------------------------------------------
1 | function promiseAll(promiseTask) {
2 | let res = new Array(promiseTask.length);
3 | let completed = 0;
4 |
5 | return new Promise((resolve, rejects) => {
6 | for (let i = 0; i < promiseTask.length; i++) {
7 | Promise.resolve(promiseTask[i])
8 | .then((data) => {
9 | res[i] = data;
10 | completed++;
11 |
12 | if (completed === promiseTask.length) {
13 | resolve(res);
14 | }
15 | })
16 | .catch((error) => {
17 | reject(error);
18 | });
19 | }
20 | });
21 | }
22 |
23 | const promise1 = Promise.resolve(1);
24 | const promise2 = Promise.resolve(2);
25 | const promise3 = new Promise((resolve) => {
26 | setTimeout(() => {
27 | resolve(30);
28 | }, 1000);
29 | });
30 |
31 | promiseAll([promise1, promise2, promise3])
32 | .then((res) => {
33 | console.log(res);
34 | })
35 | .catch((error) => console.log("One of the promise failed", error));
36 |
--------------------------------------------------------------------------------
/LeetCode/680-Valid_Palindrome_II.java:
--------------------------------------------------------------------------------
1 | class Solution {
2 | public boolean validPalindrome(String s) {
3 | int a_pointer = 0;
4 | int b_pointer = s.length() - 1;
5 |
6 | while(a_pointer <= b_pointer){
7 | if(s.charAt(a_pointer) != s.charAt(b_pointer)){
8 | return helperMethod(s, a_pointer+1, b_pointer) || helperMethod(s, a_pointer, b_pointer-1);
9 | }
10 |
11 | a_pointer++;
12 | b_pointer--;
13 |
14 | }
15 |
16 | return true;
17 | }
18 |
19 | public boolean helperMethod(String s, int i, int j){
20 | int a_pointer = i;
21 | int b_pointer = j;
22 |
23 | while(a_pointer <= b_pointer){
24 | if(s.charAt(a_pointer) != s.charAt(b_pointer)){
25 | return false;
26 | }
27 |
28 | a_pointer++;
29 | b_pointer--;
30 | }
31 | return true;
32 | }
33 | }
--------------------------------------------------------------------------------
/Daily Bytes/007-Valid_Palindrome_II.java:
--------------------------------------------------------------------------------
1 | class Solution {
2 | public boolean validPalindrome(String s) {
3 | int a_pointer = 0;
4 | int b_pointer = s.length() - 1;
5 |
6 | while(a_pointer <= b_pointer){
7 | if(s.charAt(a_pointer) != s.charAt(b_pointer)){
8 | return helperMethod(s, a_pointer+1, b_pointer) || helperMethod(s, a_pointer, b_pointer-1);
9 | }
10 |
11 | a_pointer++;
12 | b_pointer--;
13 |
14 | }
15 |
16 | return true;
17 | }
18 |
19 | public boolean helperMethod(String s, int i, int j){
20 | int a_pointer = i;
21 | int b_pointer = j;
22 |
23 | while(a_pointer <= b_pointer){
24 | if(s.charAt(a_pointer) != s.charAt(b_pointer)){
25 | return false;
26 | }
27 |
28 | a_pointer++;
29 | b_pointer--;
30 | }
31 | return true;
32 | }
33 | }
--------------------------------------------------------------------------------
/React Machine Coding/Custom Hook/useLocalStorage/App.js:
--------------------------------------------------------------------------------
1 | import { useEffect, useState } from "react";
2 | import useLocalStorage from "./components/useLocalStorage";
3 | import "./styles.css";
4 |
5 | export default function App() {
6 | const [user, setUser] = useLocalStorage("userName", "Guest");
7 | const [theme, setTheme] = useLocalStorage("dark", false);
8 |
9 | return (
10 |
24 | {/*
25 |
26 | */}
27 |
28 |
29 |
30 |
32 | {state.toString()}
31 |
11 |
24 |
25 | 26 |
36 | );
37 | }
38 |
--------------------------------------------------------------------------------
/Daily Bytes/001-Reverse String.java:
--------------------------------------------------------------------------------
1 | // This question is asked by Google. Given a string, reverse all of its characters and return the resulting string.
2 |
3 | // Ex: Given the following strings...
4 |
5 | // “Cat”, return “taC”
6 | // “The Daily Byte”, return "etyB yliaD ehT”
7 | // “civic”, return “civic”
8 |
9 |
10 |
11 |
12 | import java.lang.*;
13 | import java.io.*;
14 | import java.util.*;
15 |
16 |
17 | public class ReverseString{
18 |
19 | public static void main(String []args){
20 | String input;
21 | Scanner sc = new Scanner(System.in);
22 | System.out.println("Enter the desired String: ");
23 | input = sc.nextLine();
24 |
25 | byte[] strAsByteArray = input.getBytes();
26 |
27 | byte[] result = new byte[strAsByteArray.length];
28 |
29 | for (int i = 0; i < strAsByteArray.length; i++){
30 | result[i] = strAsByteArray[strAsByteArray.length - i - 1];
31 | }
32 |
33 | System.out.println(new String(result));
34 | }
35 | }
--------------------------------------------------------------------------------
/BigFrontEnd/DSA /0121_Best_Time_To_Buy_Stock.js:
--------------------------------------------------------------------------------
1 | // JS Solution is as follows :
2 | var maxProfit = function(prices) {
3 | let min_price = prices[0];
4 | let max_profit = 0;
5 |
6 | for(let index in prices){
7 | if(prices[index] < min_price ){
8 | min_price = prices[index];
9 | }
10 | else if (prices[index] - min_price > max_profit){
11 | max_profit = prices[index] - min_price;
12 | }
13 | }
14 | return max_profit;
15 | };
16 |
17 |
18 | // class Solution {
19 | // public int maxProfit(int[] prices) {
20 | // int min_price = Integer.MAX_VALUE;
21 | // int max_profit = 0;
22 |
23 | // for(int i = 0; i < prices.length; i++){
24 | // if(prices[i] < min_price){
25 | // min_price = prices[i];
26 | // } else if (prices[i] - min_price > max_profit){
27 | // max_profit = prices[i] - min_price;
28 | // }
29 | // }
30 | // return max_profit;
31 | // }
32 | // }
--------------------------------------------------------------------------------
/LeetCode/695-Max_Area_of_Island.java:
--------------------------------------------------------------------------------
1 | class Solution {
2 | boolean seen[][];
3 |
4 | public int maxAreaOfIsland(int[][] grid) {
5 | int max_area = 0;
6 |
7 | int rows = grid.length;
8 | int columns = grid[0].length;
9 |
10 | seen = new boolean[rows][columns];
11 |
12 | for(int i =0 ; i < rows; i++){
13 | for(int j = 0; j < columns; j++){
14 | max_area = Math.max(max_area, area(i,j,grid));
15 | }
16 | }
17 |
18 | return max_area;
19 | }
20 |
21 | public int area(int row, int column, int[][] grid){
22 | if(row < 0 || row >= grid.length || column < 0 || column >= grid[row].length ||seen[row][column] || (grid[row][column] == 0)){
23 | return 0;
24 | }
25 |
26 | seen[row][column] = true;
27 |
28 | return (1 + area(row+1, column, grid) + area(row-1, column, grid) + area(row, column + 1, grid) + area(row, column - 1, grid));
29 | }
30 | }
--------------------------------------------------------------------------------
/React Machine Coding/Custom Hook/React Hooks Polyfills/useMemo/useCustomMemo.js:
--------------------------------------------------------------------------------
1 | // useMemo Polyfill
2 |
3 | import { useEffect, useRef } from "react";
4 |
5 | const areEqual = (prevDeps, nextDeps) => {
6 | if (prevDeps === null) return false;
7 |
8 | if (prevDeps.length !== nextDeps.length) return false;
9 |
10 | for (let i = 0; i < prevDeps.length; i++) {
11 | if (prevDeps[i] !== nextDeps[i]) {
12 | return false;
13 | }
14 | }
15 |
16 | return true;
17 | };
18 |
19 | const useCustomMemo = (cb, deps) => {
20 | // variavle or state -> to store cache value
21 | const memoizedRef = useRef(null);
22 | //changes in deps
23 | if (!memoizedRef.current || !areEqual(memoizedRef.current.deps, deps)) {
24 | memoizedRef.current = {
25 | value: cb(),
26 | deps,
27 | };
28 | }
29 | //cleanup logic
30 | useEffect(() => {
31 | memoizedRef.current = null;
32 | }, []);
33 | // return memoized value(if any)
34 | return memoizedRef.current.value;
35 | };
36 |
37 | export default useCustomMemo;
38 |
--------------------------------------------------------------------------------
/BigFrontEnd/JS Interview Concept Snippets/Function_Binding.js:
--------------------------------------------------------------------------------
1 | // bind - pollyfill using apply()
2 | Function.prototype.bindUsingApply = function (ctx, ...args) {
3 | let fn = this;
4 |
5 | let allArgs = args;
6 |
7 | return function (...newArgs) {
8 | allArgs = [...allArgs, ...newArgs];
9 | return fn.apply(ctx, allArgs);
10 | };
11 | };
12 |
13 | // bind - polyfill without using apply()
14 | Function.prototype.bindWithoutUsingApply = function(ctx, ...args){
15 | ctx.callableFn = this;
16 |
17 | let allArgs = args;
18 |
19 | return function (...newArgs) {
20 | allArgs = [...allArgs, ...newArgs];
21 | return ctx.callableFn(allArgs);
22 | };
23 | }
24 |
25 | let myName1 = printname.bindUsingApply(user, "123");
26 | let myName = printname.bindWithoutUsingApply(user, "mohanty");
27 |
28 | myName();
29 | myName1();
30 |
31 | // function print() {
32 | // console.log(this.firstname);
33 | // }
34 |
35 | // let myFunc = print.bind(user);
36 |
37 | // myFunc();
--------------------------------------------------------------------------------
/Geeks For Geeks/Linked List/002-Linked_List_Traversal.cpp:
--------------------------------------------------------------------------------
1 | #include Hello
12 | setUser(e.target.value)} 16 | /> 17 | 18 | setTheme(e.target.checked)} 22 | /> 23 |24 |
25 | 26 |
33 |
35 | This content changes theme
34 |
30 | {intervalTime.toFixed(3)}
31 |
32 |
33 | 34 | 35 |
36 | );
37 | }
38 |
--------------------------------------------------------------------------------
/CodeForces/A-Contest_Start.java:
--------------------------------------------------------------------------------
1 | import java.util.Scanner;
2 |
3 | public class HelloWorld{
4 |
5 | public static void main(String []args){
6 | Scanner sc = new Scanner(System.in);
7 | int k = sc.nextInt();
8 |
9 | for(int i = 0; i < k; i++){
10 | long n = sc.nextInt();
11 | long x = sc.nextInt();
12 | long t = sc.nextInt();
13 |
14 | if(t < x){
15 | System.out.println("0");
16 | continue;
17 | }
18 | long first = t/x;
19 | if(first >= n-1){
20 | long ans = n - 1;
21 | ans = (ans * (ans + 1))/2;
22 | System.out.println(ans);
23 | }
24 | else{
25 | long ans1 = first;
26 | ans1 = (ans1 * (ans1 + 1))/2;
27 | long ans2 = (n -1 - first) * first;
28 | long ansf = ans1 + ans2;
29 | System.out.println(ansf);
30 | }
31 | }
32 |
33 | }
34 | }
--------------------------------------------------------------------------------
/BigFrontEnd/DSA /0217_Contains_Duplicates.js:
--------------------------------------------------------------------------------
1 | // Solution 1 : Using HashSet in Java
2 | // class Solution {
3 | // public boolean containsDuplicate(int[] nums) {
4 | // HashSet32 |
33 | 34 | 35 |
24 |
36 | );
37 | }
38 |
--------------------------------------------------------------------------------
/BigFrontEnd/JS Interview Concept Snippets/PromiseAllSettledPolyfill.js:
--------------------------------------------------------------------------------
1 | function promiseAllSettled(promiseTask) {
2 | let res = new Array(promiseTask.length);
3 | let completed = 0;
4 |
5 | return new Promise((resolve) => {
6 | for (let i = 0; i < promiseTask.length; i++) {
7 | Promise.resolve(promiseTask[i])
8 | .then((data) => {
9 | res[i] = { status: "fulfilled", data };
10 | })
11 | .catch((error) => {
12 | res[i] = { status: "rejected", error };
13 | })
14 | .finally(() => {
15 | completed++;
16 |
17 | if (completed === promiseTask.length) {
18 | resolve(res);
19 | }
20 | });
21 | }
22 | });
23 | }
24 |
25 | const promise1 = Promise.resolve(1);
26 | const promise2 = Promise.reject(2);
27 | const promise3 = new Promise((resolve) => {
28 | setTimeout(() => {
29 | resolve(30);
30 | }, 1000);
31 | });
32 |
33 | promiseAllSettled([promise1, promise2, promise3])
34 | .then((res) => {
35 | console.log(res);
36 | })
37 | .catch((error) => console.log("One of the promise failed", error));
38 |
--------------------------------------------------------------------------------
/React Machine Coding/BreadCrumb Menu/pages/home.js:
--------------------------------------------------------------------------------
1 | import { useEffect, useState } from "react";
2 | import { Link } from "react-router-dom";
3 |
4 | export default function Home() {
5 | const [trendingProducts, setTrendingProducts] = useState([]);
6 |
7 | useEffect(() => {
8 | fetch("https://dummyjson.com/products")
9 | .then((res) => res.json())
10 | .then((data) => {
11 | const sliceTrending = data.products.slice(0, 6);
12 | setTrendingProducts(sliceTrending);
13 | });
14 | }, []);
15 |
16 | return (
17 | Hello
25 | 26 |
33 |
35 | Subham
34 |
18 |
35 | );
36 | }
37 |
--------------------------------------------------------------------------------
/Geeks For Geeks/DSA 450/007-Kadane_Algorithm.java:
--------------------------------------------------------------------------------
1 |
2 |
3 |
4 |
5 |
6 |
7 |
8 |
9 |
10 |
11 |
12 |
13 |
14 |
15 |
16 |
17 |
18 |
19 |
20 |
21 |
22 |
23 |
24 |
25 |
26 |
27 |
28 |
29 |
30 |
31 |
32 |
33 |
34 |
35 |
36 |
37 |
38 |
39 |
40 |
41 |
42 | Refresh
43 |
44 | Time (IST) Status Lang Test Cases Code
45 | 2022-12-29 21:58:12 Correct java 10133 / 10133 View
46 | class Solution{
47 |
48 | // arr: input array
49 | // n: size of array
50 | //Function to find the sum of contiguous subarray with maximum sum.
51 | long maxSubarraySum(int arr[], int n){
52 |
53 | // Your code here
54 | int max_so_far = Integer.MIN_VALUE, max_ending_here = 0;
55 |
56 | for (int i = 0; i < n; i++) {
57 | max_ending_here = max_ending_here + arr[i];
58 | if (max_so_far < max_ending_here)
59 | max_so_far = max_ending_here;
60 |
61 | if (max_ending_here < 0)
62 | max_ending_here = 0;
63 | }
64 | return max_so_far;
65 |
66 | }
67 |
68 | }
--------------------------------------------------------------------------------
/LeetCode/013-3Sum.java:
--------------------------------------------------------------------------------
1 | class Solution {
2 | public List
19 | {trendingProducts.map((prod) => (
20 |
28 |
29 |
30 |
33 |
34 |
21 |
22 |
23 |
26 | ))}
27 | {prod.title}
24 | 25 |
27 | {cartProducts.map((product) => (
28 |
35 | );
36 | };
37 |
38 | export default CartList;
39 |
--------------------------------------------------------------------------------
/Geeks For Geeks/Arrays/50 Top Problems/001-PeakElement.java:
--------------------------------------------------------------------------------
1 | // GFG Problem Link : https://practice.geeksforgeeks.org/problems/peak-element/1
2 | // GFG Article : https://www.geeksforgeeks.org/find-a-peak-in-a-given-array/
3 | // Time Complexity : O(Logn) (Divide and Conquer Method)
4 | // YouTube Reference : https://www.youtube.com/watch?v=zNEn4n0IdPY
5 |
6 |
7 | class Solution
8 | {
9 | // Function to find the peak element
10 | // arr[]: input array
11 | // n: size of array a[]
12 | public int peakElement(int[] arr,int n)
13 | {
14 | //add code here.
15 | int low = 0;
16 | int high = n-1;
17 |
18 | while(low <= high){
19 |
20 | int mid = (high + low)/2;
21 |
22 |
23 | if((mid == 0 || arr[mid - 1] <= arr[mid]) && (mid == n - 1 || arr[mid + 1] <= arr[mid]))
24 | {
25 | return mid;
26 | }
27 |
28 | else if (arr[mid] < arr[mid + 1]){
29 | low = mid + 1;
30 | }
31 | else {
32 | high = mid - 1;
33 | }
34 | }
35 | return -1;
36 | }
37 | }
--------------------------------------------------------------------------------
/CodeForces/B-Social_Network.java:
--------------------------------------------------------------------------------
1 | import java.util.Scanner;
2 |
3 | import java.util.Stack;
4 |
5 |
6 | public class HelloWorld{
7 |
8 | public static void main(String []args){
9 |
10 | Scanner sc = new Scanner(System.in);
11 |
12 | int n = sc.nextInt(); // The number of friends
13 | int k = sc.nextInt(); // The Size of Conversation displayed on screen
14 |
15 | int no;
16 | Stack
11 | {Array(size)
12 | .fill("")
13 | .map((_, i) => {
14 | let starClass = "star";
15 | const starValue = i + 1;
16 |
17 | if (hoverRating >= starValue) {
18 | starClass += " hover";
19 | } else if (rating >= starValue) {
20 | starClass += " active";
21 | }
22 |
23 | return (
24 | onChange(starValue)}
28 | onMouseEnter={() => handleStarHover(starValue)}
29 | onMouseLeave={() => handleStarHover(0)}
30 | >
31 | ★
32 |
33 | );
34 | })}
35 |
36 | );
37 | };
38 |
39 | export default StarRating;
40 |
--------------------------------------------------------------------------------
/React Machine Coding/JS Machine Coding/Stop Watch/script.js:
--------------------------------------------------------------------------------
1 | let timer = null;
2 | let elapsedSeconds = 0;
3 |
4 | const display = document.getElementById("display");
5 | const start = document.getElementById("start");
6 | const stop = document.getElementById("stop");
7 | const reset = document.getElementById("reset");
8 |
9 | function formatTime(seconds) {
10 | const hrs = String(Math.floor(seconds / 3600)).padStart(2, "0");
11 | const min = String(Math.floor((seconds % 3600) / 60)).padStart(2, "0");
12 | const secs = String(Math.floor(seconds % 60)).padStart(2, "0");
13 |
14 | return `${hrs} : ${min} : ${secs}`;
15 | }
16 |
17 | function updateDisplay() {
18 | display.textContent = formatTime(elapsedSeconds);
19 | }
20 |
21 | start.addEventListener("click", function () {
22 | if (timer) return;
23 | timer = setInterval(function () {
24 | elapsedSeconds++;
25 | updateDisplay();
26 | }, 1000);
27 | });
28 |
29 | stop.addEventListener("click", function () {
30 | clearInterval(timer);
31 | timer = null;
32 | });
33 |
34 | reset.addEventListener("click", function () {
35 | clearInterval(timer);
36 | timer = null;
37 | elapsedSeconds = 0;
38 | updateDisplay();
39 | });
40 |
41 | updateDisplay;
42 |
--------------------------------------------------------------------------------