import math
print(dir(math))

print("Number Functions")

print("math.ceil(4.3) =", math.ceil(4.3))  # Smallest integer ≥ value
print("math.floor(4.7) =", math.floor(4.7))  # Largest integer ≤ value
print("math.trunc(5.9) =", math.trunc(5.9))  # Truncates decimal part
print("math.fabs(-7.5) =", math.fabs(-7.5))  # Absolute value
print("math.factorial(5) =", math.factorial(5))  # 5! = 120
print("math.modf(5.75) =", math.modf(5.75))  # (fractional, integer) parts
print("math.copysign(3, -8) =", math.copysign(3, -8))  # Copy sign of second value to first
print("math.isfinite(10) =", math.isfinite(10))  # True if finite
print("math.isinf(math.inf) =", math.isinf(math.inf))  # True for infinity
print("math.isnan(math.nan) =", math.isnan(math.nan))  # True for NaN

print("Power, Root, Exponential, Log Functions")

print("math.pow(2, 3) =", math.pow(2, 3))  # 2^3 = 8.0
print("math.sqrt(16) =", math.sqrt(16))  # Square root
print("math.exp(1) =", math.exp(1))  # e^1
print("math.expm1(1) =", math.expm1(1))  # e^1 - 1
print("math.log(8, 2) =", math.log(8, 2))  # Log base 2
print("math.log2(16) =", math.log2(16))  # Log base 2
print("math.log10(1000) =", math.log10(1000))  # Log base 10
print("math.log1p(1) =", math.log1p(1))  # log(1+x) accurate for small x

print("Combinatorics")

print("math.comb(5, 2) =", math.comb(5, 2))  # 5 choose 2 = 10
print("math.perm(5, 2) =", math.perm(5, 2))  # Permutations of 5P2 = 20

print("GCD, LCM, Modulus")

print("math.gcd(20, 8) =", math.gcd(20, 8))  # 4
print("math.lcm(12, 15) =", math.lcm(12, 15))  # 60
print("math.fmod(20, 3) =", math.fmod(20, 3))  # Remainder (modulus)
print("math.remainder(20, 3) =", math.remainder(20, 3))  # IEEE remainder

print("Trigonometric")

print("math.sin(math.radians(90)) =", math.sin(math.radians(90)))  # sin 90°
print("math.cos(math.radians(0)) =", math.cos(math.radians(0)))  # cos 0°
print("math.tan(math.radians(45)) =", math.tan(math.radians(45)))  # tan 45°
print("math.degrees(math.pi) =", math.degrees(math.pi))  # Convert pi radians to degrees
print("math.radians(180) =", math.radians(180))  # 180° to radians

print("Inverse Trigonometric")

print("math.asin(1) =", math.asin(1))  # arcsin(1)
print("math.acos(1) =", math.acos(1))  # arccos(1)
print("math.atan(1) =", math.atan(1))  # arctan(1)
print("math.atan2(1, 1) =", math.atan2(1, 1))  # arctan(y/x) handling quadrants

print("Hyperbolic")

print("math.sinh(0) =", math.sinh(0))  # Hyperbolic sine
print("math.cosh(0) =", math.cosh(0))  # Hyperbolic cosine
print("math.tanh(0) =", math.tanh(0))  # Hyperbolic tangent
print("math.asinh(1) =", math.asinh(1))  # Inverse hyperbolic sine
print("math.acosh(1) =", math.acosh(1))  # Inverse hyperbolic cosine
print("math.atanh(0.5) =", math.atanh(0.5))  # Inverse hyperbolic tangent

print("Exponent and Mantissa")

print("math.frexp(8) =", math.frexp(8))  # (mantissa, exponent)
print("math.ldexp(0.5, 4) =", math.ldexp(0.5, 4))  # 0.5 × 2^4 = 8

print("Floating Point Summation and Precision Utilities")

