The Horizon Group’s Post

Hi ! connections 😍 , This is the day 17 of 50 days DSA challenge. Today I learnt about the implementation of "Doubly linked list " in java. * Just creating the linked list and insert values on that list Example: // Doubly linked list class Doublylinked{       node head;    node tail;    class node{      int data;       node prev;      node next;             node(int data)      {      this.data=data;      }    }        Doublylinked(){      head =null;      tail=null;    }         public void insertbeginning(int val)    {      node a = new node(val);      a.next=head;      if(head==null)      {        tail=a;      }      else      {        head.prev=a;              }      head=a;   }    public static void main(String[] args) {   } }

DSA Challenge Week-9: Binary Tree Problem: Maximum width of Binary Tree 1. **Pair Class**:   - This class represents a pair of values: an integer (`num`) and a `TreeNode` (`node`).   - It has a constructor to initialize these values. 2. **Solution Class**:   - It contains the `widthOfBinaryTree` method to find the width of a binary tree.   - It initializes a queue (`q`) to store pairs of nodes and their positions.   - It initializes a variable `ans` to store the width of the tree.   - It enqueues the root node along with its position index (0) into the queue. 3. **Main Loop**:   - While the queue is not empty, it iterates through each level of the tree.   - At each level, it records the position indices of the first and last nodes (`first` and `last`).   - It calculates the width of the current level (`last - first + 1`) and updates `ans` if it's greater than the previous width. 4. **Enqueuing Nodes**:   - For each node in the current level, it dequeues the node and enqueues its left and right children if they exist.   - The position indices of left and right children are calculated relative to the position of their parent. 5. **Return**:   - After processing all levels, it returns the maximum width (`ans`) found in the tree. 🔗 https://lnkd.in/gBujjEPE GitHub link: https://lnkd.in/gfaN6epT Thanks to Anchal Sharma #java #dsachallenge #binaryTree

Deleting A Node From A Binary Search Tree Question: Given a Binary Search Tree and a node value x. Delete the node with the given value x from the BST. If no node with value x exists, then do not make any change. Return the root of the BST after deleting the node with value x. Do not make any update if there's no node with value x present in the BST. Explanation: Deleting a node from a BST involves three main cases: 1️⃣ Leaf Node: The node has no children. 2️⃣ One Child: The node has one child. 3️⃣ Two Children: The node has two children. In the first two cases, the node can be removed directly. In the third case, the node's value needs to be replaced with its in-order successor (the smallest value in its right subtree) or in-order predecessor (the largest value in its left subtree), and then delete that successor or predecessor. Approach: 1. Recursively traverse the tree to find the node with the given value x. 2. If the node is found: - If it has no children, simply return null. - If it has one child, return that child. - If it has two children, replace the node's value with its in-order successor's value, then recursively delete the in-order successor. 3. Continue this process until the correct node is deleted and the BST properties are maintained. Time Complexity: O(h) - In the worst case, we might need to traverse from the root to the leaf, which takes O(h), where h is the height of the tree. For a balanced BST, h=O(log⁡ n), and for a skewed tree, h=O(n). Space Complexity: O(h) - O(h) due to the recursion stack. For a balanced BST, h=O(log⁡ n), and for a skewed tree, h=O(n). Question Link: https://lnkd.in/d3sRNbmV Solution Link: https://lnkd.in/dryxYevs #DSA #ProblemSolving #DeletingNode #BinarySearchTree #LeetCode #JAVA #LinkedInLearning

Hey people , Today i have successfully completed 4 problem on strings which has helped in understanding how strings are used in real time Day 47 / 100 : Topic Learning : Binary String Problem 1 : Minimum Number of Flips Approach Link : https://lnkd.in/ghYKdT9J Problem 2 : Student Attendance Record Approach Link : https://lnkd.in/gH5Nyk5C Problem 3 : Ransom Note Approach Link : https://lnkd.in/gDhvbJ5A Problem 4 : Way Too Long Words Code : package Strings; import java.util.Scanner; public class longWords { public static void main(String[] args) { Scanner sc = new Scanner(System.in); int n = sc.nextInt(); // Number of words sc.nextLine(); // To consume the leftover newline for (int i = 0; i < n; i++) { String s = sc.nextLine(); // Read each word int len = s.length(); if (len <= 10) { System.out.println(s); // If the word is not too long, print it as is } else { // Abbreviation: first letter + number of characters between + last letter String abbreviation = s.charAt(0) + String.valueOf(len - 2) + s.charAt(len - 1); System.out.println(abbreviation); } } sc.close(); } } Approach : If the string length is not more than 10 return the string itself if the string count is more than 10 then return like geeksForGeeksFor g- count of middle characters from the string - last char like this  Simple logic /// As per my understanding its Simple Lol !

