Inspiriert von Sprechen Sie doppelt? Ich habe mir eine schwierigere Herausforderung ausgedacht. Bestimmen Sie bei einer gegebenen Zeichenfolge, ob die Zeichenfolge für ein beliebiges n-speak ist .$n\geq 2$

N-speak wird definiert, indem jeder Buchstabe mal wiederholt wird . Mit wird der String in transformiert . Ihr Ziel ist es, herauszufinden, ob die Eingabe eine gültige Ausgabe für eine N-Speak-Transformation ist.$n$$n = 4$HelloHHHHeeeelllllllloooo

Es ist zu beachten, dass jeder Satz, der für ist, auch k-sprachig ist. Somit sind die zu lösenden harten Teile ungerade Werte von .$n = 2k$$n$

Eingang

Eine Zeichenfolge, die aus mindestens 2 Zeichen besteht. Die Eingabe kann auch eine Liste von Zeichen sein. Die Eingabe unterscheidet zwischen Groß- und Kleinschreibung.

Ausgabe

Truthywenn der String n-speak ist, falseysonst.

Beispiele

Wahre Fälle

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

Wenn Sie zusätzliche Wahrheitsfälle generieren möchten, können Sie dieses MathGolf-Skript verwenden . Platzieren Sie die Zeichenfolge in Anführungszeichen und den Wert von als Eingabe.$n$

Falsche Fälle

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

Natürlich, da dies Codegolf ist, machen Sie sich bereit, einige Bytes zu kürzen!

APL (Dyalog Unicode) , 12 Byte

Läuft mit ⎕io←0

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

Probieren Sie es online!

Golf zusammen mit Adám .

In der Eingabe (Beispiel: "aaccccaaaaaabb"Verwenden von "", um einen String (ein Array von Zeichen) und ein Zeichen ''zu bezeichnen)

∊0⍞0 mit 0en umgeben und abflachen, 0 'a' 'a' 'c' 'c' 'c' 'c' 'a' 'a' 'a' 'a' 'a' 'a' 'b' 'b' 0

2≠/ paarweise ungleich ausführen, 1 0 1 0 0 0 1 0 0 0 0 0 1 0 1

⍸ Holen Sie sich die 0-indizierten Indizes, 0 2 6 12 14

∨/ GCD berechnen, 2

1≠ ist das nicht gleich 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 wurde aus der JavaScript-Antwort von @Arnauld portiert .

Probieren Sie es online aus.

Erläuterung:

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 Erklärung:

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

Gelee , 5 Bytes

Œɠg/’

Probieren Sie es online!

JavaScript (ES6), 53 Byte

Abgeleitet von dem regulären Ausdruck, der von @wastl in Is it double speak verwendet wird. .

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

Probieren Sie es online!

Rekursive Version, 55 Bytes

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

Probieren Sie es online!

Kommentiert

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¿≠

Probieren Sie es online!

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

Probieren Sie es online!

_{-4 Bytes, danke an Jitse}

Python 3 , 69 Bytes

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

Probieren Sie es online!

QuadS , 16 Byte ^SBCS

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

Probieren Sie es online!

1≠ ist 1 verschieden von

∨/ der GCD

⍵ des Ergebnisses von

(.)\1* PCRE Suche nach einem beliebigen Zeichen, gefolgt von 0 oder mehr Wiederholungen

⊃⍵L und Rückgabe der ersten der Matchlängen (dh der Länge des Matchs)

Stax , 5 Bytes

╢b}▄;

Führen Sie es aus und debuggen Sie es

Verfahren:

• Lauflängen berechnen.
• GCD des Arrays
• Ist> 1?

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

Probieren Sie es online aus

PHP ,76 75 Bytes

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

Probieren Sie es online!

Erster Versuch, ein etwas naiver iterativer Ansatz.

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 , Danke an @ Night2!

Perl 6 , 30 27 26 Bytes

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

Probieren Sie es online!

Verwendet auch den GCD-Trick, verwendet jedoch den Index der Endposition jedes Laufs, der mit dem regulären Ausdruck übereinstimmt. Gibt eine negative Zahl (wahr) zurück, wenn n-speak, andernfalls null (falsch).

Haskell , 48 Bytes

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

Probieren Sie es online!

Einfach; benutzt den GCD-Trick.