print("math.fsum([0.1, 0.1, 0.1, 0.1, 0.1, 0.1, 0.1, 0.1, 0.1, 0.1]) =",math.fsum([0.1] * 10))  # Accurate sum of floats
print("math.isclose(0.1 + 0.2, 0.3) =", math.isclose(0.1 + 0.2, 0.3))  # Check closeness
print("math.ulp(1.0) =", math.ulp(1.0))  # Unit in last place (smallest diff representable)

print("Geometry & Distance Functions")

print("math.hypot(3, 4) =", math.hypot(3, 4))  # sqrt(3^2 + 4^2)
print("math.dist((0,0), (3,4)) =", math.dist((0,0), (3,4)))  # Euclidean distance
print("math.prod([1, 2, 3, 4]) =", math.prod([1, 2, 3, 4]))  # Product of list
print("math.isqrt(10) =", math.isqrt(10))  # Integer square root

print("Special Functions")

print("math.gamma(5) =", math.gamma(5))  # Gamma(5) = (5-1)!
print("math.lgamma(5) =", math.lgamma(5))  # log(gamma(5))
print("math.erf(1) =", math.erf(1))  # Error function value at 1
print("math.erfc(1) =", math.erfc(1))  # Complementary error function

print("Constants")

print("math.pi =", math.pi)  # π
print("math.e =", math.e)  # Euler's number e
print("math.inf =", math.inf)  # Infinity
print("math.nan =", math.nan)  # Not a number (NaN)

# House dimensions
base_width = 8   # in meters
roof_height = 3  # in meters
cost_per_sq_meter = 250  # ₹ per square meter
tile_length = 0.5  # meters
tile_width = 0.5   # meters

# Calculations
slope_length = math.hypot(base_width / 2, roof_height)
roof_area = 2 * (slope_length * base_width / 2)
angle_radians = math.atan(roof_height / (base_width / 2))
angle_degrees = math.degrees(angle_radians)
total_cost = math.ceil(roof_area) * cost_per_sq_meter
tile_area = tile_length * tile_width
num_tiles = math.ceil(roof_area / tile_area)

# Output
print(f"Roof slope length: {slope_length:.2f} meters")
print(f"Roof area: {roof_area:.2f} square meters")
print(f"Roof angle: {angle_degrees:.2f} degrees")
print(f"Estimated cost: ₹{total_cost}")
print(f"Number of tiles needed: {num_tiles}")

radius = 7.5  # meters
depth = 0.3   # meters (topsoil)
cost_per_cubic_meter = 90  # ₹
cost_per_meter_fence = 35  # ₹

# Calculations
area = math.pi * math.pow(radius, 2)
circumference = 2 * math.pi * radius
volume = area * depth
rounded_area = math.ceil(area)
rounded_circumference = math.floor(circumference)
total_soil_cost = math.ceil(volume * cost_per_cubic_meter)
fence_cost = math.ceil(circumference * cost_per_meter_fence)

# Output
print(f"Garden area: {area:.2f} sq meters")
print(f"Garden circumference: {circumference:.2f} meters")
print(f"Topsoil volume: {volume:.2f} cubic meters")
print(f"Total soil cost: ₹{total_soil_cost}")
print(f"Fencing cost: ₹{fence_cost}")

total_height = 3  # meters
step_height = 0.15  # meters
step_depth = 0.30  # meters

# Calculations
num_steps = math.ceil(total_height / step_height)
actual_height = num_steps * step_height
total_depth = num_steps * step_depth
stair_length = math.hypot(actual_height, total_depth)
angle_radians = math.atan(actual_height / total_depth)
angle_degrees = math.degrees(angle_radians)
tread_area = num_steps * step_depth * 1  # 1 meter width

# Output
print(f"Total steps: {num_steps}")
print(f"Actual height: {actual_height:.2f} meters")
print(f"Staircase length: {stair_length:.2f} meters")
print(f"Stair angle: {angle_degrees:.2f} degrees")
print(f"Tread surface area: {tread_area:.2f} sq meters")

radius = 2.5  # meters
brick_width = 0.3  # meters
thickness = 0.2  # meters

