Questo è n-speak?

33

Ispirato da Parla due volte? , Ho escogitato una sfida più dura. Data una stringa, determinare se la stringa è n-speak , per qualsiasi .n≥2

N-speak si definisce ripetendo ogni lettera volte. Con , la stringa viene trasformata in . Il tuo obiettivo è capire se l'input è un output valido per qualsiasi trasformazione n-speak.nn=4HelloHHHHeeeelllllllloooo

Va notato che qualsiasi frase valida n-speak, per , è valida anche k-speak. Pertanto, le parti difficili da risolvere saranno valori dispari di .n=2kn

Ingresso

Una stringa composta da almeno 2 caratteri. L'input potrebbe anche essere un elenco di caratteri. L'input fa distinzione tra maiuscole e minuscole.

Produzione

Truthyse la stringa è n-speak, falseyaltrimenti.

Esempi

Casi veri

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

Se vuoi generare ulteriori casi di verità, puoi usare questo script MathGolf . Inserire la stringa tra virgolette e il valore di come input.n

Falsi casi

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

Naturalmente, dato che si tratta di codice golf, preparati a tagliare alcuni byte!

code-golf  string  decision-problem 
— maxb
fonte
Caso di prova suggerito:aabbab
— Adám,
Caso di prova suggerito:aaaabbb
— 640 KB
Li aggiungerò entrambi domani, buoni suggerimenti.
— max
4
Sono sinceramente onorato e lusingato che tu abbia usato e ampliato la mia sfida :)
— AJFaraday
@AJFaraday felice che ti sia piaciuto! Mi sono piaciute entrambe le tue sfide, che mi hanno dato l'idea per questa. Potrebbe esserci una sfida ancora più difficile in arrivo.
— maxb

Risposte:

16

APL (Dyalog Unicode) , 12 byte

Funziona con ⎕io←0

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

Provalo online!

Giocato a golf insieme ad Adám .

Sull'input (esempio :, "aaccccaaaaaabb"usando ""per indicare una stringa (una matrice di caratteri) e ''per indicare un carattere)

∊0⍞0 circondare con 0 e appiattire, 0 'a' 'a' 'c' 'c' 'c' 'c' 'a' 'a' 'a' 'a' 'a' 'a' 'b' 'b' 0

2≠/ eseguire a coppie non uguali, 1 0 1 0 0 0 1 0 0 0 0 0 1 0 1

⍸ ottenere gli indici indicizzati 0, 0 2 6 12 14

∨/ calcolare il GCD, 2

1≠ questo non è uguale a 1?

— Kritixi Lithos
fonte
10

Java 10, 85 byte

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

Regex portato dalla risposta JavaScript di @Arnauld .

Provalo online.

Spiegazione:

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

Spiegazione 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 byte

Derivato dall'espressione regolare usata da @wastl in È double speak? .

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

Provalo online!

Versione ricorsiva, 55 byte

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

Provalo online!

Commentate

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 byte

γ€g¿≠

Provalo online!

— Erik the Outgolfer
fonte
Ho pensato che il mio 14-byte in MathGolf fosse buono, ma l'hai appena schiacciato. Mi piacerebbe una spiegazione sia per questo che per la tua risposta Jelly.
— max
2
@maxb Prende davvero solo le lunghezze delle corse di gruppo, calcola il loro GCD e verifica se non è 1.
— Erik the Outgolfer
5

QuadS , 16 byte SBCS

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

Provalo online!

1≠ è 1 diverso da

∨/ il GCD

⍵ del risultato di

(.)\1* PCRE Ricerca di qualsiasi carattere seguito da 0 o più ripetizioni dello stesso

⊃⍵L e restituendo la prima delle lunghezze della partita (ovvero la lunghezza della partita)

— Adamo
fonte
4

Query T-SQL 2008, 193 byte

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

Provalo online

— t-clausen.dk
fonte
"Collate Thai_Bin" è davvero necessario?
— Dr Y Wit,
1
@DrYWit dipende, il database potrebbe essere impostato come case sensitive. Ma i database con distinzione tra maiuscole e minuscole non sono una scelta popolare. Questo potrebbe essere gestito in modo diverso usando HASHBYTES o forse VARBINARY, ma è più costoso in byte
— t-clausen.dk
4

PHP ,76 75 byte

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

Provalo online!

Primo tentativo, un approccio iterativo un po 'ingenuo.

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

— 640KB
fonte
4

Perl 6 , 30 27 26 byte

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

Provalo online!

Utilizza anche il trucco GCD, ma utilizza l'indice della posizione finale di ogni corsa corrispondente a regex. Restituisce un numero negativo (verità) se n-parla, zero (falsa) altrimenti.

— nwellnhof
fonte
3

Brachylog , 5 byte

ġz₂=Ṁ

Provalo online!

Riceve input attraverso la variabile input e output in caso di esito positivo o negativo.

