# Basic tuple merging
first_half = (1, 2, 3)
second_half = (4, 5, 6)
combined = first_half + second_half

coordinates_2d = (10, 20)
z_coordinate = (30,)
coordinates_3d = coordinates_2d + z_coordinate

colors_primary = ("red", "green", "blue")
colors_secondary = ("orange", "purple", "yellow")
all_colors = colors_primary + colors_secondary

print(f"Combined numbers: {combined}")
print(f"3D coordinates: {coordinates_3d}")
print(f"All colors: {all_colors}")

# Simple concatenation examples
part1 = (1, 2, 3)
part2 = (4, 5, 6)
part3 = (7, 8, 9)

# Two-tuple concatenation
combined_two = part1 + part2
print(f"Two parts: {combined_two}")

# Multiple concatenation
combined_all = part1 + part2 + part3
print(f"All parts: {combined_all}")

# Mixed data types
numbers = (1, 2, 3)
letters = ("a", "b", "c")
symbols = ("!", "@", "#")
mixed = numbers + letters + symbols
print(f"Mixed data: {mixed}")

# Building composite structures
# User profile components
basic_info = ("Alice", 25)
contact_info = ("alice@email.com", "555-1234")
preferences = ("dark_mode", "notifications_on")

# Complete user profile
user_profile = basic_info + contact_info + preferences
print(f"User profile: {user_profile}")

# Geographic data
city = ("New York",)
state = ("NY",)
country = ("USA",)
coordinates = (40.7128, -74.0060)

# Complete location
full_location = city + state + country + coordinates
print(f"Location: {full_location}")

# Database record construction
id_field = (1001,)
timestamp = ("2024-01-15", "14:30")
data_fields = ("processed", True, 99.5)
complete_record = id_field + timestamp + data_fields
print(f"Record: {complete_record}")

# Working with empty tuples
base_data = (1, 2, 3)
empty = ()
optional_data = (4, 5) if True else ()

# Safe concatenation
result1 = base_data + empty  # No effect
result2 = base_data + optional_data  # Adds elements

print(f"Base + empty: {result1}")
print(f"Base + optional: {result2}")

# Conditional building
def build_tuple_conditionally(include_extra=False):
    core = ("essential", "data")
    extra = ("bonus", "info") if include_extra else ()
    return core + extra

normal_tuple = build_tuple_conditionally(False)
extended_tuple = build_tuple_conditionally(True)

print(f"Normal: {normal_tuple}")
print(f"Extended: {extended_tuple}")

# Interleaving elements using zip
names = ("Alice", "Bob", "Carol")
ages = (25, 30, 28)
jobs = ("Engineer", "Designer", "Manager")

# Create interleaved pairs
name_age_pairs = tuple(zip(names, ages))
print(f"Name-age pairs: {name_age_pairs}")

# Flatten interleaved data
interleaved = tuple(item for pair in zip(names, ages) for item in pair)
print(f"Interleaved: {interleaved}")

# Three-way interleaving
three_way = tuple(zip(names, ages, jobs))
print(f"Three-way tuples: {three_way}")

# Flatten three-way
flat_three_way = tuple(item for triple in zip(names, ages, jobs) for item in triple)
print(f"Flat three-way: {flat_three_way}")

# Conditional merging based on criteria
scores_math = (85, 92, 78, 96)
scores_science = (88, 89, 82, 94)
student_names = ("Alice", "Bob", "Carol", "David")

# Merge high scores only (>= 90)
high_math = tuple(score for score in scores_math if score >= 90)
high_science = tuple(score for score in scores_science if score >= 90)
all_high_scores = high_math + high_science

print(f"High math scores: {high_math}")
print(f"High science scores: {high_science}")
print(f"All high scores: {all_high_scores}")

# Conditional student data merging
def merge_student_data(names, math_scores, science_scores, min_score=85):
    qualified_students = ()
    for name, math, science in zip(names, math_scores, science_scores):
        if math >= min_score and science >= min_score:
            student_data = (name, math, science)
            qualified_students += (student_data,)
    return qualified_students

qualified = merge_student_data(student_names, scores_math, scores_science)
print(f"Qualified students: {qualified}")

# Merging with transformations
temperatures_f = (68, 75, 82, 90)
temperatures_c = (20, 24, 28, 32)

