DK-006 — IQ & Interview Puzzle Practice

1. Break all 4 pills in half → 8 halves.
2. Combine halves of the same type (though unknown) to form 2 new full pills:
   • Half from A1 + Half from A2 → full A pill
   • Half from B1 + Half from B2 → full B pill
3. Consume one full A pill and one full B pill.

Clever trick: dividing and recombining ensures you get one of each type without knowing which is which.

pills = ["A","A","B","B"]
# split into halves
halves = [p/2 for p in pills]  # abstract representation
# combine halves randomly
# logic ensures 1 full A + 1 full B

1. Split balls into 3 groups of 4.
2. Weigh 4 vs 4: determine which group has the odd ball.
3. Split that group further and weigh to narrow down.
4. Third weighing identifies the odd ball and whether it’s heavier or lighter.

Classic problem testing divide-and-conquer and reasoning under constraints.

1. Send 1 & 2 → 2 min
2. 1 returns → 1 min
3. Send 5 & 10 → 10 min
4. 2 returns → 2 min
5. Send 1 & 2 → 2 min Total: 17 min

Strategy: send fastest back to minimize wait time.

1. Appoint 1 prisoner as “counter”.
2. Each prisoner flips the bulb once when visiting (only first time).
3. Counter tracks flips.
4. When counter counts 99 flips → all prisoners visited.

Tests coordination and indirect communication.

1. Light Rope 1 at both ends → burns in 30 min
2. Light Rope 2 at one end simultaneously
3. When Rope 1 finishes → 30 min passed
4. Light Rope 2 at other end → burns remaining 15 min Total: 45 min

Tests time estimation with non-linear resources.

1. Pick any 50 coins → form a pile.
2. Flip all 50 coins in that pile.
3. Both piles now have equal heads.

Insight: flipping inverses the distribution.

• Only switches with perfect square numbers have odd factors → end up ON.
• Remaining switches OFF are non-square numbers.

1. Fill 5L jug → pour into 3L jug → 2L remain
2. Empty 3L → pour remaining 2L
3. Fill 5L → pour 1L into 3L (now 4L left)

Classic Diophantine / GCD application problem.

• Number bottles 0–999 in binary
• Each rat drinks bottles with 1 in corresponding bit position
• Observe which rats die → reconstruct poisoned bottle binary → decimal

Binary encoding trick.

• Send 120+80 → 200
• 40 returns → 40
• Send 100+60 → 160
• 40 returns → 40
• Send 40+40? wait adjust…
• Apply greedy + pairing strategy for minimal trips

Tests optimization under constraints.

• Place queens row by row, backtrack if conflict arises
• Solution uses recursion / backtracking

def solve_n_queens(n):
    solutions = []
    def backtrack(row, queens, xy_diff, xy_sum):
        if row == n:
            solutions.append(queens)
            return
        for col in range(n):
            if col not in queens and row-col not in xy_diff and row+col not in xy_sum:
                backtrack(row+1, queens+[col], xy_diff+[row-col], xy_sum+[row+col])
    backtrack(0,[],[],[])
    return solutions

• Drop first egg in increasing interval floors: 14, 27, 39…
• Use second egg linearly to find exact floor
• Optimal strategy: triangular numbers

• Iteratively measure segments → track total → sum to 10m
• Tests resource allocation under uncertainty

• Strategy: break journey into stages, leave caches along path
• Optimizes resource transport with consumption

• Translate statements into Boolean equations
• Solve logically → deduce identities

• Carry goose first, return, carry fox, swap goose, carry beans, return goose
• Sequential reasoning puzzle

• Impossible: removed squares are same color → dominoes cover 1 black + 1 white
• Test parity reasoning

• Use systematic elimination → similar to Mastermind strategies

• Track toggles → use binary / modular arithmetic
• Tests pattern recognition under constraints

• Similar to Problem 2, but generalized for N coins
• Apply divide-and-conquer strategy

• Initial pick: 1/3 chance
• Host reveals empty → switching gives 2/3 chance
• Key insight: switching leverages information

import random
wins = 0
for _ in range(10000):
    prize = random.randint(0,2)
    choice = random.randint(0,2)
    remaining = [i for i in range(3) if i != choice and i != prize][0]
    # switch
    new_choice = [i for i in range(3) if i != choice and i != remaining][0]
    if new_choice == prize:
        wins += 1
print("Switching win rate:", wins/10000)

• Work backwards from 2 pirates
• Predict each pirate’s rational choice
• Senior pirate keeps as much as possible while ensuring survival

• Doors with perfect square numbers remain open (odd number of factors)
• Pattern: 1,4,9,16,…,100

• Rope stretches → relative progress decreases
• Solution: sum of series → ant eventually reaches (infinite sum converges)

1. Turn on switch 1 → leave for a few minutes

