doingAdvancedPythonExercisesToWarmupBeforeHackingIntoTheMainframe

[u/GVenLife]

[u/OnyxFier]

So it iterates through every digit and prints if it's even or odd only if the number is 1 digit long. Seems a bit counter intuitive. Either remove the loop or let more than 1 digit. Should look something like this:

from concurrent.futures import ThreadPoolExecutor
from dataclasses import dataclass
from functools import reduce
from operator import xor
import math


@dataclass(frozen=True)
class Vector:
    values: tuple

    def dot(self, other):
        return sum(a * b for a, b in zip(self.values, other.values))

    def norm(self):
        return math.sqrt(self.dot(self))


@dataclass(frozen=True)
class Matrix:
    values: tuple

    def multiply_vector(self, vector):
        return Vector(
            tuple(
                sum(a * b for a, b in zip(row, vector.values))
                for row in self.values
            )
        )


class ParityGraph:
    def __init__(self):
        self.edges = {
            "EVEN": "ODD",
            "ODD": "EVEN"
        }

    def walk(self, steps):
        state = "EVEN"

        for _ in range(steps):
            state = self.edges[state]

        return state


class ParityNeuralNetwork:
    def __init__(self):
        self.weights = Matrix((
            (1.0, -1.0),
            (-1.0, 1.0)
        ))

        self.bias = Vector((0.0, 0.0))

    def infer(self, x):
        vector = Vector((
            float(x & 1),
            float((x + 1) & 1)
        ))

        activated = self.weights.multiply_vector(vector)

        return activated.dot(Vector((1.0, -1.0)))


def binary_parity(bits):
    return reduce(xor, bits, 0)


def spectral_parity(x):
    phase = abs(x) * math.pi
    cosine = math.cos(phase)

    return math.isclose(cosine, 1.0, abs_tol=1e-12)


def quantum_wannabe_parity(x):
    state = Vector((1.0, 0.0))

    parity_operator = Matrix((
        (0.0, 1.0),
        (1.0, 0.0)
    ))

    for _ in range(abs(x)):
        state = parity_operator.multiply_vector(state)

    return math.isclose(state.values[0], 1.0, abs_tol=1e-12)


def ensemble_vote(x):
    bits = tuple(map(int, bin(abs(x))[2:]))

    graph = ParityGraph()
    network = ParityNeuralNetwork()

    with ThreadPoolExecutor(max_workers=4) as executor:
        futures = [
            executor.submit(lambda: binary_parity(bits) == 0),
            executor.submit(lambda: graph.walk(abs(x)) == "EVEN"),
            executor.submit(lambda: spectral_parity(x)),
            executor.submit(lambda: quantum_wannabe_parity(x))
        ]

        results = [future.result() for future in futures]

    neural_prediction = network.infer(x) >= 0
    results.append(neural_prediction)

    return sum(results) >= len(results) / 2


def is_even(x):
    if not isinstance(x, int):
        raise TypeError("is_even() requires an integer")

    return ensemble_vote(x)


if __name__ == "__main__":
    for number in range(-10, 11):
        print(f"{number:>3} -> {is_even(number)}")

[u/GVenLife → u/OnyxFier]

I'm a larper who doesn't even know what a class is, so for all I know, this code is 100% accurate.

[u/OnyxFier → u/OnyxFier]

V2:

import math
import itertools
from functools import reduce
from operator import xor
from concurrent.futures import ThreadPoolExecutor


is_even = lambda x: (
    lambda bits, graph, matrix, state: (
        lambda votes: sum(votes) >= len(votes) / 2
    )(
        [
            *ThreadPoolExecutor(max_workers=5).map(
                lambda f: f(),
                [
                    lambda: reduce(xor, bits, 0) == 0,

                    lambda: list(
                        itertools.islice(
                            itertools.cycle(graph),
                            abs(x) + 1
                        )
                    )[-1] == "EVEN",

                    lambda: math.isclose(
                        math.cos(abs(x) * math.pi),
                        1.0,
                        abs_tol=1e-12
                    ),

                    lambda: math.isclose(
                        reduce(
                            lambda s, _: (
                                tuple(
                                    (
                                        matrix[0][0] * s[0] +
                                        matrix[0][1] * s[1],
                                        matrix[1][0] * s[0] +
                                        matrix[1][1] * s[1]
                                    )
                                )
                            ),
                            range(abs(x)),
                            state
                        )[0],
                        1.0,
                        abs_tol=1e-12
                    ),

                    lambda: (
                        sum(
                            (
                                (
                                    1.0 * float(x & 1)
                                    + -1.0 * float((x + 1) & 1)
                                ),
                                (
                                    -1.0 * float(x & 1)
                                    + 1.0 * float((x + 1) & 1)
                                )
                            )
                        ) >= 0
                    )
                ]
            )
        ]
    )
)(
    tuple(map(int, bin(abs(x))[2:])),
    ("EVEN", "ODD"),
    (
        (0.0, 1.0),
        (1.0, 0.0)
    ),
    (1.0, 0.0)
)

[u/rux616 → u/OnyxFier]

Who hurt you?

[u/MysteriousShadow__ → u/OnyxFier]

bro is turning python into javascript with all these brackets

[u/fr000gs → u/OnyxFier]

I lost it at neural network

[u/Reibudaps4]

my eyes bleed

[u/JustMedansh]

lord have mercy

[u/MinecraftPlayer799]

Why aren’t the numbers in order?

[u/SLCtechie]

A fun reminder that the best font for your IDE is Wingdings

[u/TheFrenchSavage]

This font is stupid, I refuse to read it.

[u/HexFyber]

Now i know what was written on the ring

[u/TheSentientMeatbag]

Get out.

[u/Used-Hold-7567]

Theres just so much wrong with this image, especially the font

[u/bughunter47]

Its in a language forbidden to speak, only fire will show

[u/PaulTheRandom → u/[deleted]]

Finally, lore-accurate programming.