Optimal Stock Buying and Selling for Maximum Profit

Hello dudes and dudettes!! 🚀 Day 12/150 — Solved LeetCode 380: Insert Delete GetRandom O(1) Today’s problem felt like a real brain workout 🧠 — not because it was long, but because it demanded the right idea. At first, it looks simple: 👉 Insert 👉 Delete 👉 Get Random But the catch? ⚡ All operations must run in O(1) time That’s where things get interesting. 🧠 Initial Thought Process Using a list? Insert ✅ Get random ✅ Remove ❌ (takes O(n)) Using a set? Insert ✅ Remove ✅ Get random ❌ So clearly… one data structure alone isn’t enough. 💡 The Breakthrough Moment The solution clicked when I realized: 👉 Why not combine the strengths of both? Use a list for fast random access Use a hash map for instant lookups This combination unlocks true O(1) performance for all operations. 🔥 The Most Interesting Part — Deletion Trick Normally, removing an element from a list is expensive because elements need to shift. But here’s the smart trick: 👉 Swap the element to be removed with the last element 👉 Remove the last element 👉 Update the index in the hash map That’s it. No shifting. No extra cost. 💥 Constant time deletion achieved. 📊 How It Works (Simple Flow) Imagine storing values like this: A list keeps all elements A map stores each value’s index Whenever you: Insert → add to list + store index Remove → swap + pop + update index GetRandom → pick directly from list Everything stays efficient and clean. 😎 What I Learned Sometimes one data structure isn’t enough — combining them is the real power Smart tricks (like swap & pop) can completely change time complexity Designing systems is more about thinking than coding 🎯 Key Takeaway “Efficiency isn’t about doing things faster… it’s about avoiding unnecessary work.” 🔥 Another solid step forward in the journey. On to the next challenge. #LeetCode #Algorithms #DataStructures #ProblemSolving #CodingJourney #100DaysOfCode #Python #LearningInPublic

Shallow Copy vs Deep Copy — The 2 AM Bug Trap 🛑 Most developers think they understand copying objects, until their original data mysteriously changes. That’s not a bug, that’s memory behavior biting you. → Shallow Copy Creates a new container, but nested objects are still shared (by reference) 👉 Change nested data → both copies change. Best for: Flat, simple data. → Deep Copy Creates a completely independent clone, everything is copied recursively. 👉 Change anything → original stays untouched Best for: Complex, nested structures. 💡 Rule of Thumb Shallow → when you only need a surface-level copy Deep → when you need true isolation ⚠️ The real trap: Most bugs aren’t syntax errors. They come from not understanding how data behaves in memory. If you’ve ever spent hours debugging only to realize it was a shallow copy issue. Welcome to the club 😄 #Python #Python3 #Programming #SoftwareEngineering #CleanCode #Debugging #TechTips #PythonDeveloper  #BackendDevelopment

From Analysis to Action: Building a Predictive Dashboard for A/L Performance 🚀💻 Following our research on the GCE A/L results, I wanted to make our findings interactive and accessible. I developed this Streamlit Web Application to transform static data into a dynamic exploration tool. Features I’m most excited about: ⚖️ Equity Simulation: An interactive tab using Lorenz Curves and Gini Coefficients to visualize achievement distribution. 🔮 Z-Score Predictor: A real-time tool that estimates performance based on subject marks and background features. 🎨 User Experience: Designed to make complex Exploratory Data Analysis (EDA) intuitive for any user. Building this helped me bridge the gap between statistical modeling and software deployment. It's one thing to find an insight—it's another to build a tool that lets others find them too! Check out the demo below! 👇 #Streamlit #Python #DataVisualization #WebDev #DataScience #AppliedStatistics #Portfolio #Coding

I recently had a very interesting problem to solve: how to safely store and parse user inputted formulas for our analytics platform. At first glance, it sounds simple. Take a formula, evaluate it, return a number. Something like: (meta.spends + (ads.spends - 50)) * 100 My first instinct was the obvious one: just evaluate the string. That idea lasted about 30 seconds. Because the moment you try to do this in a real system, things get complicated very quickly: • Users can input anything which is a security risk • Formulas need to be reusable and debuggable • Metrics depend on other metrics so ordering matters • You need control over functions and allowed operations I explored existing options, but they were either unsafe (like "eval"), too limited or too heavy for what we needed. I realized we had to build a lightweight execution engine, so here's what we ended up doing: 1. Parse the formula into an Abstract Syntax Tree (AST) 2. Evaluate it in a controlled environment (no arbitrary execution) 3. Extract dependencies to understand which variables are required 4. Support custom functions like SUM, AVG, etc. But the most interesting realization came later. Formulas are not isolated, they form a graph. One metric depends on another, which can depend on another in turn. Suddenly, this becomes a dependency problem. Which means: • You need to resolve execution order • You need to detect cycles • You need to think like a query planner, not just a parser What started as "just evaluate a formula" turned into designing a small, safe, and extensible computation layer. And this is something I have noticed repeatedly. The interesting problems are not always the big ones. They are the ones that look simple enough to ignore, until you try to build them properly. #engineering #systemdesign #python #analytics #backend #softwaredevelopment

