संक्षिप्तिकरण का सामान्यीकरण

Question

शब्दों की सूची और उनके संक्षिप्तीकरण के इनपुट को देखते हुए, उस पैटर्न का उत्पादन करते हैं जिसके द्वारा संक्षिप्ताक्षर बनाए जा सकते हैं।

आइए हम उदाहरण का इनपुट लेते हैं

potato ptao
puzzle pzze

एक उदाहरण के रूप में (वह है, संक्षिप्त नाम potatoहै ptao, और संक्षिप्त नाम puzzleहै pzze)।

प्राप्त करने के लिए हर संभव तरीके पर विचार ptaoसे potato। एक संभव तरीका यह है कि पहले, तीसरे, चौथे और छठे अक्षरों को लें, जिन्हें हम निम्न रूप में संदर्भित करेंगे 1346। लेकिन चूंकि tऔर oशब्द में कई बार दिखाई देते हैं, वहाँ उत्पन्न करने के लिए कई अन्य संभावित तरीके हैं ptaoसे potato: 1546, 1342, और 1542।

इसी तरह, ध्यान दें कि pzzeसे उत्पन्न किया जा सकता puzzleसे किसी के साथ 1336, 1346, 1436, 1446। केवल एक ही पैटर्न जो इन दो संक्षिप्त रूपों में है 1346; इसलिए, इस इनपुट के लिए आउटपुट होना चाहिए। यदि कई संभावित पैटर्न संभव हैं, तो आप किसी भी, कुछ या सभी (कम से कम एक) को आउटपुट कर सकते हैं।

आप मान सकते हैं कि:

• इनपुट शब्द और संक्षिप्तीकरण में केवल निचला अक्षर होता है।

• इनपुट में कम से कम एक शब्द / संक्षिप्त नाम जोड़ी है।

• इसके संक्षिप्त शब्द से प्रत्येक संक्षिप्त नाम का बनना संभव है।

• हमेशा कम से कम एक पैटर्न होगा जो हर संक्षिप्त नाम बनाता है।

• प्रत्येक शब्द की अधिकतम लंबाई 9 वर्ण है।

इनपुट को निम्नलिखित में से किसी एक के रूप में लिया जा सकता है:

• 2-आयामी सरणी / सूची / tuples / etc की सरणी। [[word, abbr], [word, abbr], ...]

• फ्लैट 1-आयामी सरणी / सूची [word, abbr, word, abbr, ...]

• एकल स्ट्रिंग, किसी भी एकल वर्ण द्वारा सीमांकित जो एक लोअरकेस अक्षर नहीं है "word abbr word abbr"

• हैश / सहयोगी सरणी / आदि। {word => abbr, word => abbr, ...}

इनमें से किसी भी इनपुट विकल्प में, आपको शब्द / abbr का क्रम स्वैप करने की अनुमति है (कृपया अपनी पोस्ट में इनपुट प्रारूप का पूरी तरह वर्णन करें)।

आउटपुट एकल संख्या के रूप में दिया जा सकता है, गैर-अंकों के द्वारा सीमांकित एक स्ट्रिंग, या एक सरणी / सूची / टपल / आदि। संख्या की।

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

परीक्षण के मामले (याद रखें कि आपको केवल )1 परिणाम आउटपुट करने की आवश्यकता है यदि कई पैटर्न काम करते हैं):

In                                Out
--------------------------------------------------------
potato ptao puzzle pzze         | 1346
aabbcc abc fddeef def           | 246
prgrmming prgmg puzzles pzzlz   | 14353
aaaaa a bbbb b ccc c dd d e e   | 1
aaaaa a bbbb b ccc c            | 1, 2, 3
abcxyz zbcyax                   | 623514
abcxyz acbbacbcbacbbac          | 132213232132213
potato ptao                     | 1346, 1546, 1342, 1542
a aaaaa                         | 11111

Comments

बस यह सुनिश्चित करने के लिए कि मैं समझ गया हूं, संक्षिप्त नाम प्रक्रिया अक्षरों को फिर से व्यवस्थित कर सकती है?

— xnor

@xnor सही, जैसा कि परीक्षण के कई मामलों में देखा गया है।

— दरवाज़े

2 डी सरणी अन्य अभिविन्यास हो सकता है? प्रत्येक पंक्ति, प्रत्येक पंक्ति में नहीं, शब्द की एक जोड़ी होगी / abbrev

