पुनरावर्ती योग

Question

लक्ष्य

से विकिपीडिया :

एक पुनरावर्ती संक्षिप्तिकरण एक ऐसा संक्षिप्त नाम है जो स्वयं को उस अभिव्यक्ति के लिए संदर्भित करता है जिसके लिए वह खड़ा है।

आपका लक्ष्य यह जांचना है कि क्या एक स्ट्रिंग एक पुनरावर्ती संक्षिप्त है।

• संक्षिप्त नाम पहला शब्द है
• शब्द संवेदनशील नहीं होते, एक ही स्थान से अलग होते हैं।
• दिए गए स्ट्रिंग में कोई विराम चिह्न नहीं है और न ही एपोस्ट्रोफ।
• प्रत्येक शब्द का केवल पहला अक्षर ब्रीफकेस का हिस्सा हो सकता है।

आपको फ़ंक्शन शब्द भी देना चाहिए । सादगी के लिए, प्रत्येक शब्द को एक फ़ंक्शन शब्द माना जा सकता है।

उदाहरण

f("RPM Package Manager")         =>     { true, [] }
f("Wine is not an emulator")     =>     { true, ["an"] }
f("GNU is not Unix")             =>     { true, ["is"] }
f("Golf is not an acronym")      =>     { false }  
f("X is a valid acronym")        =>     { true, ["is","a","valid","acronym"] }  

आप एक पूर्ण कार्यक्रम या एक समारोह दे सकते हैं।
इनपुट स्ट्रिंग को STDIN से या एक फ़ंक्शन तर्क के रूप में लिया जा सकता है।
आउटपुट परिणाम सही / गलत हो सकता है, 0/1, हां / नहीं ...
फ़ंक्शन शब्द सूची (सूची का कोई भी प्रारूप मान्य है) दिया जाना चाहिए यदि और केवल यह एक पुनरावर्ती संक्षिप्त नाम (भले ही सूची खाली हो) । आपको फ़ंक्शन शब्दों के कैपिटलाइज़ेशन को संरक्षित करने की आवश्यकता नहीं है।

मानदंड जीतना

यह एक कोड-गोल्फ , सबसे छोटा कोड जीत है।

Comments

क्या हमें फ़ंक्शन शब्दों के कैपिटलाइज़ेशन को संरक्षित करना है?

— एल्गोरिथमशार्क

क्या यह गलत मूल्य के साथ तार की सूची के लिए स्वीकार्य है, या नहीं?

— अंडरग्राउंडोरेल

चूँकि शब्द सूची स्वयं बूलियन मान को अपनी उपस्थिति के द्वारा एनकोड करती है, क्या हम बूलियन को छोड़ सकते हैं?

— जॉन ड्वोरक

हर्ड यूनिक्स-रिप्लेसमेंट डेमन्स के हर्ड के लिए खड़ा है। Hird का मतलब है हर्ड ऑफ इंटरफेसेस रिप्रेजेंटेटिव डेप्थ। यहाँ उदाहरण क्यों समझ में नहीं आता है, और दावा है कि पुनरावर्ती योग नहीं हैं?

— कोनराड बोरोस्की

@xfix, विकिपीडिया बताता है कि वे पारस्परिक पुनरावर्ती शब्दकोष हैं ।

— माइकल एम।

Answer 1

गोल्फस्क्रिप्ट, 51 50 चार्ट

{32|}%" "/(1>\{.1<2$1<={;1>}{\}if}/{]!}{]`1" "@}if

यह शायद आगे गोल्फ हो सकता है। STDIN पर इनपुट लेता है। बूलियन 0/1 है।

ऑनलाइन टेस्ट करें

---

स्पष्टीकरण:

{32|}%      # change everything to lower-case
" "/        # splits the string by spaces
(1>         # takes the first word out and removes the first letter
\           # moves the list of remaining words in front of the acronym word
{           # for every word:
  .1<2$1<=    # compares the first letter of the word with
              # the next unmatched letter of the acronym
  {;1>}       # if they are the same, discard the word and the now-matched letter
  {\}         # otherwise store the word in the stack
  if          # NB. if all letters have been matched, the comparison comes out as false
}/
{]!}        # if there are still unmatched letters, return 0 (`!` non-empty list)
{]`1" "@}   # otherwise, return 1, and display the list of function words
if

