Est-ce n-parler?

33

Inspiré par Est-ce une double parole? , J'ai imaginé un défi plus difficile. Étant donné une chaîne, déterminez si la chaîne est n-parler , pour tout n≥2 .

N-parler est défini en répétant chaque lettre n fois. Avec n=4 , la chaîneHelloest transformée enHHHHeeeelllllllloooo. Votre objectif est de déterminer si l'entrée est une sortie valide pour toute transformation en n-parler.

Il convient de noter que toute phrase qui est n-parler valide, pour n=2k , est également k-parler valide. Ainsi, les parties difficiles à résoudre seront des valeurs impaires de n .

Contribution

Une chaîne composée d'au moins 2 caractères. L'entrée peut également être une liste de caractères. L'entrée est sensible à la casse.

Sortie

Truthysi la chaîne est n-parler, falseysinon.

Exemples

Vrais cas

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

Si vous souhaitez générer des cas véridiques supplémentaires, vous pouvez utiliser ce script MathGolf . Placez la chaîne entre guillemets et la valeur de n comme entrée.

Faux cas

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

Bien sûr, puisque c'est du golf de code, préparez-vous à couper quelques octets!

code-golf  string  decision-problem 
— maxb
source
Cas de test suggéré:aabbab
— Adám
Cas de test suggéré:aaaabbb
— 640 Ko
Je les ajouterai tous les deux demain, bonnes suggestions.
— maxb
4
Je suis vraiment honoré et flatté que vous ayez utilisé et élargi mon défi :)
— AJFaraday
@AJFaraday heureux que vous l'ayez aimé! J'ai apprécié vos deux défis, ce qui m'a donné l'idée de celui-ci. Il pourrait y avoir un défi encore plus difficile à venir bientôt.
— max

Réponses:

16

APL (Dyalog Unicode) , 12 octets

Fonctionne avec ⎕io←0

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

Essayez-le en ligne!

Golfé avec Adám .

Sur l'entrée (exemple:, "aaccccaaaaaabb"utiliser ""pour désigner une chaîne (un tableau de caractères) et ''pour désigner un caractère)

∊0⍞0 entourer de 0 et aplatir, 0 'a' 'a' 'c' 'c' 'c' 'c' 'a' 'a' 'a' 'a' 'a' 'a' 'b' 'b' 0

2≠/ effectuer par paire non égal, 1 0 1 0 0 0 1 0 0 0 0 0 1 0 1

⍸ obtenir les indices indexés 0, 0 2 6 12 14

∨/ calculer le GCD, 2

1≠ n'est-ce pas égal à 1?

— Kritixi Lithos
source
10

Java 10, 85 octets

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

Regex porté à partir de la réponse JavaScript de @Arnauld .

Essayez-le en ligne.

Explication:

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

Explication de l'expression régulière:

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

JavaScript (ES6), 53 octets

Dérivé de l'expression régulière utilisée par @wastl dans Is it double speak? .

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

Essayez-le en ligne!

Version récursive, 55 octets

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

Essayez-le en ligne!

Commenté

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

05AB1E , 5 octets

γ€g¿≠

Essayez-le en ligne!

— Erik le golfeur
source
Je pensais que mon 14 octets dans MathGolf était bon, mais vous venez de l'écraser. J'aimerais une explication à la fois pour cela et votre réponse Jelly.
— max
2
@maxb Cela prend vraiment la longueur des courses de groupe, calcule leur GCD et teste si ce n'est pas 1.
— Erik the Outgolfer
6

Python 2 , 73 70 69 67 octets

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

Essayez-le en ligne!

-4 octets, grâce à Jitse

— TFeld
source
2
Vous pouvez économiser 3 octets en remplaçant set(...)par{...}
— Jitse
1
En outre, vous pouvez supprimer l'espace dans...1 in[...
— Jitse
@Jitse Merci :)
— TFeld
5

QuadS , 16 octets SBCS

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

Essayez-le en ligne!

1≠ est 1 différent de

∨/ le GCD

⍵ du résultat de

(.)\1* PCRE Recherche d'un caractère suivi de 0 ou plusieurs répétitions de celui-ci

