Python Input & Output

# =============================================================================
#Filename: 01_input_comparison.py
#Description: Speed comparison of input() vs sys.stdin.readline() (using io.StringIO)
#Time complexity: O(n) — reads n lines
#Space complexity: O(n) — stores the read data
# =============================================================================
#Note: Instead of using actual stdin, a virtual input stream is created with io.StringIO
#to compare the internal parsing speed of the two methods.
# =============================================================================

import sys
import io
import time
import random


def simulate_input_builtin(lines: list) -> list:
    """Reads line by line like input() and converts to an integer.

    The actual input() has additional overhead such as system calls and prompt handling,
    but here we measure the pure parsing speed difference with readline()."""
    result = []
    for line in lines:          #Pre-prepared list of lines
        result.append(int(line.strip()))  #Simulating input() behavior
    return result


def simulate_readline(stream: io.StringIO, n: int) -> list:
    """Reads one line at a time from a stream like sys.stdin.readline()."""
    result = []
    for _ in range(n):
        result.append(int(stream.readline()))  #\n is ignored when converting with int()
    return result


def simulate_read_all(stream: io.StringIO) -> list:
    """Read all at once using sys.stdin.read().split()."""
    return list(map(int, stream.read().split()))


def benchmark_io(n: int = 100_000) -> None:
    """Compare the speed of reading n integers using three different methods."""
    print(f"\n input method speed comparison (n={n:,} integers)")
    print("=" * 55)

    #Generate test data
    random.seed(42)
    numbers = [random.randint(1, 10 ** 9) for _ in range(n)]
    text = '\n'.join(map(str, numbers)) + '\n'
    lines = [str(x) for x in numbers]  #Convert to string beforehand

    # -----------------------------------------------------------------------
    #Method 1: Simulate input() (parse from list of strings)
    # -----------------------------------------------------------------------
    t0 = time.perf_counter()
    result1 = simulate_input_builtin(lines)
    t_input = time.perf_counter() - t0
    print(f"Simulated input()      : {t_input:.4f} seconds")

    # -----------------------------------------------------------------------
    #Method 2: Simulate sys.stdin.readline()
    # -----------------------------------------------------------------------
    stream2 = io.StringIO(text)
    t0 = time.perf_counter()
    result2 = simulate_readline(stream2, n)
    t_readline = time.perf_counter() - t0
    print(f"Simulated sys.stdin.readline(): {t_readline:.4f} seconds")

    # -----------------------------------------------------------------------
    #Method 3: Simulate sys.stdin.read().split()
    # -----------------------------------------------------------------------
    stream3 = io.StringIO(text)
    t0 = time.perf_counter()
    result3 = simulate_read_all(stream3)
    t_read = time.perf_counter() - t0
    print(f"sys.stdin.read().split(): {t_read:.4f} seconds")

    # -----------------------------------------------------------------------
    #Verify results
    # -----------------------------------------------------------------------
    assert result1 == result2 == result3, "The results are different!"
    print("\n results match: OK")

    # -----------------------------------------------------------------------
    #Speed comparison summary
    # -----------------------------------------------------------------------
    baseline = t_read  #Based on read().split()
    if baseline > 0:
        print("Speed Comparison (compared to read().split())")
        print(f"input() simulation:          {t_input/baseline:>6.1f} times slower")
        print(f"readline() simulation:       {t_readline/baseline:>6.1f} times slower")
        print(f"read().split():        {1.0:>6.1f} times (baseline)")

    print("[Conclusion]")
    print("- The more input there is, the more advantageous sys.stdin.read() becomes.")
    print("- In competitive programming, if N > 10,000, use sys.stdin.")


def show_usage_patterns() -> None:
    """Prints the correct input pattern."""
    print("\n" + "=" * 55)
    print("Practical input pattern examples")
    print("=" * 55)

    patterns = [
        ("Single integer",
         "n = int(sys.stdin.readline())"),
        ("Two space-separated integers",
         "a, b = map(int, sys.stdin.readline().split())"),
        ("List of integers",
         "arr = list(map(int, sys.stdin.readline().split()))"),
        ("Overwriting input",
         "input = sys.stdin.readline\nn = int(input())"),
        ("Read all at once",
         "data = sys.stdin.read().split()\nn = int(data[0])"),
    ]

    for name, code in patterns:
        print(f"\n# {name}")
        for line in code.split('\n'):
            print(f"  {line}")


def main():
    print("=" * 55)
    print("Python I/O speed comparison demo")
    print("=" * 55)

    #Demonstrate newline handling in readline()
    print("[readline() \n handling]")
    stream = io.StringIO("hello\nworld\n")
    raw = stream.readline()
    print(f"readline() result: repr={repr(raw)}")
    print(f"After .strip():   {repr(raw.strip())}")
    print(f"int() conversion:      {int('42\n')} (\n automatically ignored)")

    #Benchmark execution
    benchmark_io(n=100_000)
    show_usage_patterns()


