OpenAI ChatGPT 5 vs Grok 4 - Which one creates better Python code?

# Script to read a list of integers and output the sum of even numbers
def sum_of_even_numbers(numbers):
    return sum(num for num in numbers if num % 2 == 0)

if __name__ == "__main__":
    # Read input from the user
    try:
        numbers = list(map(int, input("Enter integers separated by spaces: ").split()))
        total_even = sum_of_even_numbers(numbers)
        print("Sum of even numbers:", total_even)
    except ValueError:
        print("Please enter valid integers only.")

# Read a line of input containing space-separated integers
input_line = input("Enter a list of integers separated by spaces: ")

# Convert the input string into a list of integers
numbers = list(map(int, input_line.split()))

# Initialize sum of even numbers
even_sum = 0

# Iterate through the list and add even numbers to the sum
for num in numbers:
    if num % 2 == 0:
        even_sum += num

# Output the sum
print("Sum of even numbers:", even_sum)

import csv
from collections import defaultdict

def total_sales_per_product(csv_file):
    sales = defaultdict(float)

    with open(csv_file, newline='', encoding='utf-8') as f:
        reader = csv.DictReader(f)
        for row in reader:
            try:
                product = row['product']
                quantity = float(row['quantity'])
                price = float(row['price'])
                sales[product] += quantity * price
            except (KeyError, ValueError):
                print(f"Skipping invalid row: {row}")

    return sales

if __name__ == "__main__":
    file_path = "transactions.csv"  # Change to your file path
    sales_totals = total_sales_per_product(file_path)

    print("Total Sales Per Product:")
    for product, total in sales_totals.items():
        print(f"{product}: ${total:,.2f}")

import pandas as pd

# Prompt user for the CSV file path
file_path = input("Enter the path to the CSV file: ")

# Load the CSV file into a DataFrame
df = pd.read_csv(file_path)

# Assuming the CSV has columns 'Product' and 'Sales'
# Group by 'Product' and sum the 'Sales'
total_sales = df.groupby('Product')['Sales'].sum()

# Print the total sales per product
print("Total sales per product:")
print(total_sales)

def first_non_repeating_char(s):
    from collections import Counter
    counts = Counter(s)

    for char in s:
        if counts[char] == 1:
            return char
    return None  # If no non-repeating character found

# Example usage
text = "swiss"
result = first_non_repeating_char(text)
if Code:
    print(f"The first non-repeating character is: '{result}'")
else:
    print("No non-repeating character found.")

import collections

def first_non_repeating_char(s):
    """
    Returns the first non-repeating character in the string.
    If no such character exists, returns None.
    """
    count = collections.Counter(s)
    for char in s:
        if count[char] == 1:
            return char
    return None

# Example usage
input_string = input("Enter a string: ")
result = first_non_repeating_char(input_string)
print("First non-repeating character:", result)

import requests

def get_bitcoin_price_usd():
    url = "https://api.coindesk.com/v1/bpi/currentprice/USD.json"
    try:
        response = requests.get(url, timeout=5)
        response.raise_for_status()  # Raise HTTPError for bad responses
        data = response.json()
        price = data["bpi"]["USD"]["rate"]
        print(f"Current Bitcoin Price: ${price} USD")
    except requests.exceptions.RequestException as e:
        print(f"Error fetching Bitcoin price: {e}")
    except (KeyError, ValueError) as e:
        print(f"Error parsing response: {e}")

if __name__ == "__main__":
    get_bitcoin_price_usd()

import requests

# Define the API endpoint
url = "https://api.coingecko.com/api/v3/simple/price?ids=bitcoin&vs_currencies=usd"

# Fetch the data
response = requests.get(url)

# Check if the request was successful
if response.status_code == 200:
    data = response.json()
    bitcoin_price = data['bitcoin']['usd']
    print(f"Current Bitcoin price in USD: ${bitcoin_price}")
else:
    print(f"Error fetching data: {response.status_code}")

import requests
from bs4 import BeautifulSoup