Answer 2

रेगेक्स, .NET स्वाद, 62 बाइट्स

(?i)(?<=^\w(?<c>\w)*)( \k<c>(?<-c>)\w+| (?<w>\w+))*$(?(c)(?!))

आप इसे यहाँ परीक्षण कर सकते हैं । यदि इनपुट एक पुनरावर्ती संक्षिप्त नाम है, तो यह एक मिलान प्राप्त करेगा, और कैप्चरिंग समूह wमें सभी फ़ंक्शन शब्द होंगे। यदि यह नहीं है, तो कोई मुकाबला नहीं होगा।

यह फ़ंक्शन शब्दों के कैपिटलाइज़ेशन को संरक्षित करता है (लेकिन केस-असंवेदनशील रूप से मेल खाता है)।

दुर्भाग्य से, परीक्षक एक नामित कैप्चरिंग समूह के पूरे स्टैक को प्रदर्शित नहीं करता है, लेकिन यदि आपने इसे .NET में कहीं भी उपयोग किया है w समूह करेगा आदेश में सभी समारोह शब्द होते हैं।

यहाँ एक C # स्निपेट साबित करना है कि:

var pattern = @"(?i)(?<=^\w(?<c>\w)*)( \k<c>(?<-c>)\w+| (?<w>\w+))*$(?(c)(?!))";
var input = new string[] {
    "RPM Package Manager",
    "Wine is not an emulator",
    "GNU is not Unix",
    "Golf is not an acronym",
    "X is a valid acronym"
};

var r = new Regex(pattern);
foreach (var str in input)
{
    var m = r.Match(str);
    Console.WriteLine(m.Success);
    for (int i = 0; i < m.Groups["w"].Captures.Count; ++i)
        Console.WriteLine(m.Groups["w"].Captures[i].Value);
}

यहाँ एक त्वरित स्पष्टीकरण है। मैं इस स्निपेट के साथ नाम समूह में संक्षिप्त अक्षरों के ढेर का निर्माण करने के लिए .NET के संतुलन समूहों का उपयोग कर रहा हूंc

^\w(?<c>\w)*

चाल यह है कि मुझे स्टैक के शीर्ष पर दूसरे अक्षर की आवश्यकता है और सबसे नीचे अंतिम एक है। इसलिए मैंने इन सभी को एक ऐसे लुकबाइंड में डाल दिया, जो कि एक्सीडेंट के बाद की स्थिति से मेल खाता है । यह मदद करता है, क्योंकि .NET मैच को दाएं से बाएं देखता है, इसलिए यह पहले अक्षर से सामना करता है।

एक बार जब मुझे वह स्टैक मिल गया, तो मैं शब्द के बाकी स्ट्रिंग शब्द से मेल खाता हूं। या तो शब्द की शुरुआत एक्ट्रेस स्टैक के ऊपर अक्षर से होती है। उस स्थिति में मैं उस पत्र को स्टैक से पॉप करता हूं:

 \k<c>(?<-c>)\w+

अन्यथा, मैं वैसे भी शब्द से मेल खाता हूं और wस्टैक पर धक्का दूंगा जिसमें फिर सभी फ़ंक्शन शब्द होंगे:

 (?<w>\w+)

अंत में मैं यह सुनिश्चित करता हूं कि मैं स्ट्रिंग के अंत तक पहुंच गया हूं $और यह भी सुनिश्चित करता हूं कि मैंने सभी अक्षरों का उपयोग किया है, यह देखकर कि स्टैक खाली है:

(?(c)(?!))

इसे आइडोन पर टेस्ट करें।

Comments

महान नियमित अभिव्यक्ति, लेकिन सवाल स्पष्ट रूप से कहता है "आप एक पूर्ण कार्यक्रम दे सकते हैं या एक समारोह "।

— टूथब्रश