— लुइस मेंडो

@DonMuesli नहीं, यह नहीं हो सकता।

— दरवाज़े

क्या हम शून्य-अनुक्रमण का उपयोग कर सकते हैं, इसलिए 1346 के बजाय 0235 प्रिंट करें?

— डेनकर

Answer 1

पायथ, 19 बाइट्स

[e-mail]

यहाँ यह कोशिश करो!

निम्नलिखित प्रारूप में एक सूची लेता है:

[["word","abbr"],["word","abbr"],...]

वैकल्पिक 17 बाइट्स समाधान जो शून्य-आधारित सूचकांकों की सूची के परिणामस्वरूप परिणाम देता है जो 1-तत्व सूची में लिपटे होते हैं:

[e-mail]

व्याख्या

उदाहरण: [["potato", "ptao"],["puzzle", "pzze"]]

सबसे पहले हम संक्षिप्त विवरण में हर उस चार्ट को बनाते हैं जिसमें पैदावार में सभी घटनाओं के सूचकांकों की सूची दी गई है

[[[0], [2, 4], [3], [1, 5]], [[0], [2, 3], [2, 3], [5]]]

फिर हम इस सूची को स्थानांतरित करते हैं जो हमें देता है

[[[0], [0]], [[2, 4], [2, 3]], [[3], [2, 3]], [[1, 5], [5]]]

इसलिए प्रत्येक पृथक्करण के प्रत्येक वर्ण के सूचक एक सूची में एक साथ हैं।

फिर हमें उन सभी सूचियों में एक सामान्य सूचकांक खोजना होगा, जिनकी पैदावार होती है:

[[0], [2], [3], [5]]

यह ऊपर मेरे वैकल्पिक 17 बाइट समाधान का आउटपुट है। यह तब रूपांतरित हो जाता है [1,3,4,6]।

कोड टूटना

[e-mail] # Q = इनपुट

एम क्यू # मानचित्र इनपुट डी के साथ
        m ed # k के साथ प्रत्येक पृथक्करण का नक्शा
            mbhd # नक्शा शब्द चार सूची में
         mxk # सूचकांकों की सूची में प्रत्येक संक्षिप्त चार्ट को मैप करें
      .T # ट्रांसपोज़
    Fd # हर तत्व को मोड़ो
   @ # और उपस्थिति पर फ़िल्टर करें
 hh # परिणाम का पहला तत्व und और बढ़ाएँ

Comments

क्या आप dmपहले भी सही नहीं हटा सकते थे @?

— दरवाज़े

@Doorknob मैं कर सकता हूँ। कि जगह के लिए धन्यवाद!

— डेनकर

Answer 2

MATL , 29 बाइट्स

!"@Y:!=2#fX:wX:h]N$v1XQtv4#X>

इनपुट निम्नलिखित प्रारूप में एक 2D सरणी है:

{'potato' 'ptao'; 'puzzle' 'pzze'}

इसे ऑनलाइन आज़माएं! ( लिंक किए गए कोड में इस उत्तर के बाद से भाषा में बदलाव के कारण कुछ संशोधन शामिल हैं )

!       % take input. Transpose
"       % for each column
  @Y:   %   push column. Unpack the two strings and push them onto the stack
  !     %   transpose second string
  =     %   matrix with all pairwise matchings of characters in word and abbreviation
  2#f   %   find row and col indices of those matchings
  X:    %   transform into column vector
  wX:   %   swap, transform into column vector
  h     %   concat into a two-col matrix
]       % end for
N$v     % concatenate all matrices containing the indices
1       % push 1
XQ      % build matrix adding 1 for each (row,col) index
tv      % concat vertically with itself, so that it has at least two rows.
        % This forces the following function to work on each col.
4#X>    % arg max of each col: position that produces a match in all pairs.
        % If there are several maximizers in each col this gives the first

कोड में कुछ शामिल (और लम्बी!) ट्रिक्स की आवश्यकता थी

• इनपुट आकार के आधार पर find( f) बदलने से उत्पन्न वैक्टर के उन्मुखीकरण को रोकें । ये कथन हैं X:wX:: दोनों आउटपुट को कॉलम वैक्टर बनाने के लिए मजबूर करते हैं।
• min( X>) फ़ंक्शन के "पहले गैर-सिंगलटन आयाम के साथ काम" डिफ़ॉल्ट व्यवहार का प्रतिकार करें । ये कथन हैं tv: कम से कम दो पंक्तियों को आश्वस्त करने के लिए स्वयं की एक प्रति सम्‍मिलित करें);

