हकलाना एक ऐसी समस्या है जिसका हम में से कई लोगों ने अनुभव किया होगा या कम से कम इसे देखा होगा। यद्यपि अधिकांश प्रसिद्ध भाषण मान्यता सॉफ्टवेयर्स के साथ गंभीर मुद्दों पर बात की जाती है, चलो एक सॉफ्टवेयर की कल्पना करते हैं जो हकलाना समझता है, लेकिन उन्हें ठीक नहीं कर सकता है और केवल उन्हें ही लिख सकता है।

इस तरह के एक सॉफ्टवेयर द्वारा लिखित एक उदाहरण इस तरह हो सकता है: "कृपया सावधान रहें सावधान" । इस उदाहरण में "सावधान" मूल शब्द है और "सीए" स्टट्ड शब्द हैं।

चुनौती

एक प्रोग्राम या फ़ंक्शन लिखें जो मूल शब्दों को रखते हुए इनपुट से हटाए गए शब्दों को ठीक करता है। का उदाहरण तय संस्करण के लिए "कृपया हो सीए सीए सावधान" होगा "कृपया सावधान रहें" ।

यह कोड-गोल्फ है , हर भाषा में सबसे कम जवाब जीतता है!

फंसे हुए शब्द क्या हैं?

हकलाने के कई अलग-अलग रूप हैं। लेकिन इस चुनौती की सरलता के लिए, हम इसे निम्नलिखित नियमों तक सीमित करने जा रहे हैं:

रुके हुए शब्द एक अपूर्ण भाग या पूरे मूल शब्द हो सकते हैं। "असम्बद्ध भाग" से मेरा मतलब है कि मूल शब्द वास्तव में रूके हुए शब्द से शुरू होना चाहिए। उदाहरण के लिए "ope" और "खुले" दोनों के लिए एक stuttered शब्द हो सकता है "खुला" , लेकिन "कलम" के बाद से एक नहीं हो सकता "खुला" के साथ शुरू नहीं करता है "कलम" ।
अटके हुए शब्दों में कम से कम "aeiou" स्वर शामिल होना चाहिए । उदाहरण के लिए "स्टार" "स्टार्ट" के लिए एक स्टूट्ड शब्द हो सकता है क्योंकि इसमें "ए" होता है , लेकिन "सेंट" एक स्टूट्ड शब्द नहीं हो सकता है क्योंकि इसमें कोई उल्लिखित स्वर नहीं है।
रूके हुए शब्द केवल मूल शब्द के सामने आ सकते हैं और मान्य होने के लिए कम से कम दो बार दोहराया जाना चाहिए (मूल शब्द दोहराव में नहीं गिना जाता है)। उदाहरण के लिए "ओओ ओपन" ने शब्दों को तोड़ दिया है, लेकिन "ओ ओपन ओ" नहीं है, क्योंकि मूल शब्द के बाद "ओ" की गिनती नहीं होती है और "ओ" से पहले मूल शब्द कम से कम दो बार दोहराया नहीं जाता है। "गो गो गो गो गो गो" मूल शब्द से पहले फंसे हुए शब्दों के पांच दोहराव हैं और मान्य है।
दोहराए गए शब्दों के एकल सेट में मिश्रित रूप नहीं हो सकते हैं और शब्द एक दूसरे के समान होने चाहिए। उदाहरण के लिए "ओप ओ ओपेन ओपन" को शब्दों के रूप में नहीं गिना जाता है। दूसरी ओर "ओ ओपी ओपेन ओपन" ने शब्दों को तोड़ दिया है क्योंकि पहले "ओ" को यहां एक अलग शब्द के रूप में देखा जाता है और दो "ओपी" को "ओपन" के रूखे शब्दों में गिना जाता है ।
एक-दूसरे के ठीक बाद दोहराए गए शब्दों के कई मान्य सेटों के मामले में, केवल अंतिम मूल शब्द ही रहता है। उदाहरण के लिए, "ooo op op op op" में , "oo o" भाग को पहले "op" के रूखे शब्दों के रूप में देखा जाता है , इसलिए उन्हें हटा दिया जाना चाहिए और फिर "op op op" को "open op op" के रूप में देखा जाता है। " और उन्हें भी हटा दिया जाना चाहिए, इसलिए केवल " खुले " को हटाए गए शब्दों को हटाने के बाद छोड़ दिया जाएगा। आप मान सकते हैं कि दोहराए गए शब्दों के कई वैध सेट केवल बाएं से दाएं होते हैं, इसलिए "ओप ओओ ओपन" को ठीक करने के परिणामस्वरूप "ओप ओपन ओपन" होगा (उर्फ

