वही नाम, लंगड़ा!

Question

एक फ़ंक्शन या प्रोग्राम लिखें, जब नामों की सूची, आउटपुट या रिटर्न की सूची दी जाती है, जहां दिए गए नामों के डुप्लिकेट में उनके उपनाम का एक छोटा छोटा संस्करण होता है।

इनपुट:

नामों की एक सूची, जहाँ एक नाम किसी दिए गए नाम से परिभाषित होता है और अंतिम नाम एक स्थान से अलग होता है। नाम गैर-रिक्त तार हैं जिनमें केवल अपरकेस और लोअरकेस अक्षर हैं। सूची स्ट्रिंग की एक सरणी हो सकती है, या एक निरंतर गैर-अल्फा, गैर-अंतरिक्ष चरित्र द्वारा अलग किए गए नाम, लेकिन आउटपुट इनपुट के समान प्रारूप में होना चाहिए।

आउटपुट:

उसी क्रम में इनपुट किए गए नामों की एक सूची और इन नियमों द्वारा संशोधित किए गए इनपुट के रूप में प्रारूपित करें:

• विशिष्ट नामों के लिए, दिए गए नाम का उत्पादन करें
• समान नाम साझा करने वाले नामों के लिए:
  • उनके दिए गए नाम के साथ, उनके उपनाम का सबसे छोटा यूनिक वर्जन जोड़ें, जो किसी दूसरे नाम से साझा न किया गया हो, एक अवधि के बाद। उदाहरण के लिए: John Clancy, John Smithबन जाता है John C.,John S.और James Brown, James Bratteबन जाता हैJames Bro.,James Bra.
  • यदि एक उपनाम दूसरे का एक उपसमूह है, जैसे कि Julian King,Julian Kingsley, एक अवधि के बिना छोटे वाले का पूरा उपनाम लौटाएं। उदाहरण बन जाएगाJulian King,Julian King.
• मूल रूप से एक अवधि रेगेक्स का प्रतिनिधित्व करती है .+, जहां केवल एक नाम से मेल खाना चाहिए।
• आप मान सकते हैं कि कोई भी दिए गए नाम और समान उपनाम दोनों को साझा नहीं करेगा
• नाम केस-संवेदी होते हैं

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

• John Clancy,Julie Walker,John Walker,Julie Clancy -> John C.,Julie W.,John W.,Julie C.
• Julian King,Jack Johnson,Julian Kingsley > Julian King,Jack,Julian King.
• Jack Brown,Jack Black,Jack Blue > Jack Br.,Jack Bla.,Jack Blu.
• John Storm,Jon Snow,Johnny Storm > John,Jon,Johnny
• Jill DeSoma,Jill Desmond > Jill DeS.,Jill Des.
• XxXnO sCOppeXxX,XxXNO MERCYXxX > XxXnO,XxXNO

यह कोड-गोल्फ है , इसलिए प्रत्येक भाषा की जीत के लिए सबसे कम बाइट की गिनती होती है।

Comments

संबंधित , संबंधित (साभार @ लाईकोनी)। सैंडबॉक्स पोस्ट

— जो किंग

Angela C.परीक्षण के मामले में कहां से आता है?

— caird coinheringaahing

मतलब एक Julieउफ़, धन्यवाद। नियत

— जो राजा

Answer 1

जेली ,  34 33 32  30 बाइट्स

;\ċÐf⁶t€⁶;€JṖḊ$$¦”.µ€ċ@ÐṂ€Ẏ$Ḣ€

वर्णों की सूची (यानी "तार" की एक सूची) की सूची लेने और एक ही प्रारूप और सापेक्ष क्रम में संक्षिप्त विवरण वापस करने के लिए एक विवादास्पद लिंक।

इसे ऑनलाइन आज़माएं! (एक पूर्ण कार्यक्रम परीक्षण सूट)

कैसे?

;\ċÐf⁶t€⁶;€JṖḊ$$¦”.µ€ċ@ÐṂ€Ẏ$Ḣ€ - Link: list of lists    e.g. ["Sam Ng","Sam Li","Sue Ng"]
                   µ€          - monadically for €ach:  e.g. "Sue Ng"
 \                             -   cumulative reduce with:
