Inspirado por ¿Es doble hablar? , Ideé un desafío más difícil. Dada una cadena, determine si la cadena es n-speak , para cualquier $n\geq 2$ .

N-speak se define repitiendo cada letra $n$ veces. Con $n = 4$ , la cadena Hellose transforma en HHHHeeeelllllllloooo. Su objetivo es averiguar si la entrada es una salida válida para cualquier transformación de n-speak.

Cabe señalar que cualquier oración que sea válida n-hablar, para $n = 2k$ , también es válida k-hablar. Por lo tanto, las partes difíciles de resolver serán valores impares de $n$ .

Entrada

Una cadena que consta de al menos 2 caracteres. La entrada también podría ser una lista de caracteres. La entrada es sensible a mayúsculas y minúsculas.

Salida

Truthysi la cadena es n-speak, de lo falseycontrario.

Ejemplos

Casos verdaderos

HHeelllloo,,  wwoorrlldd!!
TTTrrriiipppllleee   ssspppeeeaaakkk
QQQQuuuuaaaaddddrrrruuuupppplllleeee    ssssppppeeeeaaaakkkk
7777777-------ssssssspppppppeeeeeeeaaaaaaakkkkkkk
999999999
aaaabb
aaaaaaaabbbbcc
aaaaabbbbb
@@@

Si desea generar casos de verdad adicionales, puede usar este script MathGolf . Coloque la cadena entre comillas y el valor de $n$ como entrada.

Casos falsos

Hello, world!
TTTrrriiipppllleee   speak
aaaaaaaaaaaaaaaab
Ddoouubbllee  ssppeeaakk
aabbab
aaaabbb
a (does not need to be handled)
(empty string, does not need to be handled)

Por supuesto, como se trata de código de golf, ¡prepárate para recortar algunos bytes!

APL (Dyalog Unicode) , 12 bytes

Corre con ⎕io←0

1≠∨/⍸2≠/∊0⍞0

Pruébalo en línea!

Golf junto con Adám .

En la entrada (ejemplo: "aaccccaaaaaabb", utilizando ""para denotar una cadena (una serie de caracteres) y ''para denotar un char)

∊0⍞0 rodear con 0s y aplanar, 0 'a' 'a' 'c' 'c' 'c' 'c' 'a' 'a' 'a' 'a' 'a' 'a' 'b' 'b' 0

2≠/ realizar pares no iguales, 1 0 1 0 0 0 1 0 0 0 0 0 1 0 1

⍸ obtener los índices indexados 0, 0 2 6 12 14

∨/ calcular el MCD, 2

1≠ ¿No es esto igual a 1?

Java 10, 85 bytes

s->{var r=0>1;for(int i=0;++i<s.length();)r|=s.matches("((.)\\2{"+i+"})*");return r;}

Regex portado de la respuesta de JavaScript de @Arnauld .

Pruébalo en línea.

Explicación:

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

Explicación de expresiones regulares:

^((.)\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

Jalea , 5 bytes

Œɠg/’

Pruébalo en línea!

JavaScript (ES6), 53 bytes

Derivado de la expresión regular utilizada por @wastl en ¿Es doble hablar? .

s=>[...s].some((_,n)=>s.match(`^((.)\\2{${++n}})*$`))

Pruébalo en línea!

Versión recursiva, 55 bytes.

s=>(g=n=>s[++n]&&!!s.match(`^((.)\\2{${n}})*$`)|g(n))``

Pruébalo en línea!

Comentado

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)

05AB1E , 5 bytes

γ€g¿≠

Pruébalo en línea!

Python 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))]

Pruébalo en línea!

_{-4 bytes, gracias a Jitse}

Python 3 , 69 bytes

lambda s:any(s=="".join(i*k for i in s[::k])for k in range(2,len(s)))

Pruébalo en línea!

QuadS , ^{SBCS de} 16 bytes

1≠∨/⍵
(.)\1*
⊃⍵L

Pruébalo en línea!

1≠ es 1 diferente de

∨/ el MCD

⍵ del resultado de

(.)\1* PCRE Buscando cualquier personaje seguido de 0 o más repeticiones del mismo

⊃⍵L y devolver la primera de las duraciones del partido (es decir, la duración del partido)

Stax , 5 bytes

╢b}▄;

Ejecutar y depurarlo

Procedimiento:

• Calcular longitudes de carrera.
• MCD de matriz
• Es> 1?

Consulta T-SQL 2008, 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

Pruébalo en línea

PHP ,76 75 bytes

while(($x=strspn($argn,$argn[$n+=$x],$n))>1&&($m=max($m,$x))%$x<1);echo!$x;

Pruébalo en línea!

Primer intento, un enfoque iterativo algo ingenuo.

Sin golf:

// 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 , gracias a @ Night2!

Perl 6 , 30 27 26 bytes

{1-[gcd] m:g/(.)$0*/>>.to}

Pruébalo en línea!

También usa el truco de GCD, pero usa el índice de la posición final de cada ejecución que coincide con la expresión regular. Devuelve un número negativo (verdad) si n-habla, cero (falsey) de lo contrario.

Haskell , 48 bytes

import Data.List
f=(>1).foldr(gcd.length)0.group

Pruébalo en línea!

Sencillo; usa el truco de GCD.

Rojo , 80 bytes

func[s][repeat n length? s[if parse/case s[any[copy t skip n t]][return on]]off]