if __name__ == "__main__":
    main()

# =============================================================================
#Filename: 02_fast_io_template.py
#Description: Collection of fast I/O patterns often used in competitive programming
#Time Complexity: O(n) for each pattern
#Space Complexity: O(n) — proportional to the size of input data
# =============================================================================
#Usage:
#This file can be executed directly or used as a reference template when writing Baekjoon code.
#Demonstrates by creating virtual input with io.StringIO instead of the actual stdin.
# =============================================================================

import sys
import io


# ===========================================================================
#Pattern 1: Replace input() with sys.stdin.readline
#Most commonly used pattern — minimal changes to existing input() code
# ===========================================================================
def pattern1_override_input(fake_stdin: str) -> None:
    """input = sys.stdin.readline pattern demonstration."""
    original_stdin = sys.stdin
    sys.stdin = io.StringIO(fake_stdin)

    #Actual Baekjoon code start point -------------------------------------------------
    input = sys.stdin.readline  #Replace input() with readline

    n = int(input())                         #A single integer
    a, b = map(int, input().split())         #Two integers separated by space
    arr = list(map(int, input().split()))    #List of integers
    s = input().strip()                      #String (strip is essential!)
    # -------------------------------------------------------------------------

    print(f"[Pattern 1] n={n}, a={a}, b={b}, arr={arr}, s='{s}'")
    sys.stdin = original_stdin


# ===========================================================================
#Pattern 2: Read all input at once using sys.stdin.read() and parse
#Fastest method for large input
# ===========================================================================
def pattern2_read_all(fake_stdin: str) -> None:
    """Demonstration of the sys.stdin.read().split() pattern."""
    original_stdin = sys.stdin
    sys.stdin = io.StringIO(fake_stdin)

    #Actual Baekjoon code start point -------------------------------------------------
    data = sys.stdin.read().split()  #All tokens as a list
    idx = 0

    n = int(data[idx]); idx += 1
    arr = [int(data[idx + i]) for i in range(n)]
    idx += n
    # -------------------------------------------------------------------------

    print(f"[Pattern 2] n={n}, arr={arr}")
    sys.stdin = original_stdin


# ===========================================================================
#Pattern 3: Multiple line input — list comprehension
# ===========================================================================
def pattern3_multiline(fake_stdin: str, n: int) -> None:
    """Demonstration of a pattern for receiving multiple line input as a list."""
    original_stdin = sys.stdin
    sys.stdin = io.StringIO(fake_stdin)
    input_fn = sys.stdin.readline

    #Read n lines of [row, column] pairs
    edges = [tuple(map(int, input_fn().split())) for _ in range(n)]
    print(f"[Pattern 3] edges={edges}")
    sys.stdin = original_stdin


# ===========================================================================
#Pattern 4: Read until EOF
# ===========================================================================
def pattern4_eof(fake_stdin: str) -> None:
    """Demonstration of a pattern that reads input until EOF."""
    original_stdin = sys.stdin
    sys.stdin = io.StringIO(fake_stdin)

    results = []
    #for line in sys.stdin — automatically ends at EOF
    for line in sys.stdin:
        line = line.strip()
        if not line:          #Ignore empty lines
            continue
        a, b = map(int, line.split())
        results.append(a + b)

    print(f"[Pattern 4] Result: {results}")
    sys.stdin = original_stdin


# ===========================================================================
#Pattern 5: 2D array input (graph, matrix)
# ===========================================================================
def pattern5_2d_array(fake_stdin: str, rows: int) -> None:
    """A pattern demonstration for quickly inputting a 2D array."""
    original_stdin = sys.stdin
    sys.stdin = io.StringIO(fake_stdin)
    input_fn = sys.stdin.readline

    #Read at once using nested list comprehension
    grid = [list(map(int, input_fn().split())) for _ in range(rows)]
    print(f"[Pattern 5] grid=")
    for row in grid:
        print(f"  {row}")
    sys.stdin = original_stdin


def main():
    print("=" * 55)
    print("Demonstration of fast I/O pattern collection")
    print("=" * 55)

    #Demonstration of Pattern 1
    pattern1_override_input("5\n3 7\n1 2 3 4 5\nhello\n")

    #Demonstration of Pattern 2
    pattern2_read_all("4\n10 20 30 40\n")

    #Demonstration of Pattern 3
    pattern3_multiline("1 2\n3 4\n5 6\n", n=3)

    #Demonstration of Pattern 4 (EOF handling)
    pattern4_eof("1 2\n3 4\n5 6\n7 8\n")

    #Demonstration of Pattern 5 (2D array)
    pattern5_2d_array("1 2 3\n4 5 6\n7 8 9\n", rows=3)

    print("\n" + "=" * 55)
    print("Baekjoon code basic template")
    print("=" * 55)
    template = """import sys
input = sys.stdin.readline  # Fast input

def solve():
    n = int(input())
    arr = list(map(int, input().split()))
    # ... solution code ...
    print("Answer")

if __name__ == "__main__":
    solve()"""
    print(template)