Tomorrow, 𝗧𝗶𝘁𝗮𝗻𝗫 𝗴𝗼𝗲𝘀 𝗹𝗶𝘃𝗲. Here's what you'll see. 𝐀𝐬𝐤 𝐭𝐡𝐞 𝐃𝐞𝐞𝐩 𝐀𝐠𝐞𝐧𝐭 𝐚 𝐫𝐞𝐬𝐞𝐚𝐫𝐜𝐡 𝐪𝐮𝐞𝐬𝐭𝐢𝐨𝐧. 𝐖𝐚𝐭𝐜𝐡 𝐢𝐭: - Break it into investigation steps - Ask for your approval before proceeding (Human-in-the-Loop) - Search the web, gather data - Stream live progress with visual status updates - Deliver a report with interactive charts, KPI cards, comparison tables — all inline in chat - No matplotlib. No Python scripts. No file downloads. 𝐉𝐮𝐬𝐭 𝐛𝐞𝐚𝐮𝐭𝐢𝐟𝐮𝐥, 𝐢𝐧𝐭𝐞𝐫𝐚𝐜𝐭𝐢𝐯𝐞 𝐯𝐢𝐬𝐮𝐚𝐥𝐬 𝐫𝐞𝐧𝐝𝐞𝐫𝐞𝐝 𝐝𝐢𝐫𝐞𝐜𝐭𝐥𝐲 𝐢𝐧 𝐭𝐡𝐞 𝐜𝐨𝐧𝐯𝐞𝐫𝐬𝐚𝐭𝐢𝐨𝐧. Bar charts. Pie charts. Metric grids. Timelines. Gauges. Citations with reliability scores. All from a single prompt. 𝗧𝗼𝗺𝗼𝗿𝗿𝗼𝘄. 𝟭𝟬 𝗔𝗠 𝗖𝗲𝗻𝘁𝗿𝗮𝗹. 🔗 https://lnkd.in/g6XB5AN9 #ProductLaunch #AIDemo #DataVisualization #AGUI

In today’s crowded AI agent space, TitanX’s Deep Agent represents a notable advancement in practical capability. Tomorrow at 10 AM Central, the demo will showcase an agent that: - Decomposes complex research questions into structured steps - Seeks explicit human approval before execution - Performs live web research with visual progress updates - Delivers executive-ready outputs directly in chat, like interactive charts, KPI cards, comparison tables, timelines, gauges, and sourced citations, all rendered natively, without code or exports. This moves beyond text-heavy responses toward true AGUI, potentially accelerating insight cycles for strategy, research, and decision-making teams. Worth attending if you’re evaluating agentic AI for enterprise impact. Drop a comment if you plan to attend, especially if you are interested. 🔗 Original post: https://lnkd.in/gwyM4ZnG #AI #EnterpriseAI #DigitalEmployee #DigitalTwinOrganization #AgenticAI #AIAgents #AISafety #AIOrchestration #LLM #GenerativeAI #Automation #CyberSecurity #IAM #RBAC #ZeroTrust #AIops #MachineLearning #OpenSource #TypeScript #FutureOfWork #AutonomousAgents #AIGovernance #TechInnovation #DigitalTransformation #CES #TitanX #ProductLaunch #BuildInPublic #AIEngineering

💡 If you see 'find pair', 'count', or 'seen before' — think HashMap. Why this matters: - Turn nested loops into O(n) with a HashMap — and explain it cleanly. This topic appears repeatedly in interviews and real projects, so depth matters. Deep dive: - 🗂️ HashMap helps store and retrieve in O(1) average: • Seen elements • Frequencies / counts • Indices of elements | Practical note: connect this point to a real dataset, tool, or system decision. - 🎯 Classic HashMap problems: • Two Sum • Anagram detection • Longest substring without repeat • Frequency counts and mode | Practical note: connect this point to a real dataset, tool, or system decision. - ⚖️ Time-space trade-off: • You trade O(n) more space • To reduce time from O(n²) → O(n) • Almost always worth it | Practical note: connect this point to a real dataset, tool, or system decision. - 🗣️ In interviews, always explain: • What the map stores • When the map updates • What invariant the map maintains | Practical note: connect this point to a real dataset, tool, or system decision. - ⚠️ Edge cases to handle: • Duplicate values • Negative numbers • Initialization (0 vs 1 indexing) | Practical note: connect this point to a real dataset, tool, or system decision. How to practice today: - Define one measurable objective and baseline before changing anything. - Implement one small experiment and log outcomes clearly. - Review failure cases and write 3 improvements for the next iteration. Common mistakes to avoid: - Skipping evaluation design and relying only on one metric. - Ignoring edge cases and production constraints (latency/cost/drift). - Not documenting assumptions, data limits, and trade-offs. Mini challenge: - Build a small proof-of-concept on "DSA (Interview)" and publish your learning with metrics + trade-offs. 📌 If you want, I'll post a 'HashMap patterns' list with example problems. #dsa #algorithms #interviewprep #python #coding