In un primo momento ho pensato che questo sarebbe stato in realtà più breve della mia soluzione a È il doppio parlare? , ma poi ho capito che ġpuò e proverà una lunghezza di gruppo di 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.
— Stringa non correlata
fonte
3

Japt -¡ , 8 byte

ò¦ mÊrÕÉ

Provalo

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

Kotlin , 78 byte

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

Provalo online!

Spiegazione

{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
Forse la descrizione non è chiara, ma "aaa" è valido in 3 lingue. La stringa di input deve contenere almeno due caratteri, ma non devono essere diversi.
— max
@maxb, ok fantastico. Dovrebbero essere -2 byte. Grazie per l'aggiornamento. Lo aggiusterò domani
— Brojowski il
3

Scala , 80 byte

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

Provalo online!

PS. La soluzione originale era basata sulla splitfunzione ma è più lunga (83 byte).

s=>(s+s).split("(.)(?!\\1)").map(_.size+1).reduce((x,y)=>(BigInt(x) gcd y).toInt)>1
— Dr Y Wit
fonte
Questo ritorna trueper input aab, sfortunatamente.
— max
@maxb, grazie per il controllo. s.sostituito con (s+s).per gestirlo.
— Dr Y Wit,
Buon lavoro! Anche se ora ho notato che fallisce per aaaabbe aabbbb.
— max
@maxb, mi scuso, ora ho testato tutti i tuoi casi di test dal post iniziale.
— Dr Y Wit,
2

Brain-Flak , 96 byte

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

Provalo online!

Utilizza lo stesso trucco GCD utilizzato da molti altri invii. L'output è 0 se l'ingresso non è n-speak e un numero intero positivo altrimenti.

# 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 byte

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

Funziona presupponendo che i dati di input siano memorizzati in una tabella t (x), ad es

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

K (ngn / k) , 29 23 byte

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

Provalo online!

modifica: rimossi alcuni due punti inutili (so quando è necessaria una monade ma non è sempre chiaro per me se c'è ambiguità, quindi per impostazione predefinita x-y*x%yincludo i due punti) e ho cambiato la mod in ngn / k y!x, il che significava che potevo rimuovere un'assegnazione variabile

— scarabocchio
fonte
1

APL (Dyalog Unicode) , 24 22 byte SBCS

Funzione prefisso tacito anonimo.

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

Provalo online!

⊂ racchiudere la stringa per trattare la mappa usando l'intera stringa
 ad es"aaabbb"

⍳∘≢{... }¨ per ciascuno dei ⍳ ɩ ndices 1 tramite il conteggio dei caratteri nella stringa:
 ad es3

 ⍺↑⍺ prende il numero corrente di elementi dal numero corrente, imbottitura con 0s
 es[3,0,0]

 (≢⍵)⍴ ciclicamente r eshape nella forma del conteggio dei caratteri nella stringa
  es[3,0,0,3,0,0]

 ⍵/⍨ usalo per replicare i caratteri della stringa
  "aaabbb"

1↓ rilascia il primo ( n = 1)

⊂∊ è l'intera stringa un membro di quell'elenco?

— Adamo
fonte
Stai dividendo la stringa di input in blocchi di dimensioni n e stai verificando che tutti i caratteri siano uguali all'interno di ciascun blocco? Non sono entrato in APL, ma è sicuramente il linguaggio "golfistico" più leggibile.
— max
@maxb Sto scrivendo una spiegazione. Sto filtrando con tutte le possibili maschere [1,0,0,1,0,0…]ecc. Sarò felice di insegnarti APL (non ci vorrà molto per imparare). Basta inserire fino l'APL Orchard .
— Adám,
— Kritixi Lithos il
@Cowsquack Clever, and different, quindi perché non pubblichi {1<∨/≢¨⍵⊆⍨≢¨∪\⍵}?
— Adám,
Sfortunatamente fallisce peraacccaaaaabb
— Kritixi Lithos il
1

Retina 0.8.2 , 28 byte

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

Provalo online! Il link include casi di test. Spiegazione:

M!`(.)\1*

Dividi il testo in sequenze di caratteri identici.

.
.

Sostituiscili tutti con lo stesso personaggio.

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

Controllare se il GCD delle lunghezze delle corse è maggiore di 1.

— Neil
fonte
1

MathGolf , 14 byte

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

Provalo online!

Spiegazione

Controlla tutte le possibili divisioni della stringa di input in blocchi di uguale lunghezza e verifica se esiste una partizione in cui tutti i blocchi hanno un solo carattere univoco. 

£                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

Pyth , 8 byte

<1iFhMr8

Provalo 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 byte

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

Provalo online!

Il print"\n"piè di pagina è necessario per separare le uscite.

Ciclo diretto attraverso tutte le possibili ns. Non genera nulla per "1-speak", nient'altro per n-speak dove n> 1.

— Wastl
fonte
Utilizzando il nostro sito, riconosci di aver letto e compreso le nostre Informativa sui cookie e Informativa sulla privacy.
Licensed under cc by-sa 3.0 with attribution required.