Pruébalo en línea!

Rojo más idiomático :

Rojo , 81 bytes

func[s][any collect[repeat n length? s[keep parse/case s[any[copy t skip n t]]]]]

Pruébalo en línea!

Brachylog , 5 bytes

ġz₂=Ṁ

Pruébalo en línea!

Toma entrada a través de la variable de entrada y sale a través de éxito o fracaso.

Al principio pensé que esto sería más corto que mi solución a ¿Es doble hablar? , pero luego me di cuenta de que ġpuede y probaré una longitud de grupo de 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.

Japt -¡ , 8 bytes

ò¦ mÊrÕÉ

Intentalo

ò¦ mÊrÕÉ     :Implicit input of string
ò            :Partition by
 ¦           :  Inequality
   m         :Map
    Ê        :  Length
     r       :Reduce by
      Õ      :  GCD
       É     :Subtract 1
             :Implicit output of boolean negation

Kotlin , 78 bytes

{s->(2..s.length/2).any{i->s.chunked(i).all{z->z.length==i&&z.all{z[0]==it}}}}

Pruébalo en línea!

Explicación

{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
        }
      }
    }
  }

Scala , 80 bytes

s=>"(.)\\1*".r.findAllIn(s).map(_.size).reduce((x,y)=>(BigInt(x) gcd y).toInt)>1

Pruébalo en línea!

PD. La solución original se basó en la splitfunción pero es más larga (83 bytes).

s=>(s+s).split("(.)(?!\\1)").map(_.size+1).reduce((x,y)=>(BigInt(x) gcd y).toInt)>1

Wolfram Language (Mathematica) , 34 bytes

GCD@@Length/@Split@Characters@#>1&

Pruébalo en línea!

Perl 5 -p , 83 79 76 74 bytes

$_=s,(.)\1+,$t=length$&;$t/=2while$t%2-1;$r+=$t==($g||=$t);'',ge==$r&&/^$/

Pruébalo en línea!

Brain-Flak , 96 bytes

{<>({}())<>({}[({})]){{}<>({}<>){{(({})){({}[()])<>}{}}<>([{}()]({}<>)<>)}(<>)<>}{}}<>{}({}[()])

Pruébalo en línea!

Utiliza el mismo truco de GCD que usan muchas otras presentaciones. La salida es 0 si la entrada no es n-speak, y un entero positivo de lo contrario.

# 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
<>{}({}[()])

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))

Funciona suponiendo que los datos de entrada se almacenan en una tabla t (x), por ejemplo

with t(x) as (select 'HHeelllloo,,  wwoorrlldd!!' from dual)

K (ngn / k) , 29 23 bytes

{~|/(&/s@&1<s)!s:#'=:x}

Pruébalo en línea!

editar: eliminé algunos dos puntos innecesarios (sé cuándo se requiere un monádico pero no siempre me queda claro si hay ambigüedad, por lo que por defecto x-y*x%yincluyo los dos puntos) y cambié el mod a ngn / k y!x, lo que significa que podría eliminar una asignación variable

APL (Dyalog Unicode) , 24 22 bytes ^SBCS

Función de prefijo tácito anónimo.

⊂∊1↓⍳∘≢{⍵/⍨(≢⍵)⍴⍺↑⍺}¨⊂

Pruébalo en línea!

⊂ encierra la cadena para tratar el mapa usando toda la cadena,
 por ejemplo"aaabbb"

⍳∘≢{... }¨ para cada uno de los ⍳ ɩ ndices 1 a través del recuento de caracteres en la cadena:
 por ejemplo,3

 ⍺↑⍺ tomar el número actual de elementos del número actual, rellenando con 0s,
 por ejemplo[3,0,0]

 (≢⍵)⍴ cíclicamente r eshape en la forma de la cuenta de caracteres en la cadena
  por ejemplo,[3,0,0,3,0,0]

 ⍵/⍨ usar eso para replicar los caracteres de la cadena
  "aaabbb"

1↓ soltar el primero ( n = 1)

⊂∊ ¿Es la cadena completa un miembro de esa lista?

Retina 0.8.2 , 28 bytes

M!`(.)\1*
.
.
^(..+)(\1|¶)*$

Pruébalo en línea! El enlace incluye casos de prueba. Explicación:

M!`(.)\1*

Divide el texto en series de caracteres idénticos.

.
.

Reemplácelos todos con el mismo personaje.

^(..+)(\1|¶)*$

Compruebe si el MCD de las longitudes de las ejecuciones es mayor que 1.

Japt -mR , 12 bytes

ÊÆóXäd_äe e

Intentalo

MathGolf , 14 bytes

£─╞möl╠mÅ▀£╙╓┴

Pruébalo en línea!

Explicación

Comprueba todas las divisiones posibles de la cadena de entrada en fragmentos de igual longitud y comprueba si hay una partición en la que todos los fragmentos tienen un solo carácter único.

£                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

Pyth , 7 bytes

Outputs 0 for falsy inputs or a positive integer otherwise.

tiFhCr8

Try it online!

Pyth, 8 bytes

<1iFhMr8

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

Perl 5 -n, 38 bytes

for$i(1..y///c){print/^((.)\2{$i})*$/}

Try it online!

The print"\n" in the footer is needed to separate the outputs.

Straightforward loop through all possible ns. Outputs nothing for "1-speak", anything else for n-speak where n > 1.