@toothbrush अगर ओपी उस आधार पर मेरे जवाब को अयोग्य घोषित करने का फैसला करता है, तो ऐसा ही हो। लेकिन मुझे लगता है कि मैं एक बिंदु बना सकता हूं कि यह भाषा का एक पूर्ण कार्यक्रम है जो .NET की नियमित अभिव्यक्ति स्वाद है (ट्यूरिंग पूरी भाषा नहीं है, और एक जो चलाने के लिए थोड़ा बोझिल है, लेकिन फिर भी एक भाषा है)। किसी भी मामले में, मैं इस तथ्य को पसंद करता हूं कि मैंने इसे शुद्ध-रेगेक्स दृष्टिकोण के साथ हल किया, और मेरे पास इसका जवाब होगा कि "लालित्य" (यदि आप होगा) को नष्ट करने के बजाय अयोग्य घोषित किया गया है, तो "रेगेक्स का उपयोग करके" सिर्फ एक सी # "।

— मार्टिन एंडर

मेरे साथ ठीक है। मैं सिर्फ यह बताना चाहता था कि आप इसे याद कर रहे हैं।

— टूथब्रश

मुझें यह पसंद है। Regexes एक ट्यूरिंग-पूर्ण प्रोग्रामिंग भाषा नहीं हो सकती है, लेकिन मुझे लगता है कि इसे गिनना चाहिए।

— पॉल ड्रेपर

@PaDDper वास्तव में, मैं .NET के रेगेक्स फ्लेवर पर भी दांव नहीं लगाऊंगा। ट्यूरिंग पूरी नहीं ... बैलेंसिंग ग्रुप और राइट-टू-लेफ्ट-मैचेड लुकबाइंड्स बहुत शक्तिशाली हैं। उदाहरण के लिए पीसीआरई को ट्यूरिंग पूर्ण होने के लिए जाना जाता है (जो कि पुनरावर्ती है, मुझे यकीन नहीं है कि .NET में ढेर मनमाने ढंग से पुनरावृत्ति के लिए पर्याप्त हैं)।

— मार्टिन एंडर

Answer 3

पायथन (158, रेगेक्स के बिना)

ऐसा नहीं है कि मुझे रेगेक्स पसंद नहीं है। यह है कि मैं उन्हें नहीं जानता।

def f(x):
 s=x.lower().split();w=list(s[0][1:]);s=s[1:];o=[]
 if not w:return 1,s
 [w.pop(0)if i[0]==w[0]else o.append(i)for i in s]
 return(0,)if w else(1,o)

ओह, मेरा भी एक अनगुल्ड संस्करण था:

def acronym(string):
    scentence = string.lower().split()
    word = scentence[0][1:]
    scentence = scentence[1:]
    over = []
    if not word: return 1, scentence
    for item in scentence:
        if item[0] == word[0]:
            word = word[1:]
        else:
            over.append(item)
    if word:
        return 0,
    return 1,over

Answer 4

अजगर 2.7 - 131 126 बाइट्स

def f(s):
 s=s.lower().split();a,f=list(s[0]),[]
 for w in s:f+=0*a.pop(0)if a and w[0]==a[0]else[w]
 return(0,)if a else(1,f)

संक्षिप्त नाम के पहले शब्द में अक्षरों की एक सूची बनाता है। फिर, पूर्ण स्ट्रिंग में प्रत्येक शब्द के लिए, उस सूची के पहले तत्व से छुटकारा पाएं जिसे हमने बनाया है यदि यह उस शब्द के पहले अक्षर के समान है। अन्यथा, उस शब्द को फ़ंक्शन शब्दों की सूची में जोड़ें। आउटपुट के लिए, रिटर्न not a(अजगर में, खाली सूची के अलावा कोई भी सूची है True-y, और सूची खाली है यदि यह एक पुनरावर्ती संक्षिप्त है) और सूची यदि not a।

एक त्रुटि को ठीक करने / कुछ बाइट्स बचाने में मदद करने के लिए @ace का धन्यवाद।

Comments

पायथन 2.7.3 पर, मैं पंक्ति SyntaxError: invalid syntaxके अंत में मिलता हूं return।

— pastebin.com 0mr8spkT