⊃⍵L et renvoyer la première des longueurs de correspondance (c'est-à-dire la longueur de la correspondance)

— Adam
source
4

Requête T-SQL 2008, 193 octets

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

Essayez-le en ligne

— t-clausen.dk
source
"Collate Thai_Bin" est-il vraiment nécessaire?
— Dr Y Wit
1
@DrYWit cela dépend, la base de données pourrait être configurée comme sensible à la casse. Mais les bases de données sensibles à la casse ne sont pas un choix populaire. Cela pourrait être mieux géré différemment en utilisant HASHBYTES ou peut-être VARBINARY, mais cela coûte plus cher en octets
— t-clausen.dk
4

PHP ,76 75 octets

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

Essayez-le en ligne!

Première tentative, une approche itérative quelque peu naïve.

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 octet , merci à @ Night2!

— 640 Ko
source
4

Perl 6 , 30 27 26 octets

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

Essayez-le en ligne!

Utilise également l'astuce GCD, mais utilise l'index de la position de fin de chaque exécution correspondant à l'expression régulière. Renvoie un nombre négatif (véridique) si n-parler, zéro (falsey) sinon.

— Nwellnhof
source
3

Brachylog , 5 octets

ġz₂=Ṁ

Essayez-le en ligne!

Prend l'entrée via la variable d'entrée et sort par succès ou échec.

Au début, je pensais que ce serait en fait plus court que ma solution à Est-ce une double parole? , mais je me suis alors rendu compte que je pouvais ġet essayerais une longueur de groupe de 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.
— Chaîne non liée
source
3

Japt -¡ , 8 octets

ò¦ mÊrÕÉ

L'essayer

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

Kotlin , 78 octets

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

Essayez-le en ligne!

Explication

{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
source
Peut-être que la description n'est pas claire, mais "aaa" est valable en 3 langues. La chaîne d'entrée doit avoir au moins deux caractères, mais ils n'ont pas besoin d'être différents.
— maxb
@maxb, ok cool. Cela devrait être de -2 octets. Merci pour la mise à jour. Je vais arranger ça demain
— Brojowski
3

Scala , 80 octets

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

Essayez-le en ligne!

PS La solution d'origine était basée sur la splitfonction mais elle est plus longue (83 octets).

s=>(s+s).split("(.)(?!\\1)").map(_.size+1).reduce((x,y)=>(BigInt(x) gcd y).toInt)>1
— Dr Y Wit
source
Cela revient truepour entrée aab, malheureusement.
— maxb
@maxb, merci d'avoir vérifié. s.remplacé par (s+s).pour gérer cela.
— Dr Y Wit
Bon travail! Bien que maintenant, j'ai remarqué qu'il échoue pour aaaabbet aabbbb.
— maxb
@maxb, excuses, maintenant j'ai testé sur tous vos cas de test depuis le début du post.
— Dr Y Wit
2

Brain-Flak , 96 octets

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

Essayez-le en ligne!

Utilise la même astuce GCD que de nombreuses autres soumissions utilisent. La sortie est 0 si l'entrée n'est pas n-parler, et un entier positif sinon.

# 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
source
2

Oracle SQL, 182 octets

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

Il fonctionne avec l'hypothèse que les données d'entrée sont stockées dans une table t (x), par exemple

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

K (ngn / k) , 29 23 octets

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

Essayez-le en ligne!

edit: suppression de deux points inutiles (je sais quand un monadique est requis mais il n'est pas toujours clair pour moi s'il y a une ambiguïté, donc je sélectionne par défaut les deux-points) et changé le mod x-y*x%yen ngn / k y!x, ce qui signifiait que je pouvais supprimer une affectation de variable

— griffonner
source
1

APL (Dyalog Unicode) , 24 22 octets SBCS

Fonction de préfixe tacite anonyme.

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

Essayez-le en ligne!

⊂ entourez la chaîne pour traiter la carte en utilisant la chaîne entière,
 par exemple"aaabbb"

⍳∘≢{… }¨ Pour chacun des ⍳ ɩ ndices 1 à travers le décompte des caractères de la chaîne:
 ex.3

 ⍺↑⍺ prendre le nombre actuel d'éléments du nombre actuel, remplir avec 0
 par exemple[3,0,0]

 (≢⍵)⍴ cycliquement r Eshape dans la forme du décompte des caractères dans la chaîne ,
  par exemple[3,0,0,3,0,0]

 ⍵/⍨ utilisez-le pour répliquer les caractères de la chaîne
  "aaabbb"

1↓ déposez le premier ( n = 1)

⊂∊ la chaîne entière est-elle membre de cette liste?

— Adam
source
Divisez-vous la chaîne d'entrée en morceaux de taille n et vérifiez-vous que tous les caractères sont égaux dans chaque bloc? Je ne suis pas entré dans APL, mais c'est certainement le langage de "golf" le plus lisible.
— maxb
@maxb Je suis en train d'écrire une explication. Je filtre avec tous les masques possibles, [1,0,0,1,0,0…]etc. Je serai heureux de vous apprendre APL (cela ne prend pas longtemps à apprendre). Rendez-vous au APL Orchard .
— Adám
— Kritixi Lithos
@Cowsquack Clever, et différent, alors pourquoi ne postez-vous pas {1<∨/≢¨⍵⊆⍨≢¨∪\⍵}?
— Adám
Malheureusement, cela échoue pouraacccaaaaabb
— Kritixi Lithos
1

Retina 0.8.2 , 28 octets

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

Essayez-le en ligne! Le lien inclut des cas de test. Explication:

M!`(.)\1*

Divisez le texte en séries de caractères identiques.

.
.

Remplacez-les tous par le même caractère.

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

Vérifiez si le GCD des longueurs des pistes est supérieur à 1.

— Neil
source
1

MathGolf , 14 octets

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

Essayez-le en ligne!

Explication

Vérifie toutes les divisions possibles de la chaîne d'entrée en morceaux de longueur égale et vérifie s'il existe une partition dans laquelle tous les morceaux ont un seul caractère unique. 

£                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
source
1

Pyth , 8 octets

<1iFhMr8

Essayez-le en ligne!

<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
source
1

Perl 5 -n , 38 octets

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

Essayez-le en ligne!

le print"\n" pied de page est nécessaire pour séparer les sorties.

Boucle simple à travers tous les ns possibles . N'affiche rien pour "1-parler", rien d'autre pour n-parler où n> 1.

— wastl
source
En utilisant notre site, vous reconnaissez avoir lu et compris notre politique liée aux cookies et notre politique de confidentialité.
Licensed under cc by-sa 3.0 with attribution required.