if __name__ == "__main__":
    main()

# =============================================================================
#Filename: 03_output_optimization.py
#Description: Comparing print() vs sys.stdout.write vs buffered output speed
#Time Complexity: O(n) — n outputs
#Space Complexity: O(n) — storing results in a list for buffer method
# =============================================================================

import sys
import io
import time
import random


def method_print_loop(numbers: list) -> float:
    """A way to repeatedly call print(). It's slow, but the code is simple."""
    buf = io.StringIO()
    original = sys.stdout
    sys.stdout = buf

    t0 = time.perf_counter()
    for x in numbers:       #n print() calls
        print(x)
    elapsed = time.perf_counter() - t0

    sys.stdout = original
    return elapsed


def method_stdout_write_loop(numbers: list) -> float:
    """How to repeatedly call sys.stdout.write()."""
    buf = io.StringIO()
    original = sys.stdout
    sys.stdout = buf

    t0 = time.perf_counter()
    write = sys.stdout.write
    for x in numbers:       #n write() calls
        write(str(x))
        write('\n')
    elapsed = time.perf_counter() - t0

    sys.stdout = original
    return elapsed


def method_join_single_write(numbers: list) -> float:
    """After joining all results with join(), print once. This is the fastest method."""
    buf = io.StringIO()
    original = sys.stdout
    sys.stdout = buf

    t0 = time.perf_counter()
    #Generate a single string using list comprehension + join → 1 write
    result = '\n'.join(map(str, numbers)) + '\n'
    sys.stdout.write(result)
    elapsed = time.perf_counter() - t0

    sys.stdout = original
    return elapsed


def method_list_append_join(numbers: list) -> float:
    """Collect the content to be printed in a list and print it all at once at the end."""
    buf = io.StringIO()
    original = sys.stdout
    sys.stdout = buf

    t0 = time.perf_counter()
    output = []             #Acts as an output buffer
    for x in numbers:
        output.append(str(x))  #Convert to string and store
    sys.stdout.write('\n'.join(output) + '\n')  #Single output
    elapsed = time.perf_counter() - t0

    sys.stdout = original
    return elapsed


def benchmark_output(n: int = 100_000) -> None:
    """Compares the speed of four output methods."""
    random.seed(42)
    numbers = [random.randint(1, 10 ** 9) for _ in range(n)]

    print(f"Speed comparison of \n output methods (outputting n={n:,} integers)")
    print("=" * 55)

    t1 = method_print_loop(numbers)
    t2 = method_stdout_write_loop(numbers)
    t3 = method_join_single_write(numbers)
    t4 = method_list_append_join(numbers)

    baseline = t3 if t3 > 0 else 1e-9
    print(f"Repeated print():        {t1:.4f}s  ({t1/baseline:>5.1f}x)")
    print(f"Repeated write():        {t2:.4f}s  ({t2/baseline:>5.1f}x)")
    print(f"join + single write:     {t3:.4f}s  ({1.0:>5.1f}x, baseline)")
    print(f"list.append + join:      {t4:.4f}s  ({t4/baseline:>5.1f}x)")

    print("[Conclusion]")
    print("Outputting at once is faster than calling print() n times.")
    print("The '\n'.join(map(str, results)) pattern is recommended.")


def show_output_patterns() -> None:
    """Shows the actual output pattern."""
    print("\n" + "=" * 55)
    print("Example output patterns")
    print("=" * 55)

    results = [10, 20, 30, 40, 50]

    #Pattern 1: Repeated print() (slow)
    print("Pattern 1: Repeating print() (OK when N is small)")
    for x in results:
        print(x)

    #Pattern 2: '
'.join() output at once (recommended)
    print("Pattern 2: join + single output (recommended when N is large)")
    print('\n'.join(map(str, results)))

    #Pattern 3: Direct use of sys.stdout.write
    print("Pattern 3: sys.stdout.write")
    sys.stdout.write('\n'.join(map(str, results)) + '\n')

    #Pattern 4: Using f-strings (complex formatting)
    print("Pattern 4: f-string format output")
    pairs = [(1, 'a'), (2, 'b'), (3, 'c')]
    print('\n'.join(f"Case #{i}: {v}" for i, v in pairs))


def main():
    print("=" * 55)
    print("Output optimization demo")
    print("=" * 55)

    show_output_patterns()
    benchmark_output(n=50_000)


