def is_heterogram(s):
    """
    Checks if the input string is a heterogram (contains no repeated letters).
    
    Parameters:
    - s: Input string
    
    Returns:
    - True if the string is a heterogram, False otherwise.
    """
    s = s.lower()  # Make the string case-insensitive
    seen = set()  # Use a set to track letters

    for char in s:
        if char.isalpha():  # Only consider letters
            if char in seen:
                return False  # Found a repeated letter
            seen.add(char)
    
    return True

# Example usage
if __name__ == "__main__":
    print(is_heterogram("The quick brown fox"))  # Should return True
    print(is_heterogram("hello"))  # Should return False

False
False

print(is_heterogram("The quick fox"))
print(is_heterogram("abcdefghijklmnopqrstuvwxyz"))
print(is_heterogram("a"))
print(is_heterogram("aa"))

True
True
True
False

def is_heterogram_sets(s):
    s = s.lower().replace(' ', '')    # remove case sensitivity and spaces
    return len(set(s)) == len(s)


print(is_heterogram_sets("The quick fox"))
print(is_heterogram_sets("abcdefghijklmnopqrstuvwxyz"))
print(is_heterogram_sets("a"))
print(is_heterogram_sets("aa"))

True
True
True
False

%timeit is_heterogram("abcdefghijklmnopqrstuvwxyz")
%timeit is_heterogram_sets("abcdefghijklmnopqrstuvwxyz")

1.2 µs ± 3.72 ns per loop (mean ± std. dev. of 7 runs, 1,000,000 loops each)
465 ns ± 2.17 ns per loop (mean ± std. dev. of 7 runs, 1,000,000 loops each)

def trapezoidal_rule_integral(f, a, b, n):
    """
    Compute the definite integral of a function using the trapezoidal rule.

    Parameters:
    - f: The function to be integrated.
    - a: The lower limit of integration.
    - b: The upper limit of integration.
    - n: The number of subintervals.

    Returns:
    The approximate value of the definite integral.
    """
    h = (b - a) / n
    result = 0.5 * (f(a) + f(b))

    for i in range(1, n):
        result += f(a + i * h)

    result *= h

    return result

# Example usage: Compute the indefinite integral of x^2 from 0 to 1
def function_to_integrate(x):
    return x**2

lower_limit = 0
upper_limit = 1
num_subintervals = 1000

result = trapezoidal_rule_integral(function_to_integrate, lower_limit, upper_limit, num_subintervals)
print(f"The approximate integral is: {result}")

The approximate integral is: 0.33333349999999995

import numpy as np

def trapezoidal_rule_integral2(f, a, b, n):
    """
    Compute the definite integral of a function using the trapezoidal rule.

    Parameters:
    - f: The function to be integrated.
    - a: The lower limit of integration.
    - b: The upper limit of integration.
    - n: The number of subintervals.

    Returns:
    The approximate value of the definite integral.
    """
    x_values = np.linspace(a, b, n + 1)
    h = (b - a) / n

    result = 0.5 * (f(a) + f(b)) + np.sum(f(x_values[1:-1]))

    result *= h

    return result

# Example usage: Compute the indefinite integral of x^2 from 0 to 1 using NumPy arrays
def function_to_integrate(x):
    return x**2

lower_limit = 0
upper_limit = 1
num_subintervals = 1000

result = trapezoidal_rule_integral2(function_to_integrate, lower_limit, upper_limit, num_subintervals)
print(f"The approximate integral is: {result}")

The approximate integral is: 0.33333349999999995

%timeit trapezoidal_rule_integral(function_to_integrate, lower_limit, upper_limit, num_subintervals)
%timeit trapezoidal_rule_integral2(function_to_integrate, lower_limit, upper_limit, num_subintervals)

92.1 µs ± 651 ns per loop (mean ± std. dev. of 7 runs, 10,000 loops each)
8.17 µs ± 67.1 ns per loop (mean ± std. dev. of 7 runs, 100,000 loops each)

\begin{align}
    \frac{\partial \mathbf{u}}{\partial t} + (\mathbf{u} \cdot \nabla)\mathbf{u} &= -\nabla p + \nu \nabla^2 \mathbf{u} + \mathbf{f}, \\
    \nabla \cdot \mathbf{u} &= 0,
\end{align}

where:
\begin{itemize}
    \item $\mathbf{u}$ is the velocity vector field,
    \item $t$ is time,
    \item $p$ is the pressure field,
    \item $\nu$ is the kinematic viscosity,
    \item $\mathbf{f}$ represents external forces (e.g., gravity),
    \item $\nabla$ denotes the gradient operator,
    \item $\nabla \cdot$ represents the divergence operator,
    \item $\nabla^2$ is the Laplacian operator.
\end{itemize}

Generative AI and large language models (LLMs)¶

IMPORTANT¶

What is AI?¶

What is an LLM?¶

Examples¶

Problem cases¶

For code?¶

"That's textbook"¶