Ankit Singh Tomar

Backend Engineer | Spring Boot | Microservices
System Design, DSA
On a Break from X

[Ankit Singh Tomar @Ankitdotdev]

@kunchenguid Owning the hardware was always the best
Then came cloud computing and people started paying more without realizing 😅

[Ankit Singh Tomar @Ankitdotdev]

@madebygps @learntocloud How i can contribute to your open source?

[Z.ai @Zai_org]

Introducing GLM-5.3-Flash

- Leading capabilities at a highly competitive price
- Natively multimodal with a 1M-token context window
- A 320B-A18B model released under the MIT License
- Previously previewed as Ox Alpha, running entirely on Chinese AI chips

Blog: https://t.co/tzOmB7gdZP

Available now across all official platforms:

Weights: https://t.co/9LRMahY9Wa
API: https://t.co/VcaQnzYmS9
Coding Plan: https://t.co/Nk8Y98HNhU
ZCode: https://t.co/Peepqv4XSx
Chat: https://t.co/WCqWT0qCQb
AutoClaw: https://t.co/aGEG5HqTTb

[Qwen @Alibaba_Qwen]

⚡Meet Qwen3.8-Flash, a multimodal MoE and an early preview of the Qwen4 architecture, now open-weight!

The production version Qwen3.8-Flash will be available soon via QwenCloud API at just $ 0.16/1M input tokens and $ 0.47/1M output tokens.

125B parameters + 51B N-gram embeddings, with just 6B activated per token. Unmatched cost-efficiency.

What's new: 🥳
- Next architecture: GDN + QSA hybrid attention, Gated Residual, N-gram Embedding & Muon optimizer, serving as a precursor to the architecture used in Qwen4.
- Dramatically lower training and inference costs: trained at just 1/9 the cost of Qwen3.7-Plus, while outperforming it across the board with especially strong gains in coding and office tasks.
- Strong performance: scoring 58.7 on DeepSWE 1.1, 62.5 on SWE-bench Pro, 73.9 on CoWorkBench, 84.5 on AndroidWorld, and 95.7 on MathVision (with CI).
- 262K native context, extensible to 1M with YaRN.

We’re also releasing the weights for Qwen3.8-Flash-Next, giving the community an early look at the new architecture we’re exploring for Qwen4.🚀

We can't wait to see what you build with Qwen3.8-Flash!👀👇
- Blog: https://t.co/M5hYypFLgJ
- Technical Report: https://t.co/IF0gObIkQO
- Hugging Face: https://t.co/6ow8QVAABt
- ModelScope: https://t.co/tDOn2jNuFG

[Ankit Singh Tomar @Ankitdotdev]

Day 200/365 of the DSA grind!
• Russian Doll Envelopes (Hard): Custom sorted the 2D array to reduce the problem to an O(N log N) Longest Increasing Subsequence!
• Largest Divisible Subset: Sorted the array to leverage transitive math properties and solved via DP with path reconstruction!
• Max Sum Rectangle <= K (Hard): Collapsed the 2D matrix into 1D arrays and used a TreeSet ceiling function for O(log N) prefix sum lookups!

Next week, the pivot to Backend Architecture begins!

#DSA #Java #200DaysOfCode #LeetCode #SoftwareEngineering

[Ankit Singh Tomar @Ankitdotdev]

Day 199/365 of the DSA grind!
• Top K Frequent Elements: Counted frequencies with a HashMap and efficiently extracted the top K using a Min-Heap in O(N log K) time!
• Intersection of Two Arrays: Used a HashSet to quickly find unique common elements in O(N+M) time.
• Intersection of Two Arrays II: Swapped the Set for a HashMap to accurately track and include duplicate intersections!

#DSA #Java #100DaysOfCode #LeetCode #HashMaps #PriorityQueue

[Ankit Singh Tomar @Ankitdotdev]

Day 198/365 of the DSA grind!
O(1) logic & HashMap magic:
• Increasing Triplet Subsequence: Maintained two variables (first & second) to find an increasing triplet in pure O(N) time and O(1) space!
• Self Crossing (Hard): Avoided storing 2D coordinates by mathematically detecting spiral intersections using just the last 5 distances!
• Palindrome Pairs (Hard): Prevented O(N²) TLE by splitting words into prefixes/suffixes and using a HashMap to find matching reversed strings instantly!

#DSA #Java #100DaysOfCode #LeetCode #Algorithms #SoftwareEngineering

[Ankit Singh Tomar @Ankitdotdev]

Day 197/365 of the DSA grind!
Graphs & Divide and Conquer:
• Longest Increasing Path (Hard): Prevented TLE by using DFS with a 2D Memoization array!
• Count of Range Sum (Hard): Combined Prefix Sums with a hacked Merge Sort to count valid range bounds in O(N log N) time!
• Reconstruct Itinerary (Hard): Built the graph using Priority Queues and used Hierholzer's Algorithm (Eulerian Path) to cleverly build the itinerary in reverse!

#DSA #Java #100DaysOfCode #LeetCode #GraphTheory #Algorithms

[Ankit Singh Tomar @Ankitdotdev]

Day 196/365 of the DSA grind!
Sorting, Memoization, & OOD Patterns:
• Wiggle Sort II: Sorted the array, then cleverly distributed the largest elements to odd indices and smaller elements to even indices.
• Word Break II (Hard): Used DFS with Memoization to cache valid sentence combinations and completely avoid TLE!
• Peeking Iterator: Wrapped a standard Iterator and used a pre-fetch `cache` variable to safely allow peeking at the next element without consuming it!