इनपुट

इनपुट एक एकल पंक्ति स्ट्रिंग है जिसमें केवल ASCII अंग्रेजी अक्षर (az), अंक (0-9) और अंतरिक्ष वर्ण हैं। लेटर केसिंग महत्वपूर्ण नहीं है और आप लोअरकेस या अपरकेस या उन दोनों को स्वीकार करने का निर्णय ले सकते हैं, लेकिन आवरण समान रहना चाहिए और आप इसे आउटपुट में नहीं बदल सकते।
आप ["l","i","s","t"," ","o","f"," ","l","e","t","t","e","r","s"]स्ट्रिंग की बजाय अक्षरों की सूची (जैसे ) का उपयोग कर सकते हैं, लेकिन आप शब्दों की सूची का उपयोग नहीं कर सकते। यदि आपकी भाषा में एक अलग इनपुट संरचना है, तो इसका उपयोग करें। मुद्दा यह है कि इनपुट को शब्दों से अलग नहीं किया जाना चाहिए, इसलिए कुछ भाषाओं में शब्दों को अलग करने की लागत वास्तव में अन्य रचनात्मक समाधानों को ट्रिगर कर सकती है।
इनपुट में कोई भी, एक या एक से अधिक शब्द नहीं हो सकते हैं।
शब्दों और संख्याओं को एक ही स्थान से अलग किया जाता है और इनपुट में एक दूसरे के ठीक बगल में दोहरे स्थान नहीं होंगे।

उत्पादन

एक स्ट्रिंग या पत्र की एक सूची या आपकी भाषा में उपयुक्त संरचना जिसमें इनपुट से हटाए गए सभी लटके हुए शब्द हैं।
आउटपुट शब्दों को बिल्कुल एक स्थान (इनपुट के समान) द्वारा अलग किया जाना चाहिए।
सिंगल लीडिंग और ट्रेलिंग न्यूलाइन या स्पेस की अनुमति है।

मानक खामियों को मना किया जाता है।

परीक्षण के मामलों

कोई शब्द नहीं:

"hello world" => "hello world"

दोहराए गए शब्दों का एक एकल उदाहरण:

"ope ope ope ope open the window" => "open the window"

दोहराया शब्दों के कई उदाहरण:

"there is is is is something un un under the the the table" => "there is something under the table"

कोई रूका हुआ शब्द नहीं, पर्याप्त दोहराया नहीं:

"give me the the book" => "give me the the book"

कोई स्टूट्ड शब्द नहीं है, कोई भी उल्लिखित स्वर नहीं है:

"h h help m m m me" => "h h help m m m me"

संख्याओं को शब्दों में बँधा नहीं है, उनके पास उल्लिखित स्वर नहीं हैं:

"my nu nu number is 9 9 9 9876" => "my number is 9 9 9 9876"

लेकिन दोनों स्वरों और संख्याओं के साथ एक शब्द में अटके हुए शब्द हो सकते हैं:

"my wi wi windows10 is slow" => "my windows10 is slow"

एक ही रिपीट ग्रुप में अटके शब्दों के अलग-अलग रूपों की गणना नहीं की जाती है:

"this is an ant antarctica does not have" => "this is an ant antarctica does not have"

एक दूसरे के ठीक बाद के शब्दों के कई निरंतर सेटों के लिए, केवल अंतिम मूल शब्द रखें:

"what a be be be beauti beauti beautiful flower" => "what a beautiful flower"

यह एक दूसरे के ठीक बाद के कई निरंतर सेट का मामला नहीं है:

"drink wat wat wa wa water" => "drink wat wat water"

खाली इनपुट:

"" => ""

टिप्पणियों से अधिक मामले:

"a ab abc" => "a ab abc"
"a ab ab abc" => "a abc"
"ab ab abc abcd" => "abc abcd"
"a a ab a able" => "ab a able"
"i have ave ave average" => "i have average"
"my wi wi windows 10 is cra cra crap" => "my windows 10 is crap"

उपरोक्त परीक्षण मामलों की सूची की प्रतिलिपि बनाना आसान है:

"hello world",
"ope ope ope ope open the window",
"there is is is is something un un under the the the table",
"give me the the book",
"h h help m m m me",
"my nu nu number is 9 9 9 9876",
"my wi wi windows10 is slow",
"this is an ant antarctica does not have",
"what a be be be beauti beauti beautiful flower",
"drink wat wat wa wa water",
"",
"a ab abc",
"a ab ab abc",
"ab ab abc abcd",
"a a ab a able",
"i have ave ave average",
"my wi wi windows 10 is cra cra crap"

code-golf string

— Night2
स्रोत

2

"drink wat wat wa wa water" => "drink wat wat water"यह वास्तव में ऐसा लगता है कि नियम को पुनरावर्ती रूप से लागू करना चाहिए ताकि यह "पेय पानी" बन जाए

— जोनाह

2

@ जोना अगर आप अंतिम शब्द को पढ़ते हैं तो कौन से शब्द हैं? मैंने इस मामले को समझाया है। "वाट वा" "वा" के लिए शब्द नहीं हैं और हम केवल एक बार ठीक करते हैं, इसलिए एक बार जब हम "वाज़ वॉटर वॉटर" पी लेते हैं, तो हम नए बने स्टुट्ड शब्दों को हटाने के लिए फिर से ठीक नहीं करते हैं। लेकिन एक उल्टे मामले में जैसे "वा वा वा वाट वाटर" का परिणाम "पानी" होगा क्योंकि "वा वा" पहले "वाट" के लिए शब्द हैं और "वाटर" भी "पानी" के शब्द हैं।

— रात 2

ठीक है, ठीक है, मैं कह रहा था कि जब तक आप किसी भी अधिक नहीं कर सकते, तब तक इसे ठीक रखने के लिए समझ में आता है, लेकिन मैं एक पुनरावृत्ति पर भी ध्यान केंद्रित करने के लिए तर्क देख सकता हूं।

— जोनाह

6

सी (जीसीसी), 183 180 178 बाइट्स

f(s,t,u,T,e,r)char*s,*t,*u,*r;{for(;s=index(u=s,32);T>1&strpbrk(u,"aeiou")-1<s&&memmove(s=u,t-e,r-t-~e))for(e=++s-u,r=u+strlen(t=u),T=0;(t+=e)<r&!memcmp(u,t,e-1)&t[-1]==32;++T);}

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

खैर, सी निश्चित रूप से रेगेक्स की संक्षिप्तता के साथ प्रतिस्पर्धा नहीं कर सकता ...

यह विशेष रूप से पढ़ने के लिए कठिन है क्योंकि मैंने पूरे फ़ंक्शन को एक ही नेस्टेड जोड़ी में forछोरों के साथ ढहते हुए समाप्त कर दिया (शरीर के साथ नहीं!)। यह मूल्यांकन के आदेश को सभी विजयी बनाता है - शुरुआत के पास कोड वास्तव में अंतिम रूप से निष्पादित होता है।

मेरा पसंदीदा चाल यहाँ है strpbrk(u,"aeiou")-1<s। इसका उपयोग यह जांचने के लिए किया जाता है कि दोहराए गए शब्द में स्वर हैं या नहीं। uदोहराया शब्द की शुरुआत के लिए sअंक , और शब्द के दूसरे पुनरावृत्ति को इंगित करता है; उदाहरण के लिए:

"my nu nu number is 9 9 9 9876"
    ^  ^
    u  s

strpbrkतो में पहले वर्ण पाता है "aeiou"के बाद प्रदर्शित होने वाली u। (इस मामले में, यह 'u'तुरंत बाद है।) फिर हम जांच सकते हैं कि इस sशब्द को सत्यापित करने से पहले एक स्वर शामिल है। लेकिन वहाँ एक मामूली मुद्दा है - strpbrkरिटर्न NULL(यानी 0) अगर पूरे स्ट्रिंग में कोई स्वर नहीं है। इसे ठीक करने के लिए, मैं बस 1 घटाना है, जो बदल जाता है 0में 0xffffffffffffffff(मेरी मशीन पर) अतिप्रवाह के कारण। एक पॉइंटर का अधिकतम मूल्य होने के नाते, यह निश्चित रूप से अधिक होता है s, जिससे चेक विफल हो जाता है।

यहां टिप्पणियों के साथ थोड़ा पुराना संस्करण (परिवर्तन से पहले नियंत्रण प्रवाह में गड़बड़ी) है:

f(s,t,u,c,n,e)char*s,*t,*u,*e;{
    // set s to the position of the *next* check; u is the old position
    for(;s=index(u=s,32);) {
        // count the length of this word (incl. space); also fix s
        n=++s-u;
        // find the end of the string; assign temp pointer to start
        e=u+strlen(t=u);
        // count repetitions of the word
        for(c=0;                // number of repetitions
            (t+=n)              // advance temp pointer by length of word
            <e&&                // check that we haven't hit the end...
            !strncmp(u,t,n-1)&& // ...and the word matches...
            t[-1]==32;          // ...and the previous character was space
            ++c);               // if so, increment count
        // decide whether to remove stuttering
        c>1&&                    // count must be at least 2
        strpbrk(u,"aeiou")-1<s&& // word must contain a vowel
        // if so, move everything after the last occurrence back to the
        // beginning, and also reset s to u to start scanning from here again
        memmove(s=u,t-n,e-t+n+1);
    }
}

के लिए धन्यवाद @ user1475369 3 बाइट्स और के लिए @ceilingcat 2 बाइट्स के लिए।

— Doorknob
स्रोत

-3 बाइट्स के T>1&&strpbrkसाथ T>1&strpbrk, के r&&!strncmpसाथ r&!strncmpऔर &&t[-1]साथ की जगह &t[-1]।

— जिरोबुज़

tio.run/##bVHbjpswEH3PV0yRGtnBSEtW6kWs@xV5a/…

— girobuz

@ceilingcat आपका लिंक कुछ परीक्षण मामलों में विफल रहता है, लेकिन उन 3 अनुकूलन में से 2 काम करते हैं; धन्यवाद!

— दरवाज़े

bcmp()इसके बजाय सुझाव देंmemcmp()

— सीलिंगकैट

4

पर्ल 5 (-पी), 34 बाइट्स

Arnauld के हटाए गए उत्तर के आधार पर।

s/(\b(\w*[aeiou]\w*) )\1+(?=\2)//g

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

— ग्रिमी
स्रोत

यह "ज़ा ए अब" के लिए "ज़ैब" का उत्पादन करता है। मुझे नहीं लगता कि उस इनपुट में पाया गया एक हकलाना होना चाहिए।

— पुनरावर्ती

@recursive धन्यवाद, निश्चित।

— ग्रैमी

2

मैंने परीक्षण के मामलों को देखा और एक रेगीक्स तैयार किया, केवल इसे पहले से ही यहां खोजने के लिए। स्वाभाविक रूप से इसका मतलब है कि तुच्छ रेटिना बंदरगाह 30 बाइट्स है।

— नील

3

05AB1E , 30 29 28 बाइट्स

-1 केविन क्रूज़सेन को धन्यवाद