def get_top_hn_headlines(limit=5):
    url = "https://news.ycombinator.com/"
    try:
        response = requests.get(url, timeout=5)
        response.raise_for_status()

        soup = BeautifulSoup(response.text, "html.parser")
        headlines = [a.get_text() for a in soup.select(".titleline > a")]

        print(f"Top {limit} Hacker News Headlines:")
        for i, title in enumerate(headlines[:limit], 1):
            print(f"{i}. {title}")
    except requests.exceptions.RequestException as e:
        print(f"Error fetching Hacker News: {e}")

if __name__ == "__main__":
    get_top_hn_headlines()

import requests
from bs4 import BeautifulSoup

# Define the URL
url = 'https://news.ycombinator.com/'

# Fetch the webpage
response = requests.get(url)
response.raise_for_status()  # Raise an error for bad status codes

# Parse the HTML content
soup = BeautifulSoup(response.text, 'html.parser')

# Find the top 5 story elements
stories = soup.find_all('tr', class_='athing')[:5]

# Print the top 5 headlines
print("Top 5 News Headlines from Hacker News:")
for i, story in enumerate(stories, 1):
    title_span = story.find('span', class_='titleline')
    if title_span:
        headline = title_span.find('a').text
        print(f"{i}. {headline}")

import zipfile
import glob
import os

def zip_text_files(output_zip="archive.zip"):
    txt_files = glob.glob("*.txt")
    if not txt_files:
        print("No .txt files found in the current directory.")
        return

    with zipfile.ZipFile(output_zip, "w") as zipf:
        for file in txt_files:
            zipf.write(file, os.path.basename(file))
            print(f"Added: {file}")

    print(f"Created {output_zip} containing {len(txt_files)} files.")

if __name__ == "__main__":
    zip_text_files()

import os
from zipfile import ZipFile

# Get the current directory
current_dir = os.getcwd()

# List all .txt files in the current directory
txt_files = [f for f in os.listdir(current_dir) if f.endswith('.txt')]

# Create a zip file and add the .txt files
with ZipFile('archive.zip', 'w') as zipf:
    for file in txt_files:
        zipf.write(file)

print(f"Successfully zipped {len(txt_files)} .txt files into 'archive.zip'.")

import os
from PIL import Image
import glob

def resize_jpeg_images(width=800, height=600, output_dir="output"):
    # Create output folder if it doesn't exist
    os.makedirs(output_dir, exist_ok=True)

    # Find all .jpg and .jpeg files (case-insensitive)
    jpeg_files = glob.glob("*.jpg") + glob.glob("*.jpeg") + glob.glob("*.JPG") + glob.glob("*.JPEG")

    if not jpeg_files:
        print("No JPEG images found in the current directory.")
        return

    for file in jpeg_files:
        try:
            with Image.open(file) as img:
                img_resized = img.resize((width, height), Image.LANCZOS)
                output_path = os.path.join(output_dir, os.path.basename(file))
                img_resized.save(output_path, "JPEG")
                print(f"Resized and saved: {output_path}")
        except Exception as e:
            print(f"Error processing {file}: {e}")

if __name__ == "__main__":
    resize_jpeg_images()

import os
from PIL import Image

# Get the current directory
current_dir = os.getcwd()

# Create the output folder if it doesn't exist
output_folder = os.path.join(current_dir, 'output')
os.makedirs(output_folder, exist_ok=True)

# List all JPEG files in the current directory (case-insensitive)
jpeg_files = [f for f in os.listdir(current_dir) 
              if f.lower().endswith(('.jpg', '.jpeg'))]

# Resize each image and save to output folder
resized_count = 0
for file in jpeg_files:
    try:
        img_path = os.path.join(current_dir, file)
        img = Image.open(img_path)
        resized_img = img.resize((800, 600))
        output_path = os.path.join(output_folder, file)
        resized_img.save(output_path)
        resized_count += 1
    except Exception as e:
        print(f"Error processing {file}: {e}")

print(f"Successfully resized and saved {resized_count} JPEG images to the 'output' folder.")

import os
from pathlib import Path
from urllib.parse import urlparse
from concurrent.futures import ThreadPoolExecutor, as_completed

