DEV Community: Aditya

Arrays and Strings in C: Storing Many Values with Tested Programs (C Learning Guide, Part 6)

Aditya — Mon, 26 Oct 2026 12:51:37 +0000

In Part 6 of our beginner C series the packing tool finally remembers a whole day instead of one number: eight hourly order counts live in one array, and text becomes a string - an array of char with a hidden stop mark.

What the full guide covers:

Declaration, indexing and bounds: why C counts from 0, what lives in a[5] when you skip the braces, and why the compiler will not stop you at the edge of an array.
Walking an array with a for loop: totals, averages, the busiest hour, and counting hours above capacity in one pass.
Strings: char arrays, the '\0' terminator you can actually print, and the four workhorse functions - strlen, strcpy, strcat, strcmp - with the exact reason a = b fails for arrays (the real gcc error is shown).
Classic string algorithms by hand: reversing "table" into "elbat" and checking that "level" is a palindrome, plus dry-run tables that trace every swap.
Every program compiled with a C17 compiler with warnings on, and every output block is the captured output of a real run - including the compiler errors and the format-warning demo.

A taste of the style - one pass over the day gives three answers:

#include <stdio.h>
int main(void) {
    int orders[8] = {4, 9, 7, 12, 6, 10, 3, 8};
    int capacity = 10;
    int total = 0;
    int busiest = 0;
    int over = 0;
    for (int i = 0; i < 8; i = i + 1) {
        total = total + orders[i];
        if (orders[i] > orders[busiest]) {
            busiest = i;
        }
        if (orders[i] > capacity) {
            over = over + 1;
        }
    }
    printf("total orders today: %d\n", total);
    printf("busiest hour: index %d with %d orders\n", busiest, orders[busiest]);
    printf("hours above capacity %d: %d\n", capacity, over);
    return 0;
}

Output:

total orders today: 59
busiest hour: index 3 with 12 orders
hours above capacity 10: 1

Read the full guide with every example and practice exercise: Arrays and Strings in C: Storing Many Values with Tested Programs - C Learning Guide, Part 6

New to the series? It starts from zero setup here: Programming in C - Learning Guide series index

Functions in C: Declaration, Definition and Call by Value (C Learning Guide, Part 5)

Aditya — Sun, 25 Oct 2026 08:00:38 +0000

In Part 5 of our beginner C series the packing tool's logic moves out of main and into functions: write the check once, give it a name, call it from ten places, fix it in one spot.

What the full guide covers:

Declaration vs definition vs call: what each one says, and which of them the compiler and linker actually need.
Parameters in, return value out: the input/output contract of a function, and why void appears on both sides of main(void).
Prototypes: how to call a function that is defined later in the file, and the compiler errors you get when you skip this.
Call by value: C hands every function a copy of its arguments, so a callee cannot silently change the caller's variables - shown with a failing swap attempt and the real compiler output for each wrong turn.
Tested programs with verified expected output, plus the classic beginner mistakes (missing return, implicit declaration, swapped parameter order) with the exact diagnostics gcc prints.

A taste of the style - one job, written once, called three times:

#include <stdio.h>
int boxesNeeded(int items, int capacity) {
    int boxes = items / capacity;
    if (items % capacity != 0) {
        boxes = boxes + 1;
    }
    return boxes;
}
int main(void) {
    printf("items=%d capacity=%d boxes=%d\n", 17, 6, boxesNeeded(17, 6));
    printf("items=%d capacity=%d boxes=%d\n", 12, 6, boxesNeeded(12, 6));
    printf("items=%d capacity=%d boxes=%d\n", 5, 6, boxesNeeded(5, 6));
    return 0;
}

Output:

items=17 capacity=6 boxes=3
items=12 capacity=6 boxes=2
items=5 capacity=6 boxes=1

Read the full guide with every example and practice exercise: Functions in C: Declaration, Definition and Call by Value - C Learning Guide, Part 5

New to the series? It starts from zero setup here: Programming in C - Learning Guide series index

Loops in C: for, while and do-while (C Learning Guide, Part 4)

