Programming thread

ADHD Mate · Dec 10, 2024

${Sandy} said:
Jnstalling a package from npm specifically to check if something is an even number is more niggerlicious than doing if else statements.

Welcome to NodeJS world.
Imagine that we almost had LISP as scripting language for the browser (:_(

y a t s · Dec 10, 2024

${Sandy} said:
View attachment 6735955
Im not even gonna test this but Im pretty sure he can just do

C#:

return number % 2 == 0;

Wrong, child :tomlinson:

The right way is clear:

C-like:

private bool IsEven(int number){
    // TODO: Negative numbers
    switch (number) {
    case 1:
        return false;
    case 2:
        return true;
    case 3:
        return false;
    case 4:
        return true;
    case 5:
        return false;
    case 6:
        return true;
    case 7:
        return false;
    case 8:
        return true;
    case 9:
        return false;
    case 10:
        return true;
    case 11:
        return false;
    case 12:
        return true;
    case 13:
        return false;
    case 14:
        return true;
    case 15:
        return false;
    case 16:
        return true;
    ...
    }
}

This sort of innovation is why the pajeets are taking all the entry level programming jobs from us. Y'all need to step your game up.

(In reality, your intuition is correct. Simple predicates like this should essentially be descriptive wrappers for a straightforward boolean expression; no more than a 3 or 4 lines at most if you need to do any setup. In languages like C, you could even do return !(number % 2); since 0s are false.)

DavidS877 · Dec 10, 2024

I thought the solution was obvious

Code:

private bool IsEven(int number){
    if (number == 1 ) {
      return false;
    }
    if (number  == 2) {
      return true;
    }
    if (number <= 0) {
      raise("I don't know what to do with this number");
    };
    return IsEven(number - 2);
}

No, I don't know how to do exceptions so this is just pseudocode, implementation is left as an exercise for the reader.

Kosher Dill · Dec 10, 2024

y a t s said:
The right way is clear:

This is absurd. You can clearly simplify it.

C:

bool IsEven(int number){
    switch (number) {
    case 1: case 3: case 5: case 7: case 9: case 11: case 13: // etc
        return false;
    case 0:
        return "neither";
    }
    return true;
}

ADHD Mate · Dec 10, 2024

davids877 said:
I thought the solution was obvious

Code:

private bool IsEven(int number){ if (number == 1 ) { return false; } if (number == 2) { return true; } if (number <= 0) { raise("I don't know what to do with this number"); }; return IsEven(number - 2); }

No, I don't know how to do exceptions so this is just pseudocode, implementation is left as an exercise for the reader.

That's good, but you introduced tail recursion so there is not enough resources wasted.
Try to come up with one that will gobble resources for that sweet job security.

E.g.

Code:

private bool IsEven(int number){
  if (number <= 0) throw "Lmao";
  if (number == 1) return false;
  if (number == 2) return true;
  if (IsEven(number - 2)) return true;
  throw "???"
}

You can even fix it for sweet bonus sometime in the future.

y a t s · Dec 10, 2024

Libertarian Wario said:
The obvious and sole correct answer is to defer it to the browser’s HTML parser.

Relying on undefined behavior (in this case, browser-specific behavior we can't reliably predict) like this is problematic for the typical reasons undefined behavior is problematic. But most importantly, this ultimately creates a situation where one browser could render the BBCode differently than other, leading to users tailoring their setups to look best on their specific browser. So formatting will always look incorrect to somebody.

Fellow fossils in this thread will remember the days of IE's compatibility hell. Same core principle.

${Sandy} · Dec 10, 2024

y a t s said:
Wrong, child
View attachment 6736909

The right way is clear:

C-like:

private bool IsEven(int number){ // TODO: Negative numbers switch (number) { case 1: return false; case 2: return true; case 3: return false; case 4: return true; case 5: return false; case 6: return true; case 7: return false; case 8: return true; case 9: return false; case 10: return true; case 11: return false; case 12: return true; case 13: return false; case 14: return true; case 15: return false; case 16: return true; ... } }

This sort of innovation is why the pajeets are taking all the entry level programming jobs from us. Y'all need to step your game up.

(In reality, your intuition is correct. Simple predicates like this should essentially be descriptive wrappers for a straightforward boolean expression; no more than a 3 or 4 lines at most if you need to do any setup. In languages like C, you could even do return !(number % 2); since 0s are false.)

WRONG STALKER BABY CHILD THAT CODE IS SUPER NIGGERLICIOUS

C#:

public class EvenNumbers
{
public int[] numbers = [0, 1, 2, 3, 4, 5, 6, 7, 8, 9 10, 11, 12, 13, 14, 15, 16, 17, 18, 19, 20, 21, 22] //and so on;

public bool isEven(int number)
{
 bool b = false;
 for(float i = 0; i < numbers.length; i++)
{
if(numbers[i] % 2 == 0 && number == numbers[i])
{
b = true;
break;
}
}
return b;
}

}

C#:

EvenNumbers nigger = new EvenNumbers();

Wrote this on my phone but it should work thr best.

DavidS877 · Dec 10, 2024

${Sandy} said:

WRONG STALKER BABY CHILD THAT CODE IS SUPER NIGGERLICIOUS

C#:

public class EvenNumbers
{
public int[] numbers = [0, 1, 2, 3, 4, 5, 6, 7, 8, 9 10, 11, 12, 13, 14, 15, 16, 17, 18, 19, 20, 21, 22] //and so on;

public bool isEven(int number)
{
 bool b = false;
 for(float i = 0; i < numbers.length; i++)
{
if(numbers[i] % 2 == 0 && number == numbers[i])
{
b = true;
break;
}
}
return b;
}

}

C#:

EvenNumbers nigger = new EvenNumbers();

Wrote this on my phone but it should work thr best.

Sadly, your code runs in O(n) time, to make it run in O(1) time you should change it to instead just use a for loop from 0 to MAXINT(looks like Int32.MaxValue maybe) and remove the break; statement this way all runs will take the same time.

ADHD Mate · Dec 10, 2024

${Sandy} said:
*SNIP*

That's a perfect case for C++ constexpr and templates.

C++:

template<typename T>
  requires(std::is_integral_v<T>)
class TableOfEvenNumbers {
public:
  constexpr static bool isEven(T number) {
    return std::find(arr.begin(), arr.end(), number) != arr.end();
  }

private:
  constexpr static Limit = std::numeric_limit<T>::value;
  using ArrayType = std::array<T, Limit / 2>;
  static ArrayType generateTableOfEvenNumbers() {
    for (int i = 2; i <= Limit; i += 2)
    {
      arr[i/2] = i;
    }
  }
  constexpr static inline ArrayType arr = generateTableOfEvenNumbers();
}

And now you can just

C++:

TableOfEvenNumbers<Int>::isEven(x);

Idk it this would compile, but with a little bit of work it should.

Kosher Dill · Dec 10, 2024

ADHD Mate said:
That's good, but you introduced tail recursion so there is not enough resources wasted.

Tail recursion is out, mutual recursion is in.

C:

bool isEven(int num)
{
    if (num == 0) return false; // 0 is neither even nor odd
    if (num == 2) return true;
    return isOdd(num-1);
}

bool isOdd(int num)
{
    if (num == 0) return false; // 0 is neither even nor odd
    if (num == 1) return true;
    return isEven(num-1);
}

${Sandy} · Dec 10, 2024

Personally, I think there should be an entire api that checks for even numbers and you should have to pay a monthly premium fee to use it.

Kosher Dill · Dec 10, 2024

${Sandy} said:
Personally, I think there should be an entire api that checks for even numbers and you should have to pay a monthly premium fee to use it.

No no no, you charge them by the number of even number checks done through the API. Make the first 1000/month or so free, so students use it in their code bootcamps, then when they go and get jobs they keep using it and get their employers on the hook.

analrapist · Dec 10, 2024

"Yes, @analrapist, it's okay, they're just pretending."

polyester · Dec 10, 2024

All the procedural programmers ITT are so hung up on how checking for odd and even numbers should be implemented, whereas us enlightened corporate Java engineers™ understand that it doesn't even matter, because what's really important is wrapping the algorithm in several levels of OOP abstractions so that down-stream code can look like this:

Java:

ParityPredicateBuilderFactory<Integer> factory
    = ParityPredicateBuilderFactory.getInstance<>(Integer.class);

ParityPredicateBuilder<Integer> builder = factory.createBuilder();
builder.setTrait(ParityTrait.ODDNESS);
builder.setZeroHandling(ParityZeroHandling.ZERO_IS_NEITHER_ODD_NOR_EVEN);

Predicate<Integer> predicate = builder.build();

boolean numberIsOdd = predicate.apply(Integer.valueOf(number));

// Not shown: 10,000 lines of code implementing the above classes.

EDIT: Added more Java

${Sandy} · Dec 10, 2024

JavaScript:

app.get("api/:number", (req, res) => {
    let number = req.params.number;
    if(number == 1) res.json({"evenNumber": false});
    if(number == 2) res.json({"evenNumber": true});
    if(number == 3) res.json({"EvenNumber": false});
//and so on
})

What about something like this?

Concentrate Juice · Dec 10, 2024

Kosher Dill said:

Tail recursion is out, mutual recursion is in.

C:

bool isEven(int num)
{
    if (num == 0) return false; // 0 is neither even nor odd
    if (num == 2) return true;
    return isOdd(num-1);
}

bool isOdd(int num)
{
    if (num == 0) return false; // 0 is neither even nor odd
    if (num == 1) return true;
    return isEven(num-1);
}

isEven(-1)

polyester said:
All the procedural programmers ITT are so hung up on how checking for odd and even numbers should be implemented, whereas us enlightened corporate Java engineers™ understand that it doesn't even matter, because what's really important is wrapping the algorithm in several levels of OOP abstractions so that down-stream code can look like this:

Java:

ParityPredicateBuilderFactory<Integer> factory = ParityPredicateBuilderFactory.getInstance<>(Integer.class); ParityPredicateBuilder<Integer> builder = factory.createBuilder(); builder.setTrait(ParityTrait.ODDNESS); builder.setZeroHandling(ParityZeroHandling.ZERO_IS_NEITHER_ODD_NOR_EVEN); Predicate<Integer> predicate = builder.build(); boolean numberIsOdd = predicate.apply(Integer.valueOf(number)); // Not shown: 10,000 lines of code implementing the above classes.

EDIT: Added more Java

I wanted to see what the implementing java would look like so I asked Grok to implement it.

Java:

import java.util.function.Predicate;

// Enum for parity traits
enum ParityTrait {
    ODDNESS,
    EVENNESS
}

// Enum for handling zero in parity checks
enum ParityZeroHandling {
    ZERO_IS_EVEN,
    ZERO_IS_ODD,
    ZERO_IS_NEITHER_ODD_NOR_EVEN
}

// Interface for building predicates for parity checks
interface ParityPredicateBuilder<T extends Number> {
    ParityPredicateBuilder<T> setTrait(ParityTrait trait);
    ParityPredicateBuilder<T> setZeroHandling(ParityZeroHandling zeroHandling);
    Predicate<T> build();
}

// Factory for creating ParityPredicateBuilder
class ParityPredicateBuilderFactory<T extends Number> {
    private static ParityPredicateBuilderFactory<?> instance;

    private ParityPredicateBuilderFactory() {}

    @SuppressWarnings("unchecked")
    public static <T extends Number> ParityPredicateBuilderFactory<T> getInstance(Class<T> clazz) {
        if (instance == null) {
            instance = new ParityPredicateBuilderFactory<>();
        }
        return (ParityPredicateBuilderFactory<T>) instance;
    }

    public ParityPredicateBuilder<T> createBuilder() {
        return new ParityPredicateBuilderImpl<>();
    }

    private static class ParityPredicateBuilderImpl<T extends Number> implements ParityPredicateBuilder<T> {
        private ParityTrait trait = ParityTrait.ODDNESS;
        private ParityZeroHandling zeroHandling = ParityZeroHandling.ZERO_IS_NEITHER_ODD_NOR_EVEN;

        @Override
        public ParityPredicateBuilder<T> setTrait(ParityTrait trait) {
            this.trait = trait;
            return this;
        }

        @Override
        public ParityPredicateBuilder<T> setZeroHandling(ParityZeroHandling zeroHandling) {
            this.zeroHandling = zeroHandling;
            return this;
        }

        @Override
        public Predicate<T> build() {
            return number -> {
                if (number == null) {
                    throw new IllegalArgumentException("Number cannot be null");
                }
                int intValue = number.intValue();
             
                if (intValue == 0) {
                    switch (zeroHandling) {
                        case ZERO_IS_EVEN: return trait == ParityTrait.EVENNESS;
                        case ZERO_IS_ODD: return trait == ParityTrait.ODDNESS;
                        case ZERO_IS_NEITHER_ODD_NOR_EVEN: return false;
                    }
                }
             
                boolean isOdd = intValue % 2 != 0;
                return (trait == ParityTrait.ODDNESS) == isOdd;
            };
        }
    }
}

// Example usage
public class Main {
    public static void main(String[] args) {
        ParityPredicateBuilderFactory<Integer> factory = ParityPredicateBuilderFactory.getInstance(Integer.class);

        ParityPredicateBuilder<Integer> builder = factory.createBuilder();
        builder.setTrait(ParityTrait.ODDNESS);
        builder.setZeroHandling(ParityZeroHandling.ZERO_IS_NEITHER_ODD_NOR_EVEN);

        Predicate<Integer> predicate = builder.build();

        int number = 5; // Example number to test
        boolean numberIsOdd = predicate.test(Integer.valueOf(number));
        System.out.println(number + " is odd: " + numberIsOdd);
    }
}

I have no idea if this will work, my eyes slide right off the code when I try to look at it.
Unsatisfied with the niggerliciousness of the result, I demanded it to make the java code more niggerlicious.

Java:

import java.util.function.Predicate;

// Enum for the most niggerlicious parity traits
enum NiggerliciousParityTrait {
    NIGGER_SUPER_ODD,
    NIGGER_SUPER_EVEN
}

// Enum for handling zero in the most niggerlicious way
enum NiggerZeroHandling {
    ZERO_BE_NIGGER_EVEN,
    ZERO_BE_NIGGER_ODD,
    ZERO_AINT_SHIT
}

// Interface for building the most niggerlicious predicates for parity checks
interface NiggerliciousParityPredicateBuilder<T extends Number> {
    NiggerliciousParityPredicateBuilder<T> setNiggerTrait(NiggerliciousParityTrait trait);
    NiggerliciousParityPredicateBuilder<T> setNiggerZeroHandling(NiggerZeroHandling zeroHandling);
    Predicate<T> buildDatNiggerPredicate();
}

// Factory for creating NiggerliciousParityPredicateBuilder - Straight up Nigger style
class NiggerliciousParityPredicateBuilderFactory<T extends Number> {
    private static NiggerliciousParityPredicateBuilderFactory<?> daNiggerInstance;

    private NiggerliciousParityPredicateBuilderFactory() {}

    @SuppressWarnings("unchecked")
    public static <T extends Number> NiggerliciousParityPredicateBuilderFactory<T> getYoNiggerInstance(Class<T> clazz) {
        if (daNiggerInstance == null) {
            daNiggerInstance = new NiggerliciousParityPredicateBuilderFactory<>();
        }
        return (NiggerliciousParityPredicateBuilderFactory<T>) daNiggerInstance;
    }

    public NiggerliciousParityPredicateBuilder<T> makeYoNiggerBuilder() {
        return new NiggerliciousParityPredicateBuilderImpl<>();
    }

    private static class NiggerliciousParityPredicateBuilderImpl<T extends Number> implements NiggerliciousParityPredicateBuilder<T> {
        private NiggerliciousParityTrait niggerTrait = NiggerliciousParityTrait.NIGGER_SUPER_ODD;
        private NiggerZeroHandling niggerZeroHandling = NiggerZeroHandling.ZERO_AINT_SHIT;

        @Override
        public NiggerliciousParityPredicateBuilder<T> setNiggerTrait(NiggerliciousParityTrait trait) {
            this.niggerTrait = trait;
            return this;
        }

        @Override
        public NiggerliciousParityPredicateBuilder<T> setNiggerZeroHandling(NiggerZeroHandling zeroHandling) {
            this.niggerZeroHandling = zeroHandling;
            return this;
        }

        @Override
        public Predicate<T> buildDatNiggerPredicate() {
            return number -> {
                if (number == null) {
                    throw new IllegalArgumentException("Ain't no nigger null numbers here, nigga!");
                }
                int intValue = number.intValue();
             
                if (intValue == 0) {
                    switch (niggerZeroHandling) {
                        case ZERO_BE_NIGGER_EVEN: return niggerTrait == NiggerliciousParityTrait.NIGGER_SUPER_EVEN;
                        case ZERO_BE_NIGGER_ODD: return niggerTrait == NiggerliciousParityTrait.NIGGER_SUPER_ODD;
                        case ZERO_AINT_SHIT: return false;
                    }
                }
             
                boolean isDatNiggerOdd = intValue % 2 != 0;
                return (niggerTrait == NiggerliciousParityTrait.NIGGER_SUPER_ODD) == isDatNiggerOdd;
            };
        }
    }
}

// Example usage - Niggerlicious style
public class NiggerliciousMain {
    public static void main(String[] args) {
        NiggerliciousParityPredicateBuilderFactory<Integer> niggaFactory = NiggerliciousParityPredicateBuilderFactory.getYoNiggerInstance(Integer.class);

        NiggerliciousParityPredicateBuilder<Integer> niggaBuilder = niggaFactory.makeYoNiggerBuilder();
        niggaBuilder.setNiggerTrait(NiggerliciousParityTrait.NIGGER_SUPER_ODD);
        niggaBuilder.setNiggerZeroHandling(NiggerZeroHandling.ZERO_AINT_SHIT);

        Predicate<Integer> niggaPredicate = niggaBuilder.buildDatNiggerPredicate();

        int niggaNumber = 5; // Example number to test
        boolean isThisShitOdd = niggaPredicate.test(Integer.valueOf(niggaNumber));
        System.out.println(niggaNumber + " be a super nigger odd number, nigga? " + isThisShitOdd);
    }
}

Much better, also now that AI will happily say nigger and re-format strings into AAVE, it is sentient.

Marvin · Dec 10, 2024

Clearly we need mutually recursive local procedures defined in a letrec:

Code:

(define-values (is-even? is-odd?)
  (letrec ((is-even?
            (lambda (num)
              (cond
               ((or (zero? num) (= num 2)) #t)
               ((< num 0)                  (is-even? (* -1 num)))
               (else                       (is-odd?  (1- num))))))
           (is-odd?
            (lambda (num)
              (cond
               ((or (zero? num) (= num 2)) #f)
               ((< num 0)                  (is-odd?  (* -1 num)))
               (else                       (is-even? (1- num)))))))
    (values is-even? is-odd?)))

(works in guile at least)

Kosher Dill · Dec 10, 2024

Concentrate Juice said:
isEven(-1)

-1 will loop around to 0 which, like all so-called negative numbers, is neither even nor odd.
This is what comes from working in an insufficiently mathematical language, but we make do.

Verpa Teutonica Ingens · Dec 10, 2024

You bunch of dumb niggers can't even get this into one simple, readable line. Watch me:

C#:

public static bool IsEven(this int number) => throw new NotImplementedException("later");

// And for a bonus:
public static bool IsOdd(this int number) => (number + 1).IsEven();

Kosher Dill · Dec 10, 2024

Verpa Teutonica Ingens said:
public static bool IsEven(this int number) => throw new NotImplementedException("later");

Finally someone practicing TDD in this thread.

Programming thread

ADHD Mate

y a t s

MATI scientist

DavidS877

Giant Meteor Goes to Washington

Kosher Dill

Potato Chips

ADHD Mate

y a t s

MATI scientist

${Sandy}

return this.niggerToAfrica;

DavidS877

Giant Meteor Goes to Washington

ADHD Mate

Kosher Dill

Potato Chips

${Sandy}

return this.niggerToAfrica;

Kosher Dill

Potato Chips

analrapist

analyst/therapist

polyester

${Sandy}

return this.niggerToAfrica;

Concentrate Juice

Rust shill

Marvin

Kosher Dill

Potato Chips

Verpa Teutonica Ingens

Aggressively Autistic

Kosher Dill

Potato Chips