Mastering Data Types in Programming

🧠 **C# Tricky Basic Question – Day 4** Let’s test your understanding of **floating-point behavior in C#**. ```csharp float f = 0f / 0f; Console.WriteLine(float.IsNaN(f)); ``` 💡 **What will be the output?** A) True B) False C) Compile Error D) Runtime Error Many developers expect a **runtime error** when dividing by zero… but floating-point numbers behave differently in C#. ⚡ Understanding concepts like **NaN (Not a Number)** is important when working with **numeric computations, data processing, and scientific calculations**. 👇 **Comment your answer before running the code.** I'll share the explanation in the comments. Follow for more **daily C# tricky questions** that sharpen your programming fundamentals. #CSharp #DotNet #Programming #CodingInterview #DeveloperCommunity #SoftwareDevelopment #Codi

🔥 Day 532 of #750DaysOfCode 🔥 ✅ Solved: 1622. Fancy Sequence (Hard) Today’s problem was a tough one! This question required designing an API that supports multiple operations on a sequence efficiently using modular arithmetic, lazy updates, and modular inverse. Instead of updating every element for each operation, I used a mathematical transformation approach with two variables to keep track of multiplication and addition globally. This helped achieve O(1) per operation. 💡 Key Concepts Used: Modular Arithmetic (10^9 + 7) Fast Power (Binary Exponentiation) Modular Inverse Lazy Transformation Technique Design Data Structure 🚀 Approach: Maintain two variables a and b to represent transformation Store values in normalized form Use modular inverse while appending Compute actual value during getIndex 💻 Language: Java 💻 Topic: Design + Math + Hashing + Modular Arithmetic Hard problems like this really improve problem-solving skills and understanding of mathematical optimizations. 🔗 LeetCode Problem: Fancy Sequence #leetcode #java #datastructures #algorithms #codingchallenge #100daysofcode #programming #softwareengineer #backenddeveloper #dsa #750daysofcode

🚀 Day 121/500 – LeetCode DSA Challenge Today I solved three problems focused on strings and number manipulation. ✅ Reverse String II – Reversed every k characters using two pointers. TC: O(n) | SC: O(n) ✅ Reverse Only Letters – Applied two-pointer approach while skipping non-letter characters. TC: O(n) | SC: O(n) ✅ Digitorial Permutation – Calculated factorial sum of digits and checked digit frequency match. TC: O(d) | SC: O(1) 💡 Key Learning: Two-pointer techniques simplify many string problems, and digit-based problems often rely on frequency counting and math logic. 👉 Day 121/500 #DSA #Java #500DaysChallenge #ProblemSolving #CodingJourney

Just shipped a 25 category function test suite for Chuks programming language. One file. One golden output. Every way you can write a function in the language, exercised end-to-end. Here's what's covered: → All arrow forms: expression body, block body, zero-param, single-param → Named declarations, anonymous expressions, IIFEs → Default & optional parameters → Function type annotations and arrow type annotations in param/return positions → Higher-order functions: compose, factories, twice → Closures: counter pattern, multi-var capture, mutable shared state via getter/setter pairs → Nested functions: 2-level and 3-level deep → Recursion: fib, sumTo → Generic classes & methods: Box<T>, map<U>, Pair<A,B> → Async functions with await → Class methods: chaining, closures from methods, static → Functions in data structures: arrays and maps of functions → Callbacks: .map(), .filter(), .reduce() using all function styles → Currying: 3-level chain → Void functions, mixed parameter types, functions as arguments This isn't just a test suite, it's a living spec. If you want to understand what Chuks functions look like, this file is the answer. Follow ChuksLang on X for more: https://lnkd.in/egzWUUmR Visit chuks.org to try Chuks #ProgrammingLanguages #Compilers #softwareEngineering #Chukslang #programming

Python Journey — Day 17 | Functions & Real-World Application Today I worked on implementing string methods using logic and also built a small real-world project. Problems I solved : • Implement title() using logic • Implement split() manually • Implement join() manually • Implement center() functionality • Implement zfill() functionality 💡 Additionally, I built a mini project: • Menu-driven Banking System (Deposit, Withdraw, Check Balance) I implemented all string operations using custom logic instead of built-in functions to understand how they work internally. The banking system helped me apply functions in a real-world scenario with proper flow and user interaction. Today's learnings: Improving function design for real applications Handling user input and menu-driven programs Building confidence by creating a small real-world project Today felt exciting as I moved from basic problems to building a practical application. 10000 Coders On to Day 18 #Python #PythonDeveloper #Programming #Coding #10000coders #LearningJourney #ProblemSolving #MiniProject #CodeEveryDay #FutureDeveloper #KeepLearning