I will pay you if you're able to find a better explanation than this. Arrays are the most important data structure. 75% of problems revolve around arrays only. Most of us think that we know how an array works but do we really know it's working behind the scenes? Mostly we know what are arrays but why is it designed like this and how it actually works. But to learn about arrays, we must know about functions first. I have recorded the session where I teach about functions and then eventually learn about what, why, and how of the arrays. Divided the recording into three parts. Watching two parts is mandatory. Part 1. Functions in java: https://lnkd.in/g5dB3Ns3 Part2: Arrays in java: https://lnkd.in/gSECu_Gb And even after that if you can find an explanation better than this, I will pay you with a class and will teach you any topic live for free.

Day 36 of #100DaysOfLeetCodeChallenge: Average Salary Today, I tackled the "Average Salary" problem on LeetCode. The challenge was to compute the average salary of employees while excluding the minimum and maximum salaries from the calculation. Key Points:- Data Structures: Utilized arrays to store salary data. Algorithm: Implemented a straightforward approach to find the minimum and maximum salaries, summing the remaining values to calculate the average. Java Skills: Enhanced my proficiency in array manipulation and conditional logic. This exercise not only reinforced my Java skills but also highlighted the importance of efficient data processing. Looking forward to more challenges ahead!

🚀 Day 40: Data Structures and Algorithm with CP 60 Day ⚙️ Hard Problem Challenge! 🚀 Hello LinkedIn Family, Today marks Day 40 of our 60-day journey into the realm of Data Structures and Algorithms! 💻📚 🔗 LeetCode Profile: https://lnkd.in/gdGxiNjA ✅ Let's dive into the Day 40th challenge Problem: 🏰857. Minimum Cost to Hire K Workers There are n workers. You are given two integer arrays quality and wage where quality[i] is the quality of the ith worker and wage[i] is the minimum wage expectation for the ith worker. We want to hire exactly k workers to form a paid group. To hire a group of k workers, we must pay them according to the following rules: Every worker in the paid group must be paid at least their minimum wage expectation. In the group, each worker's pay must be directly proportional to their quality. This means if a worker’s quality is double that of another worker in the group, then they must be paid twice as much as the other worker. Given the integer k, return the least amount of money needed to form a paid group satisfying the above conditions. Answers within 10-5 of the actual answer will be accepted. #Day40 #LinkedIn #ComputativeProgramming #Challenge #LeetCode #60Daychallenge #DSA #Java #HardChallenge

Let’s learn DS everyday !! Arrays are fundamental data structures in computer science, providing a way to store and access elements in a contiguous block of memory. The efficiency of array operations is often analyzed in terms of time and space complexity. Time Complexity: Access (Read/Write): O(1) Retrieving or modifying an element by index takes constant time since arrays offer direct access to any position in memory. Search: O(n) Linear search through an array has a time complexity proportional to the number of elements, making it O(n). Insertion/Deletion (at an arbitrary position): O(n) Inserting or deleting elements at any position may require shifting subsequent elements, resulting in a linear time complexity. Insertion/Deletion (at the end): O(1) Adding or removing elements at the end of an array is efficient, as it doesn't necessitate shifting other elements. Space Complexity: Size of Array: O(n) The space required for an array is directly proportional to the number of elements it holds. Arrays are efficient for random access operations but less so for insertions and deletions, especially within the array. Other data structures like linked lists or dynamic arrays (e.g., ArrayList in Java) may be more suitable for scenarios where frequent insertions or deletions are expected. Understanding the time and space complexities of arrays is crucial for selecting the appropriate data structure based on the specific requirements of a given algorithm or application.

Hello, fellow programmers! Today, I want to share with you a C program that I wrote to copy one string to another using recursion. This is a simple but elegant way to perform string manipulation without using any built-in functions. The logic of the program is as follows: Define a function copy that takes three parameters: source, destination, and index. In the function, copy the character at the given index from the source to the destination array. If the character is the null terminator \0, it means that the end of the source string is reached, so return from the function. Otherwise, increment the index by one and call the function again with the updated index. In the main function, declare two character arrays source and destination and read the source string from the user using scanf. Call the copy function with the source, destination, and zero as the initial index. Print the destination string using printf.

Open-Source Software Question 🤔 Imagine a (we'll say hypothetical) organization has a policy that limits the number of acceptable versions of any software so, as an organization, they need to coordinate updates to things like R and Python. Does anyone have experience with this in your organization...with R and/or Python specifically? Could anyone share a policy or point me to a best practice? I don't have much production experience, mostly R&D, and am curious how this situation is typically handled (if it is encountered at all). I'm hoping to find something that aids security and infrastructure folks but doesn't require data scientists, economists, and statisticians to become full-time software developers updating their code every few months to maintain compatibility. Would love to hear people's thoughts on this.