Answer 3

पर्ल, 46 45 42 बाइट्स

के लिए +1 शामिल है -p

STDIN पर अनुक्रमिक शब्दों के रूप में इनपुट दें, जैसे

perl -p abbrev.pl
prgrmming
prgmg
puzzles
pzzlz

साथ STDIN बर्खास्त ^Dया ^Zया जो कुछ भी आपके सिस्टम पर की जरूरत है

abbrev.pl:

s#.#${${--$_.$.%2}.=$&}||=-$_#eg;$_ x=eof

व्याख्या

इस इनपुट पर विचार करें (वैचारिक लेआउट, इस कार्यक्रम के इनपुट का वास्तविक तरीका नहीं):

potatoes     ptao
puzzle       pzze

प्रोग्राम एक स्तंभ आईडी पर अनुक्रमित पूर्ण स्ट्रिंग्स के ऊर्ध्वाधर स्तंभों का प्रतिनिधित्व करते हुए तार का निर्माण करता है

id1    pp     -> 1
id2    ou     -> 2
id3    tz     -> 3
id4    az     -> 4
...

आदि। यह संक्षिप्तीकरण के लिए भी ऐसा ही करता है, लेकिन एक अलग आईडी का उपयोग करता है

ID1    pp     -> 1
ID2    tz     -> 3
ID3    az     -> 4
ID4    oe     -> 6

-pविकल्प का उपयोग करके शब्दों को एक-एक करके अनुमानित रूप से संसाधित किया जाता है । प्रत्येक शब्द का उपयोग करके चलते समय स्तंभों को बार-बार संघनन का उपयोग करके बनाया जाता है s#.# ...code.. #eg, इसलिए प्रत्येक स्तंभ को एक दोहराने योग्य आईडी की आवश्यकता होती है। मैं लाइन संख्या modulo द्वारा पीछा स्तंभ संख्या का उपयोग करता हूं। 2. स्तंभ संख्या का निर्माण किया जा सकता है --$_जिसका उपयोग वर्तमान शब्द के रूप में शुरू होता है जो केवल उपयोग के कारण a-zएक संख्यात्मक संदर्भ में 0 के रूप में मूल्यांकन करने की गारंटी है। तो मुझे मिलता है -1, -2, -3, ...। मैं वास्तव में उपयोग करना पसंद करूंगा 1, 2, 3, ..., लेकिन $_++एक सामान्य संख्यात्मक काउंटर के बजाय पर्ल मैजिक स्ट्रिंग वृद्धि को ट्रिगर करना होगा। मैं उपयोग करना चाहता हूं$_ और कुछ अन्य चर नहीं क्योंकि किसी भी अन्य चर को मुझे हर लूप में शून्य करना होगा जो बहुत सारे बाइट्स लेता है।

लाइन नंबर मोडुलो 2 यह सुनिश्चित करने के लिए है कि पूर्ण शब्द के लिए आईडी और संक्षिप्त नाम के लिए आईडी क्लैश न करें। ध्यान दें कि मैं एक स्ट्रिंग पर पूर्ण संख्या और संक्षिप्त नाम का उपयोग नहीं कर सकता, क्योंकि संयुक्त स्ट्रिंग के ऊपर एक कॉलम संख्या चल रही है क्योंकि पूर्ण शब्दों में सभी की लंबाई समान नहीं है, इसलिए संक्षिप्त शब्द कॉलम पंक्तिबद्ध नहीं होगा। मैं पहले संक्षिप्त शब्द भी नहीं रख सकता (इन सभी की लंबाई समान है) क्योंकि मुझे पूर्ण शब्दों के पहले कॉलम की संख्या 1 होने की आवश्यकता है।

मैं स्तंभ स्ट्रिंग के निर्माण के लिए एक गैर सख्त संदर्भ के माध्यम से पर्ल ग्लोबल नाम स्थान का दुरुपयोग करता हूं:

${--$_.$.%2}.=$&

इसके बाद मैं प्रत्येक कॉलम स्ट्रिंग को पहले कॉलम नंबर पर मैप करता हूं जो स्ट्रिंग कभी भी दिखाई देती है (मैपिंग पहले से ही ऊपर बताई गई है) फिर से पर्ल ग्लोबल नेमस्पेस का दुरुपयोग करके (लेकिन ध्यान दें कि नाम क्लैश नहीं कर सकते हैं ताकि ग्लोबल्स एक-दूसरे के साथ हस्तक्षेप न करें):

