Are you a C++ Chad?

There wasn't a lot of substance to this problem , so here is what I expected you to realize. It looks like most of you didn't make it past <-r-slur . !codecels get in!

• you know the code is a valid c++ function

• you know the negation and comparison operator

• you know what int8_t is

• you know this should be true in general

• you know that this problem is dependent on the signed number representation

• you know that two's complement is the one you can expect

• you know two's complement cannot be negated without potentionally causing overflow (0-INT_MIN>INT_MAX)

• you know this programm will run into UB but in practice return false if one of the inputs is int8_min (-128)

• you know this programm will run into UB but in practice return true if both inputs are int8_min (-128)

• you realize that c++ is bullshit anyway

Next time we will look into compile time meta programming using partial template specialization and SFINAE ofcourse !

I haven't used C++ since college but isn't this literally an identity?

3 < 5 so -3 > -5

C++ is for people who like wasting their time.

undefined behaviour, because if the argument is -128 the negative is undefined. Add a check for that and it returns true.

I'm not moving my finger for 250dc you fricking poorcel

Here is the online compiler I used: https://www.onlinegdb.com/online_c++_compiler

#include <iostream></iostream>

using namespace std;

bool function1(int a, int b) {

int aneg = -a;

int bneg = -b;

return ((a<b)==(aneg>bneg));

}

int main()

{

cout<<function1(1,2)<<endl;

cout<<function1(2,2)<<endl;

cout<<function1(-1,2)<<endl;

cout<<function1(1,-2)<<endl;

cout<<function1(-1,-2)<<endl;

cout<<function1(2,1)<<endl;

cout<<function1(-2,-2)<<endl;

cout<<function1(-2,1)<<endl;

cout<<function1(2,-2)<<endl;

cout<<function1(-1,-2)<<endl;

SHOW MORE

It's some bullshit and it returns true because of some bullshit

3 different input modes:

a<b returns true because both conditions are true

a>b returns true because both conditions are false

a==b returns true because both conditions are false

That function makes you a kissless virgin op

what does this have to do with c++ its just a==b

This function returns true when the inequality relationship between 'a' and 'b' is the same as that between their negations, '-a' and '-b'. In other words, if 'a' is less than 'b', then '-a' must be greater than '-b' and vice versa.

The function compares the two input values 'a' and 'b' and their negations 'aneg' and 'bneg'. It returns true if both comparisons yield the same result.

This occurs when:

1. 'a' and 'b' have the same sign (both positive or both negative), and their relative order remains the same after negation.

2. 'a' and 'b' have different signs, but the absolute value of 'a' equals the absolute value of 'b'. In this case, their relative order remains the same after negation.

Is this some dumbshit with int8_t being nothing more than a typedef of signed char.

Writing code that is purposely r-slurred is /g/ tier autism. Attempting to compile this garbage should lead to the being contacted and prison time.

Don't use bloated webshit languages, problem solved

It returns seethe cuz that's what this stack overflow copy and paste is.

Post some real code

True as long as -a and -b are both representable in an int8_t without underflow/overflow, right? I don't think this behavior was even defined until... 17? Whenever two's complement became required.

false iff one input is -128 and the other isn't, because the "negative" of min value -128 is still -128

https://en.wikipedia.org/wiki/Two%27s_complement#Most_negative_number

int8_t min = INT8_MIN;
int8_t minus_min = -INT8_MIN;
printf("%i %i\n", min, minus_min);  // Prints -128 -128, i.e. the - does nothing.

I forgot how r-slurred C++ typing is.

the catch is int8_t and I can only guess when a and b both are under 2^8/2 = 128

WHITE EXTINCTION IS LONG OVERDUE

It returns true when a and b have opposite signs (one is positive and the other is negative), and their absolute values are different.

Imagine not knowing the IEEE float spec by heart 😂😂

and also not knowing the language specific float implementation details for every language an outsourced sexy Indian dude tech interviewer might throw at you

lol, lmao

In haskell this is just

function1 = ap (ap . ((&&) .) . (<)) (flip ((<) . negate) . negate)

and doesn't contain undefined heaviour since bignum is the default

Bruh. isn't it

>int8_t aneg=-a;

I think this is cast into int because int8_t for reasons. Which causes problems but otherwise. You have negative values on aneg , bneg and postive values on a,b. if

If abneg will also be true since. Say you put in 1,2 then it's (1<2) == (-1>-2).

This function returns true when the two input values a and b have opposite signs (i.e., one is positive and the other is negative).

The function first negates the values of a and b using the unary minus operator and stores them in aneg and bneg variables, respectively.

Then it compares the original values a and b using the less-than operator < and compares the negated values aneg and bneg using the greater-than operator >.

The function returns true if and only if both comparisons yield the same result. In other words, if a is less than b, then aneg must be greater than bneg for the function to return true, and vice versa.

The reason for this behavior is that the sign of a signed integer is represented by the most significant bit (MSB) of its binary representation. If two integers have opposite signs, their MSBs will be different. Negating a number flips all its bits and adds one to its two's complement representation, effectively changing its sign. Therefore, if a is less than b, then aneg must be greater than bneg for their signs to match and vice versa.

C++ syntax is peepeepoo

Why do you pass by value?