क्या यह n-Speak है?

33

क्या यह दोहरी बात से प्रेरित है ? , मैंने एक कठिन चुनौती तैयार की। एक स्ट्रिंग को देखते हुए, यह निर्धारित करता है, तो स्ट्रिंग है n बात , किसी के लिए n≥2 ।

एन-स्पीक को प्रत्येक अक्षर n बार दोहराकर परिभाषित किया जाता है। साथ n=4 , स्ट्रिंग Helloको तब्दील हो जाता है HHHHeeeelllllllloooo। आपका लक्ष्य यह पता लगाना है कि इनपुट किसी भी n-Speak परिवर्तन के लिए एक वैध आउटपुट है या नहीं।

यह ध्यान दिया जाना चाहिए कि कोई भी वाक्य जो n n- 2 , n=2k मान्य है, वह भी मान्य k-Speak है। इस प्रकार, हल करने के लिए कठिन भागों 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)

बेशक, क्योंकि यह कोड गोल्फ है, कुछ बाइट्स ट्रिम करने के लिए तैयार हो जाओ!

code-golf  string  decision-problem 
— maxb
स्रोत
सुझाया गया परीक्षण का मामला:aabbab
— आदम
सुझाया गया टेस्ट केस:aaaabbb
— 640KB
मैं उन दोनों को कल जोड़ूंगा, अच्छे सुझाव।
— अधिकतम
4
मैं वास्तव में सम्मानित और चापलूसी कर रहा हूँ कि आपने मेरी चुनौती का उपयोग और विस्तार किया है :)
— AJFaraday
@AJFaraday को खुशी हुई कि आपको यह पसंद आया! मैंने आपकी दोनों चुनौतियों का आनंद लिया, जिसने मुझे इस एक के लिए विचार दिया। जल्द ही एक और कठिन चुनौती भी आ सकती है।
— अधिकतम

जवाबों:

16

एपीएल (डायलॉग यूनिकोड) , 12 बाइट्स

के साथ चलता है ⎕io←0

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

इसे ऑनलाइन आज़माएं!

Adám के साथ मिलकर घूमा ।

इनपुट पर (उदाहरण: "aaccccaaaaaabb"का उपयोग करते हुए "") एक स्ट्रिंग (वर्ण की एक सरणी निरूपित करने के लिए और ''एक चार निरूपित करने के लिए)

∊0⍞0 चारों ओर 0s और समतल, 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

जावा 10, 85 बाइट्स

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

Regex ने @Arnauld के जावास्क्रिप्ट उत्तर से पोर्ट किया ।

इसे ऑनलाइन आज़माएं।

स्पष्टीकरण:

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
— केविन क्रूज़सेन
स्रोत
7

जावास्क्रिप्ट (ईएस 6), 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)
— Arnauld
स्रोत
7

05AB1E , 5 बाइट्स

γ€g¿≠

इसे ऑनलाइन आज़माएं!

— आउटगोल्फर को एरिक करें
स्रोत
मुझे लगा कि मैथॉल्फ में मेरा 14-बटर एक अच्छा था, लेकिन आपने इसे कुचल दिया। मुझे इस और आपके जेली उत्तर के लिए स्पष्टीकरण पसंद है।
— अधिकतम
2
@ मैक्सब यह वास्तव में सिर्फ समूह की लंबाई लेता है, उनके GCD और परीक्षणों की गणना करता है यदि यह 1. नहीं है
— आउटगोल्फर
6

पायथन 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 बाइट्स, जीट्स के लिए धन्यवाद

— TFeld
स्रोत
2
आप की जगह 3 बाइट्स बचा सकता है set(...)के साथ{...}
— Jitse
1
इसके अलावा, आप अंतरिक्ष में निकाल सकते हैं...1 in[...
— Jitse
@ जित्स थैंक्स :)
— टीएफडीएल
5

क्वाड्स , 16 बाइट्स SBCS

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

इसे ऑनलाइन आज़माएं!

1≠ 1 से अलग है

