영감을받은 것입니다 그것을 두 번 말하는? 나는 더 어려운 도전을 고안했다. 문자열이 주어지면 n ≥ 2에 대해 문자열이 n- 스피크 인지 확인하십시오 .$n\geq 2$

N 문자는 각 문자를 $n$ 번 반복하여 정의됩니다 . 함께 $n = 4$ 의 문자열 Hello로 변환된다 HHHHeeeelllllllloooo. 목표는 입력이 n- 스피크 변환에 유효한 출력인지 확인하는 것입니다.

유효한 n- 스피크 인 $n = 2k$ 인 문장도 유효한 k- 스피크 임에 유의 하십시오. 따라서 해결하기 어려운 부분은 홀수 값입니다 .$n$

입력

2 자 이상으로 구성된 문자열 입력은 문자 목록 일 수도 있습니다. 입력은 대소 문자를 구분합니다.

산출

Truthy문자열이 n 인 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

온라인으로 사용해보십시오!

Adám과 함께 골프 를 쳤다 .

입력에서 (예 : "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과 같지 않습니까?

자바 10, 85 바이트

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

정규식은 @Arnauld 의 JavaScript 응답 에서 포팅되었습니다 .

온라인으로 사용해보십시오.

설명:

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

정규식 설명 :

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

온라인으로 사용해보십시오!

자바 스크립트 (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¿≠

온라인으로 사용해보십시오!

파이썬 2 , 73 70 69 67 바이트

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

온라인으로 사용해보십시오!

_{Jitse 덕분에 -4 바이트}

파이썬 3 , 69 바이트

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

온라인으로 사용해보십시오!

쿼드 , 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;

온라인으로 사용해보십시오!

첫 번째 시도는 다소 순진한 반복 접근 방식입니다.

언 골프 드 :

// 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로 thx!

펄 6 , 30 27 26 바이트

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

온라인으로 사용해보십시오!

또한 GCD 트릭을 사용하지만 정규식과 일치하는 각 실행의 끝 위치 색인을 사용합니다. n- 말하면 음수 (거짓)를, 그렇지 않으면 0 (거짓)을 반환합니다.

하스켈 , 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.

Japt -¡ , 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

코 틀린 , 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

온라인으로 사용해보십시오!

추신. 원래 솔루션은 split기능 을 기반으로 했지만 더 길었습니다 (83 바이트).

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

Wolfram Language (Mathematica) , 34 바이트

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

온라인으로 사용해보십시오!

펄 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 트릭을 사용합니다. 입력이 n이 아닌 경우 출력은 0이고, 그렇지 않으면 양의 정수입니다.

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

온라인으로 사용해보십시오!

편집 : 불필요한 콜론을 제거했습니다 (모나 딕이 필요한시기를 알고 있지만 모호성이 있는지 항상 명확하지는 않지만 콜론을 포함하는 것으로 기본 설정되어 있음). 모드 x-y*x%y를 ngn / k로 변경하여 y!x변수 할당을 제거 할 수 있음을 의미합니다

APL (Dyalog Unicode) , 24 22 바이트 ^SBCS

익명의 암묵적 접두사 기능.

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

온라인으로 사용해보십시오!

⊂ 전체 문자열을 사용하여 맵을 처리 할 문자열을 묶습니다.
 예 :"aaabbb"

⍳∘≢{... }¨ 의 각⍳  ɩ은 문자열의 문자 집계를 통해 1 ndices :
 예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

피스 , 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

펄 5 -n , 38 바이트

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

온라인으로 사용해보십시오!

그만큼 print"\n"꼬리말에서는 출력을 분리 할 필요가있다.

가능한 모든 ns 를 간단하게 반복합니다 . "1-speak"에 대해서는 아무것도 출력하지 않으며 n> 1 인 n-speak에는 아무것도 출력하지 않습니다.