py3

import unicodedata as ud
g="Generation";gens=[(1928,1945,f"Silent {g}"),(1946,1964,"Boomer"),(1965,1980,f"{g} X"),(1981,1996,f"{g} Y/Millennial"),(1997,2012,f"{g} Z")]
def get_gen(birthyear):
 for min,max,gen in gens:
  if min<=birthyear<=max:
   return f"{birthyear}: {gen}"
 return f"{birthyear}: {g} {[ud.name(chr(945+i+(1 if 945+i>=962 else 0))).split()[-1].title() for i,min in enumerate(range(2013,2397,16)) if min<=birthyear<=min+15][0]}"

print(get_gen(1969),
      get_gen(1996),
      get_gen(2000),
      get_gen(2013),
      get_gen(2269),
      get_gen(2396), 
      sep="\n")

1969: Generation X
1996: Generation Y/Millennial
2000: Generation Z
2013: Generation Alpha
2269: Generation Rho
2396: Generation Omega

py3

import pytz
import datetime

def get_time_in_timezone(timezone):
  tz = pytz.timezone(timezone)
  utc_now = datetime.datetime.utcnow()
  tz_now = utc_now.astimezone(tz)
  hour = tz_now.hour
  minute = tz_now.minute
  time_dict = {"hour": hour, "minute": minute}
  return time_dict

timezone = "Pacific/Chatham"
time_dict = get_time_in_timezone(timezone)
total_minutes = time_dict["hour"] * 60 + time_dict["minute"]
formatted_time = "{:02d}:{:02d}".format(total_minutes // 100, total_minutes % 100)
print(formatted_time)

06:69

import unicodedata as ud
g="Generation";gens=[(1883,1900,f"Lost {g}"),(1901,1927,f"Greatest {g}"),(1928,1945,f"Silent {g}"),(1946,1964,"Boomer"),(1965,1980,f"{g} X"),(1981,1996,f"{g} Y/Millennial"),(1997,2012,f"{g} Z")]
def get_gen(birthyear):
 for min,max,gen in gens:
  if min<=birthyear<=max:
   gen_info = f"{birthyear}: {gen}"
   if 1992 <= birthyear <= 2000:
    gen_info += "/Zillennial"
   return gen_info
 return f"{birthyear}: {g} {[ud.name(chr(945+i+(1 if 945+i>=962 else 0))).split()[-1].title() for i,min in enumerate(range(2013,2397,16)) if min<=birthyear<=min+15][0]}"

print(*map(get_gen, [1883,1900,1901,1927,1928,1945,1946,1964,1965,1980,1981,1992,1996,1997,2000,2010,2012,2013,2269,2396]), sep="\n")

1883: Lost Generation
1900: Lost Generation
1901: Greatest Generation
1927: Greatest Generation
1928: Silent Generation
1945: Silent Generation
1946: Boomer
1964: Boomer
1965: Generation X
1980: Generation X
1981: Generation Y/Millennial
1992: Generation Y/Millennial/Zillennial
1996: Generation Y/Millennial/Zillennial
1997: Generation Z/Zillennial
2000: Generation Z/Zillennial
2010: Generation Z
2012: Generation Z
2013: Generation Alpha
2269: Generation Rho
2396: Generation Omega

py3

a = 1
match a:
  case 0: print('😎')
  case 1: print('😮')

😮

python

# Unicode Secure Password Generator v1.0
import secrets
import unicodedata

def is_printable_unicode(char):
    """Check if a character is printable and not a whitespace character."""
    category = unicodedata.category(char)
    # Categories starting with 'C' are control characters, 'Z' are separators including spaces, 'M' are marks
    if category.startswith(('C', 'Z', 'M')):
        return False
    return True

def generate_printable_unicode_list(length=16):
    printable_unicode_chars = []
    
    while len(printable_unicode_chars) < length:
        # Generate a random Unicode code point
        random_code_point = secrets.randbelow(0x110000)  # Unicode range: 0 to 0x10FFFF
        
        try:
            char = chr(random_code_point)
            if is_printable_unicode(char):
                printable_unicode_chars.append(char)
        except ValueError:
            # If the code point is not a valid Unicode character, skip it
            continue
    
    return printable_unicode_chars

# Generate the list of printable Unicode characters
printable_unicode_chars = generate_printable_unicode_list()

# Print the resulting list of Unicode characters
print("".join(printable_unicode_chars))

䣢Ⲇ𐬺葉𤻙𤰚繁𞺍𦼩𤦟鍜塧𪵴𮠺𫙟😎

import math

# Constants
NANOSECONDS_IN_A_SECOND = 1_000_000_000
SECONDS_IN_A_YEAR = 60 * 60 * 24 * 365
NANOSECONDS_IN_A_YEAR = NANOSECONDS_IN_A_SECOND * SECONDS_IN_A_YEAR
MAX_YEARS = 30

# Initial value of nanoseconds
nanoseconds = 1

while True:
    # Calculate the corresponding years for the current nanoseconds
    years = nanoseconds / NANOSECONDS_IN_A_YEAR
    
    # Check if the next doubling would exceed 30 years
    if 2 * nanoseconds / NANOSECONDS_IN_A_YEAR >= MAX_YEARS:
        break
    
    # Double the nanoseconds
    nanoseconds *= 2

# Print the results in scientific notation for nanoseconds and years with one decimal place
print(f"Nanoseconds milestone: {nanoseconds:.2e} ns")
print(f"Corresponding age in years: {years:.1f} years")

Nanoseconds milestone: 5.76e+17 ns
Corresponding age in years: 18.3 years

from datetime import datetime, timedelta

# Constants
NANOSECONDS_IN_A_SECOND = 1_000_000_000
SECONDS_IN_A_YEAR = 60 * 60 * 24 * 365
NANOSECONDS_IN_A_YEAR = NANOSECONDS_IN_A_SECOND * SECONDS_IN_A_YEAR

# Function to convert nanoseconds to a timedelta
def nanoseconds_to_timedelta(nanoseconds):
    seconds = nanoseconds // NANOSECONDS_IN_A_SECOND
    remaining_nanoseconds = nanoseconds % NANOSECONDS_IN_A_SECOND
    return timedelta(seconds=seconds, microseconds=remaining_nanoseconds / 1000)

# Input birth datetime
birth_datetime_str = input("Enter your birth datetime (YYYY-MM-DD HH:MM:SS): ")
birth_datetime = datetime.strptime(birth_datetime_str, "%Y-%m-%d %H:%M:%S")

# Current datetime
current_datetime = datetime.now()

# Initial value of nanoseconds and milestones
nanoseconds = 1
previous_milestone = birth_datetime
next_milestone = birth_datetime

# Loop to find the next milestone after the current datetime
while True:
    # Calculate the next potential milestone datetime
    next_milestone = birth_datetime + nanoseconds_to_timedelta(nanoseconds)
    
    # Check if the next milestone surpasses the current datetime
    if next_milestone > current_datetime:
        break
    
    # Update the previous milestone and double the nanoseconds
    previous_milestone = next_milestone
    nanoseconds *= 2

# Output the results
print(f"Previous milestone: {previous_milestone} (nanoseconds: {nanoseconds//2:.2e} ns)")
print(f"\nNext milestone: {next_milestone} (nanoseconds: {nanoseconds:.2e} ns)")