Lấy cảm hứng từ Có phải là nói đôi? , Tôi đã nghĩ ra một thử thách khó hơn. Đưa ra một chuỗi, xác định xem chuỗi đó có phải là n-speak hay không , với mọi .$n\geq 2$

N-speak được định nghĩa bằng cách lặp lại mỗi chữ cái lần. Với , chuỗi được chuyển thành . Mục tiêu của bạn là tìm hiểu xem đầu vào có phải là đầu ra hợp lệ cho bất kỳ chuyển đổi n-speak nào không.$n$$n = 4$HelloHHHHeeeelllllllloooo

Cần lưu ý rằng bất kỳ câu nào hợp lệ n-speak, với , cũng là k-speak hợp lệ. Do đó, phần khó giải quyết sẽ là giá trị lẻ của .$n = 2k$$n$

Đầu vào

Một chuỗi bao gồm ít nhất 2 ký tự. Đầu vào cũng có thể là một danh sách các ký tự. Đầu vào là trường hợp nhạy cảm.

Đầu ra

Truthynếu chuỗi là n-speak, falseynếu không.

Ví dụ

Trường hợp thật

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

Nếu bạn muốn tạo thêm các trường hợp trung thực, bạn có thể sử dụng tập lệnh MathGolf này . Đặt chuỗi trong dấu ngoặc kép và giá trị của làm đầu vào.$n$

Trường hợp sai

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

Tất nhiên, vì đây là mã golf, hãy sẵn sàng cắt bớt một số byte!

APL (Dyalog Unicode) , 12 byte

Chạy với ⎕io←0

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

Hãy thử trực tuyến!

Chơi golf cùng với Adám .

Trên đầu vào (ví dụ : "aaccccaaaaaabb", sử dụng ""để biểu thị một chuỗi (một mảng ký tự) và ''để biểu thị một char)

∊0⍞0 bao quanh với 0s và flatten, 0 'a' 'a' 'c' 'c' 'c' 'c' 'a' 'a' 'a' 'a' 'a' 'a' 'b' 'b' 0

2≠/ thực hiện cặp đôi không bằng nhau, 1 0 1 0 0 0 1 0 0 0 0 0 1 0 1

⍸ lấy các chỉ số 0 0 2 6 12 14

∨/ tính toán GCD, 2

1≠ điều này không bằng 1?

Java 10, 85 byte

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

Regex chuyển từ câu trả lời JavaScript của @Arnauld .

Hãy thử trực tuyến.

Giải trình:

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 giải thích:

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

Thạch , 5 byte

Œɠg/’

Hãy thử trực tuyến!

JavaScript (ES6), 53 byte

Bắt nguồn từ biểu thức chính quy được sử dụng bởi @wastl trong Is it double speak? .

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

Hãy thử trực tuyến!

Phiên bản đệ quy, 55 byte

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

Hãy thử trực tuyến!

Đã bình luậ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 byte

γ€g¿≠

Hãy thử trực tuyến!

Python 2 , 73 70 69 67 byte

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

Hãy thử trực tuyến!

_{-4 byte, nhờ Jitse}

Python 3 , 69 byte

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

Hãy thử trực tuyến!

QuadS , 16 byte ^SBCS

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

Hãy thử trực tuyến!

1≠ là 1 khác với

∨/ GCD

⍵ kết quả của

(.)\1* PCRE Tìm kiếm bất kỳ ký tự nào theo sau 0 hoặc nhiều lần lặp lại

⊃⍵L và trả lại đầu tiên của độ dài trận đấu (tức là độ dài của trận đấu)

Stax , 5 byte

╢b}▄;

Chạy và gỡ lỗi nó

Thủ tục:

• Tính độ dài đường chạy.
• GCD của mảng
• Là> 1?

Truy vấn 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

Dùng thử trực tuyến

PHP ,76 75 byte

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

Hãy thử trực tuyến!

Nỗ lực đầu tiên, một cách tiếp cận lặp đi lặp lại hơi ngây thơ.

Ung dung:

// 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 đến @ Night2!

Perl 6 , 30 27 26 byte

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

Hãy thử trực tuyến!

Cũng sử dụng thủ thuật GCD, nhưng sử dụng chỉ mục của vị trí kết thúc của mỗi lần chạy khớp với biểu thức chính quy. Trả về số âm (trung thực) nếu n-speak, zero (falsey) nếu không.

Haskell , 48 byte

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

Hãy thử trực tuyến!

Nói thẳng; sử dụng thủ thuật GCD.