∨/ जीसीडी

⍵ के परिणाम के

(.)\1* किसी भी वर्ण के लिए PCRE खोज 0 या उससे अधिक पुनरावृत्ति के बाद

⊃⍵L और मैच की लंबाई के पहले (यानी मैच की लंबाई) को वापस करना

— एडम
स्रोत
4

टी-एसक्यूएल 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

इसे ऑनलाइन आज़माएं

— t-clausen.dk
स्रोत
क्या "कोलायत थाई_इन" वास्तव में आवश्यक है?
— डॉ वाई विट
1
@ यह निर्भर करता है, डेटाबेस संवेदनशील के रूप में स्थापित किया जा सकता है। लेकिन मामले संवेदनशील डेटाबेस एक लोकप्रिय विकल्प नहीं हैं। यह बेहतर ढंग से HASHBYTES या शायद वार्बिनरी का उपयोग करके संभाला जा सकता है, लेकिन यह बाइट्स में अधिक महंगा है
— t-clausen.dk
4

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 बाइट , @ रात 2 तक!

— 640KB
स्रोत
4

पर्ल 6 , 30 27 26 बाइट्स

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

इसे ऑनलाइन आज़माएं!

जीसीडी ट्रिक का भी उपयोग करता है, लेकिन रेगेक्स द्वारा मिलान किए गए प्रत्येक रन की अंतिम स्थिति के सूचकांक का उपयोग करता है। एक नकारात्मक संख्या लौटाता है (सत्य) यदि n- बोलो, शून्य (झूठी)।

— nwellnhof
स्रोत
3

ब्रेकीलॉग , 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.
— असंबंधित स्ट्रिंग
स्रोत
3

कोटलिन , 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
        }
      }
    }
  }
— Brojowski
स्रोत
शायद विवरण अस्पष्ट है, लेकिन "आआ" वैध 3-बोल है। इनपुट स्ट्रिंग में कम से कम दो अक्षर होने चाहिए, लेकिन उन्हें अलग होने की आवश्यकता नहीं है।
— अधिकतम
@ मोमक्स, ओके कूल। यह -2 बाइट्स होना चाहिए। अद्यतन के लिए धन्यवाद। मैं उस कल को ठीक करूँगा
— ब्रजोव्स्की
3

स्काला , 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
— डॉ। वाई विट
स्रोत
यह दुर्भाग्य से trueइनपुट के लिए वापस आ जाता है aab।
— अधिकतम
@ maxb, जाँच के लिए धन्यवाद। कि संभाल के s.साथ बदल दिया (s+s).।
— डॉ वाई वाईट
बहुत बढ़िया! हालांकि अब मैंने देखा कि यह aaaabbऔर के लिए विफल रहता है aabbbb।
— 16
@ maxb, माफी, अब मैंने पोस्ट शुरू करने से आपके सभी परीक्षण मामलों पर परीक्षण किया।
— डॉ वाई विट
2

ब्रेन-फ्लैक , 96 बाइट्स

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

इसे ऑनलाइन आज़माएं!

उसी GCD ट्रिक का उपयोग करता है जिसे कई अन्य सबमिशन उपयोग करते हैं। आउटपुट 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
<>{}({}[()])
— Nitrodon
स्रोत
2

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

यह एक धारणा के साथ काम करता है कि इनपुट डेटा को टेबल टी (एक्स) में संग्रहीत किया जाता है, उदाहरण के लिए

with t(x) as (select 'HHeelllloo,,  wwoorrlldd!!' from dual)
— डॉ। वाई विट
स्रोत
2

के (ngn / k) , २ ९ २३ बाइट्स

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

इसे ऑनलाइन आज़माएं!

संपादित करें: कुछ अनावश्यक कॉलोनों को हटा दिया गया (मुझे पता है कि जब एक राक्षसी की आवश्यकता होती है लेकिन यह हमेशा मेरे लिए स्पष्ट नहीं होता है अगर वहाँ अस्पष्टता है तो मैं बृहदान्त्र को शामिल करने के लिए डिफ़ॉल्ट हूं) और मॉड x-y*x%yको ngn / k के रूप में बदल दिया y!x, जिसका मतलब है कि मैं एक चर संशोधन को हटा सकता हूं

