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
,[>,]>+<<[<]>[<,[->-<]>[>]>],[>]>.
Takes the two integers separated by a single null byte. Null bytes are falsy in BF and everything else is truthy, so this prints a single 0x01 byte for truthy and a single 0x00 for falsy.
This is my first time golfing in BF, so feel free to give me suggestions...
,[>,] Read in everything from STDIN until the null byte is reached
>+ Move one space to the right and increment; this will be a flag telling us
the numbers are still equal
<<[<]> Move back to the beginning of the input
[ For each character in the input:
<, Move to the left and input a character
[->-<] Subtract this char from the char at the same spot in the original number
>[>] If this is not zero (there is a difference between the two characters)
move to the hole before the flag
> Move one character to the right
If we're in the hole before the flag this moves us onto the flag;
the loop runs once more and deposits us two spots to the right
] Endwhile
When the while loop finishes we will be one spot to the left of the flag
or already to the right if the program found a difference between the numbers
However: we will still be just to the left of the flag for cases like 24 vs 245
, So we input another byte (the next digit of the second number or 0x00)
[>] and move past the flag if it's non-zero
>. Move right (onto the flag or past the flag) and output
//f///t/f
Prints a t if they are equal, otherwise prints f.
Since there is no way to take input in ///, it is hard-coded.
/NUM1/f//NUM2/t/f
Explanation:
With example inputs of 12 and 121213. (Should return false.)
/12/f//121213/t/f/ff13/t/ff.f.With example inputs of 501 and 501. (Should return true.)
/501/f//501/t/f/f/t/ft.t.Credit to @user202729 for coming up with the better approach!
12 == 1212? tio.run/##K85JLM5ILf7/X9/QSF8fSBgapemX6Kf9/w8A I suggest tio.run/##K85JLM5ILf7/X9/QSD9NH0gC6RL9tP//AQ instead.
\$\endgroup\$
– user202729
Oct 4 '17 at 12:37
Straight from the wiki.
Please don't upvote trivial answers.
([{}]{})((){[()](<{}>)}{})
I struggled to find an esolang where this was non-trivial (and that was not already covered). I present to you, this:
**-{0~-}0~-|0~-#
This works as follows:
**-{0~-}0~-|0~-#
** take two inputs on the stack
- subtract them
{0~-}0~- this is "absolute value":
{ } while TOS is > 0
0~- this is negate:
0 push 0 [TOS, 0]
~ swap [0, TOS]
- subtract [-TOS]
thus, this negates positive numbers
0~- negate again to get a positive number
this maps equal numbers to `0` and unequal numbers to their
absolute differences
| take ln(TOS). This gives `-Infinity` for equal numbers, and
some value >= 0 for other numbers.
0~- negate. this gives Infinity for equal numbers, and a number <= 0
for unequal numbers
# output as number
Now, {...} is yup's loop and is the closest thing to a condition. It repeats the inside so long as the TOS is positive and defined. Thus, any negative or 0 value is falsey, and any positive value is truthy. Infinity is truthy, being greater than 0.
Byte count assumes ISO 8859-1 encoding.
D`
¶$
D`
Deduplicate with the implicit regex .+, i.e. if the two lines are identical, clear the second one (the separating linefeed remains though).
¶$
Try to match a linefeed followed by the end of the string. This is only possible if the first stage cleared the second line, i.e. if the two numbers were equal.
Include<MetaFunctions>
Include<Output>
Include<Input>
Include<Integer>
Include<Boolean>
Input:DefineVariable<i; 0>
Output:DefineVariable<o; 0>
Boolean:DefineVariable<c; 0>
Integer:DefineVariable<a; Input:ReadEvaluatedLineFromInput<i>>
Integer:DefineVariable<b; Input:ReadEvaluatedLineFromInput<i>>
Boolean:DefineVariable<r; Boolean:ArgumentsAreEqual<c; a; b>>
Boolean:DefineVariable<q; Boolean:LogicalNot<c; r>>
Output:DisplayAsText<o; q>
DefineMain<> [
MetaFunctions:ExecuteScript<MetaFunctions@FILE>
]
Saved 4 bytes thanks to Mr. Xcoder
Haha, no-one shall lose to Verbosity! Outputs with a Boolean<> wrapper around the result. The Boolean:LogicalNot is required due to an ongoing bug with booleans.
The ungolfed version:
Include<MetaFunctions>
Include<Output>
Include<Input>
Include<Integer>
Include<Boolean>
Input:DefineVariable<STDIN; 0>
Output:DefineVariable<STDOUT; 0>
Boolean:DefineVariable<constant; 0>
Integer:DefineVariable<FirstInput; Input:ReadEvaluatedLineFromInput<STDIN>>
Integer:DefineVariable<SecondInput; Input:ReadEvaluatedLineFromInput<STDIN>>
Boolean:DefineVariable<result; Boolean:ArgumentsAreEqual<constant; FirstInput; SecondInput>>
Boolean:RedefineVariable<result; Boolean:LogicalNot<constant; result>>
Output:DisplayAsText<STDOUT; result>
DefineMain<> [
MetaFunctions:ExecuteScript<MetaFunctions@FILE>
]
¶) counts as one byte in ISO 8859-1 encoding, so it's all the same.
\$\endgroup\$
– Riley
May 31 '17 at 20:58
=
Explanation:
= Takes two arguments and returns a 1 if they are equal, and a 0 if they are not.
Implicit print.
e tests for equality, and _ will subtract the input values from one another, yielding 0 for equals and any other value for different number.
\$\endgroup\$
– steenbergh
May 31 '17 at 22:47
Includes +1 for -r
s/^(.+),\1$//
sed doesn't have truthy/falsy values, so I use the empty string as truty and everything else as falsy. This make sense because /^$/ is the simplest (fully matching) if statement.
'?ddF',',',.....T',',':'?....':
MSM is stack based, so the two input numbers are expected to be on top of the stack, i.e. on the right of the string. MSM has neither numbers nor booleans so we are free to choose a (reasonable) representation:
T True
F False
123 numbers are just sequences of ascii digits. There's no literal
representation in MSM source code, so you have to construct them
digit by digit: 321.. -> 123 (remember: . is concatenation)
TIO doesn't support MSM out of the box, so I've included the JS interpreter from the esolang page.
How it works: (I use a and b for the two numbers on the stack).
Excerpt from the MSM command reference:
' quote, push next char on the stack, even if it is a command
? skip next command if the two top elements of the stack are equal
, drop
: expand string at top of the stack and push each char of it on the stack
. concatenate two top elements
everything else is pushed
Stack trace:
' ? d d F ' , ' , ' , . . . . . T ' , ' , ' : ' ? . . . . ' : a b
d d F ' , ' , ' , . . . . . T ' , ' , ' : ' ? . . . . ' : a b ?
The next 6 chars are pushed on the stack and concatenated with 5 dots
T ' , ' , ' : ' ? . . . . ' : a b ? ,,,Fdd
The next 5 chars are pushed on the stack and concatenated with 4 dots
' : a b ? ,,,Fdd ?:,,T
: and the two numbers are pushed
? ,,,Fdd ?:,,T : a b
Now it gets interesting. If the two numbers are equal, ,,,Fdd is skipped
?:,,T : a b -- ?:,,T as a whole is not a command, so it's pushed
: a b ?:,,T -- expand
a b ? : , , T -- push a b
? : , , T a b -- a b are still equal, so skip :
, , T a b -- drop a b
T -- MSM stops, output is True
If the two numbers are not equal, don't skip ,,,Fdd, but push it:
,,,Fdd ?:,,T : a b
: a b ,,,Fdd ?:,,T -- expand
a b ,,,Fdd ? : , , T -- push up to ?
? : , , T a b ,,,Fdd -- number b is never equal to ,,,Fdd so expand
, , T a b , , , F d d -- drop two dummy values
T a b , , , F -- push T a b
, , , F T a b -- drop b a T
F -- stop
Prompt A,B
If A=B
Disp 1
Else
Disp 0
Pretty self-explanatory. Prompts for two numbers and prints 1 if they are euqal, 0 otherwise.
Prompt A,B:A=B since the result of the = operator is 0 or 1 and will be implicitly displayed at the end of the program.
\$\endgroup\$
– kamoroso94
Jan 31 '18 at 14:31
-4 Bytes thanks to Jo King by using conditional wrapping.
?}?".@!\!.!_1/@_-<~.
More readable version:
? } ? "
. @ ! \ !
. ! _ 1 / @
_ - < ~ . . .
. . . . . .
. . . . .
. . . .
Prints 0 for truthy and 1 for falsy.
There's a no-op at the end to keep it at a sidelength of 4.
It might be possible to reduce the sidelength by one and safe a few more bytes.
? } ?
/ - ! @
" / . . .
. . . .
. . .
This is basically just subtraction and seems like cheating to me.
-nin, 134 bytes<<>[(<<>()>)<<>[({}){}]>][<><<>[<>{{}}]()>]()()[<><<>()>]>({})[<><<>(){}>[()[<><<>()>]]]{{}{<{}{()[<>{}[<><<>()>]]}>}{{}(<>()){}}()}{}
$ pgm="..." # the program above
$ ./flurry -nin -c $pgm 0 0
1
$ ./flurry -nin -c $pgm 123 45
0
$ ./flurry -nin -c $pgm 123 123
1
There is no task that is trivial in every language. Seriously.
Since Flurry's only representation of a number is Church numeral, this program takes only non-negative integers as input. Outputs 1 if two Church numerals represent the same number, 0 otherwise.
Implements the following function:
// (n+1-m) * (m+1-n), where a-b gives zero if a < b
// This gives 1 when m==n (both sides of * are 1)
// and 0 otherwise (one side is 0)
main = (\npm. <SK> (m p (succ n)) (n p (succ m))) n pred m
// succ n = n + 1
succ = S<SK>
// pred n = n - 1 (pred 0 = 0); implemented using pair construct
next-pair-helper = \fmn. f n (succ n) = \fm. S f succ = \f. K(S f succ)
= {()[<>{}[<><<>()>]]}
next-pair = \p. <p next-pair-helper>
= {<{}{()[<>{}[<><<>()>]]}>}
pred = \n. n next-pair zero-pair K
= {{}{<{}{()[<>{}[<><<>()>]]}>}{{}(<>()){}}()}
x=>y=>x==y
(=)
Brackets are necessary, plain = is a syntax error
#==#2&
Equal or SameQ for 5 bytes each.
\$\endgroup\$
– Not a tree
Jun 1 '17 at 7:49
x=>y=>!(x-y)
Because 0 is false and all other numbers are true in JavaScript, if x-y equals 0, a not ! of that 0 will return true, and a not ! of any other number will return false. Two bytes longer than simple comparison x==y as shown in @Shaggy's answer.
(x,y int)
\$\endgroup\$
– powelles
May 31 '17 at 20:44
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