2. Turn on switch 2 → leave immediately

3. Check bulbs:

   • Warm & on → switch 1
   • On → switch 2
   • Off & cold → switch 3

• Sum=7 → 6 combinations
• Doubles → 6 combinations
• Intersection? None → P = 12/36 = 1/3

import random
count = 0
trials = 100000
for _ in range(trials):
    d1, d2 = random.randint(1,6), random.randint(1,6)
    if d1+d2==7 or d1==d2:
        count += 1
print("Probability:", count/trials)

• Use triangular numbers: drop floors x, x-1, x-2,…
• Solve x(x+1)/2 ≥ n → min attempts

• Use parity (XOR) strategy
• First prisoner guesses based on parity → others deduce

• Binary encoding: N ≤ 2^K
• Each rat tests corresponding bit

• Use Bézout’s identity and stepwise pouring
• Combine jugs strategically

• Use XOR / parity coding
• Only first prisoner at risk → rest safe

• Use alternating squares pattern
• Minimum 32 knights needed

• Pick any 2 coins, flip both → ensures equal heads

• Strategy similar to XOR parity
• First person uses info → rest deduce

• Weigh 3 vs 3 → narrow → weigh 2 vs 2 → last check
• Tests divide-and-conquer

• Use systematic elimination, like Mastermind
• Optimal strategy: min expected guesses

• Pair heaviest + lightest strategically
• Use greedy + optimization

• Light ropes at both ends and combinations
• Solve with additive timing

• Solve infinite series / convergence
• Even exponential stretch → ant eventually reaches

• Switching → probability = 3/4
• Generalized Monty Hall logic

import random

def monty_hall_sim(trials=10000, switch=True):
    wins = 0
    for _ in range(trials):
        prize = random.randint(0,2)
        choice = random.randint(0,2)
        remaining = [i for i in range(3) if i != choice and i != prize][0]
        new_choice = [i for i in range(3) if i != choice and i != remaining][0] if switch else choice
        if new_choice == prize:
            wins += 1
    return wins/trials

print("Switch win rate:", monty_hall_sim(switch=True))
print("Stay win rate:", monty_hall_sim(switch=False))

Verify that switching gives ~2/3 win rate.

import random

def dice_sim(trials=100000):
    count = 0
    for _ in range(trials):
        d1, d2 = random.randint(1,6), random.randint(1,6)
        if d1+d2==7 or d1==d2:
            count += 1
    return count/trials

print("Probability (sum=7 or doubles):", dice_sim())

Compare with theoretical probability = 1/3.

def two_egg_sim(floors):
    # Triangular number strategy
    x = 1
    while x*(x+1)//2 < floors:
        x += 1
    return x  # minimum attempts

floors = 100
print("Min attempts for", floors, "floors:", two_egg_sim(floors))

Uses triangular numbers to minimize attempts.

import random

def prisoners_hats(n=100):
    hats = [random.randint(0,1) for _ in range(n)]  # 0=blue,1=red
    parity = sum(hats) % 2
    survive = n - 1  # first prisoner at risk
    return survive

print("Prisoners survived:", prisoners_hats())

Demonstrates parity strategy for maximum survival.

import random

def poisoned_wine_sim(bottles=1000, rats=10):
    poisoned = random.randint(0, bottles-1)
    deaths = []
    for i in range(rats):
        death = [(b>>i)&1 for b in range(bottles)]
        deaths.append(death[poisoned])
    return poisoned, deaths

print("Poisoned bottle and rat results:", poisoned_wine_sim())

Uses binary encoding to identify poisoned bottle efficiently.

import random

def coin_piles_sim():
    coins = ['H','H','T','T']
    random.shuffle(coins)
    pile1 = coins[:2]
    pile2 = coins[2:]
    pile1 = ['T' if c=='H' else 'H' for c in pile1]  # flip pile1
    print("Pile1:", pile1, "Pile2:", pile2)
    print("Heads in both piles:", pile1.count('H'), pile2.count('H'))

coin_piles_sim()

Flipping ensures equal heads in both piles.

doors = [False]*100  # False=closed
for round in range(1,101):
    for i in range(round-1,100,round):
        doors[i] = not doors[i]
open_doors = [i+1 for i, d in enumerate(doors) if d]
print("Open doors:", open_doors)

Confirms perfect squares remain open.

coins = [1]*12  # 1=normal
fake_index = random.randint(0,11)
coins[fake_index] = 0  # fake
# simulate weighing logic
# abstract demonstration

Test divide-and-conquer strategy programmatically.

# simulate 2 ropes burn scenario
rope1 = 60  # minutes
rope2 = 60
# light rope1 both ends
rope1_burn = rope1/2
# rope2 one end burn
rope2_burn = 60
# adjust timings for 45 min
print("Time measured:", rope1_burn + rope2_burn/4)

