[Question]
  [
You will be given 3 integers as input. The inputs may or may not be
 different from each other. 
You have to output 1 if all three inputs
 are different from each other, 
and 0 if any input is repeated more
 than once.
This is [code-golf](/questions/tagged/code-golf "show questions tagged 'code-golf'"), so make your code as short as possible!
  
[Answer]
# [Python 3](https://docs.python.org/3/), ~~23~~ ~~21~~ 20 bytes
```
lambda*a:len({*a})>2
```
[Try it online!](https://tio.run/##K6gsycjPM/6fZhvzPycxNyklUSvRKic1T6NaK7FW087of0FRZl6JRpqGoY6RjrGmJhcy3wiJb6xjDJL/DwA "Python 3 – Try It Online")
[Answer]
# [Perl 6](https://github.com/nxadm/rakudo-pkg), 7 bytes
```
*.Set>2
```
[Try it online!](https://tio.run/##K0gtyjH7n1upoJamYPtfSy84tcTO6L81V3FipYKSSryCrZ1CtUKahkq8pkKtkkJafhGXhomOgqWOgqGmDpeGqY6CkY6CKYhpCBTSUTADMS10FIBqTEBMYx0FENK0/g8A "Perl 6 – Try It Online")
[Answer]
# [R](https://www.r-project.org/), 13 bytes
A different solution to @Kirill by using [`mad()`](https://stat.ethz.ch/R-manual/R-devel/library/stats/html/mad.html) for an unintended purpose!
```
mad(scan())>0
```
[Try it online!](https://tio.run/##PYxBCsIwEEX3PcWAmwyMwVSKCta7hHQiATuBJnUjPXtsKpW/eXwebyoH4HF@2RzkCclZUQhBUhgYLPhZXA5RCHycIHPaLBflzRJYHDe@3x2ltcZPLdyP/w/ddpfRDuoXx8epLI1Xhlo64wrtDoY66ipcaF2FGxm6YvkC "R – Try It Online")
[Answer]
# [R](https://www.r-project.org/), ~~24~~ ~~22~~ 20 bytes
```
all(table(scan())<2)
```
[Try it online!](https://tio.run/##PY3BCsIwEETv/YoFL1lYA4kUFerHxLiRQNxAm/YifntsKpW5PIbHzFgPwK85uRLlCZN3ohCiTPHB4CDM4kvMQhDyCIWnzfJZFpbI4rkLt91RWmt8t4Xh@O/Qb3V1Kani7onV7wIHi/XTBWXI0glXsDsY6qlvcKY1Da5k6IL1Cw "R – Try It Online")
Returns a boolean, but as folks have already discussed on the [Python answer](https://codegolf.stackexchange.com/a/171616/78274), this should be OK.
Thanks to digEmAll for saving 2 bytes.
[Answer]
# JavaScript, 22 bytes
If we can output boolean values then the last 2 bytes can be removed.
```
a=>new Set(a).size>2&1
```
[Try it online](https://tio.run/##y0osSyxOLsosKNHNy09J/Z9m@z/R1i4vtVwhOLVEI1FTrzizKtXOSM3wf3J@XnF@TqpeTn66RjRXtKGOkY5xrA6IAWRCGEY6hjARECNWLzexQCNNU/M/AA)
For the same byte count, this works on arrays of any size but assumes the input will never contain a `0` and output is a boolean.
```
a=>!a[new Set(a).size]
```
[Try it online](https://tio.run/##y0osSyxOLsosKNHNy09J/Z9m@z/R1k4xMTovtVwhOLVEI1FTrzizKjX2f3J@XnF@TqpeTn66RppGtKGOkY5xrKbmfwA)
[Answer]
# [Ruby](https://www.ruby-lang.org/), 16 bytes
```
->a{1-(a<=>a|a)}
```
[Try it online!](https://tio.run/##KypNqvyfZvtf1y6x2lBXI9HG1i6xJlGz9n9BaUmxQlp0tKGOkY5xbCwXgm@MxgfC2Nj/AA "Ruby – Try It Online")
[Answer]
# [Cubix](https://github.com/ETHproductions/cubix), ~~55~~ 25 bytes
*-29 thanks to Jo King*
```
O@O1u|@O@II-!/;I-!/;u^?-p
```
[Try it online!](https://tio.run/##Sy5Nyqz4/9/fwd@wtMbB38HTU1dR3xpMlMbZ6xb8/2@oYKRgBAA)
It should be possible to golf off quite a few bytes.
[Answer]
# [05AB1E](https://github.com/Adriandmen/05AB1E/wiki/Commands), 2 [bytes](https://github.com/Adriandmen/05AB1E/wiki/Codepage)
```
ÙQ
```
[Try it online](https://tio.run/##yy9OTMpM/f//8MzA//@jjXWMdUxiAQ) or [verify some more cases](https://tio.run/##yy9OTMpM/W/q5nl4gr2SwqO2SQpK9v8Pzwz8r/M/2ljHWMcklivaUMdIxxhI65rqmOoYGoBEjIx1oBjIM9DRtdAxiAUA).
**Explanation:**
```
Ù     # Uniquify the (implicit) input
 Q    # Check if it's still equal to the (implicit) input
```
[Answer]
# Mathematica, 13 bytes
```
Boole[E!=##]&
```
Pure function. Takes three integers as input and returns `0` or `1` as output. I know that this is rather similar to [David G. Stork's answer](https://codegolf.stackexchange.com/a/171658), but it exploits `SlotSequence` to shave off a byte (as compared to `Boole@*Unequal`).
[Answer]
# [J](http://jsoftware.com/), 4 bytes
```
-:~.
```
[Try it online!](https://tio.run/##y/qfVmyrp2CgYKVg8F/Xqk7vvyaXkp6CepqtnrqCjkKtlUJaMRdXanJGvkKagqGCkYIxjGME4vwHAA "J – Try It Online")
## Explanation:
Is the argument equal `-:` to itself after removing the duplicates `~.` 
[Answer]
# [K (oK)](https://github.com/JohnEarnest/ok), 4 bytes
```
3=#?
```
[Try it online!](https://tio.run/##y9bNz/7/39hW2d5QwUjB@P9/AA "K (oK) – Try It Online")
Does the count of the distinct elements equal 3?
[Answer]
# Japt `-N`, 3 bytes
```
eUâ
```
[Try it](https://ethproductions.github.io/japt/?v=1.4.6&code=ZVXi&input=WzEsMiwzXQotTg==)
---
## Explanation
`Uâ` deduplicates the input and `e` tests if it's equal to the original.
[Answer]
# [C (gcc)](https://gcc.gnu.org/), ~~25~~ 26 bytes
```
f(a,b,c){a=a-b&&a-c&&b-c;}
```
[Try it online!](https://tio.run/##S9ZNT07@/z9NI1EnSSdZszrRNlE3SU0tUTdZTS1JN9m69n9mXolCbmJmnoYmVzUXZ0ERkJ@moaSaEpOnpKOQpmGoo2Cko2CsqWmNXdIQnyRQpyF2SROEsbX/AQ "C (gcc) – Try It Online")
[Answer]
# [brainfuck](https://esolangs.org/wiki/Brainfuck), 91 bytes
```
,>,>,[-<-<->>]>>+++++++[>+++++++<-]+<<<<[>]>>[<<<[-<->]<[>]>>->[>.<<<->>-]<+]<+[>>>[>]<-.>]
```
[Try it online!](https://tio.run/##NUsxCoBADHtQ7YG6lnykdFBBOAQHwffXlMMkQ5qk@7P1@3yPK3MC6WokEIAM@G9MQ4zwKr1MLWPcCkdjxlcNE8rBFWttiMx5WT8 "brainfuck – Try It Online")
### How it works
```
,>,>,                   'read input as A, B, and C
[-<-<->>]>>+            'compute A-C, B-C
++++++[>+++++++<-]+     'prepare output
<<<<[>]>>               'if A-C != 0 && B-C != 0
[
    <<<[-<->]           'compute A-B
    <[>]>>->            'if A-B != 0
    [>.<<<->>-]         'print 1
    <+
]
<+
[                       'else (this else is for both of the if statements, even though they are nested... wierd, I know)
    >>>[>]              
    <-.>                'print 0
]
```
[Answer]
# Powershell, ~~27~~ 25 bytes
*-2 bytes thanks @AdmBorkBork*
```
+!(($args|group).Count-3)
```
Test script:
```
$f = {
+!(($args|group).Count-3)
}
&$f 1 2 3
&$f 3 2 1
&$f 2 1 3
&$f 2 2 3
&$f 2 1 1
&$f 2 1 2
```
Explanation:
```
    $args|group           # Group arguments
   (           ).Count    # Count of groups 
  (                   -3) # is 0 if inputed integers are unique
 !                        # operator not converts int to boolean: true if integers are unique
+                         # converts boolean to int: 1 if integers are unique, otherwise 0
```
[Answer]
# [Jelly](https://github.com/DennisMitchell/jelly), 2 bytes
```
QƑ
```
[Try it online!](https://tio.run/##y0rNyan8/z/w2MT/h9sfNa35/z@aK9pQR0EXiA1idRSUFRJzchRK8zILS1O5og10FAwVdIxidbiiLXUUTIDKLIFssAaoeghQVihKLUhNLElNUcjMK0lNTy0q5orWNTQAmQshQEYAWSAUyxULAA "Jelly – Try It Online")
[Answer]
# Common Lisp, ~~25~~ 2 bytes
```
/=
```
[Try it online!](https://tio.run/##JcsxCoAwDAXQq/zN/EnSzh5GK0KhNKF6/1h0etMrrd4e0swclw3IjgOFqB2LSIIiEZ95qlMlcRrER@0PJNYt/kPGCw)
-23 bytes thanks to @ceilingcat!
[Answer]
# [APL (Dyalog Unicode)](https://www.dyalog.com/), 3 [bytes](https://codegolf.meta.stackexchange.com/a/9429/43319 "When can APL characters be counted as 1 byte each?")[SBCS](https://github.com/abrudz/SBCS ".dyalog files using a single byte character set")
Anonymous tacit prefix function. Takes list as argument.
```
∪≡⊢
```
[Try it online!](https://tio.run/##SyzI0U2pTMzJT////1HHqkedCx91Lfqf9qhtwqPevkd9Uz39H3U1H1pv/KhtIpAXHOQMJEM8PIP/pykYKhgpGHNBaEMA "APL (Dyalog Unicode) – Try It Online")
`∪` does the set of unique elements from the argument
`≡` match
`⊢` the unmodified argument?
[Answer]
# [Clean](https://github.com/Ourous/curated-clean-linux), 32 bytes
```
import Data.List
$l|hasDup l=0=1
```
[Try it online!](https://tio.run/##S85JTcz7n5ufUpqTqpCbmJn3PzO3IL@oRMElsSRRzyezuIRLJacmI7HYpbRAIcfWwNbwf3BJIlDeVkFFIdpQx1DHKPb/v@S0nMT04v@6nj7/XSrzEnMzkyGcgJzEkrT8olwA "Clean – Try It Online")
[Answer]
# [Attache](https://github.com/ConorOBrien-Foxx/Attache), 10 bytes
```
`==#Unique
```
[Try it online!](https://tio.run/##SywpSUzOSP2fpmBl@z/B1lY5NC@zsDT1v19qakpxtEpBQXJ6LFdAUWZeSUhqcYlzYnFqcXSajkI0lwIQRBvqKBjpKBjH6kC4BmCuJYxrqaNgoaNgAuNCFBsiyVoi6TU0AOqGEbFcsbH/AQ "Attache – Try It Online")
This is a fork of the operator ``==` and `Unique`, equivalent to:
```
{ _ == Unique[_] }
```
## Alternatives
`{#_=#Unique[_]}` (15 bytes)
`Any##Same=>Pairs@Sort` (21 bytes)
`Any@{`=&>_[[0'1,1'2,2'0]]}` (26 bytes)
`&${not(x=y or y=z or x=z)}` (26 bytes)
`&${x/=y and y/=z and x/=z}` (26 bytes)
`{Any!Same=>Chop&2!_[0'1'1'2'2'0]}` (33 bytes)
[Answer]
# Java 9, ~~43~~ 27 bytes
*thanks to @Olivier Grégoire*
```
(a,b,c)->a!=b&b!=c&a!=c?1:0 
```
Previous attempt:
```
(a)->a[0]==a[1]||a[0]==a[2]||a[1]==a[2]?0:1
```
[Answer]
# [Red](http://www.red-lang.org), 21 bytes
```
func[b][b = unique b]
```
[Try it online!](https://tio.run/##K0pN@R@UmhIdy5Vm9T@tNC85Oik2OknBVqE0L7OwNFUhKfZ/QVFmXolCmkK0oYKRgnEsFwrfKPY/AA "Red – Try It Online")
[Answer]
# T-SQL, 39 bytes
```
SELECT IIF(a=b OR b=c OR c=a,0,1)FROM s
```
Input is taken as separate columns **a, b, c** from a pre-existing table **s**, [per our IO standards](https://codegolf.meta.stackexchange.com/questions/2447/default-for-code-golf-input-output-methods/5341#5341).
Tried a variation using `COUNT DISTINCT` from input taken as separate rows, but that was a couple bytes longer.
[Answer]
# Pyth, 3 bytes
```
s{I
```
Takes input as a list.  
[Try it here](http://pyth.herokuapp.com/?code=s%7BI&input=%5B3%2C%201%2C%204%5D&debug=0)
### Explanation
```
s{I
 {IQ     Check if the (implicit) input is invariant under deduplication.
s        Cast to int.
```
If we're allowed to treat True and False as 1 and 0 (which they are under the hood in Pyth), we can drop the `s` to get down to 2 bytes.
[Answer]
# SmileBASIC, ~~25~~ 24 bytes
```
READ A,B,C?A-B&&B-C&&C-A
```
[Answer]
# [Ruby](https://www.ruby-lang.org/), 11 bytes
```
->a{a==a|a}
```
[Try it online!](https://tio.run/##KypNqvyfZvtf1y6xOtHWNrEmsfZ/QWlJsUJadLShjpGOcWwsF4JvjMYHwtjY/wA "Ruby – Try It Online")
Assuming we can return a boolean. Which everyone is doing nowadays.
[Answer]
# [Brachylog](https://github.com/JCumin/Brachylog), 6 bytes
```
d?∧1|0
```
[Try it online!](https://tio.run/##SypKTM6ozMlPN/r/P8X@UcdywxqD//@jjXVMdUxi/0cBAA "Brachylog – Try It Online")
# short explanation
`d?` **d**eduplcates input an test if still equal to input(**?**)
`∧1` if true return 1
`|0` else return 0
[Answer]
# [><>](https://esolangs.org/wiki/Fish), ~~19~~ 17 bytes
-2 bytes by Jo King.
```
:{:{:{=}=}=++0=n;
```
[Try it online!](https://tio.run/##S8sszvj/36q2FoxsQVBb21Ajz/r///@6ZQqGcMIYAA "><> – Try It Online")
[Answer]
# [q](https://kx.com/download) 14 bytes
```
{x~distinct x}
```
Technically this solution will return '1b' or '0b', which is the way a boolean value is distinguished from a numeric type, though it retains all arithmetic functionality, and so is in essence a 1 or 0:
```
q)1b +35
36
```
To return 1 or 0 non-boolean you have the below, which takes the byte count to 21
```
{$[x~distinct x;1;0]}
```
[Answer]
# [JavaScript (Node.js)](https://nodejs.org), 67 bytes
```
f=a=>a.map((m,i)=>a.map((n,j)=>m==n&i!=j).every(z=>!z)).every(y=>y)
```
[Try it online!](https://tio.run/##y0osSyxOLsosKNHNy09J/f8/zTbR1i5RLzexQEMjVydTE87J08kCcnJtbfPUMhVtszT1UstSiyo1qmztFKs0YbxKW7tKzf/J@XnF@Tmpejn56RppGtGGOkAYq6nJhSFuhFPcGCT@HwA "JavaScript (Node.js) – Try It Online")
]