[Question]
  [
You met a 4-th dimensional being who challenged you to a game of dice. The rules are simple: each player rolls 3 6-sided dice and takes the sum of each combination of 2 dice. The player with the highest sum wins. If the first-highest sum is a tie, consider the second-highest sum, and so on.
Your opponent's dice look normal, but you think they might have more than 6 sides! **Your goal is to find out if the alien rolled a number higher than 6.**
Your input is a set of 3 integers, separated by at least one character (space or otherwise). Input must not be hard coded.
```
// All valid inputs
6 7 9
6, 7, 9
(6, 7, 9)
```
Your output is a string representing if the alien cheated. Any output is allowed, as long as two distinct values exist for cheating/valid. Appended whitespace is permitted.
```
"üòÄ" // (U+1F600) Valid set of dice
"üò†" // (U+1F620) Invalid set of dice
```
Examples:
```
<-: 8 11 9
->: üòÄ       // Dice can be found to be 3, 5, and 6, which are all on 6-side die
```
```
<-: 9 11 6
->: üò†       // Dice can be found to be 2, 7, and 4, which means the alien cheated!
```
Assumptions:
* Input will be 3 integers, 2-12
* Input numbers can be in any order
* Die values will be positive integers
* Alien only cheated if they rolled greater than 6
Write a program or function that takes inputs, returns or prints outputs.
Fewest bytes wins!
  
[Answer]
# [Husk](https://github.com/barbuz/Husk), 8 bytes
```
¬¨>6-‚ñº¬π¬ΩŒ£
```
[Try it online!](https://tio.run/##yygtzv6f@6ip8f@hNXZmuo@m7Tm089Dec4v///8fHW2hY2ioYxmrE20OYcQCAA "Husk ‚Äì Try It Online")
Outputs `1` for normal dice, `0` if the alien cheated.
Checks whether half (`¬Ω`) of the sum (`Œ£`) minus (`-`) the smallest (`‚ñº`) element is not (`¬¨`) greater than 6 (`>6`).
[Answer]
# [R](https://www.r-project.org/), 28 bytes
```
function(x)sum(x/2)-min(x)>6
```
[Try it online!](https://tio.run/##K/qfmJOZmhefnJGaWJKaYvs/rTQvuSQzP0@jQrO4NFejQt9IUzc3E8S1M0NVq5GsYaFjaKhjqampoKxgplucmZKaopCSmZzKha7OHKEOLKWQWawAls3MS1f8DwA "R ‚Äì Try It Online")
Same approach as [my Husk answer](https://codegolf.stackexchange.com/a/243606/95126).
[Answer]
# [Haskell](https://www.haskell.org/), 20 bytes
```
f l=any(<sum l/2-6)l
```
[Try it online!](https://tio.run/##y0gszk7Nyfn/P00hxzYxr1LDprg0VyFH30jXTDPnf25iZp6CrUJKPpdCQVFmXomCikKaQrSFjqGhjmUsipg5FjFLkJhZ7H8A "Haskell ‚Äì Try It Online")
Inspired by [*@DominicVanEssen* R answer](https://codegolf.stackexchange.com/a/243607/52210).  
Tells if it's a cheater (the alien.. not Dominic).
[Answer]
# [JavaScript (Node.js)](https://nodejs.org), 36 bytes
```
f=(a,b,c)=>a>b|a>c?f(b,c,a):b+c-a<13
```
[Try it online!](https://tio.run/##VchBDkAwEADAu5d0YytpJIJQb9kuFdJYUXHy9@LoOLPSRZGPZT/1JuOUku8VoUOG3pJ1N1kevHqNBK3LWVNnysSyRQlTEWRWXtVoDDYA2b@bryuA9AA "JavaScript (Node.js) ‚Äì Try It Online")
Like the hypot one
[Answer]
# JavaScript (ES6), 35 bytes
Expects `([a,b,c])`. Returns *true* for cheating or *false* for valid.
```
A=>A.some(x=>eval(A.join`+`)/2>x+6)
```
[Try it online!](https://tio.run/##y0osSyxOLsosKNHNy09J/Z9m@9/R1s5Rrzg/N1WjwtYutSwxR8NRLys/My9BO0FT38iuQttM839yfl5xfk6qXk5@ukaaRrSZjoKCuY6CZaymJhealIWOgqEhdilLiJQZUOo/AA "JavaScript (Node.js) ‚Äì Try It Online")
[Answer]
# [C (gcc)](https://gcc.gnu.org/) (-O0), 73 bytes
```
#define g(a,b) if(a>b)a^=b^=a^=b;
f(a,b,c){g(a,b)g(b,c)g(a,b)a=b+c-a<13;}
```
[Try it online!](https://tio.run/##JYpNCsIwEIX3OcVQKcxgugiCWGI8SmEyaUIWBhF3pWePHfoWj@/9yFREer@kNde2QkG2kaBm5FckXkJcgro3WRcrtJ2XghpO5hCvMvHT3fzea/vBm2tDMpuBQ5/vUWUcxgRjGixkfFjn7EyKs@KdyJu9/wE "C (gcc) ‚Äì Try It Online")
Not the prettiest solution
# [C (gcc)](https://gcc.gnu.org/) (-O0), 38 bytes, shamelessly copy [this](https://codegolf.stackexchange.com/a/243605/108879) beautiful answer.
```
f(a,b,c){a=a>b|a>c?f(b,c,a):b+c-a<13;}
```
[Try it online!](https://tio.run/##Fcg9CoAwDEDhvacoBSHBOBRB1PpzljRScbCIuKlnr/VNH0@qVSSlAEyeBG8eefIPTzIHyIMYe19KxYOt3Zu2eOmdtwiobqVzx5lXAFMsulgM6QAtWUsd/ux@NohOvekD "C (gcc) ‚Äì Try It Online")
*-2 bytes thanks to AZTECCO*
[Answer]
# [05AB1E](https://github.com/Adriandmen/05AB1E/wiki/Commands), ~~7~~ 6 [bytes](https://github.com/Adriandmen/05AB1E/wiki/Codepage)
```
O;Œ±√†6‚Ä∫
```
Inspired by [*@DominicVanEssen*'s R answer](https://codegolf.stackexchange.com/a/243607/52210).  
Takes a list `[a,b,c]` as input, and outputs `1`/`0` for cheating/valid respectively.
[Try it online](https://tio.run/##yy9OTMpM/f/f3/rcxsMLzB417Pr/P9pCx9BQxzIWAA) or [verify all test cases](https://tio.run/##yy9OTMpM/V9Waa@k8KhtkoKSfaXLf3/rcxsPLzB71LDrv87/6GgLHUNDHctYnWhLEMMsNhYA).
**Explanation:**
```
O       # Sum the three values in the (implicit) input-list
        #  e.g. [8,11,9] ‚Üí 28
        #  e.g. [9,11,6] ‚Üí 26
 ;      # Halve it
        #  ‚Üí 14
        #  ‚Üí 13
  Œ±     # Take the absolute difference of this sum with each value in the
        # (implicit) input-list
        #  ‚Üí [6,3,5]
        #  ‚Üí [4,2,7]
   √†    # Pop and push its maximum
        #  ‚Üí 6
        #  ‚Üí 7
    6‚Ä∫  # Check if this is larger than 6
        #  ‚Üí 0
        #  ‚Üí 1
        # (after which this is output implicitly as result)
```
[Answer]
# [MATL](https://github.com/lmendo/MATL), 10 bytes
```
2/sGX<-IE>
```
[Try it out](https://matl.suever.net/?code=2%2FsGX%3C-IE%3E&inputs=%5B9%2C+11%2C+6%5D&version=22.4.0) / [Test three cases](https://tio.run/##y00syfmfkKlQEuWnYK9QoacQqxDh8d9Iv9gjwkbX09Xuf0js/2gLHQVDQx0Fy1iuaEsI0wzINIeLGugbAAA "MATL ‚Äì Try It Online")
Port of @Dominic van Essen's answers. 1 = You cheating alien! 0 = Never had a moment of doubt.
`4-sGX<E-F>` [Try it online!](https://tio.run/##y00syfmfkKlQEuWnYK9QoacQqxDh8d9Et9gjwsZV183uf0js/2gLHQVDQx0Fy1iuaEsI0wzINIeLGugbAAA "MATL ‚Äì Try It Online") is another 10 byter.
## MATL, 11 bytes
```
.5IXy-iY*7<
```
[Try it out](https://matl.suever.net/?code=.5IXy-iY%2a7%3C&inputs=%5B9%3B+11%3B+6%5D&version=22.4.0) / [Test three cases](https://tio.run/##y00syfmfkKlQEuWnYK9QoacQqxDhoVDxX8/UM6JS1yNSy8wu8X9I7P9oC2sFQ0NrBctYrmhLCNMMyDSHixroGwAA)
Outputs truthy (all 1s) for no cheating, falsy (some 0s) for cheating.
For given input [a, b, c], the system of linear equations is
:
\$ d\_2 + d\_3 = a \$
,
\$ d\_1 + d\_3 = b \$
,
\$ d\_1 + d\_2 = c \$
Or in matrix form:
\$ \begin{bmatrix}
0 & 1 & 1 \\
1 & 0 & 1 \\
1 & 1 & 0 
\end{bmatrix}\begin{bmatrix}
d\_1 \\
d\_2 \\
d\_3 
\end{bmatrix} = \begin{bmatrix}
a \\
b \\
c 
\end{bmatrix} \$
The solution - the set of dice values - is the inverse of the matrix on the left, multiplied by the input. This inverse is equal to \$ 0.5 - I\_3 \$ (where \$I\_3\$ is the 3x3 identity matrix).
`.5IXy-` computes this inverse, `iY*` multiplies that by the input, `7<` checks if all of the resulting dice values are less than 7 (and hence valid).
[Answer]
# [Retina 0.8.2](https://github.com/m-ender/retina/wiki/The-Language/a950ad7d925ec9316e3e2fb2cf5d49fd15d23e3d), 34 bytes
```
\d+
$*
O`1+
^
12$*
(1+)(1+),\1,\2$
```
[Try it online!](https://tio.run/##K0otycxL/K@q4Z7wPyZFm0tFi8s/wVCbK47L0AjI1jDU1gRhnRhDnRgjlf//zXTMdSy5LHQMDYGUJYgyAwA "Retina 0.8.2 ‚Äì Try It Online") Link includes test cases. Outputs `1` for normal dice, `0` if the alien cheated. Explanation:
```
\d+
$*
```
Convert to unary.
```
O`1+
```
Sort into order.
```
^
12$*
```
Add 12 to the smallest value.
```
(1+)(1+),\1,\2$
```
The sum should then equal or exceed the sum of the other two values.
[Answer]
# [Vyxal](https://github.com/Vyxal/Vyxal), 7 bytes
```
‚àë¬Ω?g-6‚â§
```
[Try it Online!](https://vyxal.pythonanywhere.com/#WyIiLCIiLCLiiJHCvT9nLTbiiaQiLCIiLCJbOSwgMTEsIDZdIl0=)
Port of [@Dominic van Essen's Husk answer](https://codegolf.stackexchange.com/a/243606/107299). `1` if the dice are normal, `0` if the alien used tesseracts for its dice.
```
‚àë¬Ω?g-6‚â§ # Takes list as input
‚àë       # Sum of the list
 ¬Ω      # Halved..
    -   # Minus...
  ?g    # Smallest element of the input
     6‚â§ # Is less than or equal to 6?
```
[Answer]
# [J](http://jsoftware.com/), ~~20~~ 11 bytes
```
12<+/-2*<./
```
-9 bytes thanks @Bubbler
[Try it online!](https://tio.run/##y/qvpKeepmBrpaCuoKNgoGAFxLp6Cs5BPm7/DY1stPV1jbRs9PT/a3JxpSZn5CukKVgoGBoqWMJ4liCe2X8A "J ‚Äì Try It Online")
[Answer]
# [R](https://www.r-project.org/), 28 bytes
```
function(x)any(sum(x)/2>6+x)
```
[Try it online!](https://tio.run/##K/qfZvs/rTQvuSQzP0@jQjMxr1KjuDQXyNI3sjPTrtD8n6aRrGGhY2ioY6mpqaCskJaYWcQFEjNHiCVnpCaWZOal/wcA "R ‚Äì Try It Online")
Alternate and equally-golfy solution porting [this python answer](https://codegolf.stackexchange.com/a/243649/67312) -- the naive port would be something like `sum(x)-2*x>12` which is a byte longer.
[Answer]
# [Julia 1.0](http://julialang.org/), 23 bytes
```
x->sum(x/2)-min(x...)>6
```
[Try it online!](https://tio.run/##yyrNyUw0rPifpmCr8L9C1664NFejQt9IUzc3M0@jQk9PT9PO7L9DcUZ@uUKaRrSFjoKhoY6CZawmF1zMEiJmhixmDlf3HwA "Julia 1.0 ‚Äì Try It Online")
Port of @Dominic van Essen's answers. Output is the answer to the question "Did the alien cheat?"
### Julia 1.2 or above, with `using LinearAlgebra`, 23 bytes
```
x->any((.5 .-I(3))x.>6)
```
(doesn't work on TIO since it only has Julia 1.0)
**18 bytes** without the `any` call, if output can be all 0s for no cheating, at least one 1 for cheating alien.
Find the dice values by solving the system of linear equations via matrices, and check if any are greater than 6. (More explanation in my [MATL answer](https://codegolf.stackexchange.com/a/243688/8774)).
[Answer]
# [Python 3](https://docs.python.org/3/), ~~27~~ 26 bytes
## Code
```
lambda v:sum(v)/2-min(v)>6
```
Outputs `True` for cheated and `False` for valid.
[Try it online!](https://tio.run/##K6gsycjPM/6fZqvxPycxNyklUaHMqrg0V6NMU99INzczD8iwM/uvyVVQlJlXopGmoWGmo2BoqKNgqampo5Cal2KrpKT5HwA)
## Explanation
Let \$a\$, \$b\$ and \$c\$ be the three dice rolls, where \$a\$ is the highest roll. Therefore, if \$a > 6\$, the alien cheated, and otherwise they did not.
The sum of the numbers is \$2a + 2b + 2c\$. The minimum of the numbers is \$b + c\$. Therefore, `sum(v)/2-min(v)` is \$(2a + 2b + 2c)/2 - (b + c)\$ which is \$a\$. If this is greater than \$6\$, the alien cheated.
[Answer]
# [Python 3.8 (pre-release)](https://docs.python.org/3.8/),~~38~~ ~~28~~ 27 bytes
**Latest Answer**
```
lambda *a:sum(a)/2-min(a)>6
```
[Try it online!](https://tio.run/##K6gsycjPM7YoKPqfZhvzPycxNyklUUEr0aq4NFcjUVPfSDc3Mw/IsDP7X1CUmVeikaZhqWNoqGOmqckFE7AACVhqav4HAA "Python 3.8 (pre-release) ‚Äì Try It Online")
**Old Answer**
```
lambda x,y,z:max(x-y+z,x+y-z,y+z-x)>12
```
[Try it online!](https://tio.run/##K6gsycjPM7YoKPqfZhvzPycxNyklUaFCp1Knyio3sUKjQrdSu0qnQrtSt0oHyNKt0LQzNPpfUJSZV6KRpmGpY2ioY6apyQUTsAAJWGpq/gcA "Python 3.8 (pre-release) ‚Äì Try It Online")
**Output** : Gives `True` when cheated and `False` when not.
Thank you [Aetol](https://codegolf.stackexchange.com/users/111337/aetol) for the suggestion of using `a+b+c-2*min(a,b,c)>12` instead of `max(x-y+z,x+y-z,y+z-x)>12`
[This](https://codegolf.stackexchange.com/a/243660/106829) R answer gave the nice `sum(a)/2-min(a)>6` Idea
[Answer]
# [Pyth](https://github.com/isaacg1/pyth), ~~22~~ ~~18~~ 11 bytes
```
L>-/sb2hSb6
```
Port of [@Lecdi's Python 3 solution](https://codegolf.stackexchange.com/a/243699/108170).
```
L>-/sb2hSb6
L             # lambda b:
    sb        # sum(b)
   /  2       # sum(b) / 2
       hSb    # min(b)
  -           # sum(b)/2 - min(b)
 >        6   # sum(b)/2 - min(b) > 6
 
```
[Try it online!](https://tio.run/##K6gsyfj/38dOV784ySgjOMnsf2W0pYKhoYKZJldltAWIZan5/19@QUlmfl7xfwA "Pyth ‚Äì Try It Online")
[Answer]
# [Charcoal](https://github.com/somebody1234/Charcoal), 8 bytes
```
‚Ä∫Œ£Œ∏‚äó‚Å∫‚Å∂‚åäŒ∏
```
[Try it online!](https://tio.run/##S85ILErOT8z5/z@gKDOvRMO9KDWxJLVII7g0V6NQU0fBJb80KSc1RSMgp7RYw0xHwTczLzMXLAcC1v//R0db6hga6pjFxv7XLcsBAA "Charcoal ‚Äì Try It Online") Link is to verbose version of code. Takes input as an array and outputs `-` if the alien cheated, nothing if it didn't. Explanation: Inspired by @DominicvanEssen's answers.
```
  Œ∏         Input array
 Œ£          Summed
‚Ä∫           Is greater than
       Œ∏    Input array
      ‚åä     Minimum
    ‚Å∫       Plus
     ‚Å∂      Literal integer `6`
   ‚äó        Doubled
            Implicitly print
```
[Answer]
# [Ruby](https://www.ruby-lang.org/), 21 bytes
```
->*s{s.sum/2-s.min<7}
```
[Try it online!](https://tio.run/##KypNqvyfZvtf106ruLpYr7g0V99It1gvNzPPxrz2f4FCWrSFjqGhjmUsF4htCWKbxf4HAA "Ruby ‚Äì Try It Online")
[Answer]
# [Etch](https://github.com/GingerIndustries/Etch), 47 bytes
`s=:get;:split" ";:intify;;:out:sum s;/2-:min s;>6;`
A straightforward point of [this Husk answer](https://codegolf.stackexchange.com/a/243606/108218).
[Answer]
# [BQN](https://mlochbaum.github.io/BQN/index.html), 9 bytes
```
¬Ø12>-Àú¬¥‚àò‚à®
```
[Try it at BQN online REPL](https://mlochbaum.github.io/BQN/try.html#code=QWxpZW5faXNfY2hlYXRpbmcg4oaQIMKvMTI+LcucwrTiiJjiiKgKQWxpZW5faXNfY2hlYXRpbmfCqCDin6ggOOKAvzEx4oC/OSwgOeKAvzEx4oC/NiDin6k=)
Outputs `0` if the dice are 6-sided, `1` if the alien is cheating.
We calculate the highest die roll using a single `fold` (or `reduce` in some languages) of a "minus" operation across the 3 sums-of-2-rolls in increasing order.  
Consider initial die rolls of `s`, `m` and `l`, where `l` is the (possibly non-unique) largest, and `s` is the smallest. Then, the sums-of-2-rolls, in increasing order, are: `s+m`, `s+l`, `m+l`.  
Folding "minus" across this yields `(s+m minus s+l) minus m+l` = `m-l - (m+l)` = `-2l`.
So we just need to check whether the result is less than minus 12: if it is, then `l` was greater than 6 and the alien was cheating.
```
         ‚à®   # sort the input
        ‚àò    # and use that to
     -Àú¬¥     # fold 'subtracted from' from the right
¬Ø12>         # and check whether it's less than minus 12
```
This comes out 1 byte shorter than the "subtract the lowest value from half the sum of the input" approach (`12<+¬¥-2√ó‚åä¬¥` = 10 bytes in [BQN](https://mlochbaum.github.io/BQN/index.html): [try it](https://mlochbaum.github.io/BQN/try.html#code=QWxpZW5faXNfY2hlYXRpbmcg4oaQIDEyPCvCtC0yw5fijIrCtApBbGllbl9pc19jaGVhdGluZ8KoIOKfqCA44oC/MTHigL85LCA54oC/MTHigL82IOKfqQ==))
[Answer]
# [Scala](https://www.scala-lang.org/), 35 bytes
[Try it online!](https://tio.run/##bYw9D4IwFAB3fsUb2wRRGPwgwYQ4ORMnwvCEB9aUqm01GMJvr8hgQuJ6dzlTokR3O1@ptJBKQepwIbRUQe8qqqFmXZzRIz8qW/CkC8yzXUbBatEFrVD7tfMAvlmLQjHUjYkh1RrfeWa1UE3BYzgpYSGBfiwBXiihEiWFI5lCtvUhDH3Y8ZmPfn4z8/fxaqViNZsu/B@NJjp4g@c@)
```
def f(x:Seq[Int])=x.sum/2.0-x.min>6
```
]