DSA series... 🚀 Chapter 2: "Sliding Window Fixed Size" LeetCode#30: (Level: Hard) Substring with Concatenation of All Words... This problem can be solved efficiently using the "Sliding Window + HashMap" approach to detect valid word combinations inside a string. Simple Flow Explanation... ✍️ 1⃣ Initialize Essentials... - Check edge cases and calculate the "single word length" and the "total length of all words combined". 2⃣ Map the Target Words... - Store each word and its expected frequency in a "HashMap" to know how many times it should appear. 3⃣ Use Offset Strategy... - Since every word has the same length, start sliding windows from multiple offsets (0 to wordLength−1) to cover all possible positions. ** Expand the Window ** - Move the "right pointer" word by word and add each discovered word to the current frequency map. ** Shrink the Window ** - If a word appears more times than expected, move the "left pointer" to remove extra words from the window. 4⃣ Match and Record... - When the window contains all required words with correct frequencies, record the starting index. 5⃣ Reset on Invalid Word... - If a word is "not in the target list", clear the current window and start checking from the next position. Why This Works... 🛠️ Instead of checking every substring, we treat the string as fixed-length word blocks and slide the window efficiently. Complexity... 📊 Time Complexity : O(n × wordLength). Space Complexity : O(m) ; m -> Unique words. Stay tuned for next chapter that was "Sliding Window - Dynamic Programming"... 🔥 If you have any thoughts and suggestions, Drop on the comment section or DM me... 💬 #Java #Algorithms #SlidingWindow #LeetCode #CodingInterview #DSA #SoftwareEngineering

## C Post 4: Small Syntax Details Matter More Than You Think In C, comments, keywords, and identifiers look basic. But they shape how clearly you write and read code. Comments explain intent. Keywords are reserved words like `int`, `return`, and `if`. Identifiers are the names you create for variables and functions. ```c #include <stdio.h> int main(void) {   int score = 95;  /* score is an identifier */   // printf is a library function name   printf("score = %d\n", score);   return 0; } ``` What syntax detail helped C start making sense to you? #CProgramming #CodingJourney #CSyntax

Day 53 of #100DaysOfLeetCode 💻✅ Solved #171. Excel Sheet Column Number problem in Java. Approach: • Initialized a variable to store the result • Traversed each character of the string • Converted each character to its corresponding value using `'A' → 1` • Multiplied the current result by 26 (base value) and added the character value • Repeated the process to build the final column number Performance: ✓ Runtime: 1 ms (Beats 91.40% submissions) ✓ Memory: 43.31 MB (Beats 92.36% submissions) Key Learning: ✓ Understood how base-26 number system works ✓ Learned how to convert characters into numeric values ✓ Strengthened problem-solving skills with string and math combination Learning one problem every single day 🚀 #Java #LeetCode #DSA #Strings #Math #ProblemSolving #CodingJourney #100DaysOfCode

Day 59 — Understanding Threads in Modern C++ Today, I explored multithreading in C++ using "std::thread." A thread is an independent path of execution within a program, allowing tasks to run concurrently rather than sequentially. Here’s a basic example: #include <iostream> #include <thread> void task() { std::cout << "Hello from thread!\n"; } int main() { std::thread t(task); t.join(); // wait for the thread to finish } Key concepts I learned include: • "std::thread" creates a new execution path • "join()" waits for a thread to finish • "detach()" allows it to run independently • Shared data between threads must be protected using "std::mutex" • Modern C++ threading is portable with "<thread>" and "<chrono>" One important lesson: not all compilers support threading equally. Some older MinGW versions don’t fully support "std::thread," highlighting the importance of understanding your toolchain alongside the language. Threads offer significant opportunities for performance, concurrency, and real-world system programming. Step by step, I am getting closer to mastering modern C++.

Most of us know that adding strings in a loop is a performance killer. Still, even a single line of concatenation can create a "terrifying abyss" of temporary objects and unnecessary memory allocations. I just published a deep dive on Medium about String Expressions—a technique that gives you JavaScript-level syntax with performance that beats manual reserve() and append() optimization. In this post: ✅ Why std::format isn't always the answer. ✅ The hidden cost of std::to_string. ✅ How the simstr library uses lazy evaluation to achieve 20% faster results than manual C++ code. #cpp #programming #algorithms