Rot , 80 Bytes

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

Probieren Sie es online!

Mehr idiomatisches Rot :

Rot , 81 Bytes

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

Probieren Sie es online!

Brachylog , 5 Bytes

ġz₂=Ṁ

Probieren Sie es online!

Übernimmt die Eingabe über die Eingabevariable und gibt sie über Erfolg oder Misserfolg aus.

Zuerst dachte ich, das wäre tatsächlich kürzer als meine Lösung für Ist es doppelt gesprochen? , aber dann wurde mir klar, dass ġich eine Gruppenlänge von 1 probieren kann und werde.

ġ        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ÕÉ

Versuch es

ò¦ 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}}}}

Probieren Sie es online!

Erläuterung

{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

Probieren Sie es online!

PS. Die ursprüngliche Lösung basierte auf der splitFunktion, war jedoch länger (83 Byte).

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

Wolfram Language (Mathematica) , 34 Byte

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

Probieren Sie es online!

Perl 5 -p , 83 79 76 74 Bytes

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

Probieren Sie es online!

Brain-Flak , 96 Bytes

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

Probieren Sie es online!

Verwendet denselben GCD-Trick, den viele andere Einreichungen verwenden. Die Ausgabe ist 0, wenn die Eingabe nicht n-sprachig ist, und andernfalls eine positive Ganzzahl.

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

Es wird davon ausgegangen, dass die Eingabedaten in einer Tabelle t (x) gespeichert sind, z

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

K (NGN / k) , 29 23 Bytes

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

Probieren Sie es online!

edit: einige unnötige Doppelpunkte entfernt (ich weiß, wann eine Monade erforderlich ist, aber es ist mir nicht immer klar, ob es Unklarheiten gibt, so dass ich standardmäßig den Doppelpunkt x-y*x%yeinbeziehe ) und den Mod auf ngn / ks geändert habe y!x, was bedeutete, dass ich eine variable Zuweisung entfernen konnte

APL (Dyalog Unicode) , 24 22 Bytes ^SBCS

Anonyme implizite Präfixfunktion.

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

Probieren Sie es online!

⊂ Schließen Sie die Zeichenfolge ein, um die Karte mit der gesamten Zeichenfolge zu behandeln,
 z"aaabbb"

⍳∘≢{... }¨ für jede der ⍳ ɩ ndices 1 durch die Strichliste der Zeichen in der Zeichenkette:
 zB3

 ⍺↑⍺ nimm die aktuelle Anzahl der Elemente aus der aktuellen Anzahl, fülle sie mit 0s auf,
 z[3,0,0]

 (≢⍵)⍴ zyklisch r eshape in die Form der tally der Zeichen in der Zeichenkette
  zB[3,0,0,3,0,0]

 ⍵/⍨ Verwenden Sie dies, um die Zeichen der Zeichenfolge zu replizieren
  "aaabbb"

1↓ lass den ersten fallen ( n = 1)

⊂∊ Ist die gesamte Zeichenfolge Mitglied dieser Liste?

Retina 0.8.2 , 28 Bytes

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

Probieren Sie es online! Link enthält Testfälle. Erläuterung:

M!`(.)\1*

Teilen Sie den Text in Läufe mit identischen Zeichen auf.

.
.

Ersetze sie alle mit dem gleichen Charakter.

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

Prüfen Sie, ob der GCD der Lauflängen größer als 1 ist.

Japt -mR , 12 Bytes

ÊÆóXäd_äe e

Versuch es

MathGolf , 14 Bytes

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

Probieren Sie es online!

Erläuterung

Überprüft alle möglichen Unterteilungen der Eingabezeichenfolge in gleichlange Abschnitte und prüft, ob es eine Partition gibt, in der alle Abschnitte nur ein einziges Zeichen haben.

£                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

Ausgänge 0 für falsy Eingänge oder eine positive Ganzzahl anders.

tiFhCr8

Probieren Sie es online!

Pyth , 8 Bytes

<1iFhMr8

Probieren Sie es 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})*$/}

Probieren Sie es online!

Das print"\n" in der Fußzeile wird benötigt, um die Ausgänge zu trennen.

Einfache Schleife durch alle möglichen ns. Gibt nichts für "1-speak" aus, alles andere für n-speak, wobei n> 1 ist.