${${--$_.$.%2}.=$&} ||= -$_

मुझे उपेक्षा करनी पड़ती है $_क्योंकि जैसे मैंने ऊपर बताया कि मैं स्तंभों की गणना करता हूं -1, -2, -3, ...। ||=मेक सुनिश्चित करें कि केवल किसी दिए गए स्तंभ की पहली उपस्थिति एक नया स्तंभ संख्या हो जाता है, अन्यथा पिछले कॉलम संख्या संरक्षित है और मूल्य के रूप में लौट आए। यह विशेष रूप से प्रत्येक संक्षिप्त शब्द के लिए होगा क्योंकि विनिर्देश गारंटी देता है कि पूर्ण शब्दों में एक कॉलम है जो पहले से दिखाई देगा। तो बहुत अंतिम संक्षिप्त शब्द में प्रत्येक अक्षर को पूर्ण शब्द में कॉलम नंबर से बदल दिया जाएगा जो सभी संक्षिप्त शब्दों के लिए कॉलम के साथ मेल खाता है। तो बहुत अंतिम प्रतिस्थापन का परिणाम अंतिम परिणाम है जो वांछित है। इसलिए यदि हम इनपुट के अंत में हैं तो ही प्रिंट करें:

$_ x=eof

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

Answer 4

हास्केल, 74 बाइट्स

import Data.List
foldl1 intersect.map(\(w,a)->mapM(`elemIndices`(' ':w))a)

इनपुट प्रारूप तार के जोड़े की एक सूची है, जैसे:

*Main > foldl1 intersect.map(\(w,a)->mapM(`elemIndices`(' ':w))a)  $ [("potato","ptao"),("puzzle","pzze")]
[[1,3,4,6]]

यह कैसे काम करता है: mapM(जैसा कि sequence . map) पहले हर जोड़े (w,a)को संक्षेप में अक्षरों के सूचकांक की सूचियों की सूची में बदल देता है ( ' ':हास्केल के मूल 0-आधारित सूचकांक को 1-आधारित पर फिक्स करता है), उदाहरण के लिए ("potato", "ptao") -> [[1],[3,5],[4],[2,6]]और उसके बाद सभी संयोजनों की सूची में जहां स्थिति में तत्व वें सब लिस्ट iसे लिया गया है i, जैसे [[1,3,4,2],[1,3,4,6],[1,5,4,2],[1,5,4,6]]। foldl1 intersectइस तरह की सभी सूचियों के प्रतिच्छेदन को पाता है।

Answer 5

ईएस 6, 92 बाइट्स

(w,a)=>[...a[0]].map((_,i)=>[...w[0]].reduce((r,_,j)=>w.some((s,k)=>s[j]!=a[k][i])?r:++j,0))

शब्दों के एक समूह और संक्षिप्तिकरण के एक सरणी के रूप में इनपुट को स्वीकार करता है। 1-आधारित सूचकांकों की एक सरणी लौटाता है (जिसकी कीमत मुझे 2 बाइट्स डेमिटी है)। कई समाधानों के मामले में, उच्चतम सूचकांक लौटाए जाते हैं।

Answer 6

पायथन 3, 210 बाइट्स

यहाँ पर टॉपर्स को जब्त करने वाला एक प्रभावशाली उत्तर नहीं है, लेकिन यह वास्तव में कुछ पागल सूची की समझ है जो मैंने कभी पायथन के साथ की है। दृष्टिकोण काफी स्पष्ट है।

 def r(p):
    z=[[[1+t[0]for t in i[0]if l==t[1]]for l in i[1]]for i in[[list(enumerate(w[0])),w[1]]for w in p]]
    return[list(set.intersection(set(e),*[set(i[z[0].index(e)])for i in z[1:]]))[0]for e in z[0]]

फ़ंक्शन इनपुट की अपेक्षा हमेशा स्ट्रिंग 2-डी सरणी की तरह करता है: [[word, abbr],...]और पूर्णांकों की सूची देता है।

Ps: एक विस्तृत विवरण जल्द ही आ रहा है

Ps2: आगे के गोल्फ सुझावों का स्वागत किया जाता है!