if __name__ == "__main__":
    main()

# =============================================================================
#Filename: 04_eof_handling.py
#Description: Demonstration of various patterns to read until EOF (End of File)
#Time complexity: O(n) — proportional to the number of lines
#Space complexity: O(n) — storing results
# =============================================================================
#EOF problem types:
#- When it says "until the end of input"
#- When the number of lines is not given
#- Baekjoon examples: Problem 10951 A+B-4, Problem 11021 A+B-7
# =============================================================================

import sys
import io


def pattern_try_except(fake_input: str) -> list:
    """Method 1: readline() returns an empty string at EOF.

    readline() returns '\n' for an empty line,
    and '' (empty string) at EOF."""
    original_stdin = sys.stdin
    sys.stdin = io.StringIO(fake_input)

    results = []
    try:
        while True:
            line = sys.stdin.readline()
            if not line:        #readline() returns an empty string at EOF
                break
            line = line.strip()
            if not line:        #Skip empty lines
                continue
            a, b = map(int, line.split())
            results.append(a + b)
    except (EOFError, ValueError):
        pass  #EOF or invalid input → exit quietly

    sys.stdin = original_stdin
    return results


def pattern_for_in_stdin(fake_input: str) -> list:
    """Method 2: for line in sys.stdin pattern.

    This is the most Pythonic way.
    Iterating over the file object directly automatically ends at EOF."""
    original_stdin = sys.stdin
    sys.stdin = io.StringIO(fake_input)

    results = []
    for line in sys.stdin:      #Automatically exit at EOF
        line = line.strip()
        if not line:
            continue
        a, b = map(int, line.split())
        results.append(a + b)

    sys.stdin = original_stdin
    return results


def pattern_read_all_split(fake_input: str) -> list:
    """Method 3: Read all with sys.stdin.read() and then parse.

    Read the input at once into memory and then parse it.
    It is the fastest because there are no repeated system calls."""
    original_stdin = sys.stdin
    sys.stdin = io.StringIO(fake_input)

    data = sys.stdin.read().split()  #Read all and then split by whitespace
    results = []
    i = 0
    while i + 1 < len(data):
        a = int(data[i])
        b = int(data[i + 1])
        results.append(a + b)
        i += 2

    sys.stdin = original_stdin
    return results


def pattern_readline_empty_check(fake_input: str) -> list:
    """Method 4: Detect EOF with the return value of readline().

    readline() returns '' → EOF
    readline() returns '\n' → empty line (not EOF)"""
    original_stdin = sys.stdin
    sys.stdin = io.StringIO(fake_input)

    results = []
    while True:
        line = sys.stdin.readline()
        if line == '':           #EOF detection: empty string
            break
        line = line.strip()
        if not line:             #Skip empty lines (if only '\n')
            continue
        try:
            a, b = map(int, line.split())
            results.append(a + b)
        except ValueError:
            continue             #Ignore incorrect format

    sys.stdin = original_stdin
    return results


def main():
    print("=" * 55)
    print("Demonstrate EOF handling patterns")
    print("=" * 55)

    #Test input (including empty lines)
    test_input = "1 2\n3 4\n\n5 6\n7 8\n"
    expected = [3, 7, 11, 15]  #a+b for each line

    print(f"\nTest input:")
    for line in test_input.rstrip('\n').split('\n'):
        display = repr(line) if line else "'' (empty line)"
        print(f"  {display}")
    print(f"\nExpected result: {expected}")

    #Demonstrate each pattern
    r1 = pattern_try_except(test_input)
    r2 = pattern_for_in_stdin(test_input)
    r3 = pattern_read_all_split(test_input)
    r4 = pattern_readline_empty_check(test_input)

    print(f"\nMethod 1 (readline + empty check): {r1}")
    print(f"Method 2 (for in stdin):           {r2}")
    print(f"Method 3 (read all):               {r3}")
    print(f"Method 4 (readline empty check):   {r4}")

    all_correct = (r1 == r2 == r3 == r4 == expected)
    print(f"\nAll method results match: {all_correct}")

    print("\n" + "=" * 55)
    print("Explanation of readline() EOF behavior")
    print("=" * 55)
    stream = io.StringIO("line1\nline2\n")
    print(f"1st time: repr={repr(stream.readline())}  <- normal line")
    print(f"2nd time: repr={repr(stream.readline())}  <- normal line")
    print(f"3rd time: repr={repr(stream.readline())}  <- EOF! empty string")
    print(f"4th time: repr={repr(stream.readline())}  <- still empty string")

    print("[Conclusion] readline() returns '' → EOF signal")
    print("[Conclusion] readline() returns '\n' → empty line (not EOF)")


if __name__ == "__main__":
    main()