@ace हुह, जब मैं इसका परीक्षण किया तो मैं यह काम कर सकता था। मैं कुछ बदल दिया है और फिर से परीक्षण करने के लिए भूल गया होगा। मैं एक तय पर काम करूँगा!

— अंडरग्राउंडोरेल

आप उपयोग कर सकते हैं for w in s:f+=0*a.pop(0)if a and w[0]==a[0]else[w]जो छोटा है और टैब पर निर्भर नहीं है। returnकथन के अनुसार, मैंने पाया 0if a else(1,f)कि जो आपके मूल से छोटा है।

— pastebin.com 0mr8spkT

ओह, और यदि आप एक ही पंक्ति में पहले दो बयान डालने के लिए अर्धविराम का उपयोग करते हैं तो आप इंडेंटेशन के एक बाइट को बचाते हैं।

— pastebin.com 0mr8spkT

मैंने त्रुटि को ठीक करने का एक तरीका खोजा, लेकिन जब मैं यहां वापस आया तो इसे पोस्ट करने के लिए आपने इसे टिप्पणियों में और नीचे रखा था: पी

— भूमिगत

Answer 5

पायथन - 154 वर्ण

पहली बार गोल्फ प्रयास कोड। मुझे लगता है कि अजगर इसके लिए सबसे अच्छी भाषा नहीं है, सभी लंबे कीवर्ड दिए गए हैं। इसके अलावा, मुझे नहीं लगता कि यह फ़ंक्शन मूर्खतापूर्ण है। यह ओपी के इनपुट के लिए काम करता है, लेकिन मुझे यकीन है कि मैं अपवादों के बारे में सोच सकता था।

def f(s):
    w=s.lower().split();r=list(w[0]);return(True,[x for x in w if x[0]not in r])if len(r)==1 or[x for x in[y[0]for y in w]if x in r]==r else False

Comments

मैं १५६ अक्षर (न्यूलाइन और टैब कैरेक्टर दोनों को गिनता हूं) को गिनता हूं, लेकिन आप उन दो पात्रों को हटाकर इसे १५४ तक वैध रूप से प्राप्त कर सकते हैं क्योंकि न तो वास्तव में आवश्यक हैं। PPCG, btw में आपका स्वागत है। :)

— भूमिगत '

Answer 6

ECMAScript 6 (105 बाइट्स):

f=s=>(r=(a=s.toUpperCase(i=1).split(' ')).map((w,c)=>c?a[0][i]==w[0]?(i++,''):w:''),a[0].length==i?1+r:0)

फ़ायरफ़ॉक्स के ब्राउज़र कंसोल में फ़ंक्शन दर्ज करें, और फिर फ़ंक्शन को इस तरह से कॉल करें:

f('ABC Black Cats')     // 1,,
f('ABC is Black Cats')  // 1,IS,,
f('ABC Clapping Cats')  // 0

Comments

नियमों का बहुत अनुपालन नहीं करता है The function words list ... must be given if and only if this is a recursive acronym:। यह उन्हें सतर्क करेगा।

— MT0

@ MT0 ठीक है। मैंने उस आवश्यकता पर ध्यान नहीं दिया। मैं देखूंगा कि क्या मैं इसे फिर से लिख सकता हूं।

— टूथब्रश

@ MT0 मैंने अभी कोड अपडेट किया है।

— टूथब्रश

Answer 7

हास्केल - 287 बाइट्स

सबसे छोटी प्रविष्टि नहीं (अरे यह हास्केल है, आपसे क्या अपेक्षा थी?), लेकिन फिर भी लिखने में बहुत मज़ा आता है।

import Data.Char
import Data.List
f""w=map((,)False)w
f _[]=[]
f(a:as)(cs@(c:_):w) 
 |toLower a==toLower c=(True,cs):f as w
 |True=(False,cs):f(a:as)w
g s=if(length$filter(fst)d)==length v
  then Just$map(snd)$snd$partition(fst)d 
  else Nothing
 where 
  w=words s
  v=head w
  d=f v w

के साथ परीक्षण किया गया

map (g) ["RPM Package Manager","Wine is not an emulator","GNU is not Unix","Golf is not an acronym","X is a valid acronym"]