# Calculations
arc_length = math.pi * radius
curve_area = arc_length * thickness
height = radius
num_bricks = math.ceil(arc_length / brick_width)
angle_per_brick = 180 / num_bricks
first_angle = math.radians(angle_per_brick)

# Output
print(f"Arc length: {arc_length:.2f} meters")
print(f"Curve surface area: {curve_area:.2f} sq meters")
print(f"Arch height: {height} meters")
print(f"Bricks needed: {num_bricks}")
print(f"Angle between bricks: {angle_per_brick:.2f} degrees")

radius = 1.2  # meters
height = 2.5  # meters
paint_cost_per_sqm = 45     # ₹ per sq meter
water_cost_per_litre = 0.07 # ₹ per litre

# Calculations
lateral_area = 2 * math.pi * radius * height
circle_area = math.pi * math.pow(radius, 2)
total_surface_area = lateral_area + 2 * circle_area
volume_cubic_m = circle_area * height
volume_litres = volume_cubic_m * 1000
painting_cost = math.ceil(total_surface_area * paint_cost_per_sqm)
water_cost = math.floor(volume_litres * water_cost_per_litre)

# Output
print(f"Tank surface area: {total_surface_area:.2f} sq meters")
print(f"Water volume: {volume_litres:.2f} litres")
print(f"Painting cost: ₹{painting_cost}")
print(f"Water fill cost: ₹{water_cost}")

print(dir(random))

# random(): random float in [0.0, 1.0)
print("random.random() =", random.random())  # Random float between 0.0 and 1.0

# randint(a, b): integer in [a, b]
print("random.randint(1, 6) =", random.randint(1, 6))  # Random integer between 1 and 6 (inclusive)

# uniform(a, b): float in [a, b]
print("random.uniform(1.5, 10.5) =", random.uniform(1.5, 10.5))  # Random float between 1.5 and 10.5

# randrange(start, stop[, step])
print("random.randrange(1, 10, 2) =", random.randrange(1, 10, 2))  # Random odd number between 1 and 10

# choice(seq): randomly select an element from a sequence
print("random.choice(['apple', 'banana', 'cherry']) =", random.choice(['apple', 'banana', 'cherry']))  # Random element from list

# choices(population, weights=None, k=1): list of k elements with replacement
print("random.choices(['red', 'blue', 'green'], weights=[10, 1, 1], k=3) =", random.choices(['red', 'blue', 'green'], weights=[10, 1, 1], k=3))  # Randomly choose 3 items, biased to pick 'red'

# sample(population, k): list of k unique elements from population
print("random.sample([1, 2, 3, 4, 5], 2) =", random.sample([1, 2, 3, 4, 5], 2))  # Random 2 items from list, without replacement

# shuffle(x): shuffle a sequence in place
lst = [1, 2, 3, 4]
random.shuffle(lst)
print("random.shuffle([1, 2, 3, 4]) =", lst)  # Shuffle list in place

# betavariate(alpha, beta): Beta distribution
print("random.betavariate(2, 5) =", random.betavariate(2, 5))  # Random float from Beta distribution

# expovariate(lambd): Exponential distribution
print("random.expovariate(1.5) =", random.expovariate(1.5))  # Random float from Exponential distribution

# gammavariate(alpha, beta): Gamma distribution
print("random.gammavariate(2, 3) =", random.gammavariate(2, 3))  # Random float from Gamma distribution

# gauss(mu, sigma): Gaussian (normal) distribution
print("random.gauss(0, 1) =", random.gauss(0, 1))  # Random float from Normal distribution with mean 0 and std deviation 1

# lognormvariate(mu, sigma): Log-normal distribution
print("random.lognormvariate(0, 0.5) =", random.lognormvariate(0, 0.5))  # Random float from Log-normal distribution

# normalvariate(mu, sigma): Normal distribution
print("random.normalvariate(100, 15) =", random.normalvariate(100, 15))  # Random float from Normal distribution with mean 100 and std deviation 15