— घसीट
स्रोत
1

एपीएल (डायलॉग यूनिकोड) , 24 22 बाइट्स एसबीसीएस

बेनामी tacit उपसर्ग समारोह।

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

इसे ऑनलाइन आज़माएं!

⊂ पूरे स्ट्रिंग का उपयोग कर नक्शे का इलाज करने के लिए स्ट्रिंग संलग्न करें
 उदा"aaabbb"

⍳∘≢{... }¨ से प्रत्येक के लिए ⍳ ɩ स्ट्रिंग में वर्णों की संख्या के माध्यम से 1 ndices:
 जैसे3

 ⍺↑⍺ वर्तमान संख्या से तत्वों की वर्तमान संख्या लें, 0s
 जैसे पैडिंग[3,0,0]

 (≢⍵)⍴ चक्रीय r eshape स्ट्रिंग में वर्णों की संख्या के आकार में
  जैसे[3,0,0,3,0,0]

 ⍵/⍨ स्ट्रिंग के पात्रों को दोहराने के लिए इसका उपयोग करें
  "aaabbb"

1↓ पहला वाला छोड़ें ( n = 1)

⊂∊ क्या संपूर्ण स्ट्रिंग उस सूची का सदस्य है?

— एडम
स्रोत
क्या आप इनपुट स्ट्रिंग को n- आकार के विखंडू में विभाजित कर रहे हैं, और जाँच रहे हैं कि सभी वर्ण प्रत्येक चंक के भीतर समान हैं? मुझे एपीएल में नहीं मिला है, लेकिन यह निश्चित रूप से सबसे पठनीय "गोल्फिंग" भाषा है।
— अधिकतम
@ मैक्सब मैं एक स्पष्टीकरण लिखने की प्रक्रिया में हूं। मैं सभी संभव मास्क [1,0,0,1,0,0…]आदि के साथ फ़िल्टर कर रहा हूं । मुझे आपको एपीएल सिखाने में खुशी होगी (यह सीखने में लंबा समय नहीं लगता)। बस एपीएल ऑर्चर्ड के लिए पॉप ।
— आदम
यहाँ {1<∨/≢¨⍵⊆⍨≢∘∪¨,\⍵}18 के लिए है
— Kritii Lithos
@ क्लोवर क्लीवर और अलग, तो आप पोस्ट क्यों नहीं करते {1<∨/≢¨⍵⊆⍨≢¨∪\⍵}?
— Adám
दुर्भाग्य से यह विफल हो जाता हैaacccaaaaabb
— कृति लिथोस
1

रेटिना 0.8.2 , 28 बाइट्स

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

इसे ऑनलाइन आज़माएं! लिंक में परीक्षण के मामले शामिल हैं। स्पष्टीकरण:

M!`(.)\1*

पाठ को समान वर्णों के रनों में विभाजित करें।

.
.

उन सभी को एक ही चरित्र के साथ बदलें।

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

जांचें कि रनों की लंबाई का GCD 1 से अधिक है या नहीं।

— नील
स्रोत
1

मैथॉल्फ , 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
— maxb
स्रोत
1

पर्ल 5 -n , 38 बाइट्स

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

इसे ऑनलाइन आज़माएं!

print"\n"पाद लेख में आउटपुट को अलग करने की जरूरत है।

सभी संभव nएस के माध्यम से सीधा लूप । आउटपुट "1-स्पीक" के लिए कुछ भी नहीं है, n-Speak के लिए और कुछ भी नहीं जहाँ n> 1।

— wastl
स्रोत
हमारी साइट का प्रयोग करके, आप स्वीकार करते हैं कि आपने हमारी Cookie Policy और निजता नीति को पढ़ और समझा लिया है।
Licensed under cc by-sa 3.0 with attribution required.