แรงบันดาลใจจากมันเป็นสองเท่าพูด? ฉันคิดว่าความท้าทายที่หนักกว่า ได้รับสตริงตรวจสอบว่าสตริงคือn พูด , สำหรับการใด ๆ$n\geq 2$ 2

N-speak ถูกกำหนดโดยการทำซ้ำแต่ละตัวอักษร$n$ครั้ง ด้วย$n = 4$ , สตริงจะถูกเปลี่ยนไปHello HHHHeeeellllllllooooเป้าหมายของคุณคือการพิจารณาว่าอินพุตเป็นเอาต์พุตที่ถูกต้องสำหรับการแปลง n-speak ใด ๆ

ควรสังเกตว่าประโยคใด ๆ ที่ถูกต้อง n-speak สำหรับ$n = 2k$ก็เป็น k-speak ที่ใช้ได้เช่นกัน ดังนั้นในส่วนที่ยากที่จะแก้จะเป็นค่าคี่n$n$

อินพุต

สตริงที่ประกอบด้วยอักขระอย่างน้อย 2 ตัว อินพุตอาจเป็นรายการของอักขระ การป้อนข้อมูลเป็นกรณี ๆ ไป

เอาท์พุต

Truthyถ้าสตริงเป็น n-speak falseyมิฉะนั้น

ตัวอย่าง

กรณีที่แท้จริง

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

หากคุณต้องการสร้างกรณีความจริงเพิ่มเติมคุณสามารถใช้สคริปต์ MathGolfนี้ วางสตริงภายในเครื่องหมายคำพูดและค่าของ$n$เป็นอินพุต

กรณีเท็จ

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

แน่นอนเนื่องจากนี่คือรหัสกอล์ฟเตรียมตัวให้พร้อมเพื่อตัดแต่งบางไบต์!

APL (Dyalog Unicode)ขนาด 12 ไบต์

ทำงานด้วย ⎕io←0

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

ลองออนไลน์!

แข็งแรงเล่นกอล์ฟร่วมกับอดัม

ในอินพุต (ตัวอย่าง: "aaccccaaaaaabb"ใช้""เพื่อแสดงถึงสตริง (อาร์เรย์ของตัวอักษร) และ''เพื่อแสดงถึงอักขระ)

∊0⍞0 ล้อมรอบด้วย 0 วินาทีและแบน 0 'a' 'a' 'c' 'c' 'c' 'c' 'a' 'a' 'a' 'a' 'a' 'a' 'b' 'b' 0

2≠/ ดำเนินการเป็นสองเท่าไม่เท่ากัน 1 0 1 0 0 0 1 0 0 0 0 0 1 0 1

⍸ รับดัชนี 0 ดัชนี 0 2 6 12 14

∨/ คำนวณ GCD 2

1≠ นี่ไม่เท่ากับ 1 ใช่ไหม

Java 10, 85 ไบต์

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

Regex รังเพลิงจาก@Arnauldคำตอบ JavaScript 's

ลองออนไลน์

คำอธิบาย:

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:

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

เยลลี่ 5 ไบต์

Œɠg/’

ลองออนไลน์!

JavaScript (ES6), 53 ไบต์

มาจากการแสดงออกปกติที่ใช้โดย @wastl ในมันพูดสองครั้ง? .

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

ลองออนไลน์!

เวอร์ชันแบบเรียกซ้ำ 55 ไบต์

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

ลองออนไลน์!

แสดงความคิดเห็น

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 ไบต์

γ€g¿≠

ลองออนไลน์!

Python 2 , 73 70 69 67 ไบต์

lambda s:s in[''.join(c*n for c in s[::n])for n in range(2,len(s))]

ลองออนไลน์!

_{-4 ไบต์ขอบคุณ Jitse}

Python 3 , 69 ไบต์

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

ลองออนไลน์!

QuadS , 16 ไบต์^SBCS

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

ลองออนไลน์!

1≠ แตกต่างจาก 1

∨/ GCD

⍵ ของผลลัพธ์ของ

(.)\1* PCRE ค้นหาอักขระใด ๆ ตามด้วยการทำซ้ำ 0 ครั้งขึ้นไป

⊃⍵L และส่งคืนความยาวของการแข่งขันครั้งแรก (เช่นความยาวของการแข่งขัน)

Stax , 5 ไบต์

╢b}▄;

เรียกใช้และแก้ไขข้อบกพร่อง

ขั้นตอน:

• คำนวณระยะความยาว
• GCD ของอาร์เรย์
• เป็น> 1 หรือไม่

แบบสอบถาม T-SQL 2008 ขนาด 193 ไบต์

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

ลองออนไลน์

PHP ,76 75 ไบต์

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

ลองออนไลน์!

ความพยายามครั้งแรกวิธีการทำซ้ำค่อนข้างไร้เดียงสา

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 ไบต์ , ขอบคุณไปที่ @ Night2!

Perl 6 , 30 27 26 ไบต์

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

ลองออนไลน์!

ใช้เคล็ดลับ GCD เช่นกัน แต่ใช้ดัชนีของตำแหน่งสิ้นสุดของการวิ่งแต่ละครั้งที่จับคู่โดย regex ส่งกลับจำนวนลบ (ความจริง) ถ้า n-speak, zero (falsey) เป็นอย่างอื่น

