परिचय

एक पुनरावर्ती संक्षिप्तिकरण एक ऐसा संक्षिप्त नाम है जो स्वयं के लिए होता है या उदाहरण के लिए संदर्भित करता है: के Fishलिए एक पुनरावर्ती संक्षिप्तिकरण हो सकता है Fish is shiny hero, ध्यान दें कि कैसे वह भी स्वयं को शामिल करता है। एक अन्य उदाहरण है Hi-> Hi igloo। या भी ppcg paints->ppcg paints cool galaxies pouring acid into night time stars

तो मूल रूप से, एक वाक्य एक पुनरावर्ती संक्षिप्त है यदि प्रत्येक शब्द के पहले अक्षर पहले शब्द या शब्दों को बाहर निकालते हैं।

चुनौती

एक प्रोग्राम बनाएं जो एक अंतरिक्ष वर्ण द्वारा अलग किए गए 1 या अधिक शब्दों की एक स्ट्रिंग लेता है, और असंभव होने पर एक पुनरावर्ती संक्षिप्तिकरण, या एक खाली स्ट्रिंग को आउटपुट करता है। उदाहरण के लिए, जैसे स्ट्रिंग के लिए एक पुनरावर्ती संक्षिप्त करना असंभव है, ppcg elephantक्योंकि आप तब pसे लेना शुरू कर देंगे ppcg, फिर उस संक्षिप्त को जोड़कर, फिर eसे elephant। लेकिन अब हमारे पास एक विरोधाभास है, क्योंकि वर्तमान में संक्षिप्त रूप से "पे .." मंत्र है, जो "पीपी .." के साथ संघर्ष करता है। उदाहरण के लिए, यह भी मामला है hi। आप ले जाएगा hसे hiहै, लेकिन सजा अब खत्म हो गया है और वहाँ उल्लेख करने के लिए कोई और अधिक पत्र हैं hiऔर हम बस के साथ छोड़ दिया जाता है hजो मेल नहीं खाताhi। (स्ट्रिंग को संक्षेप में अक्षरों की मात्रा के बराबर या उससे अधिक शब्दों की मात्रा की आवश्यकता होती है)

इनपुट और आउटपुट संवेदनशील नहीं हैं

प्रतिबंध

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

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

hi igloo -> hi
ppcg paints -> (impossible)
ppcg paints cool giraffes -> ppcg
ppcg paints cool galaxies pouring acid into night time stars -> ppcgpaints
ppcg paints cool galaxies pouring acid into night time -> ppcg
ppcg questions professional pool challengers greatly -> (impossible)
I -> I

स्कोरिंग

यह कोड-गोल्फ है , इसलिए बाइट्स में सबसे छोटा स्रोत कोड जीत जाता है

code-golf string

— FireCubez
स्रोत

1

क्यू, क्यू [कियू] संज्ञा, बहुवचन क्यू या क्यू, क्यू या क्यू। अंग्रेजी वर्णमाला का 17 वां अक्षर, एक व्यंजन। क्विक या क्ष द्वारा दर्शाए गए किसी भी ध्वनि, जैसे कि त्वरित, बरी, या इराक में। Q.

— l4m2

3

इसके अलावा, मुझे नहीं लगता कि ppcg शब्दकोश में एक शब्द है

— l4m2

1

ठीक है, उन परीक्षा मामलों में से एक जैसा कि मुझे उम्मीद नहीं थी। बस यह सुनिश्चित करने के लिए कि हम में से कोई भी एक गलती ppcg paints cool galaxies pouring acid into night timeनहीं कर रहा है "ppcgpaint" होगा जब एक संक्षिप्त रूप में बनाया जाता है, लेकिन आउटपुट ppcgकेवल एक आंशिक मैच होने के बावजूद होना चाहिए ?

— कामिल दकरी

1

जैसा कि सभी वर्तमान समाधान पहला विकल्प ले रहे हैं ("संक्षिप्त खोजें"), और "खोज वाक्य" विकल्प बहुत अधिक जटिल है (इसलिए पहले एक के साथ प्रतिस्पर्धी होने का कोई तरीका नहीं है - आपको शुरू करने के लिए कुछ शब्द सूची की आवश्यकता है), मैं इसे इस चुनौती से निकालने और इसे अपना प्रश्न बनाने का सुझाव दूंगा।

— पाओलो एबरमन

2

@ Pa @loEbermann ठीक है, मैंने इसे हटा दिया

— FireCubez

5

जाप , 13 बाइट्स

¸
mÎ¬
VøUÎ ©V

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

— लुइस फेलिप डी जीसस मुनोज
स्रोत

11 बाइट्स

