Code Golf Stack Exchange is a question and answer site for programming puzzle enthusiasts and code golfers. It only takes a minute to sign up.
Sign up to join this community
{x:Int,y:Int->print(x==y)}
\$\endgroup\$
– 2xsaiko
Jan 12 '18 at 13:34
?:=:
This takes a and b in from the command line and prints -1 when equal, 0 when not.
Alternative 4-byter
?:-:
This prints the result of subtracting b from a and gives 0 for equals, and any other value else-wise.
e1:0
Outputs 1 if inputs are equal, otherwise 0
e1:0 Implicit input to stack
e If last 2 items are equal..
1 ..push 1 to stack
: else
0 ..push 0 to stack
Implicit endif
Implicit output of last item on stack
f(a,b){return a==b;}
310310412D301
Outputs 1 if the values are equal, otherwise 0
310310412D301
3 Read..
1 ..from I/O (STDIN)
0 ..to stack
310 Read 2nd input as above
4 Apply math function...
12D ..isEqual, pop both items and push a 1
if they are equal, otherwise push a 0
3 Read..
0 ..from stack
1 ..to I/O (STDOUT)
-4 bytes thanks to @totallyhuman - Changed floats to ints
-1 byte by removing space between second method argument and comma.
-24 by converting the whole program to a lambda (woo).
(i,j)->i==j;
Takes the form of a java.util.function.BiFunction< Boolean, Integer, Integer > using an expression lambda.
float isn't decimal either; it's IEEE binary32. "decimal" is a stupid way of describing binary integers. It only makes sense when talking about their string representation, or with decimal floating point (en.wikipedia.org/wiki/Decimal_floating_point), which isn't provided in hardware by most FPUs. IIRC, IBM's POWER architecture has decimal float support, which is useful for some financial stuff.
\$\endgroup\$
– Peter Cordes
Jan 10 '18 at 2:06
$.$%=<
Formats into this triangle:
$
. $
% = <
Commands executed (without no-ops or directionals): $$=%
Pretty simple.
$ - read input as integer= - compare top two stack values for equality% - print result
81D81D412D301
Pretty simple. Ungolfed:
81D ; builtin - read INT to stack
81D ; builtin - read INT to stack
412D ; compare for equality
301 ; print to STDOUT
$:$=%
Explanation:
$ read integer input
: set notepad to input
$ read integer input
= compare notepad to input
% print notepad
[S S S N
_Push_0][S N
S _Duplicate_0][S N
S _Duplicate_0][T N
T T _Read_STDIN_as_integer][T T T _Retrieve][S S S T N
_Push_1][S N
S _Duplicate_1][T N
T T _Read_STDIN_as_integer][T T T _Retrieve][T S S T _Subtract][N
T S N
_If_0_Jump_to_Label_EQUAL][T N
S T _Print_as_integer][N
N
N
_Exit_program][N
S S N
_Create_Label_EQUAL][S S S T N
_Push_1][T N
S T _Print_as_integer]
Letters S (space), T (tab), and N (new-line) added as highlighting only.
[..._some_action] added as explanation only.
Try it online (with raw spaces, tabs and new-lines only).
Outputs 1/0 as truthy/falsey values. 3 bytes could be saved by removing NNN if 1/01 as truthy/falsey values are allowed.
Pseudo-code:
Integer i = STDIN as number
Integer j = STDIN as number
If(i == j):
Call function EQUAL()
Print 0 to STDOUT
Exit program
function EQUAL:
Print 1 to STDOUT
Exit automatically with error
lambda a,b:a==b
Like this:
def equality(a, b): Declare a function
return a == b Return True if equal, False if not
not(variance(Ans
Gives {1} as truthy value or {0} for falsy. -1 bytes thanks to lirtosiast!
-16 bytes thanks to @mazzy (Basically their answer!)
!($args[0]-$args[1])
Simple. Takes arguments from commandline arguments.
!($args[0]-$args[1]) or $a,$b=$args;!($a-$b) or param($a,$b)!($a-$b)
\$\endgroup\$
– mazzy
Dec 3 '18 at 5:40
."."\</<*:
This is likely to be ungolfed: tell me if there's a better approach.
Explanation:
First, I'll name the two input A and B.
."." pushes A, duplicate it, pushes B, duplicate it. So now the stack is: A A B B.
\ rotates the stack, so the stack is now B A A B.
</<* Pushes A <= B, move it to the bottom of the stack, and pushes B <= A, then multiply them, as they are both boolean, this is equivalent to the and operation.
: Outputs the result.
{}{{}{}}[{}{{{}}}[<>()]](){{}}
You can test it with the interpreter:
$ for i in {0..5}; do
$ for j in {0..5}; do
$ ./Flurry -nin -c '{}{{}{}}[{}{{{}}}[<>()]](){{}}' $i $j
$ done | xargs
$ done
1 0 0 0 0 0
0 1 0 0 0 0
0 0 1 0 0 0
0 0 0 1 0 0
0 0 0 0 1 0
0 0 0 0 0 1
In Flurry, popping from the stack returns the I combinator (λa. a), which also happens to be the Church numeral representation for the number 1. Thus we can compute N != M using the following method:
N times.M times and ignore the value.This is how the program works conceptually, but we can combine the first two steps and the second two steps using a few tricks.
{{}} represents the I combinator (1 = I = λa. a).{{{}}} is a function that pushes its argument to the stack and returns the I combinator (λa. (push a; λb. b))[<>()] represents zero (0 = S K = λab. b).n{{{}}}[<>()], which has the following semantics:
n > 1, push 0 to the stack, followed by n - 1 ones, and return 1.n = 0, push nothing to the stack and return 0.{{}{}} is a function that takes an argument a, pops a value b from the stack, and returns ba. In this case, a and b are both guaranteed to be either zero or one, so it effectively returns 0 if (a, b) == (1, 0) and 1 otherwise.n {{}{}} [m {{{}}} 0], which has the following semantics:
m = 0, [m {{{}}} 0] pushes nothing and returns 0. Since the stack is empty, {{}{}} always pops one, so its return value is always 1. Thus the entire expression is 0 if n = 0 and 1 otherwise.m > 0, [m {{{}}} 0] pushes 0 followed by n - 1 ones and returns 1. Thus {{}{}} always returns the value popped from the stack, and n {{}{}} 1 pops n times and returns the last value popped. The entire expression is 0 if n = m and 1 otherwise.The last step is to take the resulting number (representing whether the values are unequal) and negate it by applying it to () and {{}}.
0: 31 c0 xor %eax,%eax
2: 39 f7 cmp %esi,%edi
4: 0f 94 c0 sete %al
7: c3 retq
bool return values to be in the low 8 bits; the remaining bits of rax are allowed to hold garbage. The only reason you (or gcc) would xor-zero eax would be for performance reasons to avoid a potential false dependency.
\$\endgroup\$
– Peter Cordes
Jan 9 '18 at 13:24
f(a,b){return a-b;}
#define f(a,b) a-b
"Truthy" value is 0 and "Falsy" value is anything but.
int f(int a, int b){ return a==b;}? Becauseintin C represents numbers with base-2 bit-patterns, not decimal. (The details are implementation-defined, but there are enough requirements in the C standard that I don't think an implementation could legally choose a BCD (binary-coded-decimal) representation. At least not forunsigned char.) I think you're getting mixed up by source code that looks likeint a = 1234;. That uses a decimal representation in the source, but not in the program.int a=0x4d2;is identical to1234. \$\endgroup\$ – Peter Cordes Jan 10 '18 at 4:20