अपेक्षित उत्पादन

[Just [],Just ["an"],Just ["is"],Nothing,Just ["is","a","valid","acronym"]]

Ungolfed

import Data.Char
import Data.List

f :: String -> [String] -> [(Bool, String)]
f "" w = map ((,) False) w
f _ [] = []
f (a:as) ((c:cs):w) | toLower a == toLower c = (True, c:cs) : f as w
                    | otherwise = (False, c:cs) : f (a:as) w

g :: String -> Maybe [String]
g s = if (length $ filter (fst) d) == (length v)
          then Just $ map (snd) $ snd $ partition (fst) d 
          else Nothing
  where w = words s
        v = head w
        d = f v w

Answer 8

जावास्क्रिप्ट (ECMAScript 6) - 97 वर्ण

f=x=>(r=(a=x.toLowerCase(i=0).split(' ')).filter(y=>y[0]!=a[0][i]||i-i++),i==a[0].length?[1,r]:0)

टेस्ट:

f("RPM Package Manager")
[1, []]

f("GNU is not Unix")
[1, ["is"]]

f("X is an acronym")
[1, ["is", "an", "acronym"]]

f("Golf is not an acronym")
0

f("Wine is not an emulator")
[1, ["an"]]

Answer 9

प्रतिबल - 133

f: func[s][w: next take s: split s" "y: collect[foreach n s[either n/1 = w/1[take w][keep n]]]reduce either/only w: empty? w[w y][w]]

Ungolfed:

f: func [s] [
    w: next take s: split s " "
    y: collect [
        foreach n s [
            either n/1 = w/1 [take w][keep n]
        ]
    ]
    reduce either/only w: empty? w [w y][w]
]

के साथ परीक्षण किया गया:

foreach t [
    "RPM Package Manager"  "Wine is not an emulator"  
    "GNU is not Unix"      "Golf is not an acronym"  
    "X is a valid acronym"
][probe f t]

आउटपुट:

[true []]
[true ["an"]]
[true ["is"]]
[false]
[true ["is" "a" "valid" "acronym"]]

Answer 10

जूलिया - 116 बाइट्स

f(w)=(a=split(lowercase(w));L=1;A=a[];while a!=[];a[][1]==A[1]?A=A[2:]:(L=[L,a[]]);a=a[2:];A>""||return [L,a];end;0)

कम गोल्फ वाला:

f(w)=(
 a=split(lowercase(w))
 L=1
 A=a[]
 while a!=[]
  if a[][1]==A[1]
   A=A[2:]
  else
   L=[L,a[]]
  end
  a=a[2:]
  if !(A>"")
   return [L,a]
  end
 end
0)

0अंत पर यह उत्पादन 0. अन्यथा बनाता है, यह आउटपुट एक सरणी युक्त 1समारोह शब्दों द्वारा पीछा किया। उदाहरण के लिए:

julia> f("RPM Package Manager")
1-element Array{Any,1}:
 1

julia> f("Golf is not an acronym")
0

julia> f("GNU is not Unix")
2-element Array{Any,1}:
 1    
  "is"

julia> f("X is a valid acronym")
5-element Array{Any,1}:
 1         
  "is"     
  "a"      
  "valid"  
  "acronym"

Answer 11

ब्रेकीलॉग , 29 बाइट्स

ḷṇ₁XhY∧X;0zpᵐz{ċ₂ˢ}ᵐZhhᵐcY∧Zt

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

आउटपुट चर के माध्यम से फ़ंक्शन शब्दों को आउटपुट करता है यदि इनपुट एक पुनरावर्ती संक्षिप्त है, और विफल रहता है यदि यह नहीं है।

   X                             X is
ḷ                                the input lowercased
 ṇ₁                              and split on spaces,
    hY                           the first element of which is Y
      ∧                          (which is not X).
       X  z                      X zipped
        ;0                       with zero,
           pᵐ                    with all pairs permuted (creating a choicepoint),
             z                   zipped back,
              {   }ᵐ             and with both resulting lists
               ċ₂ˢ               losing all non-string elements,
                    Z            is Z.
                      hᵐ         The first elements of the elements of
                    Zh           the first element of Z
                        cY       concatenated are Y
                          ∧      (which is not Z).
                           Zt    The last element of Z is the output.