— झबरा

1

यह ppcg paints cool galaxies pouring acid into night time starsपरीक्षण के मामले में विफल रहता है

— कामिल दकरी

यहाँ एक संस्करण है जो उस परीक्षण मामले के लिए काम करता है, लेकिन यह गोल्फ नहीं है

— कामिल दकरी

मेरे पिछले 13 बाइट्स समाधान सही था Dx \

— लुइस फेलिप डी जीसस मुनोज़

वर्तमान संस्करण बस जाँच करता है कि संक्षिप्त नाम में पहला शब्द है, जिसके परिणामस्वरूप कुछ नए मुद्दे हैं

— कामिल दकरी

5

05AB1E , 16 बाइट्स

ð¡©ηʒJ®€нJηså}θJ

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

— Emigna
स्रोत

1

आपके अंतिम संपादन में ð¡इसके स्थान पर परिवर्तन क्यों हुआ #? कुछ विशेष परीक्षण के मामले जिन्हें मैं ध्यान नहीं दे रहा हूं?

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

@KevinCruijssen: क्योंकि #एकल शब्द इनपुट के लिए विफल होगा एक खाली स्ट्रिंग के बजाय इनपुट आउटपुट।

— एमिग्ना

आह हाँ, यह बात थी। मुझे याद है कि पहले भी ऐसा ही कुछ पूछा गया था। मुझे अभी भी #उसी तरह कार्य करना चाहिए जैसा कि ð¡.. क्या कोई उपयोग-मामला है जिसके बारे में आप सोच सकते हैं कि आप रिक्त स्थान पर स्ट्रिंग विभाजित करना चाहते हैं, लेकिन यदि इसमें कोई स्थान नहीं है, तो यह स्ट्रिंग (स्ट्रिंग के बजाय) रहना चाहिए एक सूची में लिपटे)? इसे पढ़ने वाले अन्य लोग; FYI करें: #रिक्त स्थान के बिना स्ट्रिंग पर (स्पेस पर विभाजन) का उपयोग करना स्ट्रिंग में परिणाम है (यानी "test" -> "test")। ð¡रिक्त स्थान के बिना एक स्ट्रिंग पर (अंतरिक्ष में विभाजन) का उपयोग करना सूची (यानी "test" -> ["test"]) में लिपटे स्ट्रिंग में परिणाम देता है ।

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

@ केविनक्रूजसेन: मुझे लगता है कि इसका मुख्य रूप #से इस्तेमाल किया जा रहा है quit if true(जो इसका मुख्य कार्य है)। यदि #गलत दिया गया है, तो आप शायद नहीं चाहेंगे कि चेक की गई सूची को लिस्ट में लपेटा जाए, जिसे स्टैक पर छोड़ दिया गया है।

— एमिगा

1

@KamilDrakari: अब काम करता है।

— एमिगा

2

हास्केल, 51 48 बाइट्स

संपादित करें: -3 बाइट्स @xnor के लिए धन्यवाद।

(\w->[r|p<-scanl1(++)w,map(!!0)w==p,r<-p]).words

ढूँढता है।

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

\w->            .words -- let 'w' be the input list split into words
   p<-scanl1(++)w      -- loop 'p' through the list starting with the first word
                       --  and appending the next words one by one, e.g.
                       --  "Fish","is","shiny","hero" -> "Fish","Fishis","Fishisshiny","Fishisshinyhero"
     ,map(!!0)w==p     -- if the word made out of the first characters of the
                       --  words of 'w' equal 'p'
  [r|   r<-p]          -- return the letters of 'p' - if the check before
                       --  never evaluates to True then no letters, i.e. the
                       --  the empty string is returned

— nimi
स्रोत

चूंकि आप उपयोग नहीं कर रहे हैं x, इसलिए रचना (\w-> ...).wordsछोटा होगा।

— xnor

2

पर्ल 6 , 50 42 58 49 बाइट्स

-9 बाइट्स nwellnhof के लिए धन्यवाद

{~first {m:g/<<./.join~~/^$^a/},[R,] [\~] .words}

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