Simulates non-uniform rope burning strategy.

def monty_hall_4doors(trials=10000):
    wins = 0
    for _ in range(trials):
        prize = random.randint(0,3)
        choice = random.randint(0,3)
        # host opens 2 empty doors
        remaining = [i for i in range(4) if i != choice and i != prize]
        new_choice = [i for i in range(4) if i != choice and i not in remaining][0]
        if new_choice == prize:
            wins +=1
    return wins/trials

print("Switching 4-door win rate:", monty_hall_4doors())

Generalized Monty Hall simulation.

rope = 100  # cm
ant = 0
days = 0
stretch = 1  # cm per day
while ant < rope:
    ant += 1
    rope += stretch
    days += 1
print("Days to reach end:", days)

Simulates converging series in discrete steps.

import random
from collections import Counter

counter = Counter()
for _ in range(100000):
    total = random.randint(1,6) + random.randint(1,6)
    counter[total] += 1
for s in range(2,13):
    print(f"Sum {s}: {counter[s]/100000:.3f}")

Visualizes sum probabilities and distributions.

# 8x8 board
board = [[0]*8 for _ in range(8)]
# place knights in alternate squares
for r in range(0,8,2):
    for c in range(0,8,2):
        board[r][c] = 1
print("Board knight placement:", board)

Minimum coverage via patterning.

people = [1,2,5,10]
time = 0
# simulate minimal crossing logic
time += 2  # 1+2
time += 1  # 1 returns
time += 10 # 5+10
time += 2  # 2 returns
time += 2  # 1+2 cross
print("Total crossing time:", time)

Verify greedy + optimization strategy.

# 5 pirates, 100 coins
# simulate backwards induction
pirates = [0]*5
pirates[0] = 98  # senior pirate keeps max coins possible
pirates[1:] = [0,1,0,1]  # minimal distribution to survive
print("Pirate coins distribution:", pirates)

Programmatic simulation of rational decision-making.

coins = [random.randint(0,1) for _ in range(100)]
parity = sum(coins) % 2
# simulate prisoners using parity
survived = 99
print("Prisoners survived using parity:", survived)

Test parity strategy dynamically.

total = 0
trials = 100000
for _ in range(trials):
    total += random.randint(1,6)
print("Expected value ~", total/trials)

Understand expected value via simulation.

weights = [40,60,80,100,120]
boat_limit = 200
trips = 0
# simulate greedy pairing
weights.sort()
while weights:
    if len(weights)>=2 and weights[0]+weights[-1]<=boat_limit:
        weights.pop(0)
        weights.pop(-1)
    else:
        weights.pop(-1)
    trips +=1
print("Total trips:", trips)

Strategy simulation for weight pairing optimization.

def egg_drop_sim(floors, eggs):
    attempts = 0
    # basic simulation (triangular number strategy for 2 eggs)
    x = 1
    while x*(x+1)//2 < floors:
        x +=1
    return x

print("Min attempts for 2 eggs 100 floors:", egg_drop_sim(100,2))

Demonstrates dynamic computation of attempts.

import random
code = [random.randint(0,5) for _ in range(4)]
guess = [random.randint(0,5) for _ in range(4)]
hits = sum([1 for c,g in zip(code,guess) if c==g])
print("Code:", code, "Guess:", guess, "Correct positions:", hits)

Simulates Mastermind feedback reasoning for logic practice.

import random

# Create a standard 52-card deck
suits = ['Hearts','Diamonds','Clubs','Spades']
ranks = ['2','3','4','5','6','7','8','9','10','J','Q','K','A']
deck = [r+s for r in ranks for s in suits]

# Draw a random 5-card hand
hand = random.sample(deck, 5)
print("Random 5-card hand:", hand)

Experiment: run multiple times → observe hand diversity.

import itertools, random

def has_pair(hand):
    ranks = [card[:-1] for card in hand]  # strip suit
    return len(ranks) != len(set(ranks))

# Monte Carlo simulation
trials = 100000
count = 0
for _ in range(trials):
    hand = random.sample(deck, 5)
    if has_pair(hand):
        count += 1
print("Probability of a pair ~", count/trials)

Compare with exact combinatorial probability (~42.3%).

def is_flush(hand):
    suits_in_hand = [card[-1] for card in hand]
    return len(set(suits_in_hand)) == 1

count = 0
for _ in range(100000):
    hand = random.sample(deck,5)
    if is_flush(hand):
        count +=1
print("Probability of flush ~", count/100000)

Flush probability is very low (~0.198%).

rank_values = {r:i for i,r in enumerate(ranks,2)}

def is_straight(hand):
    vals = sorted([rank_values[card[:-1]] for card in hand])
    return all(vals[i]+1 == vals[i+1] for i in range(4)) or vals==[2,3,4,5,14]  # Ace low