Aditya — Sat, 24 Oct 2026 05:46:51 +0000

In Part 4 of our beginner C series we move from decisions to repetition: loops. for, while and do-while can all express any repetition, but each one makes one shape of work read most clearly.

What the full guide covers:

The three loop shapes and how to pick between them: for when you know the number of passes (one per box, numbers 1 to 10), while when you repeat until a condition changes (packing until nothing remains), and do-while when the work must happen at least once (asking a question until the answer is valid).
break and continue: leave early or skip a turn without stopping everything.
Input validation loops: refuse bad input before the loop uses it, and re-ask without writing the question twice.
A side-by-side comparison table (condition checked when, runs at least once, when to reach for it) and runnable examples with verified expected output.

A taste of the style - counting down with a for loop:

#include <stdio.h>
int main(void) {
    for (int i = 3; i >= 1; i--) {
        printf("%d\n", i);
    }
    printf("Go!\n");
    return 0;
}

Output:

3
2
1
Go!

Read the full guide with every example and practice exercise: Loops in C: for, while and do-while - C Learning Guide, Part 4

New to the series? It starts from zero setup here: Programming in C - Learning Guide series index

Variables, Data Types and printf scanf in C: C Learning Guide, Part 2

Aditya — Thu, 22 Oct 2026 05:49:41 +0000

Part 2 of TechVani's free C Learning Guide is live: variables, data types and printf scanf in C.

This part covers how C stores and moves data: int, float, char and the other basic types, declaring and naming variables, reading input with scanf, printing with printf and its format specifiers, and the small conversion and sizing details exams love to test.

Every code sample in the guide is actually compiled and run, with the checked output shown beside it - no invented results.

Read the full part (free): https://techvaniai.blogspot.com/2026/10/variables-types-input-output-c-guide.html

if, else and Input Validation in C: C Learning Guide, Part 3

Aditya — Thu, 22 Oct 2026 05:45:02 +0000

Part 3 of TechVani's free C Learning Guide is live: if, else and input validation in C.

This part covers writing decisions in C the way exams and real programs need them: if / else if / else structure, the classic = vs == mistake in conditions, validating user input instead of trusting it, and small tested programs you can run and modify.

Every code sample in the guide is actually compiled and run, with the checked output shown beside it - no invented results.

Read the full part (free): https://techvaniai.blogspot.com/2026/10/if-else-input-validation-c-guide.html

Earlier parts:

Part 1: From a Problem to a C Program - https://techvaniai.blogspot.com/2026/10/from-problem-to-c-program-c-learning.html
Part 2: Variables, Data Types and printf scanf - https://techvaniai.blogspot.com/2026/10/variables-types-input-output-c-guide.html

Python mutable default arguments: why your list keeps growing (tested examples)

Aditya — Sun, 18 Oct 2026 05:47:14 +0000

A list that keeps growing between function calls is one of the most common Python surprises in exams and interviews. Here is why it happens, with output I ran on Python 3.10.

The bug

def add_bad(x, bucket=[]):
    bucket.append(x)
    return bucket

print(add_bad(1))
print(add_bad(2))
print(add_bad(3))

Output:

[1]
[1, 2]
[1, 2, 3]

You expected [1], [2], [3]. Python builds the default value once, when def runs, not on each call. Every call that skips bucket reuses the same list. You can see it:

print(add_bad.__defaults__)   # ([1, 2, 3],)

The fix

Use None as the default and create the list inside the function.

def add_ok(x, bucket=None):
    if bucket is None:
        bucket = []
    bucket.append(x)
    return bucket

print(add_ok(1))   # [1]
print(add_ok(2))   # [2]

Same family: shallow copies

list.copy() copies only the outer list. The inner lists are shared.

import copy
a = [[1, 2], [3, 4]]
b = a.copy()
b[0].append(99)
print(a)             # [[1, 2, 99], [3, 4]]  a changed too

c = copy.deepcopy(a)
c[0].append(5)
print(a, c)          # a is unchanged by c

Same family: the grid trap

grid = [[0] * 3] * 2
grid[0][0] = 7
print(grid)    # [[7, 0, 0], [7, 0, 0]]  both rows are one list

