[Question]
  [
They say that `hate` is a strong word. I wanted to find out why, so I had a good look at the word.
I noticed that every consonant had a vowel after it. That made it look quite strong to me, so I decided that that's what makes a word strong.
I want to find more strong words, so I'll need a program for it!
# Finding strong words
Strong words are words where every consonant (letters in the set `BCDFGHJKLMNPQRSTVWXZ`) is followed by a vowel (letters in the set `AEIOUY`). That's it. Nothing else matters.
If the word starts with a vowel, you don't have to worry about any of the letters before the first consonant. If the word has no consonants in it at all, it's automatically a strong word!
Some examples of strong words are `agate`, `hate` and `you`. `agate` is still a strong word because although it starts with a vowel, every consonant is still followed by a vowel. `you` is a strong word because it has no consonants.
There is no restriction on length for strong words.
# The challenge
Write a program or function that takes a non-empty string as input, and outputs a truthy value if it is a strong word or a falsy value if it is not.
# Clarifications
* You may decide to take the input in either lowercase or uppercase. Specify which in your answer.
* Words will not contain punctuation of any kind. They will only contain plain letters in the set `ABCDEFGHIJKLMNOPQRSTUVWXYZ`.
* Instead of truthy and falsy values, you may choose two distinct and consistent values to return for true and false. If you do this, specify the values you have picked in your answer.
	+ You may alternatively output a falsy value for a strong word and a truthy one for a non-strong word.
# Test cases
```
Input      -> Output
hate       -> true
love       -> true
popularize -> true
academy    -> true
you        -> true
mouse      -> true
acorn      -> false
nut        -> false
ah         -> false
strong     -> false
false      -> false
parakeet   -> false
```
# Scoring
Since this is [code-golf](/questions/tagged/code-golf "show questions tagged 'code-golf'"), the answer with the least bytes wins!
  
[Answer]
# JavaScript (ES6), ~~36~~ ~~28~~ 27 bytes
*Saved 1 byte by inverting the result, as suggested by LarsW*
Takes input in lowercase. Returns `false` for a strong word and `true` for a non-strong word.
```
s=>/[^aeiouy]{2}/.test(s+0)
```
### How?
We append a `0` (non-vowel) at the end of the input string and look for two consecutive non-vowel characters. This allows us to cover both cases that make a word *not* strong:
* it contains two consecutive consonants
* *or* it ends with a consonant
### Test cases
```
let f =
s=>/[^aeiouy]{2}/.test(s+0)
;[
  "hate", "love", "popularize", "academy", "you", "mouse", "a", "euouae",
  "acorn", "nut", "ah", "strong", "false", "parakeet"
]
.forEach(s => console.log(s + ' --> ' + f(s)))
```
[Answer]
# [Python 2](https://docs.python.org/2/), 48 bytes
```
lambda s:'se, F'in`[v in'aeiouy'for v in s+'b']`
```
An unnamed function taking a (lowercase) string, `s`, and returning `False` if strong or `True` if not.
**[Try it online!](https://tio.run/##JY7BCsIwEETP@hVLoKzFetCjoEd/QgVXm9pgmw3JplB/Pib1Mm9m2IVxs/RsD6k73dJA47MlCEcMuoELGvu4TmAskjYcZ@zYQ8kQtvjE@yOVQnSQ0m1UT6JVowaeChy7OJA33xLoRa0e5@xmjllHjuHfs7eZNkpJfZYgnu07m46G5caRp4/WourjeuW8sQKq2h8C7M5QBQUVbMqGBrqFNdkWcHlGyPtQfNRYp/QD "Python 2 – Try It Online")** (inverts the results to match the OP)
### How?
Non-strong words have either a consonant followed by a consonant or end in a consonant.
The code adds a consonant to the end (`s+'b'`) to make the required test be just for two consonants in a row.
It finds out if each letter in the altered word is a vowel with the list comprehension `[v in'aeiouy'for v in s+'b']`.
It now needs to check for two `False` results in a row (signalling a non-strong word), it does so by getting a string representation (using ``...``) of this list and looking for the existence of `'se, F'`. This is the shortest string found in `'False, False'` but none of: `'True, True'`; `'False, True'`; or `'True, False'`.
As an example consider `'nut'`, the list comprehension evaluates each letter, `v`, of `'nutb'` for existence in `'aeiouy'` yielding the list `[False, True, False, False]`, the string representation of this list is `'[False, True, False, False]'` which contains `'e, F'` here: `'[False, True, Fals>>e, F<<alse]'` hence the function returns `True` meaning that nut is **not** a strong word.
[Answer]
# [Jelly](https://github.com/DennisMitchell/jelly), ~~10~~ 9 [bytes](https://github.com/DennisMitchell/jelly/wiki/Code-page)
```
e€ØY;Ạ11ẇ
```
A monadic link taking a list of characters and returning:
* `0` if strong
* `1` if not
**[Try it online!](https://tio.run/##y0rNyan8/z/1UdOawzMirU8sMzR8uKv9////5flFKQA "Jelly – Try It Online")** or see the [test-suite](https://tio.run/##y0rNyan8/z/1UdOawzMirR/uWmBo@HBX@//D7Q93dz9qmJOWmFOcCqRLikqB1Fyuh7u3HN1zuB2oXMX9//@MxJJUrpz8slSugvyC0pzEosyqVK7E5MSU1NxKrsr8Uq7c/NJikEh@UR5XXmkJV2IGV3FJUX5eOhfYYK6CxKLE7NTUEgA "Jelly – Try It Online").
### How?
```
e€ØY;Ạ11ẇ - Link: list of characters, s      e.g. "hate"  or  "you"  or  "not"
  ØY      - consonant yield                   "BCDFGHJKLMNPQRSTVWXZbcdfghjklmnpqrstvwxz"
e€        - exists in? for €ach letter            [1,0,1,0]   [0,0,0]    [1,0,1]
     Ạ    - all truthy? (1 for any valid input)   1           1          1
    ;     - concatenate                           [1,0,1,0,1] [0,0,0,1]  [1,0,1,1]
      11  - literal eleven
        ẇ - sublist exists?                       0           0          1
          -  N.B.: left of ẇ implicitly makes digits so it looks for the sublist [1,1]
```
Note: The reason for using `Ạ` is just to save a byte over using `1` (since we then want to use `11` straight away).
[Answer]
# [05AB1E](https://github.com/Adriandmen/05AB1E), 8 bytes
### Code
```
žPS¡¦õÊP
```
Uses the **05AB1E** encoding. [Try it online!](https://tio.run/##MzBNTDJM/f//6L6A4EMLDy07vPVwV8D//4npiSWpAA "05AB1E – Try It Online")
### Explanation
```
žPS¡         # Split the string on consonants (bcdfghjklmnpqrstvwxz)
    ¦        # Remove the first element of the array to handle cases when the
               string starts with a consonant
     õÊP     # Check if the empty string is not in the array
```
### Example
```
             # "popularize"
žPS¡         # ['', 'o', 'u', 'a', 'i', 'e']
    ¦        # ['o', 'u', 'a', 'i', 'e']
     õÊ      # [1, 1, 1, 1, 1]
       P     # 1
```
[Answer]
# [R](https://www.r-project.org/), 43 bytes
```
function(s)grep("[^aeiouy]{2}",paste(s,""))
```
[Try it online!](https://tio.run/##K/qfZvs/rTQvuSQzP0@jWDO9KLVAQyk6LjE1M7@0MrbaqFZJpyCxuCRVo1hHSUlT83@ahlJiemJJqpImF5BZmV8KYSTl52dDWBlwSaBZqXlKmv8B "R – Try It Online")
A port of Arnauld's JavaScript answer; returns 1 for weak words and `integer(0)` for strong ones; it appends a  (space) to the end of the string.
This is actually vectorized; with a vector of strings, it returns the indices (1-based) of the weak words.
[Answer]
# Dyalog APL, 20 bytes
```
⎕←∧/2∨/0,⍨⍞∊'aeiouy'
```
[Try it online!](https://tio.run/##ATwAw/9hcGwtZHlhbG9nLWNsYXNzaWP//@KOleKGkOKIpy8y4oioLzAs4o2o4o2e4oiKJ2FlaW91eSf//2hhdGU)
[Answer]
# [Haskell](https://www.haskell.org/), ~~61~~ 54 bytes
```
f=and.(zipWith(||)=<<tail).(map(`elem`"aeiouy")).(++"z")
```
[Try it online!](https://tio.run/##JYpBDoMgEEXX7SnIrCA2nkCP0HUXTRMndSxEYAiCica7U2w3/7//8jUuM1lbytSjH1u5m/AwScvjUH3XJTRWtdJhkANZcgMgGc4bqGqbBnZQxaHxohcjXy/1dxcyRONTOynxBI2J4AaW17MCh2wxmv0c@MaR3FZp41zTcV7@nqOv7XM6l66xpMj@U2FC@/sEjDgTJXiVLw "Haskell – Try It Online")
I had to add a `z` at the end of the string to handle the case of a trailing consonant. 
[Answer]
# [Husk](https://github.com/barbuz/Husk), 12 bytes
```
ΛΣX_2m€¨γaıu
```
[Try it online!](https://tio.run/##ASMA3P9odXNr///Om86jWF8ybeKCrMKozrNhxLF1////ImFnYXRlIg "Husk – Try It Online")
Thanks to [H.PWiz](https://codegolf.stackexchange.com/users/71256/) for help with -4. ~~Returns inconsistent but appropriately truthy or falsy values.~~  
Thanks to [Leo](https://codegolf.stackexchange.com/users/62393/leo) for -1, now returns consistent truthy/falsy value.
[Answer]
# [Java (OpenJDK 8)](http://openjdk.java.net/), ~~93~~ 81 bytes
```
s->{int w=0,p=w,l;for(char c:s)w|=p&(p=l="aeiouy".indexOf(c)>>31);return w+p>=0;}
```
[Try it online!](https://tio.run/##LY6xTsMwFEX3fIWVAdmQWkVspI4ESGyIoWPV4eE4xaljW/ZzQ1Ty7cFBvePVubqnhwtsnFe2b8@LHrwLSPrc8YTa8C5ZidpZfl8XhTQQI/kAbcm1IDkRAbUk7zdoJ78hHI7Vq3NGgW1IJ5a4aa7aIhnFtvJirEzduUBXkMjnyMZf4e@oF0aUoLRLU8m1bdXPZ0cla5qnR1YHhSlYMj74Rmzrecki67dPXyZ/3xQuTrdkyGZ0j0Hb0@FIIJwiu4mu2U8R1cBdQu4zgsbSjoP3ZqKlhwBnpbDk6N6y20sIMFHGWP0/n4t5@QM "Java (OpenJDK 8) – Try It Online")
[Answer]
# [Ruby](https://www.ruby-lang.org/), 25 bytes
```
->w{w+?t!~/[^aeiouy]{2}/}
```
[Try it online!](https://tio.run/##LYpBDoIwFESvUklIF4JEE5fiQZqafLUIEfhN2y9UwKvXFN3MvJcZQ1cfqlPIy2Eatme3@RTiAqpB8nI6LMUSBK/BKZ4x3uJrbY2aWjDNezW4wV11PqJHitUh2f@Epo/Qk1u9jmmdwf4RqYL2d9Rg4KmU43LXgZ7mcdbkLEvS/dGyvGSpTVIxZpUYpVzCFw "Ruby – Try It Online")
Everybody else is doing it, so why can't Ruby?
[Answer]
# [Pyth](https://pyth.readthedocs.io), 18 bytes
```
:+Q1."2}M>åYà
```
**[Verify all the test cases.](https://pyth.herokuapp.com/?code=%3A%2BQ1.%222%7D%04M%C2%83%3E%C2%85%C3%A5Y%13%C3%A0%C2%9B&test_suite=1&test_suite_input=%22hate%22%0A%22love%22%0A%22popularize%22%0A%22academy%22%0A%22you%22%0A%22mouse%22%0A%22acorn%22%0A%22nut%22%0A%22ah%22%0A%22strong%22%0A%22false%22%0A%22parakeet%22&debug=0)**
"Borrowed" the regex from [the JS answer](https://codegolf.stackexchange.com/a/142279/59487). This returns `False` for strong words, `True` otherwise
[Answer]
# [Brachylog](https://github.com/JCumin/Brachylog), ~~18~~ ~~11~~ 10 bytes
```
,Ḷs₂{¬∈Ẉ}ᵐ
```
[Try it online!](https://tio.run/##LY07DsIwEESvsnJB5YrrIIpN4nyE4438iRQ@TQoUOg5CQQNCKbmJc5EQmzQ7b2Z2tYnGtOwkFdv5NF2fU99vOIOMhAFFFkQrFMgqtxwSTcyPt/NSVwaM1aSKEFz86z5z/3mb5fj0fUzD4MchpvMOWIlWMA5MUhu1ocZJ1NUxOkwxE3UXsCMXpCZn1oq0CqCcjb4Mc/27UI7yv9igxoMQlsH@Bw "Brachylog – Try It Online")
Neat and simple (except maybe for the 2 extra initial bytes to handle the final consonant case, like "parakeet"). 
Is falsey for strong words and truthy for non-strong words. 
```
,Ḷ               % append a newline (non-vowel) at the end of input, 
                 %   to catch final consonants
     s₂          % the result has some substring of length 2
       {¬∈Ẉ}ᵐ    % where neither of its elements belong to  
                 %   the set of alternate vowels (with "y")
```
[Answer]
# Perl 5, 31 bytes (30 + 1)
```
$_=''if/[^aeiouy](?![aeiouy])/
```
+1 byte for `-p` command line flag. Prints the word if it's a strong word, or the empty string if it is not.
[Answer]
# [Jelly](https://github.com/DennisMitchell/jelly), 11 bytes
```
e€ØY;1a2\¬Ȧ
```
[Try it online!](https://tio.run/##y0rNyan8/z/1UdOawzMirQ0TjWIOrTmx7P///4nJ@UV5AA "Jelly – Try It Online")
```
e€ØY;1a2\¬Ȧ  Main link
 €           For each letter
e            Is it an element of
  ØY         The consonants (excluding Yy)?
    ;1       Append 1 (true) (consonant) to make sure last letter isn't consonant
       2\    For all (overlapping) slices of length 2 (the <link><nilad>\ functionality)
      a      Logical AND of the two values; is it a consonant pair?
         ¬   Logical NOT vectorizing; for each (overlapping) pair, is it not a consonant pair?
          Ȧ  Any and all; make sure all pairs are not consonant pairs
```
Yes I know I've been beaten a lot by Jonathan Allan but I wanted to share my approach anyway :P
-4 bytes by stealing a little bit of Jonathan Allan's answer (instead of appending a consonant to check for last-letter edge case, just append 1)  
-1 byte thanks to miles
[Answer]
# Awk, 39 bytes
```
/([^aeiouy]{2}|[^aeiouy]$)/{print "n"}
```
prints `n` for non-strongword, nothing (or, just a newline) for strongword
following the pack and searching for two consecutive non-vowels on lowercase input
testing
```
$ awk -f strongwork.awk
hate
love
popularize
academy
you
mouse
acorn
n
nut
n
ah
n
strong
n
false
n
parakeet
n
```
[Answer]
# [Kotlin](https://kotlinlang.org), 49 bytes
```
{Regex(".*[^aeiouy]([^aeiouy].*|$)").matches(it)}
```
**True and false are swapped**
## Beautified
```
{
    Regex(".*[^aeiouy]([^aeiouy].*|$)").matches(it)
}
```
## Test
```
var s:(String)->Boolean =
{Regex(".*[^aeiouy]([^aeiouy].*|$)").matches(it)}
data class TestData(val input: String, val output: Boolean)
fun main(args: Array<String>) {
    val items = listOf(
            TestData("hate", true),
            TestData("love", true),
            TestData("popularize", true),
            TestData("academy", true),
            TestData("you", true),
            TestData("mouse", true),
            TestData("acorn", false),
            TestData("nut", false),
            TestData("ah", false),
            TestData("strong", false),
            TestData("false", false),
            TestData("parakeet", false)
    )
    items
            .filter { s(it.input) == it.output }
            .forEach { throw AssertionError(it.toString()) }
    println("Test Passed")
}
```
[TryItOnline](https://tio.run/##jZLBTsMwDIbvfQqr4pBMow8w0UlD7AwCbggka0vbaGlSOc6gjD17SVsYAmkqviR2vt@2lH/n2Gjb7ZHAL8QDk7alvFxeO2cUWsi7w70q1ZtIs9nTCyrtQvssTrds9nEhU5nVyJtKeaFZHrstMsLGoPfwqDzfxFTs0YC2TeAFjDPm0Jdc4KH2NU4mSREs1KitQCr9AlZE2F6NkqWEQwIxhmasag85GO35thBD/TtOU9MKWaVzYApKzs8wxu0nmcY1wSDp90kSN7hVdTuFtS5MIbUL/h/jHNkIFWj8ecoGnmSwmkQ8k7PlJDa8TlINEu6U@lls4KID@mP43V/CrNCGFcEBepdlg5ck5HlEs9FFcPwjcLTGTRUVXJF7hZX3ilg7uyZy1DdhNxpLSBnFg7qJORsr0n5RuIseVttUJsfuEw)
Based on [@Arnauld's](https://codegolf.stackexchange.com/users/58563/arnauld) [Answer](https://codegolf.stackexchange.com/questions/142278/is-it-a-strong-word/142279#142279)
[Answer]
# [Retina](https://github.com/m-ender/retina), ~~23~~ 18 bytes
```
$
$
1`[^aeiouy]{2}
```
[Try it online!](https://tio.run/##HclBCsIwEAXQ/T9HhW71Eh5ClH50akPTTJjOCEE8exS375l4KuyH8Tz1AQOO0@VGSRrt@j59el/ogqwvQdUamZZ2Ae98yNbQNLBp/EWtoISDC3Y3LU/MzL@pNK4i/gU "Retina – Try It Online") Outputs 0 for strong, 1 if not. Add 1 byte to support mixed case. Edit: Saved 5 bytes thanks to @ovs.
[Answer]
# Java 8, ~~53~~ 42 bytes
```
s->s.matches(".*[^aeiouy]([^aeiouy].*|$)")
```
-11 bytes by using the same regex as in [*@jrtapsell*'s Kotlin answer](https://codegolf.stackexchange.com/a/142332/52210) instead.
[Try it here.](https://tio.run/##jZDBbsIwDIbvPIVV7dAgkReotjcYF44IJBMMDaRxlTiVuq3P3oXBdtsyKZYS/Z/9//EFB1xxT/5yvM7GYYzwita/LwCsFwonNATr2xPgwOwIPZh6I8H6M0TVZGHKlU8UFGtgDR6eYY6rl6g7FNNSrCu93O6RLKdxV//c9PLjSVVqbu79fTq43P8YM7A9QpeTPLy2O0B1j7EZo1CnOYnusyTO116bumpRqFJfkX6HHA9lqOc@OQz2rYyiwSN1Y5EbORWZjlP801E1N6GQh4MvOvkk5Z@1RSRKYH8uYid08R9Lx4BXou9g02KaPwE) (`false` if strong; `true` if not)
**Explanation:**
```
s->               // Method with String parameter and boolean return-type
  s.matches(      //  Checks if the String matches the following regex:
    ".*           //   One or more characters
     [^aeiouy]    //   Followed by a consonant
     ([^aeiouy].* //   Followed by another consonant (+ any more characters)
      |$)")       //   Or the end of the String
                  // End of method (implicit / single-line return statement)
```
So it basically checks if we can find two adjacent consonants, or if the String ends with a consonant.
---
Old answer (**53 bytes**):
```
s->s.matches("[aeiouy]*([a-z&&[^aeiouy]][aeiouy]+)*")
```
[Try it here.](https://tio.run/##jZBBboMwEEX3OcWIRYQTwQVQe4NmkyWi0sQ4wYnxII@NRCrOTp2GLFtX8izs//T/91xxxIIGZa/tbZEGmeEDtf3aAGjrlTujVHB4XAFOREahBZkfvdP2AiyqKMxx4mGPXks4gIU3WLh457JHLzvFeVaj0hSmZpfXWNy32/pzfWheyl7sMrFUT6shnEy0Wh1H0i30sdQaWzeA4tnoOLFXfUnBl0OUvLG5LWWedehVJn7a/Q4ZGtPQQEMw6PQ9jaLEVvVTkpsoJJmeAv@ZKKqHkOhDziaTbPDpn3VJhL0je0liZzT8j6Wjw5tSr2LzZl6@AQ) (`true` if strong; `false` if not)
Uses regex to see if the input-String matches the 'strong'-regex. Note that `String#matches` in Java automatically adds `^...$` to check if the String entirely matches the given regex.
**Explanation":**
```
 s->                   // Method with String parameter and boolean return-type
  s.matches(           //  Checks if the String matches the following regex:
    "[aeiouy]*         //   0 or more vowels
    ([a-z&&[^aeiouy]]  //     { A consonant,
     [aeiouy]+)        //       plus one or more vowels }
    *")                //    Repeated 0 or more times
                       // End of method (implicit / single-line return statement)
```
---
A search instead of matches (like a lot of other answers use) is actually longer in Java:  
**70 bytes**:
```
s->java.util.regex.Pattern.compile("[^aeiouy]{2}").matcher(s+0).find()
```
[Try it here.](https://tio.run/##jZBBasMwEEX3OcXglUWJKN2a9gYNhSxDChN54iiRNUYahbrBZ3eVJl22KkgLMY//3@iIZ1zyQP7YnmbjMEZ4ResvCwDrhcIeDcHq@gTYMTtCD6ZeS7C@g6iaPJjyzScKijWwAg/PMMflyzFH6yTW6UAdfeg3lBzoteF@sI7qavOOZDmN28vTVCndo5gDhTo@PCq9t76t1dzcsoe0czn7XnFm20KfLe8emy2guimuxyjUa06ihzwS5@tcWFcHFKrUt@7vkONzGRp4SA6D/SyjaLClfixyI6ci03OKfzaq5joo@HDwxSafpLzZoYhECey7IrZHF//x6RjwRPQjNi2m@Qs) (`false` if strong; `true` if not)
[Answer]
# [Python 2](https://docs.python.org/2/), 58 bytes
*-30 bytes by realizing it can be as simple as [Arnauld's JS answer](https://codegolf.stackexchange.com/a/142279/68615).*
```
lambda s:re.search('[^aeiouy]([^aeiouy]|$)',s)<1
import re
```
[Try it online!](https://tio.run/##PY7BCsIwEETv/Yo9CGlBBD0W@yW1wtpubbDNhs1GqPjvkVTxMvOGmcP4VSd2pzQ2lzTjchsQQi10CITST6Vpr0iW49qVf3rvKrMP1flY2MWzKAglpaABGmjNhEpmD2bm5@aefZxR7GtL2ONAy5px5Zht4Rh@FYvL4KJuecoaVNjdM404f4ceBR9EarqiGFnAgnWwHajBi3UKY2mr9AE "Python 2 – Try It Online")
[Answer]
# [SOGL V0.12](https://github.com/dzaima/SOGL), ~~19~~ 18 [bytes](https://github.com/dzaima/SOGL/blob/master/chartable.md)
```
æ"[^ŗy]”ŗ(ŗ|$)”øβ=
```
[Try it Here!](https://dzaima.github.io/SOGLOnline/?code=JUU2JTIyJTVCJTVFJXUwMTU3eSU1RCV1MjAxRCV1MDM5ODFnJTI1JXUwMTdFSiV1MjAxOCVGOCV1MDNCMiUzRA__,inputs=cG9wdWxhcml6ZQ__)
Explanation:
```
æ                   push "aeiou"
 "[^ŗy]”            push "[^ŗy]" with ŗ replaced with pop
        ŗ(ŗ|$)”     push `ŗ(ŗ|$)` with ŗ replaced with pop
               øβ   replace in the input that regex with nothing
                 =  check for equality with the original input
```
[Answer]
# [05AB1E](https://github.com/Adriandmen/05AB1E), 11 bytes
```
žP¹SåJ1«11å
```
[Try it online!](https://tio.run/##MzBNTDJM/f//6L6AQzuDDy/1Mjy02tDw8NL//xPTE0tSAQ "05AB1E – Try It Online")
Uses Jonathan's algorithm, returns `0` for true and `1` for false.
[Answer]
# [Swift 3.1](https://www.swift.org), 85 bytes
```
import Foundation
{($0+"0").range(of:"[^aeiouy]{2}",options:.regularExpression)==nil}
```
**[Try it here!](http://swift.sandbox.bluemix.net/#/repl/59b513d36bb1b17773ce606b)**
This borrows [Arnauld's regex](https://codegolf.stackexchange.com/a/142279/59487).
[Answer]
# Lua, 41 bytes
```
return#(io.read()..0):match"[^aeiouy]+"<2
```
Reads from standard input
# Lua (loadstring'ed), 37 bytes
```
return#((...)..0):match"[^aeiouy]+"<2
```
Reads from function parameter(s)
---
Input is lowercase
Sees if there is a string of length 2 or more, consisting only of not vowels (consonants) or if the string ends with a non-vowel
Returns true/false
[Answer]
## C++, ~~195~~ 194 bytes
-1 bytes thanks to Zacharý
Uppercase, return true if input is a strong word, false otherwise ( C++ have simple int to bool implicit cast rules, 0 => false, true otherwise )
```
#include<string>
#define C(p)(v.find(e[p])==size_t(-1))
std::string v="AEIOUY";int s(std::string e){for(int i=0;i<e.size()-1;++i)if(e[i]>64&&e[i]<91&&C(i)&&C(i+1))return 0;return!C(e.size()-1);}
```
**Code to test :**
```
auto t = {
    "HATE",
    "LOVE",
    "POPULARIZE",
    "ACADEMY",
    "YOU",
    "MOUSE",
    "ACORN",
    "NUT",
    "AH",
    "STRONG",
    "FALSE",
    "PARAKEET"
};
for (auto&a : t) {
    std::cout << (s(a) ? "true" : "false") << '\n';
}
```
[Answer]
# C, 107 Bytes
```
i,v,w,r,t;a(char*s){w=0;for(r=1;*s;s++){v=1;for(i=6;v&&i;)v=*s^" aeiouy"[i--];r=w&&v?0:r;w=v;}return r&~v;}
```
Returns 1 for *strong* word and 0 for *weak* word. Tested with the words given in the main post.
[Answer]
# [C (gcc)](https://gcc.gnu.org/), 59 bytes
```
f(char*s){return*s?strcspn(s,"aeiouy")+!s[1]<2?f(s+1):0:1;}
```
[Try it online!](https://tio.run/##PVDBbsMgDD3DVzCmSpBkU7Nj060/UO22U5cDIqRBSyDCMCmr8u0ZKdlOfrafn58tn65SLkvLZCdcBvzmlA/OZHAC7ySMhkFBhdI2TJTnD3Ap6@PLqWWQl/ywP5TVvDxqI/vQKHIE32j73L1hbTwZhDaMkxtG0hrwZF1AsoThUpPXtYVoJ7yixYp6@72h0Y6hF07/bLmQolHDlJLJhgQGG@CfYJ1J0AS/1Tq6hniGNddUakX/NzEKJ76UStz3j/MZo7nCqLWOsNW9jv72VTSq64roPL8fgkYXey2ju3IPZNd8xp13SkHiR2LkPGrMGKUnRgE8L78 "C (gcc) – Try It Online")
[Answer]
# **PHP, 69 bytes**
```
preg_match("/([^AEIOUY][^AEIOUY]+|[^AEIOUY]$)/",$_SERVER['argv'][1]);
```
Returns **1** is the word is not strong.
[Answer]
# [CJam](https://sourceforge.net/p/cjam), 57 bytes
```
q{"aeiouy"#W=}%_,:B{_A={_A_)\B(<{=!X&:X;}{0:X;;;}?}&}fA;X
```
[Try it online!](https://tio.run/##S85KzP3/v7BaKTE1M7@0Ukk53LZWNV7Hyqk63tEWiOM1Y5w0bKptFSPUrCKsa6sNgKS1da19rVptmqN1xP//ufmlxakA "CJam – Try It Online")
---
Reads input, converts to 1s for consonants, 0s for vowels. For every consonant, AND predefined variable X (predefined to 1) with next character's value. Output X
[Answer]
# [Zsh](https://www.zsh.org/), 21 bytes
```
>$1x<*[^aeiouy](#c2)*
```
[Attempt This Online!](https://ato.pxeger.com/run?1=JckxCsIwFIDhvad4YIe24FAnh6AHEYVn-9IW07yQvEjrVVwC4uTsYbyNYqcfvv_-uIU-fXQgYSdAk5Btqe0MnzPNHmooehQCw1cCxy4a9EMgwAZbGmeYOcLI8S_sLdgogD0E8Ww70Gh-x6HHC5GUxTOKXm_fu7yeVHU4IQ0c52OxajZltbyXUirfZ36EqlwkpaVf)
Same method everyone else is using. Outputs via exit code: 1 for strong, 0 for not strong. Requires the `extendedglob` option.
]