import requests

CHUNK_SIZE = 1024 * 64  # 64KB


def unique_path(dest_dir: Path, filename: str) -> Path:
    """Return a unique path inside dest_dir by appending (1), (2), ... if needed."""
    dest = dest_dir / filename
    if not dest.exists():
        return dest
    stem, suffix = os.path.splitext(filename)
    i = 1
    while True:
        candidate = dest_dir / f"{stem} ({i}){suffix}"
        if not candidate.exists():
            return candidate
        i += 1


def filename_from_url(url: str, index: int) -> str:
    """Get a safe filename from URL; fall back to file_{index} if missing."""
    path = urlparse(url).path
    name = os.path.basename(path).strip()
    return name or f"file_{index}"


def download_file(url: str, dest_dir: Path, index: int, timeout: int = 15) -> Path:
    """Download a single file to dest_dir. Returns the saved path."""
    dest_dir.mkdir(parents=True, exist_ok=True)
    base_name = filename_from_url(url, index)
    dest_path = unique_path(dest_dir, base_name)

    headers = {"User-Agent": "python-threaded-downloader/1.0"}
    with requests.get(url, stream=True, timeout=timeout, headers=headers) as r:
        r.raise_for_status()
        with open(dest_path, "wb") as f:
            for chunk in r.iter_content(chunk_size=CHUNK_SIZE):
                if chunk:  # filter out keep-alive chunks
                    f.write(chunk)
    return dest_path


def download_concurrently(urls, out_dir="downloads", max_workers=5):
    """Download given URLs concurrently using threads."""
    dest_dir = Path(out_dir)
    results = []
    errors = []

    with ThreadPoolExecutor(max_workers=max_workers) as executor:
        future_to_url = {
            executor.submit(download_file, url, dest_dir, i): url
            for i, url in enumerate(urls, start=1)
        }
        for future in as_completed(future_to_url):
            url = future_to_url[future]
            try:
                saved_path = future.result()
                print(f"✅ Downloaded: {url} -> {saved_path}")
                results.append(saved_path)
            except Exception as e:
                print(f"❌ Failed: {url} ({e})")
                errors.append((url, e))
    print(f"\nDone. {len(results)} succeeded, {len(errors)} failed.")
    return results, errors


if __name__ == "__main__":
    # Replace these with your 5 URLs
    urls = [
        "https://example.com/file1.jpg",
        "https://example.com/file2.pdf",
        "https://example.com/file3.zip",
        "https://example.com/file4.png",
        "https://example.com/file5.mp4",
    ]
    download_concurrently(urls, out_dir="downloads", max_workers=5)

import threading
import urllib.request

def download_file(url, filename):
    """
    Downloads a file from the given URL and saves it with the specified filename.
    """
    try:
        urllib.request.urlretrieve(url, filename)
        print(f"Downloaded {filename} from {url}")
    except Exception as e:
        print(f"Error downloading {url}: {e}")

# List of 5 example URLs (replace with your actual URLs)
urls = [
    "https://www.example.com/file1.txt",
    "https://www.example.com/file2.pdf",
    "https://www.example.com/file3.jpg",
    "https://www.example.com/file4.zip",
    "https://www.example.com/file5.docx"
]

# Corresponding filenames to save the downloads
filenames = [
    "file1.txt",
    "file2.pdf",
    "file3.jpg",
    "file4.zip",
    "file5.docx"
]

# Create and start threads for concurrent downloads
threads = []
for url, filename in zip(urls, filenames):
    thread = threading.Thread(target=download_file, args=(url, filename))
    thread.start()
    threads.append(thread)

# Wait for all threads to complete
for thread in threads:
    thread.join()

print("All downloads completed.")

import sqlite3