grid2 = [[0] * 3 for _ in range(2)]
grid2[0][0] = 7
print(grid2)   # [[7, 0, 0], [0, 0, 0]]

[x] * n repeats a reference to the same object. A list comprehension builds a new row each time.

Quick rule

Never use a list, dict or set as a default argument. Use None.
copy() and slicing are shallow. Use copy.deepcopy for nested data.
Build 2D grids with a comprehension, not *.

Try to predict the output of each snippet before you run it. That habit is what exam questions test.

I wrote a longer version with 7 more tested examples and exam-style questions here: Python Mutable Default Arguments and Shallow Copies. It is part of TechVani, a free BTech CSE notes and lab-files site.

Big Data Analytics Exam Prep: 1-Mark, 4-Mark and 6-Mark Answers for BTech

Aditya — Sun, 18 Oct 2026 05:41:39 +0000

Big Data Analytics is one of those BTech subjects where the syllabus is huge but the exam repeats the same question patterns every year. I put together an exam prep guide that focuses on the first three units and organizes answers the way university papers actually ask them.

The guide covers:

1-mark questions answered in one sentence each, for quick revision
4-mark questions answered in four short points, matching how examiners award marks
6-mark questions with fuller answers, including diagrams and tables where they help

Topics include the basics of big data, the 5 V's, Hadoop and its ecosystem, HDFS, MapReduce, and NoSQL databases - all written in simple English for students who are revising the night before the exam, not reading a textbook.

I built this for my own BTech CSE prep and published it on my blog TechVani, where I share study guides, programming tutorials, and exam notes. If your big data exam is coming up, this should save you hours of digging through slides.

Read the full guide here: Big Data Analytics Exam Prep on TechVani

From a Problem to a C Program: C Learning Guide for Beginners, Part 1

Aditya — Sun, 18 Oct 2026 04:20:28 +0000

Most C tutorials start with syntax. This one starts with a problem: a shopkeeper totalling a bill by hand.

In the first part of our C Learning Guide on TechVani, we walk through the full journey from a real-world situation to a working C program:

Define the problem precisely
Decide what data goes in and what result comes out
Choose the steps (the algorithm)
Write the C code
Compile, run and test it with real numbers

Every program in the guide is compiled and run before publication, and the printed output is shown next to the code, so you can verify each example yourself.

It is written for first-semester BTech students and complete beginners: no prior programming is assumed, and every term is explained the first time it appears.

Read the full guide with all tested programs: From a Problem to a C Program: C Learning Guide, Part 1

Balanced brackets with a stack: 5 tested examples in Python

Aditya — Fri, 16 Oct 2026 07:09:38 +0000

If an exam or interview asks you to check a string like ({[]}), a stack solves it in one pass. Every output below comes from a real run on Python 3.10.

The core idea

Scan left to right. Push every opening bracket on a stack. On a closing bracket, pop and check that it matches. Only two things can go wrong: the closing bracket does not match the top of the stack, or openings are left over at the end.

Example 1: the checker

def is_valid(s):
    pair = {')': '(', ']': '[', '}': '{'}
    stack = []
    for ch in s:
        if ch in '([{':
            stack.append(ch)
        elif ch in ')]}':
            if not stack or stack.pop() != pair[ch]:
                return False
    return stack == []

print(is_valid("({[]})"))
print(is_valid("(]"))
print(is_valid("([)]"))
print(is_valid("((("))
print(is_valid(""))

Output:

True
False
False
False
True

An empty string is balanced: nothing is left unmatched.

Example 2: watch "([)]" fail

Counting brackets is not enough. This string has one of each, and it is still wrong:

def trace(s):
    pair = {')': '(', ']': '[', '}': '{'}
    stack = []
    for i, ch in enumerate(s):
        if ch in '([{':
            stack.append(ch)
            print(f"step {i}: push {ch}  stack={stack}")
        else:
            if not stack or stack[-1] != pair[ch]:
                print(f"step {i}: '{ch}' needs '{pair[ch]}' on top, stack={stack} -> FAIL")
                return
            stack.pop()
            print(f"step {i}: pop  {ch}  stack={stack}")
    print("balanced" if not stack else f"unclosed left: {stack}")