# Transform and merge
def fahrenheit_to_celsius(f):
    return round((f - 32) * 5/9, 1)

# Convert Fahrenheit and merge with Celsius
converted_f = tuple(fahrenheit_to_celsius(temp) for temp in temperatures_f)
all_celsius = converted_f + temperatures_c

print(f"Original F: {temperatures_f}")
print(f"Converted to C: {converted_f}")
print(f"All Celsius: {all_celsius}")

# Grade transformation during merge
raw_scores = (85, 92, 78, 96, 88)
bonus_scores = (3, 5, 2, 4, 6)

# Apply bonus and merge
def apply_bonus(score, bonus):
    return min(score + bonus, 100)  # Cap at 100

final_scores = tuple(apply_bonus(score, bonus) 
                    for score, bonus in zip(raw_scores, bonus_scores))

all_scores = raw_scores + final_scores
print(f"Raw scores: {raw_scores}")
print(f"Final scores: {final_scores}")
print(f"Combined: {all_scores}")

# Multiple tuple concatenation with sum()
tuple_list = [
    (1, 2, 3),
    (4, 5, 6),
    (7, 8, 9),
    (10, 11, 12)
]

# Merge all tuples using sum()
merged = sum(tuple_list, ())  # Start with empty tuple
print(f"Merged tuples: {merged}")

# Multiple data sources
user_data = [
    ("Alice", 25),
    ("Engineer",),
    ("alice@email.com", "555-1234"),
    ("preferences", "dark_mode")
]

complete_user = sum(user_data, ())
print(f"Complete user data: {complete_user}")

# Dynamic tuple collection
def collect_data(*data_sources):
    return sum(data_sources, ())

result = collect_data(
    (1, 2, 3),
    ("a", "b"),
    (True, False),
    (3.14, 2.71)
)
print(f"Collected data: {result}")

# Efficient merging with itertools.chain()
from itertools import chain

# Large tuple collection
data_chunks = [
    tuple(range(1, 4)),
    tuple(range(4, 7)),
    tuple(range(7, 10)),
    tuple(range(10, 13))
]

# Chain and convert to tuple
chained = tuple(chain(*data_chunks))
print(f"Chained result: {chained}")

# Multiple data types
mixed_data = [
    ("start",),
    (1, 2, 3),
    ("middle",),
    (4, 5, 6),
    ("end",)
]

mixed_result = tuple(chain(*mixed_data))
print(f"Mixed result: {mixed_result}")

# Function for efficient multi-merge
def merge_multiple_tuples(*tuples):
    return tuple(chain(*tuples))

# Usage example
result = merge_multiple_tuples(
    (1, 2),
    (3, 4),
    (5, 6),
    (7, 8)
)
print(f"Multi-merge result: {result}")

# Custom merging functions
def merge_with_separator(separator, *tuples):
    """Merge tuples with separator between each"""
    if not tuples:
        return ()
    
    result = tuples[0]
    for t in tuples[1:]:
        result = result + (separator,) + t
    return result

# Example usage
data1 = (1, 2, 3)
data2 = (4, 5, 6)
data3 = (7, 8, 9)

separated = merge_with_separator("---", data1, data2, data3)
print(f"With separator: {separated}")

def merge_unique(*tuples):
    """Merge tuples keeping only unique elements"""
    seen = set()
    result = ()
    
    for t in tuples:
        for item in t:
            if item not in seen:
                seen.add(item)
                result += (item,)
    return result

# Merge with uniqueness
set1 = (1, 2, 3, 4)
set2 = (3, 4, 5, 6)
set3 = (5, 6, 7, 8)

unique_merge = merge_unique(set1, set2, set3)
print(f"Unique merge: {unique_merge}")

def merge_by_position(*tuples):
    """Merge tuples by collecting elements at each position"""
    if not tuples:
        return ()
    
    max_length = max(len(t) for t in tuples)
    result = ()
    
    for i in range(max_length):
        position_elements = ()
        for t in tuples:
            if i < len(t):
                position_elements += (t[i],)
        result += (position_elements,)
    
    return result

# Position-based merging
tuple1 = ("a", "b", "c")
tuple2 = (1, 2)
tuple3 = ("x", "y", "z", "w")

position_merged = merge_by_position(tuple1, tuple2, tuple3)
print(f"Position merged: {position_merged}")