Haskell , 48 ไบต์

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

ลองออนไลน์!

ตรงไปตรงมา ใช้เคล็ดลับ GCD

สีแดง 80 ไบต์

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

ลองออนไลน์!

สำนวนสีแดงเพิ่มเติม:

สีแดง 81 ไบต์

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

ลองออนไลน์!

Brachylogขนาด 5 ไบต์

ġz₂=Ṁ

ลองออนไลน์!

รับอินพุตผ่านตัวแปรอินพุตและเอาต์พุตผ่านสำเร็จหรือล้มเหลว

ตอนแรกฉันคิดว่ามันจะสั้นกว่าโซลูชันของฉันไปหรือเปล่า แต่จากนั้นฉันก็ตระหนักว่าġสามารถและจะลองความยาวกลุ่มเท่ากับ 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.

Japtet -¡ , 8 ไบต์

ò¦ mÊrÕÉ

ลองมัน

ò¦ 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 ไบต์

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

ลองออนไลน์!

คำอธิบาย

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

สกาลา , 80 ไบต์

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

ลองออนไลน์!

PS โซลูชันดั้งเดิมขึ้นอยู่กับsplitฟังก์ชั่น แต่มันยาวกว่า (83 ไบต์)

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

ภาษา Wolfram (Mathematica) , 34 ไบต์

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

ลองออนไลน์!

Perl 5 -p , 83 79 76 74 ไบต์

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

ลองออนไลน์!

Brain-Flakขนาด 96 ไบต์

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

ลองออนไลน์!

ใช้เคล็ดลับ GCD เดียวกับที่ใช้ในการส่งอื่น ๆ เอาท์พุทเป็น 0 ถ้าอินพุตไม่พูด n- และจำนวนเต็มบวกเป็นอย่างอื่น

# 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 ไบต์

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

มันทำงานได้โดยมีสมมติฐานว่าข้อมูลอินพุตถูกเก็บไว้ในตาราง t (x) เช่น

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

K (ngn / k) , 29 23 ไบต์

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

ลองออนไลน์!

แก้ไข: ลบโคลอนที่ไม่จำเป็นออก (ฉันรู้ว่าจำเป็นต้องใช้ monadic หรือไม่ แต่จะไม่ชัดเจนสำหรับฉันถ้ามีความกำกวมดังนั้นฉันจึงเริ่มรวมโคลอน) และเปลี่ยน mod x-y*x%yเป็น ngn / k's y!xซึ่งหมายความว่าฉันสามารถลบการกำหนดตัวแปรได้

APL (Dyalog Unicode) , 24 22 ไบต์^SBCS

ฟังก์ชันนำหน้าเงียบโดยไม่ระบุชื่อ

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

ลองออนไลน์!

⊂ ใส่สตริงเพื่อจัดการกับแผนที่โดยใช้สตริงทั้งหมด
 เช่น"aaabbb"

⍳∘≢{... }¨ สำหรับแต่ละ⍳ ɩ ndices 1 ผ่านการนับของตัวละครในสตริง:
 เช่น3

 ⍺↑⍺ รับจำนวนองค์ประกอบปัจจุบันจากหมายเลขปัจจุบันเติมด้วย 0
 เช่น[3,0,0]

 (≢⍵)⍴ วนr eshape เป็นรูปร่างของนับของตัวละครในสตริง
  เช่น[3,0,0,3,0,0]

 ⍵/⍨ ใช้สิ่งนั้นเพื่อทำซ้ำอักขระของสตริง
  "aaabbb"

1↓ ดร็อปอันแรก ( n = 1)

⊂∊ สตริงทั้งหมดเป็นสมาชิกของรายการนั้นหรือไม่

เรติน่า 0.8.2 , 28 ไบต์

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

ลองออนไลน์! ลิงค์มีกรณีทดสอบ คำอธิบาย:

M!`(.)\1*

แยกข้อความออกเป็นจำนวนอักขระที่เหมือนกัน

.
.

แทนที่ด้วยอักขระเดียวกันทั้งหมด

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

ตรวจสอบว่า GCD ของความยาวของการวิ่งนั้นมากกว่า 1

Japt -mR , 12 ไบต์

ÊÆóXäd_äe e

ลองมัน

MathGolf 14 ไบต์

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

ลองออนไลน์!

คำอธิบาย

ตรวจสอบการแบ่งส่วนที่เป็นไปได้ทั้งหมดของสตริงอินพุตให้มีความยาวเท่ากันและตรวจสอบว่ามีพาร์ติชันที่ชิ้นส่วนทั้งหมดมีอักขระที่ไม่ซ้ำกันเพียงตัวเดียวหรือไม่

£                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 ไบต์

เอาต์พุต0สำหรับอินพุตที่ผิดพลาดหรือจำนวนเต็มบวกมิฉะนั้น

tiFhCr8

ลองออนไลน์!

Pyth , 8 ไบต์

<1iFhMr8

ลองออนไลน์!

<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 ไบต์

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

ลองออนไลน์!

print"\n"ในส่วนท้ายเป็นสิ่งจำเป็นที่จะแยกผลผลิต

วนลูปตรงไปตรงมาผ่านns ที่เป็นไปได้ทั้งหมด ไม่มีผลอะไรสำหรับ "1-speak", อย่างอื่นสำหรับ n-speak โดยที่ n> 1