[Question]
  [
Your task is to write a program or function that takes as input a list of positive integers and determines if there are any two integers in the list, that both appear the same number of times.
For example the list
```
[1, 2, 3, 2]
```
Has one 1 and one 3 so it satisfies the condition.
But the list
```
[3, 2, 2, 1, 2, 3]
```
does not satisfy the condition since every member appears a unique number of times.
Additionally your program should *not* satisfy this condition when its source code is interpreted as a list of bytes.
For example
```
abcb
```
Would not be a valid submission since both `a` and `c` appear exactly once.
[Here](https://tio.run/##XU8xDsIwENvzCg8MqQSVWCuyFBYkJAZecIHQVqRJ1FwH/sbGw0KqMhSms89n2ddSfBhrU@r64AfGgZjK@snmwkPnGlBELQCJxvDeOzaOY@ZrjC7Q9ZFhIZbWUxdZiAAFshZSKrUtUMIa13A7oWbwY8gzTpYSPYWv@K8J0VPnUFU4niGLmSncfM7UuWDEboP75K/LuUwGvy1DfoGxms8XPMyblIi01u/XBw "Haskell – Try It Online") is a verifier you can use if your source is in ASCII.
## Output
Your submission when executed should output one of two possible values, one when the input satisfies the condition, one when the input does not.
This is [code-golf](/questions/tagged/code-golf "show questions tagged 'code-golf'") so answers will be scored in bytes with fewer bytes being better.
  
[Answer]
# [05AB1E](https://github.com/Adriandmen/05AB1E), 6 bytes
```
D¢DD¢Q
```
[Try it online!](https://tio.run/##yy9OTMpM/f/f5dAiFyAO/P8/2lBHwUhHwRhMAtmGsQA "05AB1E – Try It Online") or [validate more test cases](https://tio.run/##yy9OTMpM/V9Waa@k8KhtkoKSfeV/l0OLXIA48L/O/@hoJRclHaVDi4CECxSDOYFKsTrRhjpGOsY6RkAWkARCMB/IU0oEqkgC4mQwDRIB8WCiSXDRRKgoCDtB1UNwbCwA).
Outputs 1 if each item appears a unique number of times, 0 otherwise.
```
D           # duplicate the input
 ¢          # count occurences of each item in the input
  DD        # triplicate the list of occurence counts
    ¢       # count occurences of each occurence count in the list of occurence counts
     Q      # check whether this is equal to the list of occurence counts
```
Without the source restriction, this could be 4 bytes: `¢Ð¢Q`.
[Answer]
# [Jelly](https://github.com/DennisMitchell/jelly), 1+2+3+4 = 10 bytes
```
ĠQQẈQƑẈĠĠĠ
```
A monadic Link which accepts a list and returns an empty list, `[]`, if the input satisfies the condition, or a list with a list containing a one, `[[1]]` if the input does not satisfy the condition.
**[Try it online!](https://tio.run/##y0rNyan8///IgsDAh7s6Ao9NBJJHFoDg/8PtRyc93DkDqyQA "Jelly – Try It Online")**
### How?
Without the source code restriction we could do the four byte `ĠẈQƑ`: `Ġ`, group indices by value; `Ẉ`length of each; `Ƒ`, is invariant under; `Q` de-duplication.
So for the \$1+2+3+4=10\$:
```
ĠQQẈQƑẈĠĠĠ - Link: list, L
Ġ          - group indices by value -> list of lists (which when flattened would contain the integers 1 to len(L) inclusive)
 Q         - de-duplicate (a no-op)
  Q        - de-duplicate (again a no-op)
   Ẉ       - length of each (group) 0> how many times each element appeared
     Ƒ     - is invariant under?:
    Q      -   de-duplication -> 0 if satisfies, 1 if not
      Ẉ    - length of each -> [] if satisfies, [1] if not
       Ġ   - group indices by value -> [] if satisfies, [[1]] if not
        Ġ  - group indices by value (a no-op)
         Ġ - group indices by value (another no-op)
```
[Answer]
# [Python 2](https://docs.python.org/2/), ~~136~~ ~~126~~ 120 bytes
A slight improvement of @xnor's solution, posted with permission. Source code has 15 distinct characters.
```
n=input()
print(not
sum(())==sum(sum(r==m
for
m
in
n)==sum(u==m
for
m
in
n)for
r
in
n
for(u)in(n)if(r==u)==(r==n)))#ouu)
```
[Try it online!](https://tio.run/##hVFNb8IwDL3nV1jlQCJVSHyckHqE637AyqELRo0Ap3Mcbf31LGkQQ2jSJLfx84trv75hlN7T6mb9EaGBqqpu1DgaomijBnYkmryoEK9aG9M0OckPN81VnTyrq3Kk6M7El2pOeUpzVUfjSJNxp9weU08@yRgz8zGaWxq@CMJuSKPVDAb2FkMA7GwP00pwcYTqq3cXhOVWgfCY3oDfaHUWYFTKLQ4Cu7f9jtlzpj8Yu3P5YJID0iNMaoN0EopGqFraM35GJDuCP4HtOw5pKAQf2ZaGbaUk/aKLC6KDZ8GjDihlsDFZINjSMnFSn3FsMruwPpKYtEsZxjiwtqb@5RK6vS9rWNWwrmFzUL9glcB6Ainu1QdfrpTYPMdBzR82tvTwsaU/jWwpLd9SOh219GzmKzMhvqOJ/MfU@Q8 "Python 2 – Try It Online")
**Input**: A string representation of a list/iterable, from stdin.  
**Output**: `True` if the list has 2 elements with the same frequency, `False` otherwise.
### Base solution
```
n=input()  # read a list/iterable from stdin 
           # This is Python2, so the input string is implicitly evaluated
print(0 != sum(     # return True if sum is not 0 (aka at least one of the following is True)
  sum(r==m for m in n)==sum(t==m for m in n) # check if frequency of r and t are the same
  for r in n for t in n if r!=t              # ignore when r==t                    
))
```
[Try it online!](https://tio.run/##XVDBbsIwDL3nK0x3IJEqNAqnSTmy6z6AcoAuFRGLGxlXwNcXJ2EMzbLi92zHzku88XHAZuqGbwcWqqqa0HqMI2ujInlk/Q4zC@cxaAU5kLUB@oEggEdAY23K8r@sNCdGmcGDcWZCfA80s6yMmWTl4szkoyxUl6P/cbD8UMB0kxPc1XU6PU4GumvnIsPm63NDNFAqH8jtT9N2WUNTw6qG9U79kUbIKhPxR/ZZLy3F16@@U/PnD7RYviAJ/JXeoihpUaJHjeZFfq7oYEo@YSo4QS7Q92kIy60Upc289YHFaCxm5nc)  
  
## Old solution using `exec`
### [Python 2](https://docs.python.org/2/), 158 bytes
```
e=s=110;"tt)e";exec"e=%c%x%c%x%c%x%cx:%ce%c(set(x))-%ce%c(set(%c%x%c(x%cc%c%c%ct,x)))"%(e-2,10,e-1,11,100,10,0x20,e-2,e,s-2,s,s-1,10,s--2,0x2e,s--1,120-2-1,s)
```
[Try it online!](https://tio.run/##zZBNCsIwEIX3PcVQCGYglSR1pfQk4kLiiIGaliZIPH2d1N8jSN684X1vVhnv6TIEO8/Uxc4YvatTQqp3lMnV1Akn8nfyVjgSTkZKMiM23/TsJY8Ty0uKD7AWkhqrjFbUGGVYWpeksy3IKlKRPbKXjhcnLgsuxOrG8o44@@s4TAniPVbnYYLeBwIfSl7HdPJhW0EPHdDt2MtSMp38KBErGCcfkiTZI857o8AqaNkP1b5dAutFGZk3at/a/Opz0S5h9d@/tnoA "Python 2 – Try It Online")
**Input**: a list or iterable.  
**Output**: a positive number if the list has 2 elements with the same frequency. `0` otherwise.
### Base solution
```
e=lambda x:len(set(x))-len(set(map(x.count,x)))
```
[Try it online!](https://tio.run/##ZY9BbsMgEEX3PgWyhAISRIC7csRJoixcMlWRMLYMrcjpncGpnUXFn2H@@7CY@ZG/p9itK9gwjJ/3gZQ@QGQJMiucy30eh5mVs5t@YhbI@erHeVoySY/UfE0LCT4C8bH6c8p3H/uGBGIJ/A6B1ZA3ZF58zAxYwO9XLYgRpMN@a67dZlB/FJHeUbfr47@Od91mTmCL1Vpd2pSztZab9gIFHGvBUkfLu0pPHVB3rPl2r5xhObqd174tZSCN0EqA1EKjlKpOFVOREXD0moki0WEIdUJilDR4A@enJw "Python 3 – Try It Online")
  
My approach is inspired by [this answer](https://codegolf.stackexchange.com/a/110722/92237), which discussed how to construct any Python programs using only the characters `exc="%\n`. The idea is to convert the program into `exec"<program>"`, then use string modulo (`%x` and `%c`) to build program string from number.
[Answer]
# [Zsh](https://www.zsh.org/), \$\sum\_{i=1}^{18} i = 171\$ bytes
```
((f--))
for u (${(u)@})((n[$#-${#@:#$u}]--))
((f-(${${(@on)n}[f]})))
#              rrrrrr[[[[[[]]]]]]]nnnnnnnn@@@@@@@@@#########{{{{{{{{{{}}}}}}}}}}}-----------))))))))
```
[Try it online!](https://tio.run/##1ZDBjoIwEIbvfYoJVNuGcEDjBUPCZh@D5WC0RKJO1QLJLumzs9MuanyE/RrCMPwz83d@7HFqpJKTlE2aKsUac4ceJB9lr0qnpMSKxykf4zKPee/qIPJikpCoNKjQVU3tFOVjeOMeqAL1HzhTPogfjE/ci/SFmmFsosfbPLe2A8lEBis6a38EExvYzNGashnFGWSC0c2AF6FkuQS9Pxrg4eu4s4AG0x7bW69Bn/VFY2cZ0WnbFeIfbUaQ5@@rtrqD9AMuu2swvYcWgRzZPFf@Sm47Mm9i2J0LTqKK7@uQmOOCS0n/IIGMmjrGwrY@TY9dDjz2bf3V6V0XYcAJhrCX06Ao6dTcH6uhTorIj74l6uSikL3eW@waEIuNhRwW9gvFUwF8oHm@5eA9R36NtMRoCwfzXrw6vIqlTJJWKV98MKinXw "Zsh – Try It Online")
Tricks used: We use subtraction instead of adding. We reuse characters we need from `for`, `(on)`, and `(u)` as parameter names. `((f--))` gets us `f=-1`, which saves us from using `1`.
[Answer]
# [Raku](https://github.com/nxadm/rakudo-pkg), ~~66~~ 57 bytes
```
*.Bag{*}.Bag{*}.all≠'l.}}}}****{{{{{{{gggggBBBBBBB'.Bag
```
[Try it online!](https://tio.run/##K0gtyjH7n1upoJZm@19LzykxvVqrFkYl5uQ86lygnqNXCwRaQFANAekg4AQB6iDF/625ihMrFdIUog11jHSMdYxj4QLGOgpGYGQIJhEy6aklevlFKcXW5FsLAA "Perl 6 – Try It Online")
10 unique characters, `*.Bag{}l'` and the 3 byte character `≠`. This uses `.Bag{*}` to get the number of times each element appears, then repeats that to get the number of times those appear and then confirms that not all of them are equal to one.
[Answer]
# JavaScript (ES6), \$\sum\limits\_{i=1}^{16}i= 136\$ bytes
Returns \$1\$ if the condition is satisfied or \$0\$ if it's not.
```
p=>p.map(aa=m=a=>aa|=1^(p[[,a]]||(m[p.map(m=>pp+=a==m,p[[,a]]=pp=1),pp]^=1)))|aa//((((((,,...........11111===>>>>>>>>>>>[[^mmmmmppp|||||
```
[Try it online!](https://tio.run/##bY/dCsIwDEbvfYpeplg7qtcZiI9ROgx1/rFuwcmu@u4znYIgHkpKm0P4cqeJxvi48XPTD6d2jlIUquPMWLNNxECECQlrooyuAfbeUAg5Q/JvIYnJa1EwmU8XmdFpwxwaubXORFUFC8bYL66AiPUX75tUYOZcmI927G6xBWfUxunV6izx2ok6KFHlHYd@HLrWdsMFzuBF2xq1kxq0/m3ulqacj/VHkVRlcFhWiwprFW280uMgn/snyDJ6fgE "JavaScript (Node.js) – Try It Online")
### How?
To minimize the number of distinct characters, we only use `map()` loops and variable names made with ***m***, ***a*** and ***p***.
Character usage breakdown:
```
  + |  / |  ^ |  ) |  ] |  , |  [ |  1 |  | |  ( |  m |  a |  . |  > |  = |  p
----+----+----+----+----+----+----+----+----+----+----+----+----+----+----+----
  1 |  2 |  3 |  4 |  5 |  6 |  7 |  8 |  9 | 10 | 11 | 12 | 13 | 14 | 15 | 16
```
### Commented
In the following source, the variables have been renamed for readability.
```
a =>                       // a[] = input array, also used to keep track of the
                           //       values that have already been counted
  a.map(r = o = v =>       // r = result flag
                           // o = object used to keep track of the character counts
                           //     that have already been encountered
                           // for each value v in a[]:
    r |=                   //   set r if ...
      1 ^ (                //     ... the test below is false:
        a[[, v]] || (      //       v has already been counted, or this is ...
          o[               //         ... the first time this count is encountered:
            a.map(V =>     //           for each value V in a[]:
              n += v == V, //             increment n if V is equal to v
              a[[, v]] =   //             mark v as counted
              n = 1        //             and start with n = 1
            ),             //           end of inner map()
            n              //         
          ] ^= 1           //         toggle o[n]
        )                  //       end of count update
      )                    //     end of test
  ) | r                    // end of outer map(); return r
```
[Answer]
# [R](https://www.r-project.org/), 78 bytes
```
all(table(table(scan()))==all(c()))#nss==bbbcccceeeeettttttaaaa(((()))))llllll
```
[Try it online!](https://tio.run/##LckxCgAxCATArwTSaJlL7WNU0kmKM//3NNwsLgu@EWwGh8XW3668ARGJ6qM1@3YnEhFNq5yLEyQsdsVsT2bkzRYf "R – Try It Online")
`table(x)` gives a table of the counts of each value in `x` (here `x` will be the input taken by `scan`); `table(table(x))` counts how many times each count occurs. We therefore want to check whether `all(table(table(x))==1)`. Adding `#` and all the necessary characters to obey the constraint would lead to a score of 91.
The trick is to avoid the character `1` by using instead `all(c())`, which is `all` of an empty vector, i.e. `TRUE`, which gets converted to `1`.
I haven't looked yet into using [octal codes](https://codegolf.stackexchange.com/a/191117/86301) for this challenge; they might lead to a better score.
[Answer]
# [Haskell](https://www.haskell.org/) (No monomorphism), 245 bytes
```
import Data.List
g1L=all o111111111LLLLLLLLLLaaaaaaaeeeeeeeegggggggghhhhhhhiiiiillllnnnnoooooppppprrrrsssstuu.map length.group.sort.map length.group.sort
o111111111LLLLLLLLLLaaaaaaaeeeeeeeegggggggghhhhhhhiiiiillllnnnnoooooppppprrrrsssstuu i=i==1
```
[Try it online!](https://tio.run/##tdCxbsMgEADQna9AKJtlS/4Ato5Oh3bJEClCqYtPhTsEZ8lfHwKNkyhRlw55Czq4O043mfQzOpcz@ECR5Zth0w2QWNh@0MY5Sf3VcGMuxpVdTRdQuQILqkIVi1TwPHfeBOlGtDx1NtIculQ@//tWvGIACRq07jNq9Yr2SixaPW90j9eVqqbBplH/2cIe16J1ciW8AdRfJKQMM39yHFAuNYiALDeyFpXj3qwEv@3ubzW9bWvK9nCre8hZ8un47YxNud2905aQPMUwQfIfY@IIRwbCMw "Haskell – Try It Online")
---
Here is a work in progress towards a better answer, it solves the problem using 9 distinct characters. However currently there are some characters that appear the same number of times (e.g. `(` and `)`). I'm going to take a break from this, if anyone wants to use this to make a more complete answer go ahead.
```
s+|(ss:sss)|s==ss=1+s+|sss|1==1=s+|sss
s+|ss=1
s|+(ss:sss)|s==ss=s|+sss|1==1=ss:s|+sss
s|+ss=ss
s(ss:sss)=ss+|sss:s(ss|+sss)
s(ss)=ss
ss(1:s)=ss(s)
ss(s:ss)=1==11
ss(s)=1==1
sss(sss)=ss(s(s(sss)))
```
[Try it online!](https://tio.run/##XYw9DsIwDIV3n4MhVtrBZYvkkyCGDkhUlArx2AhnD7YDQmKx389nn2dcTuvaniMhFdYslWh8NeSagAKAK1QBlWyZ@Sqqol1TLBVCzX@4JT/YmrAUS118cTPxqngSEEfJQSFJCZk8tlm88acStmuTfvIBU9fM7Tovm97uy/bYWXKQYRpk2Nucju0N "Haskell – Try It Online")
[Answer]
# [MATL](https://github.com/lmendo/MATL) (unreleased master), 10 bytes
```
&u&uqaaaa&
```
[Try it on MATL Online](https://matl.io/?code=%26u%26uqaaaa%26&inputs=%5B%27%26%27%2C+%27u%27%2C+%27%26%27%2C+%27u%27%2C+%27q%27%2C+%27a%27%2C+%27a%27%2C+%27a%27%2C+%27a%27%2C+%27%26%27%5D&version=ee8bd433)  
[Multiple test cases](https://matl.io/?code=%60+i+tZN+%3F+x.+%5D+XH%0A%26u%26uqaaaa%26%0AXD+Zx+T%5D&inputs=%5B%27%26%27%2C+%27u%27%2C+%27%26%27%2C+%27u%27%2C+%27q%27%2C+%27a%27%2C+%27a%27%2C+%27a%27%2C+%27a%27%2C+%27%26%27%5D%0A%5B1%2C+2%2C+3%2C+2%5D%0A%5B3%2C+2%2C+2%2C+1%2C+2%2C+3%5D%0A%5B%27a%27%2C+%27b%27%2C+%27c%27%2C+%27b%27%5D%0A%5B%27b%27%2C+%27a%27%2C+%27b%27%2C+%27b%27%2C+%27b%27%5D%0A%5B%27a%27%2C+%27a%27%2C+%27a%27%2C+%27B%27%2C+%27c%27%2C+%27c%27%2C+%27c%27%5D%0A0%2F0&version=ee8bd433)
~~[Try it online!](https://tio.run/##y00syfmfoJCpUBLlp2CvUKGnEKsQ4fHfRLkUiAoTgUDtf4SLQlSFQkjs/2h1NXUdBfVSEIFgFYKIRCyEmnosV7ShjoKRjoIxkARyjMEcIIKKAoUgSpNARDKEBRJMghuShETAlSMIJ7hGKBHLZaBvwAUA "MATL – Try It Online"), but not really - link is to an equivalent 12 byte (non-conforming) version that works on TIO, since `&u` isn't available in it yet.~~ 
0 = input satisfies the condition, 1 = does not.
Actual code is `&u&uqa&` - take the counts of unique values in the input, take the counts of unique values in *that*, decrement that by one, and see if any of it is non-zero (which would mean the count was greater than 1, hence condition not satisfied). Repeating the non-zeroness check doesn't change anything, but takes `a`'s count to 4 and so makes it occur a unique number of times.
A conforming version that can run on TIO is `888#8#u8#uqaaaa` [Try it online!](https://tio.run/##y00syfmfoJCpUBLlp2CvUKGnEKsQ4fHfwsJC2UK5FIgKE4Hgf4SLQlSFQkjs/2h1NXUdBfVSEIFgFYKIRCyEmnosV7ShjoKRjoIxkARyjMEcIIKKAoUgSpNARDKEBRJMghuShETAlSMIJ7hGKBHLZaBvwAUA "MATL – Try It Online")
[Answer]
# [Wolfram Language (Mathematica)](https://www.wolfram.com/wolframscript/), 253 bytes
```
(*!!!!!!!!!!!!!!!!!!!!!o*=L=L=L=L*Ln*n*n*nUUU))))))))))))))))))UUUUUUTTTTTTTTTTSSSSSSSSSSSrrnnrrrrrrrrrrLLLLLLLLiiiiiiiiiiiiii//ss&&########*#######@#####&&&&&&&&&&&&&&&&s/ss/ss/s/ss/ss/ss/ss//////((((((((((((((((a*aaaa*)Union@(l=Last/@Tally@#)!=Sort@l&
```
[Try it online!](https://tio.run/##bcrBCsIwDAbgu0/hGJQtDIbzXOgD9CBsPckOQWQWagdtLyJ79lri3HD6/aEhSe8Ybtc7Bn3BOPBYQPbPCFy@A9ICRSlV/lCkW7Qr56x1CznTX@rae8byGcxd0Ms2fPpL9elUpNhAwARKZfVoRWG4RB9q0aExD5GXGW9HF4Rh8eS0DXsxnJ@HqqmOVTP1u3WX5hS6TH2MLw "Wolfram Language (Mathematica) – Try It Online")
[Answer]
# [Python 3](https://docs.python.org/3/), ~~406~~ \$\sum\limits\_{i=1}^{26}i= 351\$ bytes
Saved \$27+28=55\$ bytes thanks to [Surculose Sputum](https://codegolf.stackexchange.com/users/92237/surculose-sputum)!!! 
```
lambda l:all(l.count(a)^l.count(p)for a,p in itertools.combinations(set(l),2))
import itertools##22:::^^^^dddddffffff,,,,,,bbbbbbbuuuuuuuu........ccccccccceeeeeeeeeemmmmmmmmmmmpppppppppppprrrrrrrrrrrrsssssssssssss             (((((((((((((()))))))))))))))nnnnnnnnnnnnnnnnaaaaaaaaaaaaaaaaiiiiiiiiiiiiiiiiilllllllllllllllttttttttttttttttoooooooooooooooo
```
[Try it online!](https://tio.run/##7dHNisMgEAfwu08x2IuybmDTWyB9kW4LNmpXalQSC7uUPnt2TPqR5r63/RGCmpkJ/I0/6Sv49RBrSqmT7UFJcJV0jrmiCWefmOT7@zJyEzqQIoL1YJPuUgiux4/twXqZbPA963VijouSc2LbGLr0LFytyrKqqj1SmRmJ0WFyvilumjv90D7FmW6mn4M59oK/8gtywS65V2khLGDCRH/rhlFT07fIiak/h//M/zTzQWkDR0ynIqDqy5VAjrPJYU6p4TmoAtdYKM8uPe6g4QK2O17IGLVXuJ1aT7lV5a7YWSw7CbU97ThJuk891MAIbD8ElALW@N4J3K7HLT6383wYBcH7x3kpzxubceY00tBLusL7Bi6GJX6l@OfVEVfDLw "Python 3 – Try It Online")
A veritable ~~triple~~ double super-sized whopper!!!  
Returns `False` if the input (any sequence) satisfies the condition, `True` otherwise.
[Answer]
# [Charcoal](https://github.com/somebody1234/Charcoal), ~~40~~ 23 bytes
```
⁼№θＥθι⁼Ｅθ№θιＥθ№Ｅθ№θλ№θι
```
[Try it online!](https://tio.run/##S85ILErOT8z5//9R18xDWx61TEMmzu1Gw3vRMVDXuR0QomHno8Y953YDxRr3AHWf23FuN4TaS1PDAQ "Charcoal – Try It Online") Link is to verbose version of code. Outputs `-` only if the condition is satisfied. Port of @Grimmy's 05AB1E answer. Explanation: The leading `⁼№θＥθι` exists to consume characters to meet the source layout restrictions and also happens to complement the result. The rest of the code is as follows:
```
 Ｅθ№ ι              List of counts of elements
    θ               In list
⁼                   Equals
      Ｅθ№     №θι   List of counts of counts
         Ｅθ№θλ      In list of counts
```
[Answer]
# [Wolfram Language (Mathematica)](https://www.wolfram.com/wolframscript/), ~~66~~ 55 bytes
```
####>Count@s@@o@uuunnnntttttssssss@s&@@Counts@Counts@#&
```
[Try it online!](https://tio.run/##y00syUjNTSzJTE78n2b7XxkI7JzzS/NKHIodHPIdSktL84CgBASKwcChWM3BAayiGEYpq/0PKMrMK4lW1rVLc1COVasLTk7Mq6vmqjbUMdIx1jGq1eGqBlJACBYAckPynTMSixKTS1KLnPNTUh2UyLRYSQdkCchUsCVgBtBGYx0TVC5QAAJruWr/AwA "Wolfram Language (Mathematica) – Try It Online")
Returns `True` if occurrence counts are not unique, and `False` otherwise.
```
                                              Counts@#  occurrence counts
                                       Counts@          count of counts
####                                &@@                 squared product
    >Count@s@@o@uuunnnntttttssssss@s                      >1
```
`Count@s@@o@uuunnnntttttssssss@s` simplifies to `(Count@s)@uuunnnntttttssssss@s` = `Count[...[s],s]` = 1. The product of positive integers can only be \$\not>1\$ if they are all 1.
[Answer]
# [JavaScript (Node.js)](https://nodejs.org), 253 bytes
```
n=>new(Set)(n).size>new(Set)(n.map(e=>n.filter(r=>r==e).length)).size//(======ghgmmmmmmmaaaaaaaapppppppppppwwwwwwwwwwwllllllllllllhhhhhhhhhhhhhrrrrrrrrrrrrrggggggggggggggzzzzzzzzzzzzzzzzSSSSSSSSSSSSSSSSSttttttttttttttttnnnnnnnnnnnnnnssssssssssssssssssss
```
[Try it online!](https://tio.run/##dZDBbsIwDIbvPEWPiZQFwc7uS3CsKjDFTVuFtEqjgnj5YsI2Qrd9OUTyb8fR1@GEY@XbIXy4/kRzDTShFR3MBwe5o4vYUZDCST22N0oK@oyDIG7RdWsDeeEh9wAktSVnQiOfE@u1gIhpzPkJfjG8uLywCU2KTzFv3BbsloQF7o3xDw6zXFW9G3tL2vZG1KLYqK36VNtS/kq4yifmj3Q1oc/2dQYZK0xbEdhfxv7YpzpCobXG8ltkQeo/l6VU1c/oMQ5cIb8WG96mMHpWVbx4@Z4/xA93pZzv "JavaScript (Node.js) – Try It Online")
unavoidable new Set size length map filter
[Answer]
# [Japt](https://github.com/ETHproductions/japt) [`-!`](https://codegolf.meta.stackexchange.com/a/14339/), 36 [bytes](https://en.wikipedia.org/wiki/ISO/IEC_8859-1)
```
ü mÊ
e       UUâââmÊmÊmÊmÊÊ
eUâ
```
[Try it](https://petershaggynoble.github.io/Japt-Interpreter/?v=1.4.6&flags=LSE&code=/CBtygplICAgICAgIFVV4uLibcptym3KbcrKCgoKCgoKZVXi&input=WzMsIDIsIDIsIDEsIDIsIDNdCg)
[Answer]
# [JavaScript (Node.js)](https://nodejs.org), 91 bytes
```
p=>"">p[")||]m",mp="","map"](m=>[p["map"](pa=>a-=m==pa,a=[]),mp|=p[a]>m|m>p[a],p[a]=m])==mp
```
[Try it online!](https://tio.run/##bVDRasMgFH3PV4hPyoxtt8dwhaTtVzgh4pLVEqMkXWlYtl/PNOtgjImce/UcztF71lc9msGGS977l2YxERCgegkgMBZBYjrPymHmAmDMsNMBK@JAyEh9H4IGoXNwAEEzDVLRKJ4hSK2Em51IDUsATlEAF5aaj501DdkxlO9ottmgck0rZYw4wt23iiHlT8gexCGHCmDPDmvEcYZSHpSo5kqkhiWASlEBx@wG7x/FFHVF6wdikW9R@hi9Sasg/0zlztge3ejEw9t4InK33T4kjllFi4mPfrgQWhjfj75reOdfycTP3vb1c1/TImvjoJqr7sjqnWW/hW10Y@iRoaeIitK/5NNKxn1X/SPhnCdjxeMEiEEgkOHmpId9vCzjw@JavgA "JavaScript (Node.js) – Try It Online")
Optimized from
```
A=>"">A["",E="map"](B=>[A["map"](C=>D-=B==C,D=[]),E|=A[D]>B|B>A[D],A[D]=B])>=E
```
Only 5 bytes of direct waste!
[Answer]
# [Pip](https://github.com/dloscutoff/pip), 28 bytes
```
gNUM_NMQUQNUUgg:_NgMUQgUQgQg
```
Takes the list as command-line arguments; or, with the `-r` flag, takes the list of lines of stdin. Outputs 1 if every item's count is unique, 0 if some items have identical counts.
[Try it online!](https://tio.run/##K8gs@P8/3S/UN97PNzA00C80ND3dKt4v3Tc0MB2IAtP//zfmMgJCQyA2/q9bBAA "Pip – Try It Online")
[Self-verify it online!](https://tio.run/##JYmxCcBADAN775IFfgcJXKj@UqR7sj84CgHrTsjnPjOmsIlWU7LXpqF2rj2jUu1yMUaI6jSHDFd@n5Gt45/JXM8L "Pip – Try It Online")
### Explanation
```
gNUM_NMQUQNUUg
```
No-ops to get the character counts right.
```
g:_NgMUQgUQgQg
        g       ; List of arguments
      UQ        ; Uniquify (remove duplicates)
     M          ; Map this function to each:
   N            ;   Count of
  _             ;   function argument in
    g           ;   original list
g:              ; Assign the result back to g
         UQg    ; g with duplicates removed
            Q   ; is equal (using string comparison) to
             g  ; g
```
]