trace("([)]")

Output:

step 0: push (  stack=['(']
step 1: push [  stack=['(', '[']
step 2: ')' needs '(' on top, stack=['(', '['] -> FAIL

The ) needs ( on top, but [ is in the way. The stack catches the order, not just the count.

Example 3: minimum brackets to add

For strings with only round brackets, count instead of using a real stack:

def min_adds(s):
    opens = adds = 0
    for ch in s:
        if ch == '(':
            opens += 1
        elif opens:
            opens -= 1
        else:
            adds += 1
    return opens + adds

print(min_adds("())"))
print(min_adds("((("))
print(min_adds("()))(("))

Output:

1
3
4

Example 4: minimum removals to fix a string

Track indices, then drop every bracket that never matched:

def min_removals(s):
    stack = []          # indices of '(' waiting for a match
    drop = set()        # indices to remove
    for i, ch in enumerate(s):
        if ch == '(':
            stack.append(i)
        elif ch == ')':
            if stack:
                stack.pop()
            else:
                drop.add(i)
    drop.update(stack)  # '(' that never matched
    return ''.join(ch for i, ch in enumerate(s) if i not in drop)

print(repr(min_removals("a)b(c)d")))
print(repr(min_removals("(a(b)c")))
print(repr(min_removals(")(")))

Output:

'ab(c)d'
'a(b)c'
''

Example 5: longest valid substring

A classic interview follow-up. Keep the index before the current valid run at the bottom of the stack:

def longest_valid(s):
    stack = [-1]
    best = 0
    for i, ch in enumerate(s):
        if ch == '(':
            stack.append(i)
        else:
            stack.pop()
            if stack:
                best = max(best, i - stack[-1])
            else:
                stack.append(i)
    return best

print(longest_valid("(()"))
print(longest_valid(")()())"))
print(longest_valid(""))

Output:

2
4
0

When to reach for a stack

Any "is this nested correctly" question: brackets, tags, undo history, function calls.
Counting alone never works: ([)] has equal counts and is still wrong.
One pass is enough: every example here is O(n) time and O(n) worst-case space.

More stack practice (postfix evaluation, circular queues) in DSA in 30 Days, Episode 4: https://techvaniai.blogspot.com/2026/10/dsa-04-stack-postfix-evaluation-circular-queue.html

Python docs on using lists as stacks: https://docs.python.org/3/tutorial/datastructures.html#using-lists-as-stacks

Python deque vs list: why list.pop(0) gets slow (5 tested examples)

Aditya — Thu, 15 Oct 2026 09:54:56 +0000

If you only ever call list.pop(0), your program works fine until the queue gets big. Then it slows down. Here is why, and what to use instead. Every output below comes from a real run on Python 3.10.

The core difference

A list is a dynamic array. pop(0) removes the first item and shifts every other item one place left, so it costs O(n). A deque (double-ended queue) is a linked set of blocks, so adding or removing at either end is O(1).

Example 1: both ends

from collections import deque
q = deque([1, 2, 3])
q.append(4); q.appendleft(0)
print(q)
print(q.popleft(), q.pop(), q)

Output:

deque([0, 1, 2, 3, 4])
0 4 deque([1, 2, 3])

Example 2: fixed-size window with maxlen

r = deque([1, 2, 3, 4, 5], maxlen=3)
print(r)
r.append(6); print(r)

deque([3, 4, 5], maxlen=3)
deque([4, 5, 6], maxlen=3)

Example 3: rotate

d = deque([1, 2, 3, 4, 5]); d.rotate(2); print(d)

deque([4, 5, 1, 2, 3])

Example 4: BFS, the classic queue use

g = {'A':['B','C'],'B':['D'],'C':['D','E'],'D':[],'E':[]}
def bfs(s):
    seen = {s}; q = deque([s]); out = []
    while q:
        n = q.popleft(); out.append(n)
        for m in g[n]:
            if m not in seen:
                seen.add(m); q.append(m)
    return out
print(bfs('A'))

['A', 'B', 'C', 'D', 'E']

Example 5: timing 50,000 pops from the front

import timeit
def lst():
    l = list(range(50000))
    while l: l.pop(0)
def dq():
    l = deque(range(50000))
    while l: l.popleft()
print("list.pop(0):", round(timeit.timeit(lst, number=1), 3), "s")
print("deque.popleft():", round(timeit.timeit(dq, number=1), 3), "s")

list.pop(0): 0.189 s
deque.popleft(): 0.002 s

Exact times depend on your machine. The gap grows as the queue grows.

When to use which

Queue, BFS, sliding window: deque.
Random access by index in the middle: list (deque indexing in the middle is O(n)).
Stack only (push/pop at the end): list is fine.

I wrote a longer version with 8 tested examples, a FIFO trace and exam questions here: https://techvaniai.blogspot.com/2026/10/python-deque-vs-list-queue-operations-8-tested.html

Official docs: https://docs.python.org/3/library/collections.html#collections.deque

Python mutable default arguments: why your list keeps growing (tested examples)

Aditya — Wed, 14 Oct 2026 05:55:54 +0000

A list that keeps growing between function calls is one of the most common Python surprises in exams and interviews. Here is why it happens, with output I ran on Python 3.10.

The bug

def add_bad(x, bucket=[]):
    bucket.append(x)
    return bucket

print(add_bad(1))
print(add_bad(2))
print(add_bad(3))

Output:

[1]
[1, 2]
[1, 2, 3]

You expected [1], [2], [3]. Python builds the default value once, when def runs, not on each call. Every call that skips bucket reuses the same list. You can see it:

print(add_bad.__defaults__)   # ([1, 2, 3],)

The fix

Use None as the default and create the list inside the function.

def add_ok(x, bucket=None):
    if bucket is None:
        bucket = []
    bucket.append(x)
    return bucket

print(add_ok(1))   # [1]
print(add_ok(2))   # [2]

Same family: shallow copies

list.copy() copies only the outer list. The inner lists are shared.

import copy
a = [[1, 2], [3, 4]]
b = a.copy()
b[0].append(99)
print(a)             # [[1, 2, 99], [3, 4]]  a changed too

c = copy.deepcopy(a)
c[0].append(5)
print(a, c)          # a is unchanged by c

Same family: the grid trap

grid = [[0] * 3] * 2
grid[0][0] = 7
print(grid)    # [[7, 0, 0], [7, 0, 0]]  both rows are one list

grid2 = [[0] * 3 for _ in range(2)]
grid2[0][0] = 7
print(grid2)   # [[7, 0, 0], [0, 0, 0]]

[x] * n repeats a reference to the same object. A list comprehension builds a new row each time.

Quick rule

Never use a list, dict or set as a default argument. Use None.
copy() and slicing are shallow. Use copy.deepcopy for nested data.
Build 2D grids with a comprehension, not *.

Try to predict the output of each snippet before you run it. That habit is what exam questions test.

Average memory access time with a cache: formula and a worked example

Aditya — Mon, 05 Oct 2026 05:08:39 +0000

Average memory access time (AMAT) tells you how fast a memory system is on average, once you account for cache hits and misses.

For one cache level plus main memory, with hit ratio h, cache access time Tc and main memory time Tm:

If memory is accessed only after a miss is detected: AMAT = h x Tc + (1 - h) x (Tc + Tm)
If cache and memory are accessed in parallel: AMAT = h x Tc + (1 - h) x Tm

Example: h = 0.9, Tc = 10 ns, Tm = 100 ns. With the sequential formula, AMAT = 0.9 x 10 + 0.1 x 110 = 20 ns. Parallel access gives 0.9 x 10 + 0.1 x 100 = 19 ns.

The exam trap is picking the wrong formula, so always check whether the question says the memory is accessed after a miss or simultaneously.

I wrote up 6 more solved numericals (including multi-level cache and effective CPI) on my blog TechVani: https://techvaniai.blogspot.com/2026/10/cache-memory-numericals-6-solved.html