💡 If your data is sorted (or can be sorted), two pointers might be the optimal move. Why this matters: - How to spot two-pointer opportunities and explain the invariant. This topic appears repeatedly in interviews and real projects, so depth matters. Deep dive: - 🎯 Use two pointers to reduce nested loops: • Left/right pointers from both ends • Slow/fast pointers for cycle detection • Window boundary pointers | Practical note: connect this point to a real dataset, tool, or system decision. - 📚 Common two-pointer problems: • Pair sum in sorted array • Remove duplicates in-place • Palindrome check • Container with most water | Practical note: connect this point to a real dataset, tool, or system decision. - 📌 Always define the invariant: • What remains TRUE as pointers move? • e.g., 'window contains only unique characters' • Invariant = your proof of correctness | Practical note: connect this point to a real dataset, tool, or system decision. - ⚖️ Sorting can enable two pointers: • Adds O(n log n) to complexity • But may enable O(n) pointer phase • Always mention this trade-off | Practical note: connect this point to a real dataset, tool, or system decision. - 🗣️ In interviews, be explicit: • Why do you move left++? • Why do you move right--? • What condition triggers each move? | Practical note: connect this point to a real dataset, tool, or system decision. How to practice today: - Define one measurable objective and baseline before changing anything. - Implement one small experiment and log outcomes clearly. - Review failure cases and write 3 improvements for the next iteration. Common mistakes to avoid: - Skipping evaluation design and relying only on one metric. - Ignoring edge cases and production constraints (latency/cost/drift). - Not documenting assumptions, data limits, and trade-offs. Mini challenge: - Build a small proof-of-concept on "DSA (Interview)" and publish your learning with metrics + trade-offs. 💬 Want a 'two pointers' problem set with difficulty progression? #dsa #interviewprep #algorithms #python #coding

❌ Still using loops in Pandas? ✅ Master these 30 functions → 10X faster analysis. 📥 LOADING: read_csv() | read_excel() 🔍 EXPLORATION: head() | info() | describe() | shape 🧹 CLEANING: dropna() | fillna() | drop_duplicates() ✨ TRANSFORM: rename() | astype() | apply() 📊 ANALYSIS: groupby() | pivot_table() | value_counts() | merge() 🎯 SELECTION: loc[] | iloc[] | query() 💡 QUICK EXAMPLE: ```python df = pd.read_csv('data.csv') df.dropna(inplace=True) df.groupby('Category')['Sales'].sum() ``` 🔥 MY FAVORITE: `groupby()` - Replaced 50 lines of loops with 1 line! ❓ What's YOUR go-to function? → groupby()? → apply()? → loc/iloc[]? Comment 👇 📥 **GET FREE CHEAT SHEET** Comment "PANDAS" or DM me --- 🔁 REPOST if Pandas saved you hours! 👍 Like for more Python tips 💬 Share your favorite function #Pandas #Python #DataAnalytics #Learning #CareerGrowth

Built a local LLM benchmarking dashboard. Here's what it does and why it matters: 𝗪𝗵𝗮𝘁 𝗶𝘁 𝗱𝗼𝗲𝘀: Run any prompt → measure response time → compare answers side by side 𝗪𝗵𝘆 𝗱𝗼𝗲𝘀 𝘁𝗵𝗶𝘀 𝗺𝗮𝘁𝘁𝗲𝗿? In real world scenarios, choosing the right model is one of the most important decisions you make. A model that is too slow will frustrate users. A model that is too small might give poor quality answers. This project teaches you how to make that decision using data — not guesswork. -Speed matters, a 30 second response time is unacceptable in most products -Quality matters, a fast model that gives wrong answers is useless -Cost matters, larger models use more compute and cost more to run -The right model depends on the use case, there is no single best model 𝗠𝗼𝗱𝗲𝗹𝘀 𝘁𝗲𝘀𝘁𝗲𝗱: llama3.2 (2GB) · phi4-mini (3GB) · qwen3.5:9b (6.6GB) All using Q4_K_M quantization 𝗞𝗲𝘆 𝗶𝗻𝘀𝗶𝗴𝗵𝘁: Model size alone does not determine speed. Architecture, quantization format, and memory loading all play a role. Always benchmark on your own hardware — results vary by machine. 𝗧𝗲𝗰𝗵 𝘀𝘁𝗮𝗰𝗸: Python · Ollama · Streamlit Runs fully locally — zero API costs. GitHub: https://lnkd.in/drwCqcgJ #AIEngineering #LLM #Benchmarking #Ollama #Python #BuildingInPublic