;                              -     concatenation           ["S","Su","Sue","Sue ","Sue N","Sue Ng"]
     ⁶                         -   literal space character   ' '
   Ðf                          -   filter keep if:
  ċ                            -     count (spaces)          ["Sue ","Sue N","Sue Ng"]
        ⁶                      -   literal space character   ' '
      t€                       -   trim from €ach            ["Sue","Sue N","Sue Ng"]
                 ”.            -   literal period character  '.'
                ¦              -   sparse application...
         ;€                    -   ...of: concatenate €ach (with a period)
                               -   ...only for these indexes:
               $               -     last two links as a monad:
           J                   -       range of length       [1,2,3]
              $                -       last two links as a monad:
            Ṗ                  -         pop                 [1,2]
             Ḋ                 -         dequeue             [2]  (i.e. 2,3,...,length-1)
                               -   ...i.e.:                  ["Sue","Sue N.","Sue Ng"]
                               -                   yielding: [["Sam","Sam N.","Sam Ng"],["Sam","Sam L.","Sam Li"],["Sue","Sue N.","Sue Ng"]]
                           $   - last two links as a monad:
                          Ẏ    -   tighten                   ["Sam","Sam N.","Sam Ng","Sam","Sam L.","Sam Li","Sue","Sue N.","Sue Ng"]
                       ÐṂ€     -   filter keep minimals for €ach: 
                     ċ@        -     count (sw@ping args)    [["Sam N.","Sam Ng"],["Sam L.","Sam Li"],["Sue","Sue N.","Sue Ng"]]
                            Ḣ€ - head €ach                   ["Sam N.","Sam L.","Sue"]

Answer 2

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

def f(a):n=[[x[:i]+'.'*(' 'in x[:i]<x)for i in range(x.find(' '),len(x)+1)]for x in a];print[min(x,key=sum(n,[]).count)for x in n]

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

पहले सभी उपनाम उत्पन्न करता है, निम्नानुसार है:

n == [
    ['John', 'John .', 'John C.', 'John Cl.', 'John Cla.', 'John Clan.', 'John Clanc.', 'John Clancy'],
    ['Julie', 'Julie .', 'Julie W.', 'Julie Wa.', 'Julie Wal.', 'Julie Walk.', 'Julie Walke.', 'Julie Walker'],
    ['John', 'John .', 'John W.', 'John Wa.', 'John Wal.', 'John Walk.', 'John Walke.', 'John Walker'],
    ['Julie', 'Julie .', 'Julie C.', 'Julie Cl.', 'Julie Cla.', 'Julie Clan.', 'Julie Clanc.', 'Julie Clancy'],
    ['Jill', 'Jill .', 'Jill D.', 'Jill De.', 'Jill Des.', 'Jill Desm.', 'Jill Desmo.', 'Jill Desmon.', 'Jill Desmond']
]

फिर प्रत्येक सूची में से पहला * एक उठाता है जो कम से कम लगातार होता है sum(n,[])। यह हमेशा पहला अनूठा उपनाम होगा।

ध्यान दें कि nगलत उपनाम 'John .'आदि शामिल हैं, लेकिन उन्हें कभी नहीं चुना जाएगा।

(* CPython 2.7 minऐसा करता है, वैसे भी। यह कोड पोर्टेबल नहीं हो सकता है !)

Answer 3

रूबी 165 162 161 161 बाइट्स

यदि केवल दिए गए नाम को वापस किया जाता है, तो 1 अनुगामी स्थान शामिल है, जैसे। "John "

->a,n=0,s=0{a.group_by{|i|i[n]}.values.flat_map{|i|j=i[0];k=j.index' ';i.size<2?j.size>n ?j[0,[n+1,k].max-(s>1?0:1)]+(n>k ??.:''):j:f[i,n+=1,i.count{|l|l[n]}]}}

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

163 बाइट्स यदि आप ट्रेलिंग स्थान नहीं चाहते हैं

->a,n=0,s=0{a.group_by{|i|i[n]}.values.flat_map{|i|j=i[0];k=j.index' ';i.size<2?j.size>n ?j[0..[n,k-1].max-(s>1?0:1)]+(n>k ??.: ''):j:f[i,n+1,i.count{|l|l[n+1]}]}}

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