def main():
    # Connect to (or create) the database
    conn = sqlite3.connect("example.db")
    cursor = conn.cursor()

    # Create the users table if it doesn't exist
    cursor.execute("""
        CREATE TABLE IF NOT EXISTS users (
            id INTEGER PRIMARY KEY AUTOINCREMENT,
            name TEXT NOT NULL,
            email TEXT UNIQUE NOT NULL
        )
    """)

    # Insert sample data
    sample_users = [
        ("Alice", "alice@example.com"),
        ("Bob", "bob@example.com"),
        ("Charlie", "charlie@example.com"),
    ]

    try:
        cursor.executemany("INSERT INTO users (name, email) VALUES (?, ?)", sample_users)
    except sqlite3.IntegrityError:
        # Ignore duplicates if run multiple times
        pass

    # Commit changes
    conn.commit()

    # Query all users
    cursor.execute("SELECT id, name, email FROM users")
    users = cursor.fetchall()

    print("Users in database:")
    for user in users:
        print(user)

    # Close the connection
    conn.close()

if __name__ == "__main__":
    main()

import sqlite3

# Connect to an in-memory SQLite database
conn = sqlite3.connect(':memory:')
cursor = conn.cursor()

# Create the 'users' table
cursor.execute('''
    CREATE TABLE users (
        id INTEGER PRIMARY KEY,
        name TEXT,
        age INTEGER
    )
''')

# Insert sample data
cursor.execute("INSERT INTO users (name, age) VALUES ('Alice', 30)")
cursor.execute("INSERT INTO users (name, age) VALUES ('Bob', 25)")
cursor.execute("INSERT INTO users (name, age) VALUES ('Charlie', 35)")

# Commit the changes
conn.commit()

# Query all users
cursor.execute("SELECT * FROM users")
results = cursor.fetchall()

# Print the results
print("ID | Name | Age")
print("----------------")
for row in results:
    print(f"{row[0]} | {row[1]} | {row[2]}")

# Close the connection
conn.close()

import unittest

# Example implementation of is_prime for testing purposes
# If you already have this function, you can remove this definition.
def is_prime(n):
    """Return True if n is a prime number, else False."""
    if n <= 1:
        return False
    if n <= 3:
        return True
    if n % 2 == 0 or n % 3 == 0:
        return False
    i = 5
    while i * i <= n:
        if n % i == 0 or n % (i + 2) == 0:
            return False
        i += 6
    return True


class TestIsPrime(unittest.TestCase):
    def test_primes(self):
        primes = [2, 3, 5, 7, 11, 13, 17, 19, 23, 29]
        for p in primes:
            with self.subTest(p=p):
                self.assertTrue(is_prime(p), f"{p} should be prime")

    def test_non_primes(self):
        non_primes = [0, 1, 4, 6, 8, 9, 10, 12, 15, 20, 25]
        for n in non_primes:
            with self.subTest(n=n):
                self.assertFalse(is_prime(n), f"{n} should not be prime")

if __name__ == "__main__":
    unittest.main()

import unittest

# Assuming the is_prime function is defined in a module named prime_checker
# Replace 'prime_checker' with the actual module name where is_prime is defined
from prime_checker import is_prime

class TestIsPrime(unittest.TestCase):
    def test_prime_numbers(self):
        """Test that prime numbers are correctly identified."""
        primes = [2, 3, 5, 7, 11, 13, 17, 19, 23, 29]
        for num in primes:
            with self.subTest(num=num):
                self.assertTrue(is_prime(num), f"{num} should be prime")

    def test_non_prime_numbers(self):
        """Test that non-prime numbers are correctly identified."""
        non_primes = [0, 1, 4, 6, 8, 9, 10, 12, 14, 15, 16, 18, 20, 21, 22, 24, 25, 26, 27, 28]
        for num in non_primes:
            with self.subTest(num=num):
                self.assertFalse(is_prime(num), f"{num} should not be prime")

    def test_negative_numbers(self):
        """Test that negative numbers are not considered prime."""
        negatives = [-1, -2, -3, -5, -7]
        for num in negatives:
            with self.subTest(num=num):
                self.assertFalse(is_prime(num), f"{num} should not be prime")

    def test_one_and_zero(self):
        """Explicitly test 0 and 1, which are not prime."""
        self.assertFalse(is_prime(0))
        self.assertFalse(is_prime(1))

if __name__ == '__main__':
    unittest.main()