Rocky DEM Particle Simulator’s Post

I'm excited to announce that I have completed a project on convex optimization, resulting in a powerful SVM package.(soft linear SVM) This package utilizes hinge loss and leverages subgradient descent to enhance convergence. It also incorporates L1 regularization via subgradient methods, ensuring better data fitting without overfitting specific data points. You can find the project and installation instructions on my GitHub, and I've included test code for easy verification. Special thanks to Dr. Amr Amin for his invaluable guidance throughout the course. link https://lnkd.in/dGDTuJuK #MachineLearning #SVM #Optimization #GitHub #Python #DataScience

Its not only about the speed but also the TCC - the Total Cost of Code : how much effort is required to develop and maintain quality code for a team. For instance, TCC of Python is very high due to the ambiguity created by its dynamic nature buried into the language itself. This requires a new dev team member to dig deep into the code written by others to get at least a fair picture of what it is doing, since the language itself allows literally anything, even violating the very basic rules of OOP, code visibility and type matching (unwanted, implicit type conversions). For C++ or C# a developer will instantly know the returned type of a function, verify the members of a class and also can rely on type information. All this will reduce the effort required to get know and maintain a larger codebase, resulting in a lower TCC and higher code quality.

Thrilled to share insights on computer vision and its transformative impact on industrial automation! In my recent talk, I explored how we leverage both commercial systems and custom developments in Python to tackle challenges like defect detection, production line monitoring, and part identification. From proprietary solutions to the latest advancements in vision technology, we’re pushing the boundaries to enhance quality and efficiency in manufacturing. Excited to keep innovating and collaborating in this dynamic field! #ComputerVision #IndustrialAutomation #Python #Innovation #QualityControl #SmartManufacturing

DSA:Problem No 12 #Geekstreak2024 Explanation : 1. Initialize an array res to store the repeating and missing elements. Iterate through the array, and for each element, take its absolute value and use it as an index into the array. 2. If the element at the indexed position is positive, mark it as negative by multiplying it by -1. This indicates that the element has been seen before. If the element at the indexed position is already negative, it means that the element is repeating, so store it in res[0]. 3. After the first pass, iterate through the array again to find the missing element. The first positive element encountered is the missing element, which is stored in res[1]. 4. Return the res array containing the repeating and missing elements. Efficiency : -Time Complexity :This solution has a time complexity of O(n) -Space Complexit : Auxiliary space complexity of O(1), as required. #Coding #Python #Geekstreak2024 #DeutscheBank

#day_178 #medium  #leetcode_54 - Spiral Matrix (https://lnkd.in/g2krBqcC) Given: A matrix To do: Write a code to return all matrix elements in spiral order. My Solution: 1. Initialise four pointers to denote the current boundaries (top, right, bottom, left) of the matrix layer being traversed. 2. The matrix elements are added to the matrix in a spiral order:       Traverse from left to right across the top boundary.       Traverse from top to bottom along the right boundary.   Traverse from right to left across the bottom boundary (if the bottom row is still within bounds).   Traverse from bottom to top along the left boundary (if the left column is still within bounds). 3. After each directional traversal, the respective boundary is updated inward. 4. This approach ensures that all matrix elements are printed in a spiral order from the outermost layer to the innermost layer.   Time Complexity  : O(n)   Space Complexity : O(n) my solution link - https://lnkd.in/gaMSUAvr #leetcode  #python  #datastructuresandalgorithms  #timecomplexity #spacecomplexity  #github #matrix #array #simulation #interviewpreparation #problemsolving #softwaredeveloper

Task-1 by #Technohacks Design a simple #Calculator with basic arithimetic operations. prompt the user to input two numbers and an operation choice. perform the calculation and display the result using #Python_programming language. #Technohacks #MentorSandipGavit

Thanks for your recommendation and welcome to try out PyOptInterface to accelerate the modeling workflow!

An interesting bit of information from Maximilian Parzen's presentation at the HiGHS Workshop a couple weeks ago: 🔌 Open Energy Transition tested a number of different open source #Python modeling packages for linear and mixed integer #optimization. 🏎 While it is a relatively new entrant in the space, PyOptInterface shows impressive results in formulating large models and interfacing with solvers. Benchmarks in the image are from the PyOptInterface site, and are similar to what we saw at the workshop. 💥 It's the kind of thing that seems like it may not matter until a model gets big, and then all of a sudden it's the most important thing. I've seen plenty of models take longer to formulate than they do to solve. I'll definitely be trying this one out soon: https://lnkd.in/eXHkRCRb

Day 05 of the #gfg160, #geekstreak2024 and #160daysofproblemsolving challenge is complete! Today's problem from GeeksforGeeks: Given an array of integers arr[] representing a permutation, implement the next lexicographical permutation. If no such permutation exists, rearrange into the lowest possible order. Solution: I implemented the Next Permutation Problem efficiently using the following steps: 1️⃣ Traverse the array from right to left to find the first element (arr[i]) that is smaller than its next element. 2️⃣ Find the smallest element to the right of i that is larger than arr[i] and swap them. 3️⃣ Reverse the subarray to the right of i to get the lexicographically smallest order. Complexity: Time Complexity: O(n) Finding i and swapping: O(n) Reversing the subarray: O(n) Space Complexity: O(1) (in-place modification) Efficiency: This approach is optimal as it avoids generating all permutations, focusing only on the required rearrangement. It ensures minimal operations and is suitable for large arrays due to its linear time complexity. #GeeksforGeeks #CodingChallenge #Python #ProblemSolving #WomenInTech GeeksforGeeks - RGUKT Nuzvid

🎉 I just solved the Binary Tree ZigZag Level Order Traversal problem with a 0 ms runtime on LeetCode! 🚀 My Approach: Level Order Traversal using Queue: I used a queue data structure to perform a level order traversal of the binary tree. This helped me easily track and process nodes level by level. Reversing Alternate Rows: After obtaining the level order traversal, I reversed the nodes in the alternate levels (specifically ans[1], ans[3], ans[5], etc.). This created the zigzag pattern required by the problem. This efficient approach not only ensures optimal performance but also maintains clarity and simplicity in the code. Highlights: 0 ms runtime: Achieved the fastest runtime possible on LeetCode. Space Complexity: Managed the space complexity effectively by only storing necessary elements. #LeetCode #BinaryTree #Coding #Programming #DataStructures #Algorithms #Python #100DaysOfCode #Tech