#Rγε®y¬©žMÃĀiнkĀDygαΘ+∍]R˜ðý

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

05AB1E, कोई रेग्जेस नहीं है, निश्चित रूप से इस कार्य के लिए सबसे अच्छा उपकरण की तरह नहीं दिखता है। फिर भी, यह किसी तरह से सिर्फ बमुश्किल रेटिना को हरा पाता है।

#                     # split on spaces
 R                    # reverse the list of words
  γ                   # group consecutive identical words together

ε                   ] # for each group of words y:
 ®                    #  push the previous word on the stack (initially -1)
  y                   #  push another copy of y
   ¬                  #  push the first element without popping
    ©                 #  save the current word for the next loop
     žM               #  built-in constant aeiou
       ÃĀi          ] #  if the length of the intersection is non-zero:
           н          #   take the first element of y
            kĀ        #   0 if the previous word starts with this word, 1 otherwise
              D       #   duplicate
               yg     #   length of y (the number of consecutive identical words)
                 α    #   subtract the result of the startsWith check
                  Θ   #   05AB1E truthify (1 -> 1, anything else -> 0)
                   +  #   add the result of the startsWith check
                    ∍ #   set the length of y to that value
                      #  otherwise leave y unchanged

˜                     # flatten the modified list of groups of words
 R                    # reverse the list of words
  ðý                  # join with spaces

— ग्रिमी
स्रोत

1

आप से gपहले हटा सकते हैं Ā। पायथन शैली की सत्यता पहले से ही 0खाली तारों के लिए और 1गैर-खाली तारों के लिए परिणाम होगी ।

— केविन क्रूज़सेन

@KevinCruijssen अच्छा लगता है!

— ग्रिमनी

1

पर्ल 6 , 45 बाइट्स

{S:g/<|w>(\S*<[aeiou]>\S*)\s$0+%%\s{}<?$0>//}

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

एक साधारण रेगेक्स उत्तर जो स्टुटर्स के सभी मिलानों को खाली स्ट्रिंग के साथ प्रतिस्थापित करता है।

— मजाक कर रहा है
स्रोत

1

स्टेक्स , 26 बाइट्स

å╬↓<▀.₧▀"╦n▐∞↨vß%ù:Qa3@=↔_

इसे चलाएं और डीबग करें

@ ग्रिम के पर्ल उत्तर से सीधा पोर्ट। स्टेक्स रेगेक्स पैटर्न शाब्दिक रूप से सिकुड़ने में सक्षम है, और इसमें एक स्वर स्थिरांक है जो सिकुड़ने में सक्षम है [aeiou]।

— पुनरावर्ती
स्रोत

1

साफ , 184 बाइट्स

import StdEnv,Data.List,Text
$s=join[' '](f(group(split[' ']s)))
f[[a]:t]=[a:f t]
f[h=:[a:_]:t=:[[b:_]:_]]|intersect['aeiou']a==[]=h++f t|isPrefixOf a b=f t=if(h>[a,a])[a]h++f t
f[]=[]

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

परिभाषित करता है $ :: [Char] -> [Char], जो रिक्त स्थान और समूहों पर इनपुट स्ट्रिंग को विभाजित करता है समान तत्व जो तब सहायक द्वारा ढह जाते हैं f :: [[[Char]]] -> [[Char]], लौटने से पहले शामिल होते हैं।

— Οurous
स्रोत

मेरे अटके शब्दों को ठीक करो

चुनौती

फंसे हुए शब्द क्या हैं?

इनपुट

उत्पादन

परीक्षण के मामलों

उपरोक्त परीक्षण मामलों की सूची की प्रतिलिपि बनाना आसान है:

सी (जीसीसी), 183 180 178 बाइट्स

पर्ल 5 (-पी), 34 बाइट्स

05AB1E , 30 29 28 बाइट्स

पर्ल 6 , 45 बाइट्स

स्टेक्स , 26 बाइट्स

साफ , 184 बाइट्स