उत्पादन के लिए समारोह शब्द (एक शुद्ध रूप में इस इलाज के बिना निर्णय समस्या ), यह सिर्फ 12 बाइट्स बाहर आता है, क्योंकि ∧Zt-3 के लिए छोड़ा जा सकता है, Yसाथ बदला जा सकता .-1 के लिए, और सबसे महत्वपूर्ण ;0zpᵐz{ċ₂ˢ}ᵐZhसाथ बदला जा सकता ⊇के लिए अ -13:ḷṇ₁Xh.∧X⊇hᵐc

Answer 12

कोबरा - 187

def f(s as String)
    l=List<of String>(s.split)
    a=l[0]
    l.reverse
    o=0
    for c in a,for w in l.reversed
        if c==w[0]
            l.pop
            o+=1
            break
    x=o==a.length
    print x,if(x,l,'')

Answer 13

रूबी - 173

बेहतर हो सकता था...

 f=->s{a=[];o={};s=s.split;r=true;s[0].each_char{|c|s.each{|w| w[0]=~/#{c}/i?(o[c]=1;a<<w if o[c]):(o[c]=0 if !o[c])}};r,a=false,s if o.values&[0]==[0];!r ?[r]:[r,(s-(a&a))]}

फंक कॉलिंग:

p f.call('RPM Package Manager')
p f.call('Wine is not an emulator')
p f.call("GNU is not Unix")
p f.call("Golf is not an acronym")
p f.call("X is a valid acronym")

आउटपुट:

[true, []]
[true, ["an"]]
[true, ["is"]]
[false]
[true, ["is", "a", "valid", "acronym"]]

Answer 14

जावा - 195

दुर्भाग्य से, जावा ने टपल समर्थन में नहीं बनाया है।

तो, यह एक वर्ग है जो बूलियन को 'बी' में और फंक्शन शब्द सूची को 'x' में संग्रहीत करता है।

यहाँ, फ़ंक्शन क्लास का कंस्ट्रक्टर है।

static class R{boolean b;String[]x;R(String s){String v=" ",i="(?i)",f=s.split(v)[0],r=i+f.replaceAll("(?<=.)",".* ");if(b=(s+=v).matches(r))x=(s.replaceAll(i+"\\b["+f+"]\\S* ","")+v).split(v);}}

परीक्षा

public class RecursiveAcronyms {
public static void main(String args[]) {
    String[] tests = {
            "RPM Package Manager",
            "Wine is not an emulator",
            "GNU is not Unix",
            "Golf is not an acronym",
            "X is a valid acronym"
        };
    for (String test:tests) {
        R r = new R(test);
        System.out.print(r.b);
        if (r.b) for (String s:r.x) System.out.print(" "+s);
        System.out.print("\n");
    }
}
static class R{boolean b;String[]x;R(String s){String v=" ",i="(?i)",f=s.split(v)[0],r=i+f.replaceAll("(?<=.)",".* ");if(b=(s+=v).matches(r))x=(s.replaceAll(i+"\\b["+f+"]\\S* ","")+v).split(v);}}}

Comments

सी # में ट्यूपल्स हैं, लेकिन मैं अपने समाधान पर काम करते समय इसके साथ आया: बस वापसी string[]: nullबस झूठ का मतलब है, खाली का मतलब सच है और nतत्वों का मतलब nफ़ंक्शन शब्दों के साथ सच है ।

— नंबर लॉक

मैं वह भी करना चाहूंगा। हालांकि, ओपी निर्दिष्ट करता है कि बूलियन को परवाह किए बिना प्रदान किया जाना चाहिए। जान ड्वोरक की टिप्पणी का उत्तर देखें।

— vectorized

मैं टिप्पणियों के बारे में परवाह नहीं करता क्योंकि मैं मूल पोस्ट में एक परिणामी संपादन संपादित नहीं कर सकता। और यहां तक ​​कि अगर मैंने किया , तो यह स्पष्ट रूप से " बूलियन निर्दिष्ट करने के लिए" कहता है । और यहां तक ​​कि उत्तर में ही यह कहता है कि " आउटपुट परिणाम सही / गलत हो सकता है, 0/1, हां / नहीं ... +" जिसे मैं केवल "null / null" द्वारा ellipsis में विस्तारित कर सकता हूं ...

— Num

Answer 15

अक् - १४५

awk -v RS=' ' '{c=tolower($0)};NR==1{w=c};{t=substr(c,1,1)!=substr(w,NR-s,1);if(t){f=f" "c;s++};a=a||t};END{print a&&(s>NR-length(w))?"N":"Y|"f}'

परीक्षा:

$ cat gcp.sh
#!/bin/sh
f() {
echo "$1:"
echo "$1"|awk -v RS=' ' '{c=tolower($0)};NR==1{w=c};{t=substr(c,1,1)!=substr(w,NR-s,1);if(t){f=f" "c;s++};a=a||t};END{print a&&(s>NR-length(w))?"N":"Y|"f}'
}
f "RPM Package Manager"
f "Wine is not an emulator"
f "Wine is not an appropriate emulator"
f "GNU is not Unix"
f "Golf is not an acronym"
f "Go is not an acronym"
f "Go is a valid acronym OK"
f "X is a valid acronym"
f "YAML Ain't Markup Language"

$ ./gcp.sh
RPM Package Manager:
Y|
Wine is not an emulator:
Y| an
Wine is not an appropriate emulator:
Y| an appropriate
GNU is not Unix:
Y| is
Golf is not an acronym:
N
Go is not an acronym:
N
Go is a valid acronym OK:
Y| is a valid acronym
X is a valid acronym:
Y| is a valid acronym

YAML Ain't Markup Language:
Y|

Answer 16

कॉफ़ीस्क्रिप्ट - 144

z=(a)->g=" ";b=a.split g;c=b[0];d=[];(d.push(e);g++)for e,f in b when e[0].toLowerCase()!=c[f-g].toLowerCase();if(g+c.length==f)then{1,d}else{0}

उदाहरण के लिए, इसे कॉल करें: z "GNU is not Unix"

संकलित JS:

var z;
z = function(a) {
  var b, c, d, e, f, g, _i, _len;
  g = " ";
  b = a.split(g);
  c = b[0];
  d = [];
  for (f = _i = 0, _len = b.length; _i < _len; f = ++_i) {
    e = b[f];
    if (e[0].toLowerCase() !== c[f - g].toLowerCase()) {
      d.push(e);
      g++;
    }
  }
  if (g + c.length === f) {
    return {
      1: 1,
      d: d
    };
  } else {
    return {
      0: 0
    };
  }
};

यह स्ट्रिंग को शब्दों में विभाजित करता है और फिर प्रत्येक शब्द के माध्यम से लूप करता है। यदि शब्द का पहला वर्ण अगले से मेल नहीं खाता है, तो शब्द संग्रहीत है। एक काउंटर ( g) का उपयोग यह ट्रैक करने के लिए किया जाता है कि कितने शब्दों को छोड़ दिया गया है। यदि स्किप किए गए शब्दों की संख्या और संक्षिप्तिकरण की लंबाई वाक्यांश की लंबाई से मेल खाती है, तो यह मेल खाता है, इसलिए 1 और वापस छोड़ दिए गए शब्द। यदि नहीं, तो यह मान्य नहीं था, इसलिए 0 लौटाएं।

Answer 17

सी # - 234

Tuple<bool,string[]> f(string w) {var l=w.ToLower().Split(' ');var o=new List<string>();int n=0;var a=l[0];foreach(var t in l){if(n>=a.Length||a[n]!=t[0])o.Add(t);else n++;}var r=n>=a.Length;return Tuple.Create(r,r?o.ToArray():null);}

Answer 18

अजगर (108)

l=raw_input().lower().split()
a=l[0]
e=[]
for w in l:d=w[0]!=a[0];a=a[1-d:];e+=[w]*d  
b=a==''
print b,b*`e`