[Question]
  [
Inspired by [Is it double speak?](https://codegolf.stackexchange.com/questions/189358/is-it-double-speak/), I devised a harder challenge. Given a string, determine if the string is *n-speak*, for any \$n\geq 2\$.
N-speak is defined by repeating each letter \$n\$ times. With \$n = 4\$, the string `Hello` is transformed to `HHHHeeeelllllllloooo`. Your goal is to figure out if the input is a valid output for any n-speak transformation.
It should be noted that any sentence which is valid n-speak, for \$n = 2k\$, is also valid k-speak. Thus, the hard parts to solve will be odd values of \$n\$.
## Input
A string consisting of at least 2 characters. Input could also be a list of characters. Input is case sensitive.
## Output
`Truthy` if the string is n-speak, `falsey` otherwise.
## Examples
### True cases
```
HHeelllloo,,  wwoorrlldd!!
TTTrrriiipppllleee   ssspppeeeaaakkk
QQQQuuuuaaaaddddrrrruuuupppplllleeee    ssssppppeeeeaaaakkkk
7777777-------ssssssspppppppeeeeeeeaaaaaaakkkkkkk
999999999
aaaabb
aaaaaaaabbbbcc
aaaaabbbbb
@@@
```
If you want to generate additional truthy cases, you can use [this MathGolf script](https://tio.run/##y00syUjPz0n7/18pPL9coSQjs1gBiBIVcvLz0hWKU/NKUvOSU5VyDy/L1jjcEv//v5EBAA). Place the string within the quotation marks, and the value of \$n\$ as the input. 
### False cases
```
Hello, world!
TTTrrriiipppllleee   speak
aaaaaaaaaaaaaaaab
Ddoouubbllee  ssppeeaakk
aabbab
aaaabbb
a (does not need to be handled)
(empty string, does not need to be handled)
```
Of course, since this is code golf, get ready to trim some bytes!
  
[Answer]
# [APL (Dyalog Unicode)](https://www.dyalog.com/), 12 bytes
Runs with `⎕io←0`
```
1≠∨/⍸2≠/∊0⍞0
```
[Try it online!](https://tio.run/##dY@9TsMwEID3PIU7ZUnVwIJgRqgrUl7gHF9RZEtn2YqivgBNkYpYWBEjj8Dz@EXCnY4iGPim@/vsO4hh7fYQ6GEpz68DlceXtirzYbdclON7mT825fR5yeGmzE9tOb21C3eXuksjmh4y5pu62lXbLWJgiJrGmGkiSikE51YrbnZdl1IahiHGyDOIaIzJOXPKMQB473nsnhkZLoBj2EmSR9XEE1FMUcUVWWzRr5S1kpWooAKKV9i5PsOxdKz9DjSxtu/PBclsVd9ByH8O57OpMROl4P6/NSL4Xy///MC1W0c0jtbKrNwmy8qKMv4F "APL (Dyalog Unicode) – Try It Online")
Golfed together with [Adám](https://codegolf.stackexchange.com/users/43319/ad%c3%a1m).
On the input (example: `"aaccccaaaaaabb"`, using `""` to denote a string (an array of chars) and `''` to denote a char)
`∊0⍞0` surround with 0s and flatten, `0 'a' 'a' 'c' 'c' 'c' 'c' 'a' 'a' 'a' 'a' 'a' 'a' 'b' 'b' 0`
`2≠/` perform pairwise not-equal, `1 0 1 0 0 0 1 0 0 0 0 0 1 0 1`
`⍸` get the 0-indexed indices, `0 2 6 12 14`
`∨/` compute the GCD, `2`
`1≠` is this not equal to 1?
[Answer]
# Java 10, 85 bytes
```
s->{var r=0>1;for(int i=0;++i<s.length();)r|=s.matches("((.)\\2{"+i+"})*");return r;}
```
Regex ported from [*@Arnauld*'s JavaScript answer](https://codegolf.stackexchange.com/a/189782/52210).
[Try it online.](https://tio.run/##jVJNT@MwEL33Vww@JaQNH5fVEsppteICEqI32MMkMdTEtS3baVWV/vYyjtNqU3rgHazMPM@b8ct84BInH3WzqyQ6Bw8o1GYEIJTn9g0rDo8hBCi1lhwVVMmzt0K9g0sLIrYjOpxHLyp4BAVT2LnJ3WaJFuz08u6qeNM2ITEQ08siy8StyyVX736epEVqP6cuX6Cv5twlLEny9PX1esMykbFtes7SwnLfWgW22O6K0Mi0paRGfb@lFjUsaOB@pJd/gGmc9uICZrb183UXee58wu7vOZcErcdjgNVKa2ulrOuzM9Y9ZX9vNptZa4UQxhi6zjknyjlHIX0jYtM0w4onQksgDmsCldsQm6gQJIJGEAkqQSboBKEjpV8RkwgXYSJ4BEY0EcPy33sM0@F@WX7PxXxZVtUJLhCHmue183yR69bnhqz2UtH/G@2t/ovS8fXN/16T03oMK21l/SN7Dcfm9ICHQYf0n1rrti3LoBCcDf4EV45EhiH7trPdDnVkv9ZCmdb3W3Ti1R2dsRtgmcqrGKa96nb3BQ)
**Explanation:**
```
s->{                          // Method with String parameter and boolean return-type
  var r=0>1;                  //  Result-boolean, starting at false
  for(int i=0;++i<s.length();)//  Loop `i` in the range [1, input-length):
    r|=                       //   Change the result to true if:
      s.matches("((.)\\2{"+i+"})*");
                              //    The input-String matches this regex
                              // NOTE: String#matches implicitly adds a leading ^ and 
                              //       trailing $ to match the full String
  return r;}                  // After the loop, return the result-boolean
```
*Regex explanation:*
```
^((.)\2{i})*$                 // Full regex to match, where `i` is the loop-integer
^           $                 // If the full String matches:
  (.)                         //  A character
     \2{i}                    //  Appended with that same character `i` amount of times
 (        )*                  //  And that repeated zero or more times for the entire string
```
[Answer]
# [Jelly](https://github.com/DennisMitchell/jelly), 5 bytes
```
Œɠg/’
```
[Try it online!](https://tio.run/##y0rNyan8///opJML0vUfNcz8//9/SEhIUVFRZmZmQUFBTk5OamqqgoJCcUFqYjYA "Jelly – Try It Online")
[Answer]
# [05AB1E](https://github.com/Adriandmen/05AB1E), 5 bytes
```
γ€g¿≠
```
[Try it online!](https://tio.run/##yy9OTMpM/f//3OZHTWvSD@1/1Lng//@QkJCioqLMzMyCgoKcnJzU1FQFBYXigtTEbAA "05AB1E – Try It Online")
[Answer]
# JavaScript (ES6), 53 bytes
Derived from the regular expression used by @wastl in [*Is it double speak?*](https://codegolf.stackexchange.com/a/189379/58563).
```
s=>[...s].some((_,n)=>s.match(`^((.)\\2{${++n}})*$`))
```
[Try it online!](https://tio.run/##jZFBT8MgFMfvfgqWLCm4joMX46E7GbOrSW/tdFCY1rI@Aqs9LPvslSfRaGSLvxPwf@8XeLyJd@Eb19rDsgelp10x@WJVcc79hnvYa0qf854VK8/34tC80u0TpZzV9c1xflws@tOJXc@3jE0N9B6M5gZeaFaVbtCbjF39PN3RbL3W2gQA8pyQcQRwzhilZrOM/Skuy9I517attTb0aK0JId77sA1rIUTXdYm2x8AQCAVCBYLD4d5GDXpQhCZUoQtlaEvpbiPLiI/YiI6ISBdJOO6@SGTYKeWZIIZSNs25Akw/u3@lWd1XD8L45B@EH4CcjOCM@v/YrRbdhUt@XzZRc68AhkFKdOHYcW44rZQudSZFfOL0AQ "JavaScript (Node.js) – Try It Online")
---
# Recursive version, 55 bytes
```
s=>(g=n=>s[++n]&&!!s.match(`^((.)\\2{${n}})*$`)|g(n))``
```
[Try it online!](https://tio.run/##jZFBT8MgFMfvfgqaLCu4rgcvxkN3MmZXk97amUJhtRaBwGoPc5@98iQazZjxdwL@7/0Cjxf6Rl1re3NYK83FvC9mV2xwV6hi46rVSu2WyyRx@Ss9tM@4ecI4J3V9c1wc1elErhcNee@wIqRp5lYrp6XIpe5wWpV2FLuUXP083eN0uxVCerTOMoSmSWtrpeQ8SVJyVlyWpbW273tjjO8RQiCEnHN@69eU0mEYIm2PntHjCyj3eIeFvQka8IAITKACF8jAFtPdBtYBFzABEaCBIRBx3H0RyaCTsQtBCBlr20sFkH52/0rTWlUPVLroH/gf0BmatJX8/2M3gg5/XPL7spGae671ODIGLhg7zA2mFdPFzhgNT5w/AA "JavaScript (Node.js) – Try It Online")
### Commented
```
s => (                    // s = input string
  g = n =>                // g is a recursive function taking a repetition length n
    s[++n] &&             // increment n; abort if s[n] is not defined
    !!s.match(            // otherwise, test whether s consists of groups of:
      `^((.)\\2{${n}})*$` //   some character, followed by n copies of the same character
    )                     //
    | g(n)                // or whether it works for some greater n
)``                       // initial call to g with n = [''] (zero-ish)
```
[Answer]
# [Python 2](https://docs.python.org/2/), ~~73~~ ~~70~~ ~~69~~ 67 bytes
```
lambda s:s in[''.join(c*n for c in s[::n])for n in range(2,len(s))]
```
[Try it online!](https://tio.run/##jZAxT8MwEIX3/oqrOiRBgaELolI3hLoiZSsd7NihJsZnnRNF/fXhThaQAgPf5Hv37tm@eBnOGLZzt3@ZvXrXRkHaJXDhWBR3b@hC2d4E6JCgZRHScbcLp0rqIDWp8GrLbe1tKFNVneZNQ@NwvqwiuTBAVxaHg7WeQaxrgGlCJPLemPW6qL5dTdMQkXMuxshmay0ApJS45LNSqu/7pf@ZGRnuKMPwMEkd87wESIJESIaESIrEXOXcZ24zKRMzNqMyfWY5/PDJUhSv1j@VrGrdtr86Ios/y6vNk/LJLhfI68MaJiRv/rGzaFX/1@1fr1g2Hw3iOGot07Is@bR89SqgqOYP "Python 2 – Try It Online")
-4 bytes, thanks to Jitse
[Answer]
# [QuadS](https://github.com/abrudz/QuadRS), 16 [bytes](https://codegolf.meta.stackexchange.com/a/9429/43319 "When can APL characters be counted as 1 byte each?")[SBCS](https://github.com/abrudz/SBCS ".dyalog files using a single byte character set")
```
1≠∨/⍵
(.)\1*
⊃⍵L
```
[Try it online!](https://tio.run/##KyxNTCn@/9/wUeeCRx0r9B/1buXS0NOMMdTietTVDOT5/P@fmJgMBIlgkJQEAA "QuadS – Try It Online")
`1≠` is 1 different from
`∨/` the GCD
`⍵` of the result of
`(.)\1*` PCRE Searching for any character followed by 0 or more repetitions thereof
`⊃⍵L` and returning the first of the match lengths (i.e. the length of the match)
[Answer]
# [Stax](https://github.com/tomtheisen/stax), 5 [bytes](https://github.com/tomtheisen/stax/blob/master/docs/packed.md#packed-stax)
```
╢b}▄;
```
[Run and debug it](https://staxlang.xyz/#p=b6627ddc3b&i=%22HHeelllloo,,++wwoorrlldd%21%21%22%0A%22TTTrrriiipppllleee+++ssspppeeeaaakkk%22%0A%22QQQQuuuuaaaaddddrrrruuuupppplllleeee++++ssssppppeeeeaaaakkkk%22%0A%227777777-------ssssssspppppppeeeeeeeaaaaaaakkkkkkk%22%0A%22999999999%22%0A%22aaaabb%22%0A%22aaaaaaaabbbbcc%22%0A%22aaaaabbbbb%22%0A%22Hello,+world%21%22%0A%22TTTrrriiipppllleee+++speak%22%0A%22aaaaaaaaaaaaaaaab%22%0A%22Ddoouubbllee++ssppeeaakk%22%0A%22a%22&a=1&m=2)
Procedure:
* Calculate run-lengths.
* GCD of array
* Is > 1?
[Answer]
# T-SQL 2008 query, 193 bytes
```
DECLARE @ varchar(max)='bbbbbbccc';
WITH C as(SELECT number+2n,@ t
FROM spt_values
WHERE'P'=type
UNION ALL 
SELECT n,stuff(t,1,n,'')FROM C
WHERE left(t,n)collate Thai_Bin=replicate(left(t,1),n))SELECT 1+1/~count(*)FROM C
WHERE''=t
```
**[Try it online](https://rextester.com/NST24626)**
[Answer]
# [Python 3](https://docs.python.org/3/), 69 bytes
```
lambda s:any(s=="".join(i*k for i in s[::k])for k in range(2,len(s)))
```
[Try it online!](https://tio.run/##dZCxTsMwEIb3e4prJweFDjAgImVj6IqUrXSw6ys1NrZlOwp9@uDDwIDEN0T35/cXnROv5RL8/VrGwxGWi3GEU5ppACzpWp9YdjJG8loYH@ciug6QPk4UC5cqkbRwHl9WJ9@VlpgH6a8ij@N2u3sLxgtzY/EcEho0HvNhGOyx42w5J@lfSdz1jrzIXdet3GRuvr4ek/FFnLla93siVwmh7xGXJYSUnNN6s4FpmlJKxpgYYz1BRIiYc66xzlJKay08V@ZKjVJXqpE4xyaxxRp7LLLJKrsWHhq3jdyIDWrIhm3A4w/Ab5WC776OSp1O8Dsr2Nd7hR6XkJz@7zKRf7P8g4InHcI8K8XneHXehncA@Qk "Python 3 – Try It Online")
[Answer]
# [PHP](https://php.net/), ~~76~~ 75 bytes
```
while(($x=strspn($argn,$argn[$n+=$x],$n))>1&&($m=max($m,$x))%$x<1);echo!$x;
```
[Try it online!](https://tio.run/##fVHBTsMwDD0vX@FNYWtFp4kTQt3gMqFxQULsBjukq0ertkmUpKwI8e3DabYBF96h9Xv2sxNHF/owv9OFZow7tM7CAl7YYDYDZ1pXfLDBZLVCrAlKJQnAfq@UMXWd58PhJKH0er02xpRlqbWmKkQEAGstUYqFEFVV9YVPhJZAksgJ5DKe62D0Tm/1Xm/2bm/3/tDgOmAaYAN0AAaIgCqgd92c0DOfzbJzGGiWbbc/kud9BS1hJ2qLH2ffyZhlIoQr2oxKYK9Mnf@3Do2i@jP0PLxXl7lSbZtlvt4vwN/H34KSm5QxRiexZdPWwiHQW8H0Hp7Xy4dHKKVuHdspg2JbRHB8QmGBC/MmIYZPBoDbQgUhgdGrHKWHfVHWGEW8W1hnrJZRyPbfFy4vF7zbJFzG8e3VeBzxZtGIjn4J7@L4gnfzqzj1TYe8Sw/H/n1jGkZHNWjRAcr30ijZoHQkt5I0GhinP6T5TSSRr8M3 "PHP – Try It Online")
First attempt, a somewhat naïve iterative approach.
*Ungolfed:*
```
// get the length of the next span of the same char
while( $s = strspn( $argn, $argn[ $n ], $n ) ) {
    // if span is less than 2 chars long, input is not n-speak
    if ( $s < 2 ) {
        break;
    }
    // k is GCD
    $k = max( $k, $s );
    // if span length does not divide evenly into GCD, input is not n-speak
    if( ( $k % $s ) != 0 ) {
        break;
    }
    // increment current input string index
    $n += $s;
}
```
***-1 byte***, thx to @Night2!
[Answer]
# [Perl 6](https://github.com/nxadm/rakudo-pkg), ~~30~~ ~~27~~ 26 bytes
```
{1-[gcd] m:g/(.)$0*/>>.to}
```
[Try it online!](https://tio.run/##dY/BasMwDIbvegoVythKmnaXlQ7aXXbIdZDb6MGO1RLsTsZeCGXs2TMJb7ntO0m2PvErUgpP0/WGd2c8TF@P6/dL5054fb5s7uuH5Xa1OR7rT/6esrnhSy1TZ04Y@g/KU9MQBYG5qhDHkTmlEJxbLKBt25RS3/cxRpkgIkTMOUsrtTHGew9vwiBIa5wgRtI@Fkkt1dRTUU1V1fWwK6wLuRALVDAFX4D9H6Cv1sLvv5TWdh3MtYVG7uIKR07B/XdMJOPnFfMqeHXMw2Ctzml0TaMZwPwA "Perl 6 – Try It Online")
Also uses the GCD trick, but uses the index of the end position of each run matched by the regex. Returns a negative number (truthy) if n-speak, zero (falsey) otherwise.
[Answer]
# [Haskell](https://www.haskell.org/), 48 bytes
```
import Data.List
f=(>1).foldr(gcd.length)0.group
```
[Try it online!](https://tio.run/##fZCxboMwEEDn8BUXJpAoaqeqQyKGDAztUImtqqpzbIhlgy0bxOdTny5p06VvujvfO599wWiUtdumR@/CDCecsX7Vcc76Q3F8KuveWRmK4Sxrq6ZhvpSP9RDc4rcR9QQHGNG/fUHhg55mqKEvs90H5G2r0lRrnasqgHV1LgRrpdzv82xXQd51XQhBa@29T21KKQCIMaY0xYhojOHO98SSSDWUiaQFyj2bpJJLMtmkk08DrhOemQcmMp5RDDKGYe3lBqd0LsRvzLkQ5/NdjQrXnqZpOGjTR7gKVhes/Pf1XqH5O//nHi6fpHPLIgQZ9GBan5a@SUKguF@Wks9s@wY "Haskell – Try It Online")
Straightforward; uses the GCD trick.
[Answer]
# [Red](http://www.red-lang.org), 80 bytes
```
func[s][repeat n length? s[if parse/case s[any[copy t skip n t]][return on]]off]
```
[Try it online!](https://tio.run/##hZIxb4QwDIX3@xU@pqtE1bFqly4dbm3FhjIkxNwhuDhKghC/ntqNiqJT1X4Ttt97JIaAdvtE26pD/wpbP7uujaoN6FEncDChu6TrG8R26MHrEPGp0xG51m5tO/IrJIjj4FmblBjTHByQU4r6Xm0@DC5BD9X5jDgxRHUNsCxEIUyTtcdjddhFTdOEEIZh8N6zFhEBIMbIJT9rrcdxLOQfzMzwQFuGvUFqn@3ilwBJkAjJkBBJKWOeM4@ZmPEZzOjMmCm8Lz8UPVEac9fITWO67n4g3V1dfZ@hkJx5a1TDQmGy/6@Kv9r4y4v3AxSzd0s0z8aIV1Ykd5UblnY4WcIIjvhXQLSQCAzCVTs7oX0olCe8@bRCTNy41PCna/sC "Red – Try It Online")
## More idiomatic [Red](http://www.red-lang.org):
# [Red](http://www.red-lang.org), 81 bytes
```
func[s][any collect[repeat n length? s[keep parse/case s[any[copy t skip n t]]]]]
```
[Try it online!](https://tio.run/##hZG9T8MwEMX3/hXXTkUKYkSwsDB0BXWLOvjj2kZ2fZbtKMpfH@6wiKwKwW@K37334o@EdvlE258251dYzmMwfT71KsxgyHs0pU8YURUI4DFcyvUNcu8QI0SVMj4ZlZEVDvSG4gwFshsiu8tJWGIaQoEz7A4HRM8QdR3ANBGl5L212@1us5qOx2NKaRiGGCN7EREAcs685G@llHOusX8wI8MDZRnOJlnHGpe8FEiDVEiHlEhLW/NceazkSqxgRVVcpcm@/NBo4tT6Tqii1sbcD0Rd3bvvPTSWA98adTBR8vb/q@Kncr/8eN1AM3u3ROOotWTliuSscsI2DntLmCEQvz@ihUKgEa4qWI/2oXHu8RbLDLmwcOngz9TyBQ "Red – Try It Online")
[Answer]
# [Brachylog](https://github.com/JCumin/Brachylog), 5 bytes
```
ġz₂=Ṁ
```
[Try it online!](https://tio.run/##dY2xSgNBEIZfZbP1JYVNSKE2FtcK14nF7u2qxy3MMuuxxBAIJ4Sk8xWstLSx0NoXuX2Rc4ZNIAh@1cz8//y/RlU/LB3cn42rKMX0Qsh4uUrbj9Q/p92bfMTOzuQs7d7lnXKB5vXwvV8Pny/jz@tT6vvz4WszjjeyLK11BEBRCBEjAKJzxkwmspAlSVCICOgM71VVIWLTNN57@rHWCiFCCLTSrJRq2/Zfm7eKxWuiI8itDEFO5N1nM7vZzrGcy8GczNH8rv6g6TbPTDMh4zM2c3C3Gfq5MgBdpzUXchk7WSdpcYTrDpWae07qNVHXxwNvWt7@Ag "Brachylog – Try It Online")
Takes input through the input variable and outputs through success or failure.
At first I thought this would actually be *shorter* than [my solution to Is it double speak?](https://codegolf.stackexchange.com/a/189406/85334), but then I realized that `ġ` can and will try a group length of 1.
```
ġ        It is possible to split the input into chunks of similar length
 z₂      such that they have strictly equal length, and zipped together
    Ṁ    there are multiple results
   =     which are all equal.
```
[Answer]
# [Japt](https://github.com/ETHproductions/japt) [`-¡`](https://codegolf.meta.stackexchange.com/a/14339/), 8 bytes
```
ò¦ mÊrÕÉ
```
[Try it](https://petershaggynoble.github.io/Japt-Interpreter/?v=1.4.6&flags=LaE&code=8qYgbcpy1ck&input=IkhIZWVsbGxsb28sLCAgd3dvb3JybGxkZCEhIg)
```
ò¦ mÊrÕÉ     :Implicit input of string
ò            :Partition by
 ¦           :  Inequality
   m         :Map
    Ê        :  Length
     r       :Reduce by
      Õ      :  GCD
       É     :Subtract 1
             :Implicit output of boolean negation
```
[Answer]
# [Kotlin](https://kotlinlang.org), 78 bytes
```
{s->(2..s.length/2).any{i->s.chunked(i).all{z->z.length==i&&z.all{z[0]==it}}}}
```
[Try it online!](https://tio.run/##bZIxa8MwEIV3/4qrCcEG2y1ZSgv2UDpkK6XZSgc5lhNhVXIkOSEx/u3pXZRQ4uSbdPfu3sFDjXZSqGNrxJY5DlsmYfMafTkj1CpOizetJWcKcjj2Ni2iWZbZTHK1cuvHWZwxte9FWthsue5Uw6tIYE/K/pAWh/NYnovp9OC7308/WLoBubrouHUWbzBj2P6jjgJAnOk4OA3hfM65RLROEoDdTmtjpKyqh4cwuZ5cLBbGGCFE27a4wDlH1VqLJb4ZY03TjHc@kQ5BlVUIGhiqW@9BJuRCNuRDRuREVjdez57UYz2th3uYp/GMDV4ujAXaKct7Xa@U5XJ5VyWJ9k5SzaQ9Z4qJ6gR22sjqEuO/ej/HlrPmZpSNKG8m3iutu64syYdipCgogDCIg6DuFPwyoaIYer@nDUQOhPKf4tIm8McoJ1UUTvpN5DLLl1pV8QB5DpPeZbUw1g1hfJofgiE4/gE "Kotlin – Try It Online")
## Explanation
```
{s->                      Take a string as input
  (2..s.length/2)         The each string needs two parts at least, prevents the case "aaa" is 3-speak
    .any{i->              If there is any n (in this case i) that is n-speak return true
      s.chunked(i)        Split into length i substrings
      .all{z->            All substrings z
        z.length==i       Should be completely full, ie. "aaa"->["aa","a"]
        &&                And
        z.all{            All chars (it)
          z[0]==it        Should be the same as the first char
        }
      }
    }
  }
```
[Answer]
# [Scala](http://www.scala-lang.org/), 80 bytes
```
s=>"(.)\\1*".r.findAllIn(s).map(_.size).reduce((x,y)=>(BigInt(x) gcd y).toInt)>1
```
[Try it online!](https://tio.run/##jZBBS8MwFMfv@xRZT4nUwk6i0LIND9tR3HEgSfM6a2MTktRtip@95hEmmk3wd8p7L@@X8Hc1V3zU4gVqT2oCBw@9dGRhDPmYTN64Is3do7dtvyurpdYKeF@OrqwyWrDtdnaVFbZo2l4ulFr31LHilRv6VLj2HVhhQQ41UHrIj6ys6LLdrXtPD4zsakmOrPA61KyajSY84FVPM28H/3zM2OTUaWi2WgGogNZ5Tsh@r7W1Skk5nWbs18XNZmOtbdvWGBPuAwAhxDkXynDmnHddl6w8BIZAGHIZCPsWaxMV6EAJWlCDHhShKVXdRK4jLmIiEOGRLpLs355I@rghxIVmHAhR15eGOEm35vP5z07WcOUgTTtkrXOy11bJ/wVsgHd/fO/7m8n8Xmo9DEKgA8PFhDCXM40QXFzM46yb1Fh@juMX "Scala – Try It Online")
PS. Original solution was based on `split` function but it's longer (83 bytes).
```
s=>(s+s).split("(.)(?!\\1)").map(_.size+1).reduce((x,y)=>(BigInt(x) gcd y).toInt)>1
```
[Answer]
# [Wolfram Language (Mathematica)](https://www.wolfram.com/wolframscript/), 34 bytes
```
GCD@@Length/@Split@Characters@#>1&
```
[Try it online!](https://tio.run/##y00syUjNTSzJTE7876Zg@9/d2cXBwSc1L70kQ98huCAns8TBOSOxKDG5JLWo2EHZzlDtf0BRZl5JtLKCrp2CW7RybKyagr7DoQXVSh4eqak5QJCfr6OjoFBenp9fVJSTk5KiqKiko6DkAZTL11Eozy/KSVFUqv0PAA "Wolfram Language (Mathematica) – Try It Online")
[Answer]
# [Perl 5](https://www.perl.org/) `-p`, ~~83~~ ~~79~~ ~~76~~ 74 bytes
```
$_=s,(.)\1+,$t=length$&;$t/=2while$t%2-1;$r+=$t==($g||=$t);'',ge==$r&&/^$/
```
[Try it online!](https://tio.run/##dY@xasMwEEB3fYUDqhMTO04CoTRG0KGDh3YouFtokWzhCItISDJe8u1171DrrW/R3enecWel06d5pl/M55tddjlscxqYlrc@XGla0VCy43RVWtLwcCwOFXVbBg1sQ/v7HaKsWq/zXjJGXZqWn7Scq2fONllFW0Z7qLJ9Nde1lBowJs@TZJqMcU7rrlutSNM0zjmllLUWOqSUSZJ47yGFmHM@DAN5B0YAUt4BYDjMbZTQQg09FNFEFd2BPEaKiI/YiIzwyBAhT38QrApBfv8hFKJtyRILUsNdJk8m43T33zFW8mEZsYwiL50x4ygE9uHquA3u8G1sUObm5@LttNsf9vC@Kh/O54@gNONaz4XVPw "Perl 5 – Try It Online")
[Answer]
# [Brain-Flak](https://github.com/DJMcMayhem/Brain-Flak), 96 bytes
```
{<>({}())<>({}[({})]){{}<>({}<>){{(({})){({}[()])<>}{}}<>([{}()]({}<>)<>)}(<>)<>}{}}<>{}({}[()])
```
[Try it online!](https://tio.run/##LYtBCsAgDAS/4tEc/IH4Cm/iIQULohTRY8jb02gLCbub2VwT6@Pujk2EfLDEFuBo0oUMRHyiD2rtvgEdqswHJt447bf8tXTYHv2gor8uEmOcc9Zaxxi991KKMWatpVE9IrbWxOEL "Brain-Flak – Try It Online")
Uses the same GCD trick that many other submissions use. Output is 0 if the input is not n-speak, and a positive integer otherwise.
```
# For each character in the input
{
  # Add 1 to current run length
  <>({}())<>
  # If current and next characters differ:
  ({}[({})]){
    # Clean up unneeded difference
    {}<>
    # Move current run length to left stack, exposing current GCD on right stack
    ({}<>)
    # GCD routine: repeat until L=0
    {
      # Compute L mod R
      {(({})){({}[()])<>}{}}<>
      # Move R to left stack; finish computing L mod R and push to right stack
      ([{}()]({}<>)<>)
    }
    # Push 0 for new run length
    (<>)<>
  }{}
}
# Output GCD-1
<>{}({}[()])
```
[Answer]
# Oracle SQL, 182 bytes
```
select+1-sign(min(length(x)-(select sum(length(regexp_substr(x,'(.)\1{'||i||'}',1,level)))from t connect by level<length(x))))from(select x,level i from t connect by level<length(x))
```
It works with an assumption that input data is stored in a table t(x), e.g.
```
with t(x) as (select 'HHeelllloo,,  wwoorrlldd!!' from dual)
```
[Answer]
# [K (ngn/k)](https://gitlab.com/n9n/k), ~~29~~ 23 bytes
```
{~|/(&/s@&1<s)!s:#'=:x}
```
[Try it online!](https://tio.run/##y9bNS8/7/z/NqrquRl9DTb/YQc3QplhTsdhKWd3WqqL2f5pSSEhIUVFRZmZmQUFBTk5OamqqgoJCcXExkAtkJyYmZmdnK/0HAA "K (ngn/k) – Try It Online")
edit: removed some unnecessary colons (i know when a monadic is required but it's not always clear to me if there's ambiguity so i default to including the colon) and changed the mod `x-y*x%y` to ngn/k's `y!x`, which meant i could remove a variable assignment
[Answer]
# [APL (Dyalog Unicode)](https://www.dyalog.com/), ~~24~~ 22 [bytes](https://codegolf.meta.stackexchange.com/a/9429/43319 "When can APL characters be counted as 1 byte each?")[SBCS](https://github.com/abrudz/SBCS ".dyalog files using a single byte character set")
Anonymous tacit prefix function.
```
⊂∊1↓⍳∘≢{⍵/⍨(≢⍵)⍴⍺↑⍺}¨⊂
```
[Try it online!](https://tio.run/##fZDPSsNAEMbvPsX0lBZSpHgQvSrSnkSbF9jtTjVkzS67CaWIF4VSCymKCJ499eZBvXjso@yLxNksVnrpBwnzzXy//ce07Iopk@qqrt3i3s0XPTd7cdWnm7@5x/dbV/3su@qbvlWbPJUdV31R182ee3frFTH12M2eXLV0y9fBuVs8rD8OaEhueHlC/6Q/GNZRYkqEEbNoj6O9MUT9PqIkKRXHAJOJUsZIKUSr1YyTJDHGpGmqtaYUIgKAtZYs1YyxLMua4AWpJFGLCRJRxnsdQE961LMe9rTHPR8WOAzqBtkgHYRBLCgLaqijPzXOTznflMFyPhr9t7ynRHTGpN1@CHoGFcNEGSl23V0jy7Z22OzUdE@FUmXJuc/72/rD@yMHBNpCoYVcFZAjCigUcIRrlguJotNk2nijiynYwqT5VQw7878 "APL (Dyalog Unicode) – Try It Online")
`⊂` enclose the string to treat map using the entire string  
 e.g. `"aaabbb"`
`⍳∘≢{`…`}¨` for each of the `⍳` **ɩ**ndices 1 through the tally of characters in the string:  
 e.g. `3`
 `⍺↑⍺` take the current number of elements from the current number, padding with 0s  
 e.g. `[3,0,0]`
 `(≢⍵)⍴` cyclically **r**eshape into the shape of the tally of characters in the string  
  e.g. `[3,0,0,3,0,0]`
 `⍵/⍨` use that to replicate the string's characters  
  `"aaabbb"`
`1↓` drop the first one (*n* = 1)
`⊂∊` is the the entire string a member of that list?
[Answer]
# [Retina 0.8.2](https://github.com/m-ender/retina/wiki/The-Language/a950ad7d925ec9316e3e2fb2cf5d49fd15d23e3d), 28 bytes
```
M!`(.)\1*
.
.
^(..+)(\1|¶)*$
```
[Try it online!](https://tio.run/##dY/BCsIwDEDv@YoOFLo5CzuJd8FdPAg7Dlm79jBabOkcu/hdfoA/NhOqu/l6SdK8kETzGO5y2fJzt1yyjou8rQoQ@G5ciF3O2@r5fuXFZlnq2hiHeF@WjM2z9zE6p3WWQdM0McZhGEII2GGMYYyN44gpxlJKay1ckQnBVGoEjUh5SBJZpJFHIpmkkmvhkNgnxkRImIRM2AQcfwBVlYLvP4ZK9T2ssYIa7/Ilm310@t8xwUi7jlhHwUl7P01KUR@tTtvQDiDhAw "Retina 0.8.2 – Try It Online") Link includes test cases. Explanation:
```
M!`(.)\1*
```
Split the text into runs of identical characters.
```
.
.
```
Replace them all with the same character.
```
^(..+)(\1|¶)*$
```
Check whether the GCD of the lengths of the runs is greater than 1.
[Answer]
# [Japt](https://github.com/ETHproductions/japt) [`-mR`](https://codegolf.meta.stackexchange.com/a/14339/), 12 bytes
```
ÊÆóXÃ¤d_äe e
```
[Try it](https://petershaggynoble.github.io/Japt-Interpreter/?v=1.4.6&flags=LW1S&code=ysbzWMOkZF/kZSBl&input=W1snSCcsJ0gnLCdlJywnZScsJ2wnLCdsJywnbCcsJ2wnLCdvJywnbycsJywnLCcsJywnICcsJyAnLCd3JywndycsJ28nLCdvJywncicsJ3InLCdsJywnbCcsJ2QnLCdkJywnIScsJyEnXSwKWydUJywnVCcsJ1QnLCdyJywncicsJ3InLCdpJywnaScsJ2knLCdwJywncCcsJ3AnLCdsJywnbCcsJ2wnLCdlJywnZScsJ2UnLCcgJywnICcsJyAnLCdzJywncycsJ3MnLCdwJywncCcsJ3AnLCdlJywnZScsJ2UnLCdhJywnYScsJ2EnLCdrJywnaycsJ2snXSwKWydRJywnUScsJ1EnLCdRJywndScsJ3UnLCd1JywndScsJ2EnLCdhJywnYScsJ2EnLCdkJywnZCcsJ2QnLCdkJywncicsJ3InLCdyJywncicsJ3UnLCd1JywndScsJ3UnLCdwJywncCcsJ3AnLCdwJywnbCcsJ2wnLCdsJywnbCcsJ2UnLCdlJywnZScsJ2UnLCcgJywnICcsJyAnLCcgJywncycsJ3MnLCdzJywncycsJ3AnLCdwJywncCcsJ3AnLCdlJywnZScsJ2UnLCdlJywnYScsJ2EnLCdhJywnYScsJ2snLCdrJywnaycsJ2snXSwKWyc3JywnNycsJzcnLCc3JywnNycsJzcnLCc3JywnLScsJy0nLCctJywnLScsJy0nLCctJywnLScsJ3MnLCdzJywncycsJ3MnLCdzJywncycsJ3MnLCdwJywncCcsJ3AnLCdwJywncCcsJ3AnLCdwJywnZScsJ2UnLCdlJywnZScsJ2UnLCdlJywnZScsJ2EnLCdhJywnYScsJ2EnLCdhJywnYScsJ2EnLCdrJywnaycsJ2snLCdrJywnaycsJ2snLCdrJ10sClsnOScsJzknLCc5JywnOScsJzknLCc5JywnOScsJzknLCc5J10sClsnYScsJ2EnLCdhJywnYScsJ2InLCdiJ10sClsnYScsJ2EnLCdhJywnYScsJ2EnLCdhJywnYScsJ2EnLCdiJywnYicsJ2InLCdiJywnYycsJ2MnXSwKWydhJywnYScsJ2EnLCdhJywnYScsJ2InLCdiJywnYicsJ2InLCdiJ10sClsnSCcsJ2UnLCdsJywnbCcsJ28nLCcsJywnICcsJ3cnLCdvJywncicsJ2wnLCdkJywnISddLApbJ1QnLCdUJywnVCcsJ3InLCdyJywncicsJ2knLCdpJywnaScsJ3AnLCdwJywncCcsJ2wnLCdsJywnbCcsJ2UnLCdlJywnZScsJyAnLCcgJywnICcsJ3MnLCdwJywnZScsJ2EnLCdrJ10sClsnYScsJ2EnLCdhJywnYScsJ2EnLCdhJywnYScsJ2EnLCdhJywnYScsJ2EnLCdhJywnYScsJ2EnLCdhJywnYScsJ2InXSwKWydEJywnZCcsJ28nLCdvJywndScsJ3UnLCdiJywnYicsJ2wnLCdsJywnZScsJ2UnLCcgJywnICcsJ3MnLCdzJywncCcsJ3AnLCdlJywnZScsJ2EnLCdhJywnaycsJ2snXV0)
[Answer]
# [MathGolf](https://github.com/maxbergmark/mathgolf), 14 bytes
```
£─╞möl╠mÅ▀£╙╓┴
```
[Try it online!](https://tio.run/##dY87DsIwDEB3ThGmLmVG7AxdkXqBhASokspRStW1CyeAIrEgJK6AOADcJBcJtgyIhTf59yy7ltvNGtwqpcc1Hvo4nOvn3cXhUj938dhjcTjFYR8Pt5SyojDGIQB5LkTXAYTgnNbjcTbKyrIMIVRV5b3HGWOMEKJpGkwxllJaa3FsgbQIFqRG0AmUe9bII5FMUsklmWzSp8yEaRjPGEYylkFn9gFj6ij1DjhRarn8FCijboF/Qi46CE7/f84baX9WfVdiba4B2lYpmqVn6Dq6KUsv "MathGolf – Try It Online")
## Explanation
Checks all possible divisions of the input string into equal length chunks, and checks if there is a partition in which all chunks have just one unique character. 
```
£                length of string with pop
 ─               get divisors
  ╞              discard from left of string/array (removes 1)
   mö            explicit map using 7 operators
     l           push input
      ╠          divide input into chunks of size k
       mÅ        explicit map using 2 operators
         ▀£      number of unique elements of list
           ╙     get maximum number of unique characters per chunk
                 loop ends here
            ╓    get the minimum of all maximums
             ┴   check if equal to 1
```
[Answer]
# [Pyth](https://github.com/isaacg1/pyth), 7 bytes
Outputs **0** for falsy inputs or a positive integer otherwise.
```
tiFhCr8
```
[Try it online!](https://tio.run/##dY8xDsIwDEV3nyLdCyswg1BXpF4gaSI1SpAjp1UFlw@2DN14k534Wd/ltczt2ZZ4n690bsYf320YQsgMYt8bs22IRDl733UwjiMRxRhLKTwRQjDG1Fq55dpam1KCB7My3FrPsEHSF5XEEk08EcUUVdwEJ@WgVKUoQbFKUuDyA@TVOfj@c@ncNMFeOxj4LuzNhpT9v2NKsGlfsa@Cm0dcV@dkTqJLGsnwAQ "Pyth – Try It Online")
[Answer]
# [Pyth](https://github.com/isaacg1/pyth), 8 bytes
```
<1iFhMr8
```
[Try it online!](https://tio.run/##K6gsyfj/38Yw0y3Dt8ji/38lcwjQhYBiCCiAgFQISISAbAhQAgA "Pyth – Try It Online")
```
<1iFhMr8Q   Implicit: Q=eval(input())
            Trailing Q inferred
      r8Q   Run length encode Q into [count, character]
    hM      Take first element of each
  iF        Reduce by GCD
<1          Is 1 less than the above? Implicit print
```
[Answer]
# [Perl 5](https://www.perl.org/) `-n`, 38 bytes
```
for$i(1..y///c){print/^((.)\2{$i})*$/}
```
[Try it online!](https://tio.run/##dY89a8MwEEB3/QoleLCLY9FCCd07eC14DAXJUkFI@MQpxpSQv171rmq99U339Y675DA@l/IB2Pj2cRg@lVJzd0vol6t6b9uhuzzdGn/vHhp1Lz/l42U5lnF0LhIAfS/ltgEgxmjt4SCmaUJE731KiSacc1LKnDOlFGutQwjijVgJSrUlyEDOU5XYYo09Ftlkld0gzpVTJVdSxVV0JVTEyx@Cq8aI3z6Fxsyz2GMjRvoLerkBRvvfM8npsK/YV4lXC7CuxvAcn87X8A1fkK4ellxOyzc "Perl 5 – Try It Online")
The `print"\n"` in the footer is needed to separate the outputs.
Straightforward loop through all possible `n`s. Outputs nothing for "1-speak", anything else for n-speak where n > 1.
]