# Merging nested tuple structures
coordinates_2d = ((0, 0), (10, 10), (20, 20))
coordinates_3d = ((0, 0, 0), (10, 10, 10), (20, 20, 20))

# Merge nested coordinate sets
all_coordinates = coordinates_2d + coordinates_3d
print(f"All coordinates: {all_coordinates}")

# Student records merging
class_a_students = (
    ("Alice", (85, 92, 78)),
    ("Bob", (88, 85, 92))
)

class_b_students = (
    ("Carol", (95, 89, 94)),
    ("David", (78, 82, 85))
)

all_students = class_a_students + class_b_students
print(f"All students: {all_students}")

# Nested configuration merging
database_config = (
    ("connection", ("localhost", 5432)),
    ("credentials", ("user", "password"))
)

cache_config = (
    ("redis", ("127.0.0.1", 6379)),
    ("timeout", (30,))
)

full_config = database_config + cache_config
print(f"Full config: {full_config}")

# Flattening nested tuples during merge
def flatten_and_merge(*nested_tuples):
    """Flatten nested tuples and merge into single tuple"""
    result = ()
    for nested in nested_tuples:
        for item in nested:
            if isinstance(item, tuple):
                # Recursively flatten
                result += flatten_and_merge(item)
            else:
                result += (item,)
    return result

# Test data
nested1 = ((1, 2), (3, 4))
nested2 = ((5, 6), (7, 8))
nested3 = (9, (10, 11))

flattened = flatten_and_merge(nested1, nested2, nested3)
print(f"Flattened merge: {flattened}")

# Selective flattening
def flatten_one_level(*tuples):
    """Flatten only one level of nesting"""
    result = ()
    for t in tuples:
        for item in t:
            if isinstance(item, tuple):
                result += item
            else:
                result += (item,)
    return result

# Test selective flattening
data1 = (1, (2, 3), 4)
data2 = ((5, 6), 7, (8, 9))

one_level = flatten_one_level(data1, data2)
print(f"One level flattened: {one_level}")

# Performance-conscious merging approaches
import time

def time_merging_methods(tuple_count=100, tuple_size=10):
    """Compare performance of different merging methods"""
    # Generate test data
    test_tuples = [tuple(range(i, i + tuple_size)) 
                   for i in range(0, tuple_count * tuple_size, tuple_size)]
    
    # Method 1: sum()
    start_time = time.time()
    result1 = sum(test_tuples, ())
    sum_time = time.time() - start_time
    
    # Method 2: itertools.chain()
    from itertools import chain
    start_time = time.time()
    result2 = tuple(chain(*test_tuples))
    chain_time = time.time() - start_time
    
    # Method 3: comprehension
    start_time = time.time()
    result3 = tuple(item for t in test_tuples for item in t)
    comp_time = time.time() - start_time
    
    print(f"Results equal: {result1 == result2 == result3}")
    print(f"sum() time: {sum_time:.4f}s")
    print(f"chain() time: {chain_time:.4f}s")
    print(f"comprehension time: {comp_time:.4f}s")

# Test with small dataset
print("Small dataset (10 tuples, 5 elements each):")
time_merging_methods(10, 5)

# Memory-efficient merging strategies
def efficient_merge_large(*tuple_sources):
    """Memory-efficient merging for large datasets"""
    from itertools import chain
    
    # Use generator to avoid creating intermediate structures
    def merge_generator():
        for source in tuple_sources:
            yield from source
    
    # Convert to tuple only when needed
    return tuple(merge_generator())

def chunked_merge(tuple_list, chunk_size=10):
    """Merge tuples in chunks to manage memory"""
    result = ()
    
    for i in range(0, len(tuple_list), chunk_size):
        chunk = tuple_list[i:i + chunk_size]
        chunk_merged = sum(chunk, ())
        result += chunk_merged
    
    return result

# Example usage
large_data = [tuple(range(i, i + 3)) for i in range(0, 30, 3)]
print(f"Large data sample: {large_data[:3]}...")

# Efficient merge
efficient_result = efficient_merge_large(*large_data)
print(f"Efficient merge length: {len(efficient_result)}")

# Chunked merge
chunked_result = chunked_merge(large_data, chunk_size=5)
print(f"Chunked merge length: {len(chunked_result)}")
print(f"Results equal: {efficient_result == chunked_result}")