[Question]
  [
My mom really wants me to eat broccoli, but I hate it and never want to eat it. Mom wants to trick me so she cuts it into small pieces, puts it in a salad and mixes it. Help me find out if the salad contains broccoli!
**Input:**
Array of mixed letters of all the ingredients. For a single broccoli ingredient it could be:
```
[c,o,r,b,l,c,i,o]
```
**Output:**
Boolean or other convienient output allowing to distinguish if a salad contains broccoli or not.
**Rules:**
* all possible ingredients are `onion`, `broccoli`, `celery` and `beans`
* input array is always formed of mixing valid ingredients (meaning that it can be always decoded back to the original ingredients array)
* input array cannot be decoded into more than one valid ingredient combination
* each ingredient can occur 0 or more times in the salad
**Sample test cases:**
`true` stands for a salad with broccoli
```
[c,o,r,b,l,c,i,o] //true
[o,b,n,o,i,i,e,l,n,a,o,r,n,s,b,o,c,c] //true
[l,c,b,r,r,o,r,c,i,i,c,o,c,b,o,c,c,b,i,o,l,o,l,o] //true
[] //false
[o,n,i,o,n] //false
[b,n,s,i,a,o,n,b,a,s,e,e,n,o,n] //false
[b,r,o,c,c,o,l,i,e,y,e,r,l,a,e,e,n,s,y] //false
[e,n,s,o,e,n,i,o,a,o,o,e,n,n,e,l,n,l,e,o,e,r,c,l,o,y,i,r,y,r,y,b,e,l,n,n,c,c,r,c,e,y,i,e] //false
```
**This is [code-golf](/questions/tagged/code-golf "show questions tagged 'code-golf'") so the shortest code in bytes wins!**
  
[Answer]
# [Python 2](https://docs.python.org/2/), ~~34~~ 32 bytes
-2 bytes thanks to @dingledooper
```
lambda a:cmp(*map(a.count,'bs'))
```
[Try it online!](https://tio.run/##dVHLDoMgELz7Fd7QxvTQYxO/pO0BKKYkuhi0B7/eoh3iQlOTCexjZnZxXOaXo8vatfe1l4N6ylJe9TBWp0GOlTxr96a5EWoSdb2O3tJcdtVNaNEIF@ADVEAfsOXsnn/UxdHq0EKgWMCAtuUlk9viCRwHWZ1KRjcFimd0zSw0k0jlvrFFrk/OYAUv0W6fKA7rn82IyVA6pWLLWLYkwV2iZgD6L@Oz4eOw8R0XnB55mclOe08iy0uOtcZl4rS8Rtlv6xE7Zq/Zey7Q87jHU2U6xFaLGobxTRh9/QA "Python 2 – Try It Online")
Returns `1` for true, `0` for false
[Answer]
# [J](http://jsoftware.com/), 14 bytes
```
[:=/1#.'cy'=/]
```
[Try it online!](https://tio.run/##ZY6xCgJBDER7vyJosQh6antwlWBlZSsWuyFiZMlArtqvPyNi4UkIITMvQ57Tskt3GnpKtKE99dHbjo6X82m69sPusOoStzTsbtN6IfxA@APdKTG8VFYk@pFRDKpSLcNtLGCeAZWLO5xVGfz2i6JGfbHDB5utMIXNtGKjZljJo4j9ux7ZqCpNvOYgxjYjQoJEbkYMi5erQJwrmnrzVkIxZmdpKnE6vQA "J – Try It Online")
*Idea of invariant based on letter counts from mathjunkie's [clever answer](https://codegolf.stackexchange.com/a/204690/15469) -- be sure to upvote him.*
* 0 for contains broccoli
* 1 for not
Tests if the number `c`s is equal to the number of `y`s. This will only be true when no broccoli is present.
[Answer]
# perl -ple, 14 bytes
```
$_=y-y---y-c--
```
[Try it online!](https://tio.run/##DYsxCsBACAT7e0day5R5S8iJhSDu4aXx8zEWywwDuyTsrDruKymJekxUNQPMMB2MmMaKMeXxPeAKH@Ib0vag4WJuAgk2pEZGzi7OHCyp8mG9/dlFtn4 "Perl 5 – Try It Online")
Prints 0 if no broccoli is present, something else if there is.
[Answer]
# MATLAB/[Octave](https://www.gnu.org/software/octave/), 26 bytes
```
@(b)b&&diff(sum(b'=='cl'))
```
[Try it online!](https://tio.run/##XY5BCsJADEX3nsKNTrvpDQpeZRIzEIj5kFFhTl8jgljJIuG95BPwvT5la@uyLNtlopnO56u2NvXHbaKyroWtzPPWpsIIMlaU@Xi6x0MOyUAOVTGvCO8E5l9rTBEIVmXwW5LCsn533nOr1j9xrvAdIe9a4VS7iP@7yEiYypCwmr6PnU8AycSKbJ5PmkCCDUNjxKAkzhwsQ@V7uL0A "Octave – Try It Online")
Credit to @mathjunkie's answer for the idea. Interestingly comparing `c` and `l` counts also works because `celery` has one of each, but `broccoli` has a different number.
MATLAB likes to expand `==` into 2D arrays if the inputs are vectors in differing orientations. However this doesn't work with empty arrays. Fortunately empty is false in MATLAB and non-empty with any non-zero elements is true, so we can simply use the input as a logical true-false to capture that case.
[Answer]
# [05AB1E](https://github.com/Adriandmen/05AB1E/wiki/Commands), ~~7~~ 6 [bytes](https://github.com/Adriandmen/05AB1E/wiki/Codepage)
```
„bsS¢Ë
```
-1 byte by reversing the output: will output `0` if it contains broccoli and `1` if not.
[Try it online](https://tio.run/##yy9OTMpM/f//UcO8pOLgQ4sOd///n5pXnJ@al5mfmA@k8lJz8nJS81OLknPyKzOLKosqk4AiecnJRcmplZmpAA) or [verify all test cases](https://tio.run/##Jc2xCcNQDATQVYxq7@AhUoYUX0KFQOhAHwK/S5UmTcgAKTJKvIkXcWSCioPHHUJvbLpfx/pcaNrur4mWfbu9uZ@@n/Wxz/uZBMkuBpoJHDBTj4aMzhApdOFMpJgJ5DA2eB3NEx2bMEQlR7eG4NZV4y9ZZbjp0PRW2kdpBbQ2DRVRv1yhKY5hOXJwSYik6DClyw8).
**6 [bytes](https://github.com/Adriandmen/05AB1E/wiki/Codepage)** alternative which outputs `1` if it contains broccoli and `0` if not:
```
AS¢üÊн
```
[Try it online](https://tio.run/##yy9OTMpM/f/fMfjQosN7Dndd2Pv/f2pecX5qXmZ@Yj6QykvNyctJzU8tSs7Jr8wsqiyqTAKK5CUnFyWnVmamAgA) or [verify all test cases](https://tio.run/##Jc3BCQJRDATQVpactwexBo/i4SfkEAgZyAfhN@DBk1iCdejFbcAabGTNIjkMPGYIemPT9TyW246m7@U@0W7dH96P5blcP691Xo8kSHYx0EzggJl6NGR0hkihC2cixUwgm7HB62ieaNuEISo5ujUEt64af8kqw02HprfSPkoroLVpqIj65QpNcQzLkYNLQiRFhymdfg).
**Explanation:**
```
„bs     # Push string "bs"
   S    # Convert it to a character-list: ["b","s"]
    ¢   # Count each in the (implicit) input
     Ë  # Check if the counts are the same for both letters (1 if truthy; 0 if falsey)
        # (after which it is output implicitly as result)
A       # Push the lowercase alphabet: "abcdefghijklmnopqrstuvwxyz"
 S      # Convert it to a character-list: ["a","b","c",...,"z"]
  ¢     # Count each in the (implicit) input-list
   ü    # For each overlapping pair of counts:
    Ê   #  Check that they are not equal to one another (1 if truthy; 0 if falsey)
     н  # Pop and only leave the first check (for letters 'a' and 'b')
        # (after which it is output implicitly as result)
```
If the amount of `b` and `s`/`a` are the same, it means the input only contains `beans` and no `broccoli`.
[Answer]
# [APL (Dyalog Classic)](https://www.dyalog.com/), ~~19~~ 12 bytes
```
>/+/↑'cl'=⊂⍞
```
[Try it online!](https://tio.run/##SyzI0U2pTMzJT9dNzkksLs5M/v/fTl9b/1HbRPXkHHXbR11Nj3rn/f@fVJSfnJyfkwkA "APL (Dyalog Classic) – Try It Online")
Note that you have to add `⎕←` to the beginning for it to output. Originally created with **ngn/apl**.
```
>/+/↑'cl'=⊂⍞
            ⍞ ⍝ get input
     'cl'=⊂   ⍝ make two packed vectors: characters equal to c and l
  +/↑         ⍝ turn into two row matrix and add (to get number of 'c's and 'l's
>/            ⍝ Are there more 'c's than 'l's?
```
returns broccoli: 1, no broccoli: 0
[Answer]
# JavaScript (ES6), ~~33~~ 32 bytes
*Saved 1 byte by not forcing a Boolean value, as suggested by @SteveBennett*
Takes a string and returns *undefined* (falsy) for a broccoli-free salad (yummy!) or a string (truthy) otherwise (yuck!).
```
s=>s.split`b`[s.split`s`.length]
```
[Try it online!](https://tio.run/##fY/BTkNBCEX3foW71y58f1B/pDZ5A9IWQ7gNjDXz9c@p0USTsWEBuRxyL2/lWpJDL/XJ8Srrcbfm7jnnvJjWhZb9z5jLbOKnej6sDE@YzIbTZtp/aD0/UoAZpodp@/B7fdxMjCBjxbT9d3UHATlUxbwgPKm7DCBjikCwKoNvDCms1w39w04v/pUX7/Ve5FEOV/hAJ08tcCop4mPi20eahJVOZRtQXYZ0j4LevP9rAgk2NI0WjbrizMHSVPr5@gk "JavaScript (Node.js) – Try It Online")
[Answer]
# [Charcoal](https://github.com/somebody1234/Charcoal), 7 bytes
```
›№θb№θs
```
[Try it online!](https://tio.run/##S85ILErOT8z5/z@gKDOvRMO9KDWxJLVIwzm/FMgr1FFQSlLS1FFAcIuVNDU1rf//j87XSdLJ08nXyQTCVJ0cIDsRyCsC0sVAmXydZJ3k2P@6ZTkA "Charcoal – Try It Online") Link is to verbose version of code. Outputs a Charcoal boolean; `-` for broccoli, nothing for none. Explanation:
```
 №θb    Number of `b`s in input
›       Exceeeds
    №θs Number of `s`s in input
        Implicitly print
```
[Answer]
# [JavaScript (SpiderMonkey)](https://developer.mozilla.org/en-US/docs/Mozilla/Projects/SpiderMonkey/Releases/45), 32 bytes
```
s=>s.map(c=>++this[c],r=y=0)|r>y
```
[Try it online!](https://tio.run/##ZY9hbsMgDIX/9xT7CauX7AJkB0mjhTDSsVET4WwS0u6eGTdaK03IAfw@v0c@7Lcll8OyPtES3ny@JPz0ZZvNRqaj5mIX5Ux3PK7vgXo3QDbFPOuf3JXNJaQUfRPTWY2H3kGCDBNEcBAgDQ9tu@Yvf@gTN5HFwMuzjGAFRSBWEuPuBtfpicUsiJMhJ9CO8s7ubCP1N3jo63G2kSQRBcK73iR5QbKRTSzfPC/8x@U9qAbUFxeuzGe78wTljr92kig1s/pfb7j/beQ9iYeTZxfmMn9rTTuDklgJL7q/JYxN9ku0zqv21Kvm8UWfhvYM6hVIm25W1NASwzrCqLXefgE "JavaScript (SpiderMonkey) – Try It Online")
# [JavaScript (Node.js)](https://nodejs.org), 37 bytes
```
s=>s.map(c=>n+=~~{r:1,y:-1}[c],n=0)|n
```
[Try it online!](https://tio.run/##ZY/RTsMwDEXf@xXsLQGvZa@TUj6kq2hqsqkoc6qkIFXAfr04XsUmochN4nt8b/puP23COIzTlsKbW45mSaZO5dmOCk1NT@Zy@Yr7Hcz77e6nwRbIPOtvWjBQCt6VPpxUVzQIASL04AFhgNA@VNUUP1zRBG4SiwMvxzKBFZQgsRIYxxucp3sWoyAoQyjQivLO7mwj9TdYNPl4tD5JIglEd71e8gbJJjaxfHO86B8X16AckF88c0U@25VPMN/x104QJWdm/@uN1r/1vAfxQHn2zFzkb65@ZUgSM@FEd7eEroxu9Badqg6NKh9f9KGtTqBeIWlTbzZHlco0@mHqoNNaL78 "JavaScript (Node.js) – Try It Online")
[Answer]
# [K (oK)](https://github.com/JohnEarnest/ok), 11 bytes
**Solution:**
```
</+/"sb"=/:
```
[Try it online!](https://tio.run/##Jc1BCsNACAXQu7hpSynZp@1hRjEgET84K08/NRQXH55@PF841zr2z/bcaDJ9t30dtzsJkl0M9CZwwEw9BjImQ6TRhTORYiaQy9jgPb26KmGITo5pA8FjqsZfsm/hpqXpo3VWawe0OwMd0a9coSmOsqwsbgmRFC1Teqwf "K (oK) – Try It Online")
**Explanation:**
Shamelessly stolen "more s' than b's" logic from [mathjunkie](https://codegolf.stackexchange.com/a/204690/69200):
```
</+/"sb"=/: / the solution
    "sb"=/: / "sb" equal (=) each-right (/:)
  +/        / sum
</          / s less than b? (aka no brocoli?)
```
[Answer]
# Zsh, 22 characters
```
((${#1//a}==${#1//b}))
```
Expects the ingredients as a single command line parameter.  
Sets the exit code to 1 for broccoli alert and 0 for no broccoli.
(Just to keep the exit code semantics of 0 = Ok / non-0 = error. Using `<` for comparison would save 1 character but reverse the result's encoding.)
Sample run:
```
manatwork@manatwork ~ % . ./broccoli-detector.zsh obnoiielnaornsbocc
manatwork@manatwork ~ % echo $?
1
manatwork@manatwork ~ % . ./broccoli-detector.zsh broccolieyerlaeensy
manatwork@manatwork ~ % echo $?                                      
0
```
[Try it online!](https://tio.run/##qyrO@P9fQ0OlWtlQXz@x1tYWwkqq1dT8//9/flJefmZmak5eYn5RXnFSfnIyAA "Zsh – Try It Online") / [Try all test cases online!](https://tio.run/##XZCxagMxDIbn3FOI5IKTIYRCu7SEDJ36DllsndIKjFSkW9ySZ7/qSEhp8SDpsz9@oy//mD6NZTxDWj8@OTzD2k@SIL3Ju9HAJKPH9KoyZhaHYoqoleGYuu6sBnx/Fy0kVCsVWcPRIspMVbKaeAkvYMVipobMqDizwlrjxNWsCOscXsQ5q5TsRHIlt1xqZDUH9RY0ilI4WaNIRFVSMqza2Jq1EkQQDakxpRcYtFs4jbDbwbL//fhy2mz679XDfp8vh8O1K5ftdlr8X80wr@aPCv2xG1Ro@gE "Zsh – Try It Online")
[Answer]
# [Retina 0.8.2](https://github.com/m-ender/retina/wiki/The-Language/a950ad7d925ec9316e3e2fb2cf5d49fd15d23e3d), 18 bytes
```
+`[^bs]|bs|sb
1`b
```
[Try it online!](https://tio.run/##PY5BCsQgDEX3vcfAwGQzp5hDSIcacSGUCDqbQu/u/PxKkWiS//JNy79icTyen228tvDVvp7az67L8t50jJCkShOVXZIUqesSKipDt@Bk9E0iGZMOpYJLoJxXdBu1RDpRnQxe@GGegQlaG5uGXGlYaG6AI6qMY7feppEb@CoHoiGPk@tygLuyyo57u99V2Vx/x1s5m7jOAa7h9tDJGH9yIlPP6x8 "Retina 0.8.2 – Try It Online") Link includes test cases. Explanation:
```
+`[^bs]|bs|sb
```
Delete everything that's not a `b` or an `s`, plus any remaining `bs` or `sb` pairs that result from bean salad.
```
1`b
```
Check whether there is any broccoli.
[Answer]
# [Jelly](https://github.com/DennisMitchell/jelly), ~~7~~ 6 [bytes](https://github.com/DennisMitchell/jelly/wiki/Code-page)
```
ċⱮ⁾abE
```
A monadic Link accepting a list of characters which yields `0` if the salad contains broccoli and `1` if not.
**[Try it online!](https://tio.run/##y0rNyan8//9I96ON6x417ktMcv3//796al5xfmpeZn5iPpDKS83Jy0nNTy1KzsmvzCyqLKpMAorkJScXJadWZqaqAwA "Jelly – Try It Online")** Or see the [test-suite](https://tio.run/##Lc2xDYJBCAXg/l/kGtdwCmNxEAoM4SVcdaU2Fq5iTFzARie5RU7OGIpHPiCcxKzP@bmN52OcX5X2830dl/uch8IIMlaUbVdADlUxrwhvBOalxhSBYFUGLySFZa3Z78oVvhryphVOtYn4nyL3YSpdwmpy64szIXlWkeH50AQSbOgaPTqlOHOwdJWyHb8 "Jelly – Try It Online").
### How?
Tests whether the number of `'b'`s (in both 'broccoli' & 'beans') is equal to the number of `'a'`s (in only 'beans').
```
ċⱮ⁾abE - Link: list
 Ɱ     - map across...
  ⁾ab  - ...what: list of characters = ['a', 'b']
ċ      - ...applying: count
     E - all equal?
```
[Answer]
# [Java (JDK)](http://jdk.java.net/), 41 bytes
```
s->s.reduce(0,(a,c)->c<98?a-1:c<99?a+1:a)
```
[Try it online!](https://tio.run/##ZU@xTgMxDN37FValSnfQnugGLRSxIDEwlQ0xOG6uuKTxyc5VOiG@PeQKC0JRYvu952fngCdcHHYfmY@daIJDqZs@cWjaPlJiic3FevKPtKQejyNFAc3gGTnC5wSg611gAkuYSjgJ7@BYuGqblOP@9Q1Q91afpQAv8hTT4@@c25Jvz7YbaOEu22JjjfpdT766mlc4p3qxodub63tcLFclubnHy@UK67w@m7Wi1QkVkre0@jMGYDtY8sdG@tR0ZY/UVtOZrWBmszidnzvm0DbYdWF4sLJHNUINvaNaVdebq/pnxNdkvF85k6gLxJLFRWH2IaJoNCdEOZBTFSVmEhoRxxLKyRLLL7OLxijRoXkfx1qLRAL7wWvAgtmQyyO@qFFKiMU9ePFKQQbWQQdXkEik5Af23w "Java (JDK) – Try It Online")
Uses a `chars()`-Stream as input, returns any strictly positive value if it contains brocoli.
## Credits
* -5 bytes thanks to [Elgirhath](https://codegolf.stackexchange.com/users/94596/elgirhath) by comparing `b` to `a` instead of `b` to `s`, and by allowing any positive value instead of a strict boolean.
[Answer]
# [asm2bf](https://esolangs.org/wiki/Asm2bf), 73 bytes
[Try it online!](https://tio.run/##3VPRasMwDPygm/cFQj8i/NAYBmGlgUC/P5NsxZHdhw72NqUQRz7rTqd62W/r4@tZvo8DDGFmEOlPV8mWlLLmRBfQd8okNW3AZEDdFt0ylFBiSVkhF9rS@qJ6Ar2gVICdFfv8YK44FUDQsJNQMbZ2hp7lFl7V42QMgbBdsSq8ZfMIFIoxVkkZgcEqdUDnl4nQ9I5FBgJzqLeASUPt4xThDBKqp0G7eQBWvxl0yqkuajTL3DO3snlpLeR/biLorybicgRexS9H@0M2p@WqJVfzv@oudtCy@c0tCbfQ2TDNCfwqdbRmHmy4wHgZZWJ7usqpG@lzPVmGfuFjIvfo822H0VP9yMdxL8u@b3tZ17KVZStlWbe7Pj8 "brainfuck – Try It Online")
Takes input on stdin as a string; outputs either `ASCII(0x00)` or `ASCII(0x01)`.
```
@l
in r1
ceqr1,.b
cadr2,1
ceqr1,.s
cadr3,1
jnzr1,1
gt r2,r3
outr2
```
Commented code:
```
; Essentially, our game plan is to compare amount of `b' and `s' occurences.
; Start a new label
@loop
; Read a character from stdin, put it in r1.
  in r1
; If r1 = 'b' (note the way of expressing a character constant), set
; the condition flag.
  ceq r1,.b
; If the condition flag is set, add 1 to r2
  cadd r2,1
; If r1 = 's', set the condition flag. Otherwise, clear it.
  ceq r1,.s
; If the condition flag is set, add 1 to r3
  cadd r3,1
; If r1 is bigger than zero, we didn't hit eof yet, so continue reading.
; Note: The golfed version is based on a certain property beyond explaining.
; It's related to the way how labels work under the hood.
  jnz r1,%l
; The loop finished.
; Compare r2 and r3 (the accumulators).
gt r2,r3
; Display the result
out r2
```
[Answer]
# [Japt](https://github.com/ETHproductions/japt), 6 [bytes](https://en.wikipedia.org/wiki/ISO/IEC_8859-1)
Takes input as a string with reversed output.
```
èÕ¶Uèc
```
[Try it](https://petershaggynoble.github.io/Japt-Interpreter/?v=1.4.6&code=6NW2Vehj&footer=IVU&input=WyJjb3JibGNpbyIsIm9ibm9paWVsbmFvcm5zYm9jYyIsImxjYnJyb3JjaWljb2Nib2NjYmlvbG9sbyIsICIiLCJvbmlvbiIsImJuc2lhb25iYXNlZW5vbiIsImJyb2Njb2xpZXllcmxhZWVuc3kiLCJlbnNvZW5pb2Fvb2VubmVsbmxlb2VyY2xveWlyeXJ5YmVsbm5jY3JjZXlpZSJdLW1S) - includes all test cases, footer negates the output for easier testing
[Answer]
# [C# (Visual C# Interactive Compiler)](http://www.mono-project.com/docs/about-mono/releases/5.0.0/#csc), 39 bytes
```
i=>i.Count(x=>x==98)>i.Count(x=>x=='s')
```
[Try it online!](https://tio.run/##bVDNSsQwED7bpxh62Qa6ix4EpbaXBU/ePYiHZJjVgTADk65uWfbiM/iEvkhNEIWq5DDJ95fhw7TGxPPtXvAmjcby1EJQjQPsoJ@5H3iz1b2MzaEfDn1/feV@Iau0cnNXvXiDkdKYoAehV3h4hGN11tSoFiKy1i2MtifXFlCDKDNF8WqSgiIu6IjBTA2ZUbGwgTXmsxDlx87H9J0orLKEgiT2KsEnIvlDWo7VyDSRRZ8FaVoKMqKUQ73mIXnVSEqGUSe2yaaQEUE0pInpx1mdumqr2Rlpc2880h0LNTXkLgE@3t9yGUY41q6rdmrk8RmaUlzDLaADlq8KXZWr@yfneN6uL08lCI4X5Vo@btgVc1ed5k8 "C# (Visual C# Interactive Compiler) – Try It Online")
[Answer]
# [C (gcc)](https://gcc.gnu.org/), ~~57~~ \$\cdots\$ ~~53~~ 52 bytes
Saved 3 bytes thanks to [l4m2](https://codegolf.stackexchange.com/users/76323/l4m2)!!! 
Saved a byte thanks to [Arnauld](https://codegolf.stackexchange.com/users/58563/arnauld)!!!
```
a;f(char*s){for(a=0;*s;++s)a+=*s-99?*s>120:-1;a=!a;}
```
[Try it online!](https://tio.run/##dVHBTsMwDL3vK0KkSU27ahu3ETo@hO2QmBQshRg55VCmfntxu3EAFedgx372k5@hfgUYR2fbAt4cl9lcWuLCNTtbZltV2biqKXN9ODyV@bi/3z3Ue@uaO2eH8d1hKoy6rJTY3K26kLv8fFaNumgg9hGQ9EZty44/Q7mdkZNp8okQQ0yOOGVPAIuwCJ6ZGBCBYEJ5pChvETwnWxfzb6aElJZLPmV0lLzLIaR/QSy0FDH0gaMTYO6XgVKhIGSOxCVZLQYKDJF65J57L5kEwBB6DPrPgMHObpIeU6dQBNxZcY8q41egtpiFNdvbbxbbyHnwR/7JPlh620Kf9DqftKqPav1ykq2uR8Hz5jZGQmOuhMNqGL8B "C (gcc) – Try It Online")
Takes a string as input and returns a \$1\$ for edible and a \$0\$ for *grossing me out*!
[Answer]
# [PHP](https://php.net/), ~~44~~ 42 bytes
-2 bytes thanks to @Elgirhath
```
$b=count_chars($a,1);echo+($b[98]>$b[97]);
```
[Try it online!](https://tio.run/##bY/dSsRADEbvfYqyFLpFEbxSqasPootMQpYGhnwls3sxiM9eUwQVmZmLwMnJ3zIv69PLMi/d6WJ8Vlh32vdp/Fh7OjAudn7nOXkJdnM3TsIzrvc9vT4@HJ@3cH8cp/XzauNRODCcMiuGsbvtdm@2m35SIIOqZEtwKwTmhpSZ3OGsyuDNIUWO/0f9dofD9oZ/NDq0Jluc1eBkRROMUhGxtuGxArJKFc8prFIbVmBIzEiIYHFhFohzRlWvXimIMTtLVfktX78A "PHP – Try It Online")
[Answer]
## Javascript, 46 characters
Shortening Yaraslav's answer:
```
s=>(q=z=>s.filter(e=>e==z).length)('b')>q('s')
```
## Javascript, 62 characters
```
x=>([,a,b]=/(a*)(b*)/.exec(x.sort().join``),b.length>a.length)
```
Maybe I missed something? Just counts if there are more `b` than `a`. 
[Answer]
# Google Sheets, ~~34~~ 33 bytes
*Saved 1 byte thanks to Steve Bennett*
```
=CountIf(A:A,"b")>CountIf(A:A,"s"
```
Input is in column `A`. When you exit the cell, Sheets will automatically add the trailing parentheses.
There's nothing really clever about this solution besides implementing the concept from others.
[![enter image description here](https://i.stack.imgur.com/Sau7D.png)](https://i.stack.imgur.com/Sau7D.png)
[Answer]
# [JavaScript (Node.js)](https://nodejs.org), 62 bytes
```
s=>s.filter(e=>e=='b').map(Date)>s.filter(e=>e=='s').map(Date)
```
[Try it online!](https://tio.run/##jZAxTgQxDEX7PQVdkoK5AMpWXCQxHjAy/iMngHL6IUgUi1Y7IBeW/J/tb7@Wj9LIZev3hife17y3fG7LKtrZI@cz5xxqSMtb2eJj6Zyu1Hap7gRrUF4UzzF8Sn@5qw4iqIR0uhTXGAhelQRhaZtKjyGkdBP6F4xqEGG1ArdW5@JDXKm6w0mEQN90FeiM203p4XR1Id77wZHHfk1gh0S1JgVWS2O2v9gfEzzYtUy@jUN@AuDpoGAmm19TBjsphvjwUWfFiJx4CP8atH8B "JavaScript (Node.js) – Try It Online")
# [JavaScript (Node.js)](https://nodejs.org), 56 bytes
```
s=>s.filter(e=>e=='b').length>s.filter(e=>e=='s').length
```
[Try it online!](https://tio.run/##jZBBbgMxCEX3OUV3Hi86F6icu9iUSagQP8JuK59@6kpVlCqKW7FA4j/gw1v@yJVcLu3Z8Mr7lvaajnXdRBv7wunIKYUS4qpsp3a@k@pV2glWobwqTkv4lHZ@Kg4iqIR4uBW3JRC8KAnCWi8qbQkhxofQv2AUgwirZbjVMhZPcaXiDicRAn3TRaAjHjfFl8PdhXhvkyPnfk1gU6JYlQwruTLbX@yPCe7smgdf@5QfAHg4yBjJxteUwU6KLt69l1ExIifuwr8G7V8 "JavaScript (Node.js) – Try It Online")
]