# paretovariate(alpha): Pareto distribution
print("random.paretovariate(2.5) =", random.paretovariate(2.5))  # Random float from Pareto distribution

# triangular(low, high, mode): Triangular distribution
print("random.triangular(1, 10, 5) =", random.triangular(1, 10, 5))  # Random float from Triangular distribution

# vonmisesvariate(mu, kappa): Circular (Von Mises) distribution
print("random.vonmisesvariate(0, 4) =", random.vonmisesvariate(0, 4))  # Random float from Von Mises distribution

# weibullvariate(alpha, beta): Weibull distribution
print("random.weibullvariate(1, 1.5) =", random.weibullvariate(1, 1.5))  # Random float from Weibull distribution

# seed(a=None): Initializes the random number generator
random.seed(42)
print("random.seed(42)")

# getstate(): Get the current state of the RNG
state = random.getstate()
print("random.getstate() =", state)

# setstate(state): Set the state of the RNG
random.setstate(state)
print("random.setstate(state)")

# getrandbits(k): Returns a random integer with `k` random bits
print("random.getrandbits(8) =", random.getrandbits(8))  # Random integer with 8 bits

# randbytes(n): Returns `n` random bytes
print("random.randbytes(4) =", random.randbytes(4))  # 4 random bytes

import random

print("🌟 Dora the Explorer's Ultimate Number Adventure Game 🌟")

# Dora's magical gift collection
gift_pool = [
    "Magic Map 🗺️", "Backpack 🎒", "Flying Boots 👢", "Invisible Cloak 🕶️",
    "Talking Compass 🧭", "Rainbow Seeds 🌈", "Healing Potion 🧪",
    "Teleport Stone 💠", "Golden Banana 🍌", "Bouncing Berries 🍓",
    "Crystal Crown 👑", "Enchanted Whistle 🎵"
]

# Dora’s motivational quotes
quotes = [
    "We did it, hooray! 🎉", "Let’s go explore! 🗺️", "Swiper, no swiping! 🙅",
    "Lo hicimos! 🎊", "Adventure awaits! 🚀", "Anything is possible! 🌈"
]

# Total random number of rounds between 5 to 10
total_rounds = random.randint(5, 10)
print(f"\n🌀 Dora is playing {total_rounds} magical rounds!\n")

# Dora’s magical score and gift tracker
dora_score = 0.0
total_gifts = 0

for round_num in range(1, total_rounds + 1):
    print(f"🔮 Round {round_num}:")

    # Dora's guess and the secret number
    secret_number = random.randint(1, 20)
    dora_guess = random.randrange(1, 21)

    print(f"  Dora guessed: {dora_guess}")
    print(f"  Secret number: {secret_number}")

    # Add randomness to bonus logic
    miracle_chance = random.triangular(0, 1, 0.7)
    magic_multiplier = random.betavariate(2, 5)

    print(f"  Miracle Chance: {round(miracle_chance, 2)}")

    if dora_guess == secret_number or miracle_chance > 0.6:
        # Shuffle and choose 1–3 random gifts
        random.shuffle(gift_pool)
        gift_count = random.randint(1, 3)
        gifts = random.choices(gift_pool, k=gift_count)
        score_add = random.uniform(5, 15) * magic_multiplier
        dora_score += score_add
        total_gifts += gift_count

        print(f"  🎉 Dora wins! Received miracle gift(s): {', '.join(gifts)}")
        print(f"  🌟 {random.choice(quotes)} (+{round(score_add, 2)} points)")
    else:
        print("  😢 Dora didn’t win this time...")

    print(f"  ✨ Current magic score: {round(dora_score, 2)}\n")

# Final magical summary
print("🌈 Game Over!")
print(f"🔢 Total Rounds Played: {total_rounds}")
print(f"🌟 Dora's Final Magic Score: {round(dora_score, 2)}")
print(f"📦 Total Miracle Gifts Received: {total_gifts} 🎁")