#DSA #Java #100DaysOfCode #LeetCode #SoftwareEngineering #Algorithms

[Ankit Singh Tomar @Ankitdotdev]

Day 195/365 of the DSA grind!
Matrix Traversal & Classic Backtracking:
• Spiral Matrix II: Simulated the spiral walk elegantly using direction arrays (dr, dc) and turning right upon hitting a wall!
• Sudoku Solver (Hard): Optimized the backtracking by using boolean arrays for O(1) row/col/box lookups and pre-caching empty cells!
• N-Queens (Hard): Tracked queen placements using clever diagonal math (row-col and row+col) for instant O(1) collision checks!

#DSA #Java #100DaysOfCode #LeetCode #Backtracking #Algorithms

[Ankit Singh Tomar @Ankitdotdev]

Day 194/365 of the DSA grind!
Greedy, Bitmasks, & Modified Merge Sort:
• Patching Array (Hard): A greedy approach! Tracked the smallest unreachable sum miss and optimally patched by doubling miss when needed.
• Max Product of Word Lengths: Converted words into 32-bit integer masks. Checked for shared letters instantly using (mask1 & mask2) == 0!
• Count of Smaller Numbers (Hard): Hacked the Merge Sort algorithm to count smaller elements jumping from the right half in pure O(N log N) time!

#DSA #Java #100DaysOfCode #LeetCode #MergeSort #Algorithms

[Ankit Singh Tomar @Ankitdotdev]

Day 193/365 of the DSA grind!
Deep DP Patterns today:
• Burst Balloons (Hard): Used the Matrix Chain Multiplication DP pattern! Padded the array and thought about which balloon bursts last to calculate max coins.
• Buy & Sell Stock with Cooldown: Modeled the problem as a 3-state machine (hold, sold, rest) to achieve pure O(1) space!
• Super Ugly Number: Maintained an array of pointers for k primes to efficiently generate the next smallest ugly number.

#DSA #Java #100DaysOfCode #LeetCode #DynamicProgramming #Algorithms

[Ankit Singh Tomar @Ankitdotdev]

Day 192/365 of the DSA grind! Range Sum Queries & Fenwick Trees:
• Range Sum 1D (Immutable): Standard Prefix Sum array for O(1) queries.
• Range Sum 2D (Immutable): Built a 2D Prefix Matrix using the Inclusion-Exclusion principle for O(1) rectangle sums!
• Range Sum (Mutable): Implemented a Binary Indexed Tree (Fenwick Tree) using index & -index to achieve O(log N) updates AND queries!

#DSA #Java #100DaysOfCode #LeetCode #PrefixSum #FenwickTree

[Ankit Singh Tomar @Ankitdotdev]

@amangoeliitb Had a similar experience with airtel at my home and with me so I ported all the numbers from airtel to Jio and BSNL also jio is doing pretty well in my hometown

[Boris Cherny @bcherny]

I talk to engineers at other companies every day and hear the same thing: one person is 10x'ing their output with Claude but the rest of the org hasn't caught up.

Watching teams adopt AI, I keep seeing the same 4 steps.

I mapped them out here: Steps of AI Adoption https://t.co/kQnRAUMKpP

[Ankit Singh Tomar @Ankitdotdev]

Day 191/365 of the DSA grind! Bit Magic & Cycle Detection:
• Single Number III: Used x & (-x) to isolate the rightmost set bit and separate the array into two XOR groups to find the unique numbers! • H-Index II: Leveraged the pre-sorted array to calculate the h-index in O(log N) time using Binary Search.
• Find the Duplicate Number: Treated the array values as pointers and used Floyd's Tortoise & Hare cycle detection to find the duplicate in O(1) space!

#DSA #Java #100DaysOfCode #LeetCode #Algorithms

[Ankit Singh Tomar @Ankitdotdev]

Day 190/365 of the DSA grind! Deques, Matrices, & Math:
• Sliding Window Maximum (Hard): Used a Monotonic Deque to keep track of the maximums in O(N) time by constantly popping smaller/older elements!
• Search a 2D Matrix II: Started at the top-right corner to elegantly navigate the sorted rows and columns in O(M+N) time!
• Missing Number: Skipped sorting and used Gauss's formula n*(n+1)/2 to find the missing number via simple arithmetic.

#DSA #Java #100DaysOfCode #LeetCode #Algorithms

[Ankit Singh Tomar @Ankitdotdev]

Day 189/365 of the DSA grind! Advanced Array Algorithms:
• Majority Element II: Extended the Boyer-Moore Voting Algorithm to track TWO candidates to find elements appearing > n/3 times. Pure O(1) space!
• Contains Duplicate III (Hard): Used a sliding window of Buckets (width = valueDiff + 1) to perfectly check value conditions in O(N) time without needing a balanced BST!

#DSA #Java #100DaysOfCode #LeetCode #Algorithms

[Ankit Singh Tomar @Ankitdotdev]

Day 188/365 of the DSA grind! Math, Circular DP, & Backtracking:
• Count Primes: Implemented the Sieve of Eratosthenes, optimally stopping the outer loop at ���n for lightning-fast execution!
• House Robber II: Solved the circular array constraint by breaking it into two linear House Robber problems and taking the max. Pure O(1) space!
• Combination Sum III: Textbook backtracking to precisely find k unique digits that sum to n.

#DSA #Java #100DaysOfCode #LeetCode #DynamicProgramming #Algorithms

[Ankit Singh Tomar @Ankitdotdev]

@AvinashSingh_20 gitLink : https://t.co/0eycfLTcLY
here is mine