पहला विकल्प। मैं इस तथ्य का शोषण कर रहा हूं कि ordकेवल एक स्ट्रिंग के पहले अक्षर का क्रमिक मान लौटाता है, जबकि chrsords की सूची लेता है और एक स्ट्रिंग लौटाता है। या चंद्रहेट के उत्तर से रेगेक्स छोटा है :(। संदर्भ के लिए, पिछले जवाब के .words>>.ord.chrsबजाय था[~] m:g/<<./

स्पष्टीकरण:

{~first {m:g/<<./.join~~/^$^a/},[R,] [\~] .words}
{                                               } # Anonymous code block
  first  # Find the first 
                                [R,] [\~] .words  # Of the reverse of the triangular joined words
         {                    }  # That matches:
          m:g/   /   # Match all from the original string
              <<.    # Single letters after a word boundary
                  .join    # Joined
                       ~~/^$^a/   # And starts with the given word
 ~  # And stringify Nil to an empty string

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

अब आपको "IMPOSSIBLE" आउटपुट की आवश्यकता नहीं है

— FireCubez

@ राजा मैं रेगेक्स कर सकता हूं, लेकिन मेरे जीवन के लिए मैं सभी ऑपरेटरों के साथ नहीं सोच सकता। मैं भूल जाता हूं कि x ऑपरेटर मौजूद है, उदाहरण के लिए: P

— moonheart08

1

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

^
$'¶
\G(\w)\w* ?
$1
+`^(.+)(\w.*¶\1 )
$1 $2
!`^(.+)(?=¶\1 )

इसे ऑनलाइन आज़माएं! पुनरावर्ती संक्षिप्त नाम प्राप्त करता है, यदि कोई हो। स्पष्टीकरण:

^
$'¶

इनपुट डुप्लिकेट करें।

\G(\w)\w* ?
$1

पहली पंक्ति के शब्दों को उनके प्रारंभिक अक्षरों में कम करें।

+`^(.+)(\w.*¶\1 )
$1 $2

यदि संभव हो तो मूल शब्दों से मिलान करने के लिए स्थान डालें।

!`^(.+)(?=¶\1 )

पहली पंक्ति का उत्पादन अगर यह दूसरी पंक्ति का एक उपसर्ग है।

— नील
स्रोत

पीपीसीजी पेंट्स के लिए, आउटपुट अमान्य है, इसे कुछ भी नहीं करना चाहिए क्योंकि ppकेवल पहले शब्द के एक हिस्से को, इसके बजाय सभी को मंत्र देता है

— FireCubez

@FireCubez क्षमा करें, मैं प्रश्न के पुराने संस्करण से काम कर रहा था।

— नील

1

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

$!=[~] m:g{<<.};say $! if m:g{<<\w+}.map({$_ eq $!}).any

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

पहले रेग्जेस मेरे लिए भ्रामक और अनुपयोगी थे। अचानक मैं उन्हें पूरी तरह से समझता हूं। मुझे क्या हुआ: P

पसंद को पूरा करना 1।

— moonheart08
स्रोत

अफसोस की बात है, मैं अभी भी उस स्तर पर हूं जहां रेगीज़ केवल पागलपन हैं। दुर्भाग्य से, यह ppcgpaintsपरीक्षण में विफल रहता है , अन्यथा मैंने $!∈.wordsअगर हालत के लिए कुछ सुझाव दिया होता

— Jo King

1

K (ngn / k) , 40 बाइट्स

पहला विकल्प:

{$[1=#:x;x;$[(*:t)~,/*:'t:" "\x;*:t;`]]}

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

— Thaufeki
स्रोत

2 में से कौन सा विकल्प इस पर काम करता है?

— फायरक्यूबेज़

पहला, आउटपुट स्ट्रिंग इनपुट से संक्षिप्त है। मैं अपनी पोस्ट को स्पष्ट करने के लिए संपादित करूँगा

— Thaufeki

1

155, जंग, यह ऑनलाइन कोशिश करो!

चयनित: समस्या 1: संक्षिप्त नाम ढूँढना

type S=String;fn f(t:&str)->S{let l=t.to_lowercase();let w=l.split(' ').fold(S::new(),|a,b|a+&b[..1])+" ";if (l+" ").contains(w.as_str()){w}else{S::new()}}

अनगुल्ड, बस थोड़ा सा:

fn f(t: &str) -> String {
    let l = t.to_lowercase();
    let w = l.split(' ').fold(String::new(), |a, b| a + &b[0..1]) + " ";
    if (l + " ").contains(w.as_str()) {
        w
    } else {
        String::new()
    }
}

या अगर हम मान सकते हैं कि इनपुट सभी लोअरकेस है, सिर्फ 130:

type S=String;fn f(l:S)->S{let w=l.split(' ').fold(S::new(),|a,b|a+&b[..1])+" ";if (l+" ").contains(&w.as_str()){w}else{S::new()}}

— हनीस करपिला
स्रोत

यह कार्यक्रम किन 2 विकल्पों में से करता है?

— फायरक्यूबेज़

@FireCubez अपडेट किया गया।

— हनीस करपिला

1

जेली , 9 बाइट्स

Ḳµ;\fZḢWƊ

यदि संभव हो तो पुनरावर्ती संक्षिप्त नाम का एक पूर्ण-कार्यक्रम मुद्रित करना।

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

कैसे?

Ḳµ;\fZḢWƊ - Main Link: list of characters
Ḳ         - split at space (let's call this v)
 µ        - start a new monadic chain (i.e. f(v)):
   \      - cumulative reduce v with:
  ;       -   concatenation -> [v(1), v(1);v(2), v(1);v(2);v(3); ...]
        Ɗ - last three links as a monad (i.e. f(v)):
     Z    -   transpose -> [[v(1)[1], v(2)[1], ...],[v(1)[1],v(2)[2],...],...]
      Ḣ   -   head -> [v(1)[1], v(2)[1], ...] ... i.e. 'the potential abbreviation'
       W  -   wrap in a list -> ['the potential abbreviation']
    f     - filter discard those from the left list that are not in the right list
          - implicit print -- a list of length 0 prints nothing
          -                   while a list of a single item prints that item

— जोनाथन एलन
स्रोत

"पहले शब्द को छापें" से आपका क्या मतलब है? अगर यह मौजूद है, तो इसे खोजने की जरूरत है कि क्या यह ऐसा करता है?

— फायरक्यूबेज़

"Ppcg पेंट्स ठंडी आकाशगंगाओं में आकाश में एसिड नहीं डालना" के लिए विफल रहता है, "ppcg पेंट्स" या "ppcgpaints" प्रिंट करना चाहिए

— FireCubez

ओह, मैंने आस-पास के शब्दों की आवश्यकता को याद किया :(

— जोनाथन एलन

इस आवश्यकता को पूरा करने के लिए इसे तय किया।

— जोनाथन एलन

1

जावास्क्रिप्ट [ईएस 6], 74 बाइट्स

s=>s.split` `.map(w=>(b+='('+w,e+=')?',t+=w[0]),b=e=t='')&&t.match(b+e)[0]

पर मिलान करने के लिए एक नियमित अभिव्यक्ति बनाता है। कोड में उदाहरण देखें।

सभी परीक्षण मामले:

let f=

s=>s.split` `.map(w=>(b+='('+w,e+=')?',t+=w[0]),b=e=t='')&&t.match(b+e)[0]

console.log(f('hi igloo'))
// 'hi'.match('(hi(igloo)?)?')[0] == 'hi'

console.log(f('ppcg paints'))
// 'pp'.match('(ppcg(paints)?)?')[0] == ''

console.log(f('ppcg paints cool giraffes'))
// 'ppcg'.match('(ppcg(paints(cool(giraffes)?)?)?)?')[0] == 'ppcg'

console.log(f('ppcg paints cool galaxies pouring acid into night time stars'))
// 'ppcgpaints'.match('(ppcg(paints(cool(galaxies(pouring(acid(into(night(time(stars)?)?)?)?)?)?)?)?)?)?')[0] == 'ppcgpaints'

console.log(f('ppcg paints cool galaxies pouring acid into night time'))
// 'ppcgpaint'.match('(ppcg(paints(cool(galaxies(pouring(acid(into(night(time)?)?)?)?)?)?)?)?)?')[0] == 'ppcg'

console.log(f('ppcg questions professional pool challengers greatly'))
// 'pqppcg'.match('(ppcg(questions(professional(pool(challengers(greatly)?)?)?)?)?)?')[0] == ''

console.log(f('I'))
// 'I'.match('(I)?')[0] == 'I'

console.log(f('increase i'))
// 'ii'.match('(increase(i)?)?')[0] == ''

console.log(f('i increase'))
// 'ii'.match('(i(increase)?)?')[0] == 'i'

स्निपेट का विस्तार करें

— रिक हिचकॉक
स्रोत

फेल ऑनincrease i

— l4m2

@ l4m2, अब ठीक किया गया।

— रिक हिचकॉक

0

पायथन 2 , 106 बाइट्स

पहला विकल्प - पुनरावर्ती संक्षिप्त ढूँढना।
परिणाम सूची में

I=input().split()
print[' '.join(I[:i])for i in range(1,-~len(I))if[j[0]for j in I]==list(''.join(I[:i]))]

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

पायथन 2 , 120 बाइट्स

पहला विकल्प - पुनरावर्ती संक्षिप्त ढूँढना।

def F(I,a=[],r=''):
 for j in I.split():
  a+=j,
  if list(''.join(a))==[i[0]for i in I.split()]:r=' '.join(a)
 return r

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

— मृत पोसुम
स्रोत

आपको @JoKing के अनुरोध के अनुसार "IMPOSSIBLE" को आउटपुट करने की आवश्यकता नहीं है, इससे आपकी बाइट की संख्या घट सकती है

— FireCubez

'I' जैसे एकल अक्षर काम नहीं करते हैं, यह उस एकल अक्षर

— FireCubez

@FireCubez तय

— मृत

0

जावास्क्रिप्ट, 71 बाइट्स

दृष्टिकोण १

l=s=>{p=s.split(' ');k=p.reduce((r,x)=>r+x[0],'');return k==p[0]?k:''}

Ungolfed:

l=s=>{
    p = s.split(' ');
    k = p.reduce((r,x)=>r+x[0],'');
    return k==p[0] ? k : '';
}

अंतरिक्ष द्वारा स्ट्रिंग विभाजित करें।
प्रत्येक शब्द से पहला वर्ण लेकर नई स्ट्रिंग बनाएं।
पहले शब्द से इसकी तुलना करें।

— Alpheus
स्रोत

0

रूबी `-apl` , 57 बाइट्स

$_=y="";$F.all?{|w|$F.map(&:chr).join[/^#{y+=w}/]?$_=y:p}

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

— किरिल एल।
स्रोत

0

पायथन 2 , 109 बाइट्स

def f(s,J=''.join):s=s.split();return[J(s[:i])for i in range(len(s)+1)if J(zip(*s)[0]).find(J(s[:i]))==0][-1]

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

— चास ब्राउन
स्रोत

0

स्काला, 76 बाइट्स

सरल मामले के लिए समाधान (व्हाट्सएप के बिना समरूपताएं)

def^(s:String)={val l=s.split(" ");if(l(0)==l.map(_(0)).mkString)l(0)else""}

स्काला, 144 बाइट्स 100 बाइट्स (केवल ASCII द्वारा समाधान देखें)

def^(s:String)={val l=s.split(" ");l.scanLeft(List[String]())(_:::List(_)).find(_.mkString==l.map(_(0)).mkString).map(_.mkString).getOrElse("")}

REPL में टेस्ट करें

scala> def^(s:String)={val l=s.split(" ");if(l(0)==l.map(_(0)).mkString)l(0)else""}
$up: (s: String)String

scala> ^("hi igloo")
res12: String = hi

scala> ^("ppcg paints cool giraffes")
res13: String = ppcg

scala> ^("ppcg paints Xcool giraffes")
res14: String = ""

scala> ^("ppcg paints cool galaxies pouring acid into night time stars")
res15: String = ""

scala>

scala> def^(s:String)={val l=s.split(" ");l.scanLeft(List[String]())(_:::List(_)).find(_.mkString==l.map(_(0)).mkString).map(_.mkString).getOrElse("")}
$up: (s: String)String

scala> ^("hi igloo")
res16: String = hi

scala> ^("ppcg paints cool giraffes")
res17: String = ppcg

scala> ^("ppcg paints Xcool giraffes")
res18: String = ""

scala> ^("ppcg paints cool galaxies pouring acid into night time stars")
res19: String = ppcgpaints

— डॉ। वाई विट
स्रोत

आपको इसे लैम्ब्डा में बदलने की अनुमति है

— ASCII-only

:::से बदला जा सकता है ++? इसके अलावा, List[String]-> Seq[Any]?

— एएससीआईआई-केवल

1

100?

— केवल

@ ASCII- ही, मस्त! यह समाधान पायथन को हरा देता है। :)

— डॉ। वाई विट

कभी-कभी कोड जोड़ने का मन? IMO यह थोड़ा अजीब है कि बिना समाधान देखे ही बाइटकाउंट

— ASCII-only

एक पुनरावर्ती संक्षिप्त का पता लगाएं

परिचय

चुनौती

प्रतिबंध

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

स्कोरिंग

जाप , 13 बाइट्स

05AB1E , 16 बाइट्स

हास्केल, 51 48 बाइट्स

पर्ल 6 , 50 42 58 49 बाइट्स

स्पष्टीकरण:

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

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

K (ngn / k) , 40 बाइट्स

155, जंग, यह ऑनलाइन कोशिश करो!

जेली , 9 बाइट्स

कैसे?

जावास्क्रिप्ट [ईएस 6], 74 बाइट्स

पायथन 2 , 106 बाइट्स

पायथन 2 , 120 बाइट्स

जावास्क्रिप्ट, 71 बाइट्स

रूबी -apl , 57 बाइट्स

पायथन 2 , 109 बाइट्स

स्काला, 76 बाइट्स

स्काला, 144 बाइट्स 100 बाइट्स (केवल ASCII द्वारा समाधान देखें)

रूबी `-apl` , 57 बाइट्स