Isso é n-speak?

33

Inspirado por É falar duas vezes? , Eu projetei um desafio mais difícil. Dada uma sequência, determine se a sequência é n-speak , para qualquer .n≥2

N-speak é definido repetindo cada letra vezes. Com , a sequência é transformada em . Seu objetivo é descobrir se a entrada é uma saída válida para qualquer transformação n-speak.nn=4HelloHHHHeeeelllllllloooo

Deve-se notar que qualquer sentença que seja válida para n-speak, para , também é válida para k-speak. Assim, as partes difíceis a serem resolvidas serão valores ímpares de n .n=2kn

Entrada

Uma sequência que consiste em pelo menos 2 caracteres. A entrada também pode ser uma lista de caracteres. A entrada diferencia maiúsculas de minúsculas.

Saída

Truthyse a sequência for n-speak, falseycaso contrário.

Exemplos

Casos verdadeiros

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

Se você deseja gerar casos de verdade adicionais, pode usar este script MathGolf . Coloque a string entre aspas e o valor de como entrada.n

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)

Obviamente, como se trata de código de golfe, prepare-se para aparar alguns bytes!

code-golf string decision-problem maxb
fonte
Caso de teste sugerido:aabbab
Adám em
Caso de teste sugerido:aaaabbb
640KB
Vou adicionar os dois amanhã, boas sugestões.
maxb 12/08
4
Estou genuinamente honrado e lisonjeado por você ter usado e expandido meu desafio :)
AJFaraday
@AJFaraday feliz que você tenha gostado! Gostei dos dois desafios, o que me deu a ideia para este. Pode haver um desafio ainda mais difícil em breve.
maxb 13/08

Respostas:

16

APL (Dyalog Unicode) , 12 bytes

Corre com ⎕io←0

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

Experimente online!

Jogou golfe com Adám .

Na entrada (exemplo :, "aaccccaaaaaabb"usando ""para indicar uma sequência (uma matriz de caracteres) e ''para indicar um caractere)

∊0⍞0 cercar com 0s e achatar, 0 'a' 'a' 'c' 'c' 'c' 'c' 'a' 'a' 'a' 'a' 'a' 'a' 'b' 'b' 0

2≠/ executar pares não iguais, 1 0 1 0 0 0 1 0 0 0 0 0 1 0 1

⍸ obtenha os índices indexados em 0, 0 2 6 12 14

∨/ calcular o GCD, 2

1≠ isso não é igual a 1?

Kritixi Lithos
fonte
10

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 da resposta JavaScript de @Arnauld .

Experimente online.

Explicação:

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

Explicação Regex:

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

JavaScript (ES6), 53 bytes

Derivado da expressão regular usada por @wastl em É falar duas vezes? .

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

Experimente online!

Versão recursiva, 55 bytes

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

Experimente online!

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

05AB1E , 5 bytes

γ€g¿≠

Experimente online!

Erik, o Outgolfer
fonte
Eu pensei que meu 14-byter no MathGolf era bom, mas você simplesmente o esmagou. Eu adoraria uma explicação para isso e sua resposta Jelly.
maxb 12/08
2
@maxb Realmente mede o comprimento das corridas do grupo, calcula seu GCD e testa se não é 1.
Erik the Outgolfer
6

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

Experimente online!

-4 bytes, graças ao Jitse

TFeld
fonte
2
Você pode salvar 3 bytes substituindo set(...)por{...}
Jitse 12/08
1
Além disso, você pode remover o espaço em...1 in[...
Jitse 12/08
@Jitse Thanks :)
TFeld
5

QuadS , SBCS de 16 bytes

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

Experimente online!

1≠ é 1 diferente de

∨/ o GCD

⍵ do resultado de

(.)\1* PCRE Procurando por qualquer caractere seguido por 0 ou mais repetições

⊃⍵L e retornando o primeiro comprimento da partida (ou seja, a duração da partida)

Adão
fonte
4

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

Experimente online

t-clausen.dk
fonte
"Collate Thai_Bin" é realmente necessário?
Dr Y Wit
1
@DrYWit depende, o banco de dados pode ser configurado como diferencia maiúsculas de minúsculas. Mas os bancos de dados com distinção entre maiúsculas e minúsculas não são uma escolha popular. Isso poderia ser tratado de maneira melhor usando HASHBYTES ou talvez VARBINARY, mas isso é mais caro em bytes
t-clausen.dk
4

PHP ,76 75 bytes

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

Experimente online!

Primeira tentativa, uma abordagem iterativa um tanto ingênua.

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 para @ Night2!

640KB
fonte
4

Perl 6 , 30 27 26 bytes

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

Experimente online!

Também usa o truque GCD, mas usa o índice da posição final de cada execução correspondida pelo regex. Retorna um número negativo (verdade) se n-speak, zero (falsey) caso contrário.

Nwellnhof
fonte
3

Vermelho , 80 bytes

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

Experimente online!

Vermelho mais idiomático :

Vermelho , 81 bytes

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

Experimente online!

Galen Ivanov
fonte
3

Braquilog , 5 bytes

ġz₂=Ṁ

Experimente online!

Recebe a entrada pela variável de entrada e sai por sucesso ou falha.

