Based on this question from Code Review.
Given precisely three positive integers, return the product of all of the distinct inputs. If none of the inputs are distinct, return 1. That is, implement the function:
\$ f(a,b,c) = \cases{1 & $a = b = c $ \\ a & $ b = c $ \\ b & $ a = c $ \\ c & $ a = b $ \\ a b c & otherwise } \$
Shortest code in each language wins.
a, b, c -> f(a,b,c)
7, 7, 7 -> 1
3, 3, 5 -> 5
2, 6, 6 -> 2
3, 4, 3 -> 4
1, 2, 3 -> 6
12, 9, 16 -> 1728
¢ÏP
¢ # count occurences of each number
Ï # keep only those where the count is 1
P # product (1 if the list is empty)
Saved 2 bytes thanks to 79037662!!!
f(a,b,c){a=a^b?a^c?b^c?a*b*c:a:b:b^c?c:1;}
a^c (bitwise xor) to check for equality which is shorter than c==a. Note that you'd have to flip the other parts of the ternary.
\$\endgroup\$
int. So yes, it's a golf hack to simply assign the return value to the first parameter.
\$\endgroup\$
(a,b,c)=>a-b?b-c?c-a?a*b*c:b:a:b-c?c:1
Takes input as [a,b,c].
A=>[[a,b,c]=A,1,a-b?a-c?a:b:c,a*b*c][new Set(A).size]
A => // A[] = input
[ // lookup table:
[a, b, c] = A, // set size = 0 --> impossible, so use this slot
// to split A[] into 3 distinct variables
1, // set size = 1 --> return 1
a - b ? // set size = 2 --> if a is not equal to b:
a - c ? // if a is not equal to c:
a // return a
: // else:
b // return b
: // else:
c, // return c
a * b * c // set size = 3 --> return a * b * c
] //
[new Set(A).size] // index into lookup table = size of the set
a^b^c gives the unique one. That saves 8 bytes in the second version.
\$\endgroup\$
*/@-.}./.~
}./.~ group by value and remove one from each group
-. set subtract from input
*/ product
Thanks to Adám and Bubbler in chat for helping golf this
×/∪*1=⊢∘≢⌸
×/ ⍝ Reduce by multiplication
∪ ⍝ The unique values of the input
* ⍝ To the power of
1= ⍝ Whether one is equal to
≢ ⍝ The length of
⊢∘ ⌸ ⍝ The indexes of each unique element
lambda l:eval("(%sin[%s,%s]or %s)*"*3%(l*4)+"1")
Takes in a tuple. The idea is similar to an answer in the Code Review question, which can be golfed to:
51 bytes
lambda a,b,c:a**(b!=a!=c)*b**(c!=b!=a)*c**(a!=c!=b)
Each element is included in the product if it's different from the other two, with the power setting to a harmless x**0 == 1 otherwise. We want to avoid writing the three similar terms being multiplied. Python unfortunately doesn't have a built-in list product without imports. So, we turn to eval shenanigans.
We use a longer expression that use logical short-circuiting:
60 bytes
lambda a,b,c:(a in[b,c]or a)*(b in[c,a]or b)*(c in[a,b]or c)
In this expression, the variable names cycle through a,b,c in that order four times. So, by tripling the format string "(%sin[%s,%s]or %s)*" and plugging in the input tuple repeated four times, we get the desired expression. We just need to append a "1" to deal with the trailing multiplication.
-3 bytes by taking input with scan().
prod(unique(x<-scan())^2,1/x)^!!sd(x)
sd(x) computes the standard deviation (which is 0 iff all entries are equal), so !!sd(x) is TRUE if some entries are different, and FALSE if all are equal.
unique(x)==x, so we are down to prod(x)^1unique(x)^2 and 1/x, so we are left with the sole "lonely" value(...)^0 which is 1.This is shorter than anything I could come up with based on table, tabulate, duplicated or rle(sort()).
duplicated; I did not even come close to this approach!
\$\endgroup\$
rle(sort()), don't have the chance to fully bugtest it right now though. Apparently prod(numeric(0)) == 1 so it might be solid: Try it online!
\$\endgroup\$
Commented
Feb 11, 2020 at 14:31
scan() to take input (which is surely fine). With scan(), my solution goes down to 37 bytes: Try it online!
\$\endgroup\$
Commented
Feb 11, 2020 at 14:55
ḟœ-Q$P
ḟœ-Q$P - list, L
$ - last two links as a monad:
Q - de-duplicate (L)
œ- - (L) multi-set difference (that)
ḟ - (L) filter discard if in (that)
P - product
7s:
ĠṖÐḟị⁸P
ḟṖƙ`F$P
œ-QɓḟP
\$\endgroup\$
Commented
Feb 10, 2020 at 21:21
f l=product[x|x<-l,filter(==x)l==[x]]
Pretty straightforward -- filter for elements that appear only once and take the product.
=PRODUCT(FILTER(A1#,COUNTIF(A1#,A1#)=1,1))
Input entered as a static column array (e.g. ={1;2;3}) in cell A1
=PRODUCT(IFERROR(UNIQUE(A1#,,1),1))?
\$\endgroup\$
prod((a=rle(sort(scan())))$v[a$l<2])
rle() shows its worth again. Feels like some parentheses could be golfed out somehow.
The fact that prod() of an empty numeric evaluates to 1 is the only reason this is efficient.
sort($argv);[,$a,$b,$c]=$argv;echo$a-$b?$b-$c?$a*$b*$c:$a:($b-$c?$c:1);
Might be shorter without the sort but nested ternary operator precedence blows my mind.
-1 byte thanks to @640KB
fn($a,$b,$c)=>$a-$c?$a-$b?$b-$c?$a*$b*$c:$a:$b==$c?:$c:$b==$c?:$b;
Kudos to @640KB for taming the ternary operator beast!
$n= tio.run/##LcixCoAgEAbgl/kHDR2CXLTwQaLh7ojcFIte/…
\$\endgroup\$
sort()! tio.run/##Vc9Ba4MwFAfw8/Ip/…
\$\endgroup\$
1. The subtraction is better for the upper leaves.
\$\endgroup\$
...{{*}*}:m;m\.|m/-m\.|,1=\1\if
This was... a lot more difficult than I thought it would be. Can be optimized. So much so, that I don't really want to give this much of an explanation.
Here's the process:
Take your input array and make 3 more copies of it. Make a function m, which multiplies the elements in an array together. Do that to the first array, then eliminate dupes from a second (keeping one of each). Perform m on it, then divide it from the first number. You should have the duplicate number (if there's only one pair dupe). Remove it rom your array, then return the last number. If the "suspected dupe" is 1, then just multiply again and output. If, when you remove all of the "suspected dupe"s, you're left with an array of size 1, just output 1 instead.
This was incredibly and probably needlessly complicated, but I couldn't find any good GolfScript shortcuts besides the multiplication bit. PITA.
,1+($args|group|? C* -eq 1|% N*)-join'*'|iex
where |? C* -eq 1 means |? Count -eq 1 and |% N* means |% Name.
$p=1;$args|group|? C* -eq 1|%{$p*=$_.Name};$p
lambda l:prod(x for x in l if l.count(x)<2)
from math import*
You can try it online!
Thanks @FryAmTheEggman for saving me 1 byte.
<2 instead of ==1. I also recommend looking through the code review responses - some of them can make for good golfing! :)
\$\endgroup\$
Commented
Feb 10, 2020 at 18:44
#&@@ and {a_,1}->a use the same number of characters to take first but the rule has lower precedence than the infix operator.
\$\endgroup\$
{[*] .Bag.grep(0=>1)>>.key}
(Using a Pair as matcher compares only values and ignores the key.)
fn($a)=>array_product(array_keys(array_intersect(array_count_values($a),[1])));
This isn't going to win for brevity, but just thought I'd try it entirely using chained PHP array functions.
Now using @Guillermo Phillips's suggestion for PHP 7.4 arrow function syntax to save 13 bytes.
fn($a,$b,$c)=>$a-$c?$a-$b?$b-$c?$a*$b*$c:$a:$b==$c?:$c:$b==$c?:$b;
And another crazy ternary version inspired by @Guillermo Phillips's answer!
array_count_values()? Come on guys! I've avoided the PHP 7.4+ short syntax, though I can't think of a good reason why... perhaps it's time. It's a good suggestion because it actually will save a non-trivial number of bytes.
\$\endgroup\$
psJ{{1j}qfcqpd}M-jNBL[!!
ps # Parse to list
J # Duplicate
{
{1j} # Push 1 & swap
qfc # Find least common element
qpd # Product
}M- # Create array applying each function to make each element
# {{Original list}, 1, least common, product}
jNB # Remove duplicates from original list
L[ # Find length
!! # Select that element from the array
# (zero indexed, hence the push swap to fill zero)
psJU_qpd{f:{-]1==}fe[~}IEisq1if
Can probably be golfed further.
ps # Parse to array
JU_ # (Non-destructive) is each element unique?
qpd # boxed product
{
f: # Frequency (returns {{count val} ...})
{
-]1== # Count == 1
}
fe # Find element where
[~ # Take the tail
}
IE # If unique then product, else find single
is # Is an error (i.e. single not found)
q1 # boxed 1
if # If error, push 1
sort|uniq -u|dc -e1?*?*?*p
The 3 input integers are each given on their own line.
In the case of non-distinct inputs, dc warnings are printed to stderr. These may be ignored.
uniq -u does most of the heavy lifting here. With the -u option, only non-duplicated lines are returned. uniq requires its input to be sorted.
The dc expression pushes 1 to the stack, then reads up to 3 integers, multiplying each in turn, then printing the output. If uniq pipes less than 3 integers to dc, then the surplus ? will not add to the stack and the following * will spit out a warning because * needs to pop 2 operands from the stack. But these are just warnings, dc continues execution until it prints the final product.
int f(int a,int b,int c)=>a==b?a==c?1:c:a==c?b:b==c?a:a*b*c;
Prompt A,B,C
ABC
If A=B
C
If A=C
B
If B=C
A
If A=B and A=C
1
Ans
A=sqrt(BC) is what you want...Suppose A=12, B=9, and C=16. Then A=sqrt(BC), but A!=B and A!=C.
\$\endgroup\$
≡ᵍ~gˢ×
ᵍ Group elements by
≡ value.
ˢ For each group,
~g if it is a singleton list, extract its only element,
ˢ else discard it.
× Take the product.
~g do for non-singleton lists?
\$\endgroup\$
Commented
Jan 31, 2021 at 17:46
xᵐ and xˢ (where x is any predicate) is that, if x fails on any element, xᵐ fails in its entirety, but xˢ discards any and all elements which fail instead. Failing is also what ~g does given a non-singleton list (g wraps its input into a singleton list, ~ inverts it). The utility of failure is backtracking to the most recent choice-point, and ˢ has one internally for that.
\$\endgroup\$
Commented
Jan 31, 2021 at 23:28
sets.extras math.unicode, 20 bytes[ non-repeating Π ]
Factor has a word non-repeating that gives you every element of a sequence that doesn't repeat. Turns out the answer to this question is just taking the product of this.
foo CMP $255,$0,$1
CMP $3,$1,$2
BZ $255,0F // if(a == b) goto ab
BZ $3,1F // if(b == c) goto bc
CMP $255,$0,$2
BZ $255,2F // if(a == c) goto ac
MUL $0,$0,$1 // a *= b
MUL $0,$0,$2 // a *= c
1H POP 1,0 // bc: return a
0H CSZ $2,$3,1 // ab: if(b == c) c = 1
POP 3,0 // return c
2H POP 2,0 // ac: return b
param($n)$a,$b,$c=$n|group;(($n-join'*'|iex),(($a,$b|?{$_.count-eq1}).name,1)[$a.count-eq3])[!$c]
Not terribly impressive, but given that PowerShell doesn't have a ternary operator like JavaScript, nor the same for structure as Python, I don't think this is too bad.
We take input $n as an array, then feed that into Group-Object, which stores the (potentially) three values into $a, $b, $c. Then we use array-indexing as a pseudo-ternary. We work "backwards" on the function definition given in the challenge, starting from the bottom. If we have a $c, then we have three unique values, so we -join $n with * and iex it (similar to eval). Otherwise, we have at least a duplicate, so we re-index whether $a's .count is -equal to 3. If it is, then all three values are the same, and we output 1. Otherwise, we pull out the lonely value (i.e., its .count is -equal to 1) and output its .name. In any case, the result is left on the pipeline and output is implicit.
