[Question]
  [
Given a list of non-negative integers, return whether or not that list is all the same number.
## Rules
* Input and output can be taken/given in any reasonable and convenient format
* Truthy/Falsey values can be represented as any value of your choice as long as it's reasonable and relatively consistent (e.g. `1` for falsey and `>= 2` for truthy is fine)
* There will always be at least 1 item in the input list
* The list items are guaranteed to be in the range `[0, 9]` (\$0 \le n \le 9\$)
* Standard loopholes apply
This is code golf, so the shortest program in each language wins. I've made a community wiki answer for trivial answers, so feel free to submit potentially longer programs.
## Test Cases
```
[1, 1, 1, 1, 1, 1, 1] -> True
[1, 2, 3, 4] -> False
[6, 9, 6, 9, 6] -> False
[6] -> True
[7, 7] -> True
[4, 2, 0] -> False
```
  
[Answer]
# Trivial Built-in Answers
This is the post for all of the languages where this is a built-in
## Vyxal, 1 byte
```
≈
```
[Try it Online!](http://lyxal.pythonanywhere.com?flags=&code=%E2%89%88&inputs=&header=&footer=)
# [Jelly](https://github.com/DennisMitchell/jelly), 1 byte
```
E
```
[Try it online!](https://tio.run/##y0rNyan8/9/1/9HJD3cuftQwR0HXTuFRw9yHOxY93DH/UeO2hzu6Hu6cFna4nevh7i2H2x81rYn8/z/aUEcBHcWCdIYUlaZygWSNdBSMdRRMwIJuiTnFQFEzHQVLHQUoiSKBpNVcR8EciWsCNskAoRoA "Jelly – Try It Online")
# [05AB1E (legacy)](https://github.com/Adriandmen/05AB1E/tree/fb4a2ce2bce6660e1a680a74dd61b72c945e6c3b), 1 byte
```
Ë
```
[Try it online!](https://tio.run/##MzBNTDJM/f//cPf//9GGOgpQFAsA "05AB1E (legacy) – Try It Online")
# [Wolfram Language (Mathematica)](https://www.wolfram.com/wolframscript/), 5 bytes
```
Equal
```
[Try it online!](https://tio.run/##y00syUjNTSzJTE78n2b737WwNDHnf0BRZl5JtLKuXZqDg3KsWl1wcmJeXTVXtaGOAjqq1QELG@koGOsomIB4ZjoKljoKUBIsACLMdRTMQbQJWK1BLVftfwA "Wolfram Language (Mathematica) – Try It Online")
`SameQ` also works.
# [Brachylog](https://github.com/JCumin/Brachylog), 1 byte
```
=
```
[Try it online!](https://tio.run/##SypKTM6ozMlPN/pfXa6koGunoFRuX/2obcOjpuZHHcuVSopKU/WUakDMtMScYiC79uGuztqHWyf8t/3/PzraUEcBHcXqgESNdBSMdRRMgBwzHQVLHQUoCeIDsbmOgjmQMgGrM4iNBQA "Brachylog – Try It Online")
# [Husk](https://github.com/barbuz/Husk), 1 byte
```
E
```
[Try it online!](https://tio.run/##yygtzv7/3/X////RhjpAGAsA "Husk – Try It Online")
# Haskell + [hgl](https://gitlab.com/WheatWizard/haskell-golfing-library), 2 bytes
```
lq
```
[Try it online!](https://ato.pxeger.com/run?1=m708I7E4OzUnZ8FN88zcgvyiEoXC0sSczLTM1BSFgKLUnNKUVC6oRABXmoKVlYJPZnGJgmdeiYKunYJTfn7O0tKSNF2LJWm2OYUQ5k1XrtzEzDwFW4WUfC4FhYIiBRWFNIXoWCS2ITLHSAcI0QWMYyGGLVgAoQE)
# [Factor](https://factorcode.org/), 3 bytes
```
std
```
[Try it online!](https://tio.run/##S0tMLskv@h8a7OnnbqWQVlSpkJtYkqFXXJJYkllckplcrFBQlFpSUllQlJlXolCcWliampecWqxgzVXNpQAE1QqGKLAWLmqkYKxgAuebKVhCMUIExjIHQhjbBKjPAMirVYj@X1yS8j8W6J4CBaBzkrP1/gMA "Factor – Try It Online")
Outputs `0.0` if they're the same, or something else if not. `all-eq?` and `all-equal?` are longer built-ins that output booleans. `all-equal?` uses `=` (ordinary equality) and `all-eq?` uses `eq?` (strict object reference equality), but they behave the same for integers.
# [Thunno](https://github.com/Thunno/Thunno), \$2 \log\_{256}(96) \approx\$ 1.65 bytes
```
ze
```
[Attempt This Online!](https://ato.pxeger.com/run?1=m72sJKM0Ly9_wYKlpSVpuhaLqlIhDCh_wfpoQx0FBIqFCAMA)
# [Thunno 2](https://github.com/Thunno/Thunno2), 1 byte
```
ạ
```
[Attempt This Online!](https://ato.pxeger.com/run?1=m728JKM0Ly_faMGCpaUlaboWix_uWrikOCm5GMpfsDzaUAcIYyFcAA)
[Answer]
# [Haskell](https://www.haskell.org/), 16 bytes
-12 bytes thanks to [Delfad0r](https://codegolf.stackexchange.com/users/82619/delfad0r).
```
f(a:x)=all(==a)x
```
[Try it online!](https://tio.run/##XYvNCsIwEITvfYo5eGghij/FYiHePXssOSyapsE0ShOxbx@3pReFnZ2d5ZuOwkM7l1KbUz0WkpzLpaRiTAZ1jWscrDdYn5crM5AI3fODDVpWPmi6/4LNxUdVZD1Zz6z1UQ90i1jh7Z31OnCrpxcM@5xTsxP4H5VN373AQaDkcBQ4CSx7yqxKoGIrZ26rvg "Haskell – Try It Online")
Another 16 byter:
```
f(a:x)=x==(a<$x)
```
[Try it online!](https://tio.run/##XYvNDoIwEITvPMUcOEBSjT9EIrHePXskHDZaSiNUQ2vs29eFcNFkZ2dn801H7qH6PsY2oyrkMkiZ0SkNedSoKlz9aKzG6rxciYaE654frNGyslHR/ResL9Y3eTKQscwa69VIN48Ub9sbqxy3BnpBs8851luB/2mS6bsT2AsUHA4CR4FlT5lVCpRsxcxtmi8 "Haskell – Try It Online")
[Answer]
# [R](https://www.r-project.org/), ~~17~~ 15 bytes
```
sd(scan()+!1:2)
```
[Try it online!](https://tio.run/##K/r/vzhFozg5MU9DU1vR0MpI87/pfwA "R – Try It Online")
Outputs `0` for truthy and nonzero for falsey.
Using `sd` is a classic R golfing trick: the standard deviation is `0` if and only if all elements are equal. Unfortunately, `sd` returns `NA` for length one input (since it divides by `n-1`). A neat workaround found by [pajonk](https://codegolf.stackexchange.com/users/55372/pajonk) uses R's recycling: `!1:2` is coerced to a vector `c(0,0)` and is added to the input vector. A length-one input is recycled to be length 2 (so the `sd` is guaranteed to be `0`), and for input of length more than `1`, the zeros are recycled to the length of the longer vector, which won't change the standard deviation.
```
sd(rep(scan(),2))
```
[Try it online!](https://tio.run/##K/r/vzhFoyi1QKM4OTFPQ1PHSFPzv@l/AA "R – Try It Online")
[Answer]
# [Python 3](https://docs.python.org/3/), 18 bytes
```
lambda x:len({*x})
```
[Try it online!](https://tio.run/##K6gsycjPM/6fZhvzPycxNyklUaHCKic1T6Naq6JW839BUWZeiUaaRrShDhjGampyoYkZAcX@AwA "Python 3 – Try It Online")
-5 bytes thanks to @hyper-neutrino
I'm lucky.....
[Answer]
# [Vim](https://www.vim.org), 8 bytes
```
:g/<C-r><C-w>/d
```
[Try it online!](https://tio.run/##K/v/3ypd38ZZt8gOSJTb6adw/f9vyGXKZfRftwwA "V (vim) – Try It Online")
This uses the assumption that list elements are one character. `Ctrl+R``Ctrl+W` inserts the word under the cursor, so this solution applies the `d`elete command to any line which contains the first element of the list. This results in an empty file if they're all the same, or some non-empty lines if they aren't.
If we weren't allowed to assume that items are in the range `[0,9]` then we could give false positives on numbers which are supersets of each other. We could fix this by using a regex instead for one more byte:
### [Vim](https://www.vim.org), 9 bytes
```
:%s/<C-r><C-w>\n
```
[Try it online!](https://tio.run/##K/v/30q1WN/GWbfIDkiU28Xkcf3/b2jKBUaGpv91ywA "V (vim) – Try It Online")
Vim doesn't have a concept of truthy/falsey values but if one were to believe that a buffer containing only newlines was falsey, then we could drop the `\n` from this regex to get a 7 byte solution.
[Answer]
# [Jelly](https://github.com/DennisMitchell/jelly), 2 bytes
```
IẸ
```
[Try it online!](https://tio.run/##y0rNyan8/9/z4a4d/49Ofrhz8aOGOQq6dgqPGuY@3LHo4Y75jxq3PdzR9XDntLDD7VwPd2853P6oac3//9GGOgroKBakMaSoNJULJGuko2Cso2ACFnRLzCkGiprpKFjqKEBJFAkkreY6CuZIXBOwSQYI1QA "Jelly – Try It Online")
Outputs reversed (`0` if all are equal, `1` if not)
## How it works
```
IẸ - Main link. Takes a list L on the left
I  - Increments of L
 Ẹ - Are any non-zero?
```
[Answer]
# JavaScript (non-trivial), ~~22~~ 21 bytes
*Thanks to @l4m2 for -1*
```
d=>!d.some(x=>x-d[0])
```
[Try it online!](https://tio.run/##y0osSyxOLsosKNEts/hfllikkG77P8XWTjFFrzg/N1WjwtauQtE2JdogVvN/QVFmXolGuka0oY4COorV1ORCljfSUTDWUTBBETbTUbDUUYCSqDIoPHMdBXMUAROweUAnaP4HAA "JavaScript (V8) – Try It Online")
This one's different from the `new Set` approach because it returns an actual truthy/falsy value. Although it's not as short (by just 4B, surprisingly), it's what you'd probably use if you needed this in real life, so it's definitely worth having here.
You could make it a byte shorter by removing the `!`, but then it returns `false` if all items are the same and `true` otherwise.
[Answer]
# Excel, 18 bytes
```
=MAX(A:A)=MIN(A:A)
```
Input is in column A. The formula can be input anywhere not in column A.
[Answer]
# [Proton](https://github.com/alexander-liao/proton), 7 bytes
```
set+len
```
[Try it online!](https://tio.run/##KyjKL8nP@5@mYPu/OLVEOyc1739BUWZeiUaaRrShjgI6itXU5EKWN9JRMNZRMEERNtNRsNRRgJKoMig8cx0FcxQBE7B5BkCx/wA "Proton – Try It Online")
Outputs `1` for truthy and anything else for falsy.
[Answer]
# [Jelly](https://github.com/DennisMitchell/jelly), 2 bytes
```
QL
```
[Try it online!](https://tio.run/##y0rNyan8/z/Q5//RyQ93Ln7UMEdB107hUcPchzsWPdwx/1Hjtoc7uh7unBZ2uJ3r4e4th9sfNa35/z/aUEcBHcWCNIYUlaZygWSNdBSMdRRMwIJuiTnFQFEzHQVLHQUoiSKBpNVcR8EciWsCNskAoRoA "Jelly – Try It Online")
# [Husk](https://github.com/barbuz/Husk), 2 bytes
```
Lu
```
[Try it online!](https://tio.run/##yygtzv7/36f0////0YY6YBgLAA "Husk – Try It Online")
# [05AB1E](https://github.com/Adriandmen/05AB1E), 2 bytes
```
Ùg
```
[Try it online!](https://tio.run/##yy9OTMpM/f//8Mz0//@jDXXAMBYA "05AB1E – Try It Online")
# [APL(Dyalog Unicode)](https://dyalog.com), 2 bytes [SBCS](https://github.com/abrudz/SBCS)
```
≢∪
```
[Try it on APLgolf!](https://razetime.github.io/APLgolf/?h=AwA&c=e9S56FHHKgA&f=S1MwhECuNAVjBRMFUwA&i=SwMA&r=tryAPL&l=apl-dyalog&m=train&n=f)
Thanks to [Bubbler](https://codegolf.stackexchange.com/users/78410/bubbler) for pointing this out!
---
Outputs [1 for truthy, \$>1\$ for falsey](https://chat.stackexchange.com/transcript/message/57714890#57714890). These all use the same method: counting the number of unique elements.
If the same approach is also this trivial/short in your language, feel free to edit it in if you don't want to post an answer
[Answer]
# [Ruby](https://www.ruby-lang.org/), 14 bytes
```
->a{!(a|a)[1]}
```
[Try it online!](https://tio.run/##KypNqvyfZvtf1y6xWlEjsSZRM9owtvZ/gUJadLShjgI6io3lgkkZ6SgY6yiYwETMdBQsdRSgJFwQxjDXUTCHsU3Aeg1iY/8DAA "Ruby – Try It Online")
[Answer]
# [Racket](https://racket-lang.org/), ~~37~~ 18 bytes
```
(λ(x)(apply = x))
```
[Try it online!](https://tio.run/##K0pMzk4t@a@ck5iXrlAE5nBppKSmZealKqT91zi3W6NCUyOxoCCnUsFWoUJT878ml0aagkZOZnGJgiEq1ESRMlIwVjBBFjJTsIRgZEFzBXNkrglQmwHQEgA "Racket – Try It Online")
-19 thanks to Wezl
This takes advantages of the fact that `=` in Racket can take any number of arguments. Note that the tio seems to run an old version that requires at least 2 arguments to `=` and so fails on the singleton list, but this works on my local Racket 8 installation.
[Answer]
# [brainfuck](https://github.com/TryItOnline/brainfuck), 40 bytes
Works for all characters, not just 0 to 9! (except NUL)
Returns zero for true and non-zero for false.
```
,[>,]<[->+<]<[[->+>-<<]>>[<[-]>>>]<<<]>.
```
[Try it online!](https://tio.run/##SypKzMxLK03O/v9fJ9pOJ9YmWtdO2wZIgWg7XRubWDu7aKAgkLKLtQFx9f7/NwYCQwA "brainfuck – Try It Online")
[Answer]
# Ruby, 17 bytes
```
f=->a{!a.uniq[1]}
```
Explanation: `a.uniq` is an array with unique elements of a. If all elements are the same, its second element `[1]` will be `nil`, and `!nil` is `true`.
Older answer was more readable:
```
f=->a{a.uniq.size==1}
```
[Answer]
# [Pari/GP](http://pari.math.u-bordeaux.fr/), 19 bytes
```
v(s)=gcd(s)==lcm(s)
```
[Try it online!](https://tio.run/##K0gsytRNL/j/v0yjWNM2PTkFRNnmJOcCaZBgtKGOAjqK1eSCSBjpKBjrKJhA@GY6CpY6ClASKgShzHUUzCEsE7Aeg1hNAA "Pari/GP – Try It Online")
[Answer]
# [Zsh](https://www.zsh.org/) `-o extendedglob`, 8 bytes
```
>$@
<^$1
```
[Try it online!](https://tio.run/##qyrO@F@cWqKgm6@QWlGSmpeSmpKek5/EBRIzBMH/dioOXDZxKob/bWxsVOz/AwA "Zsh – Try It Online")
Outputs via exit code; `1` for all the same, `0` for not all the same
* `>$@`: create files according to the input. This de-duplicates elements because a file can only be created once
* `^$1`: find a file that doesn't match the first element of the input (`-o extendedglob` is necessary to enable the `^` feature)
* `<`: and try to read from it. If there is no matching file (because all elements are the same) this will fail and exit with `1`
[Answer]
# [K (ngn/k)](https://codeberg.org/ngn/k), 5 bytes
```
1=#?:
```
[Try it online!](https://ngn.codeberg.page/k#eJxLszK0Vba34uLSVwhKLSktyitWMFRIyy9SKCkqTdVRMACz0xJzilO50oAyyFBfQddOIQSoDCxjpGCsYAIRc4MqN1OwhGJk4Wgds1gUveZAiMw3AZplgKQFAA3pJ7c=)
*-2 bytes thanks to ngn*
Returns `1` for true, `0` for false.
Checks if `1` is equal to the length of unique elements in `x`
[Answer]
# [Uiua](https://uiua.org), 4 [bytes](https://www.uiua.org/pad?src=U0JDUyDihpAgK0BcMOKKlwpEZWNvZGUg4oaQIOKHjOKKjy0x4pa9wrEu4o2Y4ouv4oav4oqCwq8x4qe74ouv4qe7LOKHjOKItSjihpjCrzHii68rMjU2KSAtQFwwKzEKJnAg4oqCIjggYml0IGVuY29kaW5nOlx0IiBTQkNTICLih4ziio8tMeKWvcKxLuKNmOKLr-KGr-KKgsKvMeKnu-KLr-Knuyzih4ziiLUo4oaYwq8x4ouvKzI1NikiIOKKgitAXDDih6ExMjkiLiziiLY74oiYwqzCscKv4oy14oia4peL4oyK4oyI4oGFPeKJoDziiaQ-4omlKy3Dl8O34pe_4oG_4oKZ4oan4oal4oig4qe74paz4oeh4oqi4oeM4pmt4ouv4o2J4o2P4o2W4oqa4oqb4oqd4pah4oqU4omF4oqf4oqC4oqP4oqh4oav4oaZ4oaY4oa74per4pa94oyV4oiK4oqXL-KIp1xc4oi14omh4oi64oqe4oqg4o2l4oqV4oqc4oip4oqT4oqD4oqZ4ouF4o2Y4o2c4o2a4qyaJz_ijaPijaQh4o6L4oas4pqCzrfPgM-E4oiefl9bXXt9KCnCr0AkXCLihpB8IyIKJnAg4oqCImRlY29kZWQ6XHQiIERlY29kZSAiwqPCsS0xwrjChy7DjMKlwrPCsMKIMcKfwqXCnyzCo8K_KMK1wogxwqUrMjU2KSIg4oqCK0BcMOKHoTEyOSIuLOKItjviiJjCrMKxwq_ijLXiiJril4vijIrijIjigYU94omgPOKJpD7iiaUrLcOXw7fil7_igb_igpnihqfihqXiiKDip7vilrPih6HiiqLih4zima3ii6_ijYnijY_ijZbiipriipviip3ilqHiipTiiYXiip_iioLiio_iiqHihq_ihpnihpjihrvil6vilr3ijJXiiIriipcv4oinXFziiLXiiaHiiLriip7iiqDijaXiipXiipziiKniipPiioPiipnii4XijZjijZzijZrirJonP-KNo-KNpCHijovihqzimoLOt8-Az4TiiJ5-X1tde30oKcKvQCRcIuKGkHwjIg==)
```
≅↻1.
```
[Try it!](https://uiua.org/pad?src=ZiDihpAg4omF4oa7MS4KCmYgWzEgMSAxIDEgMSAxIDFdICMgLT4gVHJ1ZQpmIFsxIDIgMyA0XSAgICAgICAjIC0-IEZhbHNlCmYgWzYgOSA2IDkgNl0gICAgICMgLT4gRmFsc2UKZiBbNl0gICAgICAgICAgICAgIyAtPiBUcnVlCmYgWzcgN10gICAgICAgICAgICMgLT4gVHJ1ZQpmIFs0IDIgMF0gICAgICAgICAjIC0-IEZhbHNl)
```
≅↻1.
   .  # duplicate
 ↻1   # rotate an array by one
≅     # do they match?
```
[Answer]
# [Arn 1.0](https://github.com/ZippyMagician/Arn) `-s`, 2 bytes
```
:@
```
Outputs 1 if all the same, >1 if they aren't all the same.
[Try it online (works in older version)](https://zippymagician.github.io/Arn?code=OkA=&input=MSAxIDEgMSAxIDEgMQoxIDIgMyA0CjYgOSA2IDkgNgo2&flags=LXM=)
`:@` groups identical values, `-s` takes size. This could be written as `(:@)#` as well, which would be 4 bytes (`«×+0`)
[Answer]
# [Branch](https://github.com/hyper-neutrino/branch-lang/), 27 bytes
```
1O,[^\,N![o#)]n^=/;^\o^*On]
```
Try it on the [online Branch interpreter](https://branch.hyper-neutrino.xyz/#WyIxTyxbXlxcLE4hW28jKV1uXj0vO15cXG9eKk9uXSIsIjExMTExMTExMTExMiIsIiJd)!
There's got to be a much shorter way to do this...
[Answer]
# [Pip](https://github.com/dloscutoff/pip), 3 bytes
```
$=g
```
Full program; takes the items from command-line arguments. [Try it online!](https://tio.run/##K8gs@P9fxTb9////RmBoDAA "Pip – Try It Online")
Alternately, a function solution that takes a list as its argument (also 3 bytes):
```
$=_
```
[Try it online!](https://tio.run/##K8gs@K/xX8U2/n@0kQIYxmr@BwA "Pip – Try It Online")
### Explanation
Not *quite* a builtin.
Pip, like Python, has chaining comparison operators: `1<5>=3` means `1<5 & 5>=3`, and `1=1=1=2` means `1=1 & 1=1 & 1=2`. Unlike Python, Pip also has the meta-operator `$`, which folds a list on a binary operator. For example, `$+` folds a list on addition, returning the sum; and `$=` folds a list on `=`. Because `=` chains, this returns the result we want: 1 if all elements are equal and 0 otherwise. The program `$=g` applies this compound operator to the full arglist `g`.
[Answer]
# [Charcoal](https://github.com/somebody1234/Charcoal), 5 bytes
```
⁼⌊θ⌈θ
```
[Try it online!](https://tio.run/##S85ILErOT8z5/z@gKDOvRMO1sDQxp1jDNzMvM7c0V6NQU0fBN7ECytbUtP7/3xAC/uuW5QAA "Charcoal – Try It Online") Link is to verbose version of code. Takes input as a string of digits by default but you can feed it an array if you insist. Outputs a Charcoal boolean, i.e. `-` for equal, nothing if not. Explanation: Simply compares the minimum and maximum input element.
[Answer]
# [Retina 0.8.2](https://github.com/m-ender/retina/wiki/The-Language/a950ad7d925ec9316e3e2fb2cf5d49fd15d23e3d), 7 bytes
```
D`.
^.$
```
[Try it online!](https://tio.run/##K0otycxL/K@q4Z7w3yVBjytOT@X/f0MI4DI0MjbhMrMEQi4zLnNzLhMjAy4A "Retina 0.8.2 – Try It Online") Link includes test cases. Takes input as a string of digits. Explanation:
```
D`.
```
Remove duplicate digits.
```
^.$
```
Check that only one digit is left.
[Answer]
# [C (gcc)](https://gcc.gnu.org/), ~~35~~ 32 bytes
```
f(int*l){l=~l[1]&&*l-*++l+f(l);}
```
[Try it online!](https://tio.run/##ZU/NToQwGLz3KSY1u4FSDH/rRhG8@QTeWA4NP9qkggHWC8FXRwqakmzSNNOZ@eabFu57UcxzbclmYMoeVfKjMj8/HplymeMop7aUHU/znWwKdS0rPPdDKdv7j5QsExBeliejz3FzXH@KN4v/Zwk4Qo5opwRaeeB45Pi/jRhuoiEiTZw5zjvupLlozfY2mpDvVpYYqn5Y/4RSDMIeCb665VnDohmoHRPUbQftAJOJ9sRMpokXO460CYz7UIJyJvUEdiE53BSHHpfm0lBeW@uWF/rWXSv6RF@F6iu9ZVprfgrZWDaWEmst4em0DfoGBgaGBkYGnjQk0/wL "C (gcc) – Try It Online")
* recursive function taking an array -1 ended
* return False if all elements are equal, True otherwise
```
{l=      - return using eax trick
~l[1]&&  - return False if next item is end and skip next part ending recursion 
*l-*++l  - 0 if different 
+f(l);}  - plus check next item 
```
[Answer]
## x86-16 machine code, 6 bytes
Hexdump:
```
0000:0000  89 F7 AC F3 AE C3                                ......
```
## Explanation
```
                                   ; Routine A. [All The Same?]
                                   ; Expects CX = Length of input,
                                   ;         SI = Initial address of list.
0000:0000  89F7        MOV DI, SI  ; A1 [Load]. Set DI to SI.
0000:0002  AC          LODSB       ;            AL = [SI++].
0000:0003  F3AE        REPZ SCASB  ; A2 [Compare].
                                   ;       ZF = 1
                                   ;       Loop CX times:
                                   ;           If AX != [DI]:
                                   ;               ZF = 0
                                   ;               Proceed to A3
                                   ;           DI ++
0000:0105  C3          RET         ; A3 [End]. End of algorithm.
                                   ;           ZF = 0 if not all same.
                                   ;           ZF = 1 if all same. █
```
[Answer]
# [Fig](https://github.com/Seggan/Fig), \$2\log\_{256}(96)\approx\$ 1.646 bytes
```
LU
```
If you test input cases, the Fig site demands no spaces, ie. `[x,y,z]` not `[x, y, z]`. Outputs `1` if all equal, else `>1`.
[Try it online!](https://fig.fly.dev/#WyJMVSIsIlsxLDEsMSwxLDEsMSwxXSJd)
```
LU
 U  : Uniquify with implicit input
L   : Length
```
[Answer]
# dc, 27 characters
```
?[0p3Q]sq[d3R!=qz0<c]dscx1p
```
Sample run:
```
bash-5.1$ dc -e '?[0p3Q]sq[d3R!=qz0<c]dscx1p' <<< '1 1 1 1 1 1 1'
1
bash-5.1$ dc -e '?[0p3Q]sq[d3R!=qz0<c]dscx1p' <<< '6 9 6 9 6'
0
```
[Try all test cases online!](https://tio.run/##lVCxTsMwEJ3jr7haoW6HKElTqBCxgIGBCbWrsVBqu2pElKRxIlUUvj3YjhrKwIAs33t3fme/8zbT@14qUWSNguARWqXbN5FpRWfIYySGi0U4jYfiAhJYmjSy6Q3cgttj4SxcwepMl6YncoI5QnWTl@0OyCdcBfG1BofRL1yY@FoSIM9l3bUGN0p3hSVPx1qJVklDX94JQruqgdyKTATsnybjCOyBf@E7kBXyGtdNsT@DsNNNWFQiK8JtXoZSQKCA9PcsqpM11wcmk82EHj6iVHCpxTGuewJpmpq73TMY5hgh7x8zjI3YH3xYdvqxORwbr2D9MXaho/QvKecwnYIS@8r9gzUlq1L13w "Bash – Try It Online")  
(Note that choosing `dc` as interpreter and running the test separately fails both in TIO and ATO. ☹)
[Answer]
# [Ly](https://github.com/LyricLy/Ly), 6 bytes
```
a0I=u;
```
[Try it online!](https://tio.run/##y6n8/z/RwNO21Pr/fzMuSy4wBgA "Ly – Try It Online")
This one works by sorting the list of number and comparing the top and bottom of the stack.
```
a       - sort the stack, implicitly reads the numbers first
 0I     - copy the bottom entry to top of the stack
   =    - compare the top two entries
    u;  - print boolean result, exit to stop from auto printing the stack
```
# [jq](https://stedolan.github.io/jq/), 14 bytes
```
unique[1]//"T"
```
[Try it online!](https://tio.run/##yyr8/780L7OwNDXaMFZfXylE6f//aDMdBUsdBSgZCwA "jq – Try It Online")
This one generates a list of unique numbers, then attempts to print the second member of that list. The `//` operator catches the exception and substitutes `T` if there's only one number.
[Answer]
# [sed](https://www.gnu.org/software/sed/), 26 bytes
```
$!{N;/^\(.*\)\n\1$/D;Q1};Q
```
[Try it online!](https://tio.run/##K05N0U3PK/3/X0Wx2s9aPy5GQ08rRjMmL8ZQRd/FOtCw1jrw/39DLiMuYy4TAA "sed – Try It Online") - Takes input as a newline separated list of numbers, exits with a non-zero exit code for "false" (i.e. not a uniform list).
##### Explanation
```
$!{                    }     if not last line, do these
   N;                          append next input line to pattern space
     /^\(.*\)\n\1$/            if pattern space is two identical lines
                   D;            delete first line, and GOTO beginning
                     Q1        quit with exit code 1 (no printing)
                        ;Q   quit with exit code 0 (no printing)
```
[Answer]
# [V (vim)](https://github.com/DJMcMayhem/V), 10 bytes
```
:sor u
Gd{
```
[Try it online!](https://tio.run/##K/v/36o4v0ihlMs9pfr/f0MuCDT5r1sGAA "V (vim) – Try It Online")
Input as a list of lines. Outputs a falsy value (Empty output) for all items equal, and outputs a number otherwise.
Gets the unique lines, goes to the last line and deletes till the beginning.
]