No começo, pensei que isso seria realmente menor do que minha solução. É falar duas vezes? , mas percebi que ġpode e vou tentar um 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.
String não relacionada
fonte
3

Japonês -¡ , 8 bytes

ò¦ mÊrÕÉ

Tente

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

Kotlin , 78 bytes

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

Experimente online!

Explicação

{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
        }
      }
    }
  }
Brojowski
fonte
Talvez a descrição não esteja clara, mas "aaa" é válido em três línguas. A sequência de entrada deve ter pelo menos dois caracteres, mas não precisa ser diferente.
maxb 13/08
@ maxb, ok legal. Isso deve ser -2 bytes. Obrigado pela atualização. Vou consertar isso amanhã
Brojowski
3

Scala , 80 bytes

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

Experimente online!

PS. A solução original foi baseada na splitfunção, mas é mais longa (83 bytes).

s=>(s+s).split("(.)(?!\\1)").map(_.size+1).reduce((x,y)=>(BigInt(x) gcd y).toInt)>1
Dr. Y Wit
fonte
Isso retorna truepara entrada aab, infelizmente.
maxb 13/08
@ maxb, obrigado por verificar. s.substituído por (s+s).para lidar com isso.
Y Yit
Bom trabalho! Embora agora eu notei que ele falha em aaaabbe aabbbb.
maxb 13/08
@ maxb, desculpas, agora testei em todos os seus casos de teste desde o início do post.
Dr. Y Wit
2

Perl 5 -p , 83 79 76 74 bytes

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

Experimente online!

Xcali
fonte
2

Brain-Flak , 96 bytes

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

Experimente online!

Usa o mesmo truque do GCD usado por muitos outros envios. A saída é 0 se a entrada não for n-speak, e um número inteiro positivo caso contrário.

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

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

Ele trabalha com a suposição de que os dados de entrada são armazenados em uma tabela t (x), por exemplo

with t(x) as (select 'HHeelllloo,,  wwoorrlldd!!' from dual)
Dr. Y Wit
fonte
2

K (ngn / k) , 29 23 bytes

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

Experimente online!

edit: removeu alguns dois pontos desnecessários (eu sei quando uma monádica é necessária, mas nem sempre é claro para mim se há ambiguidade, por padrão eu x-y*x%yincluo dois pontos) e alterei o mod para ngn / k's y!x, o que significava que eu poderia remover uma atribuição de variável

rabisco
fonte
1

APL (Dyalog Unicode) , 24 SBCS de 22 bytes

Função de prefixo tácito anônimo.

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

Experimente online!

⊂ coloque a string para tratar o mapa usando a string inteira,
 por exemplo"aaabbb"

⍳∘≢{... }¨ para cada um dos ⍳ ɩ ndices 1 através da contagem de caracteres no string:
 por exemplo,3

 ⍺↑⍺ pegue o número atual de elementos do número atual, preenchendo com 0s,
 por exemplo[3,0,0]

 (≢⍵)⍴ ciclicamente r eshape na forma da contagem de caracteres na cadeia
  , por exemplo[3,0,0,3,0,0]

 ⍵/⍨ use isso para replicar os caracteres da string
  "aaabbb"

1↓ largue o primeiro ( n = 1)

⊂∊ a string inteira é membro dessa lista?

Adão
fonte
Você está dividindo a sequência de entrada em partes de tamanho n e verificando se todos os caracteres são iguais em cada parte? Eu não entrei no APL, mas é definitivamente a linguagem de "golfe" mais legível.
maxb 12/08
@ maxb Estou no processo de escrever uma explicação. Estou filtrando todas as máscaras possíveis, [1,0,0,1,0,0…]etc. Ficarei feliz em ensinar a você APL (não demorará muito para aprender). Basta ir ao APL Orchard .
Adám 12/08
Aqui está {1<∨/≢¨⍵⊆⍨≢∘∪¨,\⍵}para 18
Kritixi Lithos
@ Cowsquack Inteligente e diferente, então por que você não publica {1<∨/≢¨⍵⊆⍨≢¨∪\⍵}?
Adám 12/08
Infelizmente ele falha paraaacccaaaaabb
Kritixi Lithos
1

Retina 0.8.2 , 28 bytes

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

Experimente online! O link inclui casos de teste. Explicação:

M!`(.)\1*

Divida o texto em séries de caracteres idênticos.

.
.

Substitua todos eles pelo mesmo caractere.

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

Verifique se o GCD dos comprimentos das execuções é maior que 1.

Neil
fonte
1

MathGolf , 14 bytes

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

Experimente online!

Explicação

Verifica todas as divisões possíveis da sequência de entrada em pedaços de comprimento igual e verifica se há uma partição na qual todos os pedaços têm apenas um caractere exclusivo. 

£                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
maxb
fonte
1

Pitão , 8 bytes

<1iFhMr8

Experimente 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
Sok
fonte
1

Perl 5 -n , 38 bytes

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

Experimente online!

o print"\n" no rodapé é necessário para separar as saídas.

Loop direto através de todos os ns possíveis . Não produz nada para "1-speak", qualquer outra coisa para n-speak onde n> 1.

wastl
fonte