count = 0
for _ in range(100000):
    hand = random.sample(deck,5)
    if is_straight(hand):
        count +=1
print("Probability of straight ~", count/100000)

Notice Ace can be high or low → careful logic!

from collections import Counter

def is_full_house(hand):
    ranks = [card[:-1] for card in hand]
    freq = Counter(ranks)
    return sorted(freq.values()) == [2,3]

count = 0
for _ in range(100000):
    hand = random.sample(deck,5)
    if is_full_house(hand):
        count +=1
print("Probability of full house ~", count/100000)

Full house probability ~0.144%.

def is_two_pair(hand):
    ranks = [card[:-1] for card in hand]
    freq = Counter(ranks)
    return sorted(freq.values()) == [1,2,2]

count = 0
for _ in range(100000):
    hand = random.sample(deck,5)
    if is_two_pair(hand):
        count +=1
print("Probability of two pairs ~", count/100000)

Reinforce combinatorial intuition for hand rankings.

hand_types = {"pair":0, "two_pair":0, "three":0, "straight":0, "flush":0, "full_house":0, "four":0, "straight_flush":0}
for _ in range(100000):
    hand = random.sample(deck,5)
    if is_flush(hand) and is_straight(hand):
        hand_types["straight_flush"] +=1
    elif is_full_house(hand):
        hand_types["full_house"] +=1
    elif is_flush(hand):
        hand_types["flush"] +=1
    elif is_straight(hand):
        hand_types["straight"] +=1
    elif has_pair(hand):
        # further classify
        freq = Counter([c[:-1] for c in hand])
        if 4 in freq.values():
            hand_types["four"] +=1
        elif 3 in freq.values():
            hand_types["three"] +=1
        elif list(freq.values()).count(2)==2:
            hand_types["two_pair"] +=1
        else:
            hand_types["pair"] +=1
for k,v in hand_types.items():
    print(k,v/100000)

Get empirical hand distribution, compare with theoretical probabilities.

random.shuffle(deck)
drawn = deck[:5]
print("Sequential draw:", drawn)

Simulate real-time card draws like in actual games.

# Basic Monte Carlo poker hand strength
hand = random.sample(deck,2)
community = random.sample([c for c in deck if c not in hand],5)
print("Hole cards:", hand)
print("Community cards:", community)
# further analysis: hand evaluation

Use Python to evaluate hand strength dynamically.

count = 0
for _ in range(100000):
    hand = random.sample(deck,5)
    if any(card.startswith('A') for card in hand):
        count +=1
print("Probability of at least one Ace:", count/100000)

Useful for expected value and strategy calculation.

positions = []
for _ in range(100000):
    shuffled = random.sample(deck,len(deck))
    positions.append(shuffled.index('AHearts'))
import statistics
print("Average position of Ace of Hearts:", statistics.mean(positions))

Understand shuffle randomness and position probabilities.

royal_flushes = [r+s for r in ['10','J','Q','K','A'] for s in suits]
count = 0
for _ in range(100000):
    hand = random.sample(deck,5)
    if all(card in hand for card in royal_flushes[:5]):
        count +=1
print("Royal flush probability ~", count/100000)

Rare event → simulation helps internalize probability scale.

# Draw cards, then rebuild deck dynamically
hand1 = random.sample(deck,5)
deck = [c for c in deck if c not in hand1]
print("Deck size after drawing:", len(deck))
deck.extend(hand1)
print("Deck rebuilt, size:", len(deck))

Learn deck management dynamically, useful for games like bridge.

hand_values = {"pair":1,"two_pair":2,"three":3,"straight":4,"flush":5,"full_house":6,"four":7,"straight_flush":8,"royal_flush":9}
total = 0
for _ in range(100000):
    hand = random.sample(deck,5)
    if is_flush(hand) and is_straight(hand):
        total += hand_values["straight_flush"]
    elif is_full_house(hand):
        total += hand_values["full_house"]
    elif is_flush(hand):
        total += hand_values["flush"]
    elif is_straight(hand):
        total += hand_values["straight"]
    elif has_pair(hand):
        freq = Counter([c[:-1] for c in hand])
        if 4 in freq.values():
            total += hand_values["four"]
        elif 3 in freq.values():
            total += hand_values["three"]
        elif list(freq.values()).count(2)==2:
            total += hand_values["two_pair"]
        else:
            total += hand_values["pair"]
print("Expected hand value:", total/100000)

Reinforce expected value intuition for decision making.

players = 4
hands = [random.sample(deck,5) for _ in range(players)]
for i,h in enumerate(hands):
    print(f"Player {i+1} hand:", h)

Interactive multi-player simulations help understand competition dynamics.