Đỏ , 80 byte

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

Hãy thử trực tuyến!

Màu đỏ thành ngữ hơn :

Màu đỏ , 81 byte

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

Hãy thử trực tuyến!

Brachylog , 5 byte

ġz₂=Ṁ

Hãy thử trực tuyến!

Đưa đầu vào thông qua biến đầu vào và đầu ra thông qua thành công hay thất bại.

Lúc đầu, tôi nghĩ rằng điều này thực sự sẽ ngắn hơn giải pháp của tôi là Có nói đôi không? , nhưng sau đó tôi nhận ra rằng ġcó thể và sẽ thử độ dài nhóm là 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 byte

ò¦ mÊrÕÉ

Thử nó

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

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

Hãy thử trực tuyến!

Giải trình

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

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

Hãy thử trực tuyến!

Tái bút Giải pháp ban đầu dựa trên splitchức năng nhưng nó dài hơn (83 byte).

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

Ngôn ngữ Wolfram (Mathicala) , 34 byte

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

Hãy thử trực tuyến!

Perl 5 -p , 83 79 76 74 byte

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

Hãy thử trực tuyến!

Brain-Flak , 96 byte

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

Hãy thử trực tuyến!

Sử dụng thủ thuật GCD tương tự mà nhiều bài nộp khác sử dụng. Đầu ra là 0 nếu đầu vào không phải là n-speak và mặt khác là số nguyên dương.

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

Nó hoạt động với một giả định rằng dữ liệu đầu vào được lưu trữ trong một bảng t (x), vd

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

K (ngn / k) , 29 23 byte

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

Hãy thử trực tuyến!

chỉnh sửa: đã xóa một số dấu hai chấm không cần thiết (tôi biết khi nào cần một đơn nguyên nhưng không phải lúc nào tôi cũng rõ ràng nếu có sự mơ hồ nên tôi mặc định bao gồm cả dấu hai chấm) và thay đổi mod x-y*x%ythành ngn / k's y!x, điều đó có nghĩa là tôi có thể xóa một phép gán biến

APL (Dyalog Unicode) , 24 22 byte ^SBCS

Chức năng tiền tố ẩn danh.

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

Hãy thử trực tuyến!

⊂ kèm theo chuỗi để xử lý bản đồ bằng toàn bộ chuỗi,
 vd"aaabbb"

⍳∘≢{... }¨ cho mỗi ⍳ ɩ ndices 1 thông qua việc kiểm đếm ký tự trong chuỗi:
 ví dụ3

 ⍺↑⍺ lấy số phần tử hiện tại từ số hiện tại, đệm bằng 0s,
 vd[3,0,0]

 (≢⍵)⍴ tuần hoàn r eshape thành hình dạng kiểm đếm các ký tự trong chuỗi,
  ví dụ[3,0,0,3,0,0]

 ⍵/⍨ sử dụng điều đó để sao chép các ký tự của chuỗi
  "aaabbb"

1↓ bỏ cái đầu tiên ( n = 1)

⊂∊ toàn bộ chuỗi là thành viên của danh sách đó?

Võng mạc 0.8.2 , 28 byte

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

Hãy thử trực tuyến! Liên kết bao gồm các trường hợp thử nghiệm. Giải trình:

M!`(.)\1*

Chia văn bản thành các ký tự giống hệt nhau.

.
.

Thay thế tất cả bằng cùng một nhân vật.

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

Kiểm tra xem GCD của độ dài các lần chạy có lớn hơn 1 không.

Japt -mR , 12 byte

ÊÆóXäd_äe e

Thử nó

MathGolf , 14 byte

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

Hãy thử trực tuyến!

Giải trình

Kiểm tra tất cả các phân chia có thể có của chuỗi đầu vào thành các đoạn có độ dài bằng nhau và kiểm tra xem có một phân vùng trong đó tất cả các khối chỉ có một ký tự duy nhất.

£                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

Bình thường , 7 byte

Đầu ra 0 cho đầu vào giả hoặc số nguyên dương khác.

tiFhCr8

Hãy thử trực tuyến!

Bình thường , 8 byte

<1iFhMr8

Hãy thử trực tuyến!

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

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

Hãy thử trực tuyến!

Phần print"\n"chân trang là cần thiết để tách các đầu ra.

Vòng lặp đơn giản thông qua tất cả các ns có thể . Không tạo ra kết quả nào cho "1-speak", bất cứ điều gì khác cho n-speak trong đó n> 1.