टैब पूरा करने को लागू करें

31

टैब समापन एक उपयोगी विशेषता है जो आंशिक रूप से लिखित आदेशों को ऑटो-पूर्ण करता है। आप इसे लागू करने जा रहे हैं।

उदाहरण के लिए, यदि उपलब्ध कमांड थे ['apply','apple','apple pie','eat'], तो aपूरा हो जाएगा appl, क्योंकि सभी कमांड जो शुरू होते हैं, वे aभी शुरू होते हैं appl।

इनपुट आउटपुट

आपको एक स्ट्रिंग, ए और तार का एक सेट इनपुट करने की आवश्यकता है, बी।

आपको ए से शुरू होने वाले सभी बी के सबसे लंबे सामान्य उपसर्ग का उत्पादन करने की आवश्यकता है।

  • यदि कोई भी विकल्प A से शुरू नहीं होता है, तो A वापस करें
  • आप मान सकते हैं कि B गैर-रिक्त है, और यह कि सभी तार गैर-रिक्त हैं
  • आप यह नहीं मान सकते कि कोई भी विकल्प A से शुरू होता है, और न ही आम उपसर्ग A से अधिक लंबा होगा
  • आप संवेदनशील या केस असंवेदनशील हो सकते हैं।
  • आपको केवल मुद्रण योग्य ASCII को संभालने की आवश्यकता है
  • बिल्ट-इन जो स्पष्ट रूप से इस कार्य को करने की अनुमति है

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

'a'       ['apply','apple','apple pie','eat'] => 'appl'
'a'       ['apple pie']                       => 'apple pie'
'apple'   ['eat','dine']                      => 'apple'
'program' ['programa','programb']             => 'program'
'*%a('    ['*%a()-T>','*%a()-T<','@Da^n&']    => '*%a()-T'
'a'       ['abs','absolute','answer']         => 'a'
'a'       ['a','abs']                         => 'a'
'one to'  ['one to one','one to many']        => 'one to '

अंतिम परीक्षण मामले पर अनुगामी स्थान पर ध्यान दें

यह एक कोड-गोल्फ है , इसलिए अपने उत्तरों को यथासंभव छोटा करें!

code-golf  string 
— नाथन मेरिल
स्रोत
— nimi
क्या आप पोस्टर के लिए गैर-वर्णनात्मक, मुद्रण योग्य ASCII वर्णों के साथ एक उदाहरण जोड़ सकते हैं?
— कॉनर ओ'ब्रायन
गैर-अक्षर वर्णों के साथ अधिक उदाहरण चोट नहीं पहुंचा सकते हैं। मैंने सिर्फ अपना उत्तर हटा दिया क्योंकि मुझे एहसास हुआ कि यह इनपुट युक्त है \​या '।
— डेनिस
यह सुनिश्चित नहीं है कि 'एक उदाहरण में कैसे प्रतिनिधित्व किया जाए। अगर मैं "तार के लिए उपयोग करता हूं , तो तार अन्य उदाहरणों की तुलना में अलग हैं।
— नाथन मेरिल
ठीक यही समस्या मेरे जवाब की थी। : पी
— डेनिस

जवाबों:

10

जावास्क्रिप्ट (ईएस 6), 75 बाइट्स

(s,a)=>/^(.*).*(\n\1.*)*$/.exec(a.filter(e=>e.startsWith(s)).join`
`)[1]||s

स्पष्टीकरण: सभी मिलान उपसर्गों पर फ़िल्टर करता है, फिर नए सिरे से जुड़ता है और एक रेगेक्स के साथ मेल खाता है जो सभी लाइनों का सबसे लंबा सामान्य उपसर्ग पाता है। यदि कोई उपसर्ग नहीं हैं, तो रेगेक्स एक खाली स्ट्रिंग लौटाता है जिस स्थिति में हम मूल स्ट्रिंग को वापस करते हैं।

— नील
स्रोत
आप एक बाइट के e.startsWith(s)साथ बदल सकते हैं e.match("^"+s)करीने से एक और बचाएगी
— शॉन एच।
@ शौन मैं matchमनमाने ढंग से मुद्रण योग्य ASCII के साथ उपयोग नहीं कर सकता ।
— नील
ओह राइट रेगेक्स और नियंत्रण वर्ण। आप अभी भी करी कर सकते हैं (s,a)=>करने के लिएs=>a=>
— शॉन एच
7

जेली , 14 12 बाइट्स

ḣJ$€ċÐff\ṪṪȯ

इसे ऑनलाइन आज़माएं! या सभी परीक्षण मामलों को सत्यापित करें ।

यह काम किस प्रकार करता है

ḣJ$€ċÐff\ṪṪȯ  Main link. Left argument: B. Right argument: A

  $€          Convert the two links to the left into a monadic chain and apply it
              to each string s in B.
 J              Generate the indices of s, i.e., [1, ..., len(s)].
ḣ               Head; for each index i, take the first i characters of s.
              This generates the prefixes of all strings in B.
     Ðf       Filter; keep prefixes for which the link to the left returns 1.
   ċ            Count the number of times A appears in the prefixes of that string.
       f\     Do a cumulative (i.e., keeping all intermediate values) reduce by
              filter, keeping only common prefixes. f/ is a more obvious choice,
              but it errors on an empty array, i.e., when A isn't a prefix of any
              string in B.
         Ṫ    Tail; take the last prefix array (if any) or return 0.
          Ṫ   Tail; take the last common prefix (if any) or return 0.
           ȯ  Logical OR (flat); replace 0 with A, leave strings untouched.
— डेनिस
स्रोत
6

पायथ, 14 13 बाइट्स

-1 बाईट के लिए @isaacg को धन्यवाद

.xe@F/#z._MQz

एक प्रोग्राम जो स्ट्रिंग की सूची लेता है, और फिर स्ट्रिंग, STDIN पर और परिणाम प्रिंट करता है।

सभी परीक्षण मामलों की जाँच करें

यह काम किस प्रकार करता है

.xe@F/#z._MQz  Program. Inputs: Q, z
        ._MQ   Map prefixes over Q
     /#z       Filter that by count(z)>0, removing the prefixes corresponding to elements
               in Q that do not start with z
   @F          Fold intersection over that. This yields all the common prefixes
  e            Yield the last element of that, giving the longest common prefix, since the
               prefixes are already sorted by length
.x             But if that throws an exception since no elements of Q start with z:
            z  Yield z instead
               Implicitly print
— TheBikingViking
स्रोत
1
f}zT=>/#z
— isaacg
5

PowerShell v3 +, 112 बाइट्स

param($a,$b)if($c=@($b-like"$a*")){([char[]]$c[0]|%{($i+="$_")}|?{($c-like"$_*").count-eq$c.count})[-1]}else{$a}

एक स्ट्रिंग के रूप में इनपुट $aऔर तार की एक सरणी लेता है $b। -likeउन तत्वों को $bउस (केस-असंवेदनशील) से बाहर निकालने के लिए ऑपरेटर का उपयोग करता है $a, स्पष्ट रूप से उन लोगों को एक सरणी के रूप में डाल देता है @(...)(क्योंकि परिणाम एक स्केलर के रूप में एक मैच हो सकता है, जिसमें बाद में अनुक्रमण विफल रहता है), और उस सरणी को संग्रहीत करें $c।

वह ifउपवाक्य बनाता है । अगर इसमें कुछ भी नहीं है $c(यानी, कुछ भी नहीं शुरू होता है $a, तो सरणी खाली है), तो आउटपुट के $aसाथ else। अन्यथा ...

हम प्रत्येक तत्व के माध्यम से $cएक charऐरे और लूप के रूप में पहला तत्व डालते हैं, पिछले के साथ स्ट्रिंग-कंक्रीटिंग और पाइपिंग पर स्ट्रैप्स को एन्कैप्सुलेटिंग परेंस के माध्यम से रखते हैं $i। उन के माध्यम से फ़िल्टर्ड रहे हैं |?{...}( Where-Objectसत्यापित करें कि खंड) .countकी $cहै -eqकरने के लिए UAL .countमें चीजों की $cहै कि कर रहे हैं -likeसबस्ट्रिंग (यानी, सबस्ट्रिंग सब कुछ $ ग में मेल खाता है)। चूंकि हम अपने सबस्ट्रिंग को सबसे कम से कम लंबे समय तक बना रहे हैं, इसलिए हमें [-1]परिणामी स्ट्रिंग्स की आखिरी आवश्यकता है ।

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

PS C:\Tools\Scripts\golfing> $tests=@('a',@('apply','apple','apple pie','eat')),@('a',@('apple pie')),@('apple',@('eat','dine')),@('program',@('programa','programb')),@('one to',@('one to one','one to many')),@('*%a(',@('*%a()-T>', '*%a()-T<', '@Da^n&'))

PS C:\Tools\Scripts\golfing> $tests|%{""+$_[0]+" ("+($_[1]-join',')+") -> "+(.\implement-tab-completion.ps1 $_[0] $_[1])}
a (apply,apple,apple pie,eat) -> appl
a (apple pie) -> apple pie
apple (eat,dine) -> apple
program (programa,programb) -> program
one to (one to one,one to many) -> one to 
*%a( (*%a()-T>,*%a()-T<,@Da^n&) -> *%a()-T
— AdmBorkBork
स्रोत
4

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

s=input();l=[x for x in input()if x[:len(s)]==s]or[s];i=len(l[0])
while len(l)>1:i-=1;l=set(x[:i]for x in l)
print l.pop()

पूर्ण कार्यक्रम; स्ट्रिंग और सूची को स्टड से ठीक उसी तरह लेता है जैसा कि उदाहरणों में दिया गया है, सिवाय इनपुट के अलग-अलग लाइनों पर होना चाहिए।

सभी परीक्षण मामलों की जाँच करें

— DLosc
स्रोत
l.pop()इसके बजाय क्यों l[-1]?
— 20
@ कोको क्योंकि lआमतौर setपर उस बिंदु पर होता है, जो अनुक्रमण ( अव्यवस्थित होने) की अनुमति नहीं देता है। (सौभाग्य से, दोनों सेट और सूचियों का समर्थन करते हैं pop()।)
— DLosc
3

पर्ल, 54 बाइट्स

के लिए +2 -Xp(के साथ जोड़ा जा सकता है -e) और +3 के लिए -i(संयुक्त नहीं किया जा सकता है) शामिल हैं

-iविकल्प के बाद STDIN और शब्द पर शब्दकोश दें , जैसे:

perl -ia -Xpe '/^\Q$^I\E.*?(?{$F[$a{$&}++]=$&})^/}{$_=pop@F||$^I'
apply
apple
apple pie
eat
^D

बस कोड:

/^\Q$^I\E.*?(?{$F[$a{$&}++]=$&})^/}{$_=pop@F||$^I
— टन हास्पेल
स्रोत
3

पर्ल, 61 बाइट्स

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

एसटीडीआईएन पर पहले शब्द के साथ चलें

tabcompletion.pl
a
apply
apple
apple pie
eat
^D

tabcompletion.pl:

#!/usr/bin/perl -0p
/^(.+)
((?!\1).*
)*(\1.*).*
((?!\1).*
|\3.*
)*$|
/;$_=$3||$`
— टन हास्पेल
स्रोत
2

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

lambda n,h:[a.pop()for a in[{s[:-i]for s in h if s.find(n)==0}for i in range(-len(`h`),0)]+[{n}]if len(a)==1][0]
— लिन
स्रोत
2

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

(a:b)?(c:d)|a==c=a:(b?d)
_?_=""
s%l=foldr1(?)$max[s][x|x<-l,x?s==s]

सहायक फ़ंक्शन ?दो वर्णों के सबसे लंबे सामान्य उपसर्ग को पुनरावर्ती रूप से पहला वर्ण लेता है, जब तक कि यह दोनों तारों के लिए समान है और तार गैर-रिक्त हैं।

मुख्य कार्य %पहली सूची है कि एक दिया के साथ शुरू में ही तार रहता है s, साथ सबसे लंबे समय तक आम उपसर्ग द्वारा जाँच sकी जा रही है s। किसी भी योग्य प्रतियोगिताओं को संभालने के लिए, यह sएक खाली परिणाम के माध्यम से जोड़ता है max। फिर, यह बाइनरी फ़ंक्शन को मोड़कर उन सबसे लंबे समय तक सामान्य उपसर्ग पाता है ?।

— XNOR
स्रोत
2

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

import os
lambda s,x:os.path.commonprefix([t for t in x if s<=t<s+'ÿ'])or s

मूल रूप से इस उत्तर में @BetaDecay द्वारा उपयोग किया गया, अंतर्निहित सुझाव देने के लिए @xnor के लिए धन्यवाद ।

स्कोरिंग उद्देश्यों के लिए, ÿएक DEL बाइट के साथ प्रतिस्थापित किया जा सकता है। Ideone पर इसका परीक्षण करें ।

— डेनिस
स्रोत
1

डी, 88 बाइट्स

S f(S)(S p,S[]q){try p=q.filter!(a=>a.startsWith(p)).fold!commonPrefix;catch{}return p;}

उपयोग:

assert(f("a", ["apply","apple","apple pie","eat"]) ==  "appl");

कोड केवल उन सभी तत्वों को हटा देता है , qजिनके साथ शुरू नहीं होता है p, फिर शेष तत्वों की सबसे बड़ी सामान्य प्रारंभिक गणना करता है।

टेम्प्लेट किए गए पैरामीटर हमें stringऔर उनमें से एक के दो दोहराव से बचाते हैं auto। अपवाद दुरुपयोग हमें अस्थायी चर और सशर्त से बचने देता है जो अन्यथा उस मामले को संभालने के लिए आवश्यक होगा जहां से कोई भी तत्व qशुरू नहीं होता है p।

— रे
स्रोत
1

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

s,x=input();r='';q=1
for c in zip(*[t for t in x if s<=t<s+'ÿ']):q/=len(set(c));r+=c[0]*q
print r or s

स्कोरिंग उद्देश्यों के लिए, ÿएक DEL बाइट के साथ प्रतिस्थापित किया जा सकता है। Ideone पर इसका परीक्षण करें ।

5 बाइट बचाने के लिए @xnor को धन्यवाद!

— डेनिस
स्रोत
साथ os.path.commonprefix के रूप में बीटा क्षय पाया , तो आप इसे आप के लिए काम करते हैं हो सकता है।
— xnor
वाह, कि बहुत सारे बाइट्स बचाता है । क्या आप वाकई अपने आप को पोस्ट नहीं करना चाहते हैं?
— डेनिस
मैं इसे अपने आप में पोस्ट करना सही नहीं समझूंगा क्योंकि यह पूरी तरह से बीटा डेके के विचार को आपके उत्तर के साथ संयुक्त है।
— xnor
आपके समाधान के लिए, यह for c in ...सीधे प्रिंट करने के लिए थोड़ा छोटा लगता है और प्रिंट करने के बाद त्रुटि के साथ समाप्त होता है if len(set(c))>1:print r or s;_।
— XNOR
मुझे लगता है कि अगर x एक सिंगलटन सरणी है तो वह विफल हो जाएगी ।
— डेनिस
1

PHP, 167 160 157 152 बाइट्स

<?for($r=preg_grep("$^".preg_quote($s=$_GET[s])."$",$a=$_GET[a]);$r[0]>$s&&preg_grep("$^".preg_quote($t=$s.$r[0][strlen($s)])."$",$a)==$r;)$s=$t;echo$s;

मैं चर के साथ preg_grepऔर असाइन करके 3 और बाइट्स बचा सकता था preg_quote, लेकिन एह।

टूट - फूट

for(
    // find items in $a that start with $s
    $r=preg_grep("$^".preg_quote($s=$_GET[s])."$",$a=$_GET[a]);
    // while the first match is longer than $s
    $r[0]>$s
    // and appending the next character of the first match
    &&preg_grep("$^".preg_quote($t=$s.$r[0][strlen($s)])."$",$a)
    // does not change the matches
    ==$r
;)
    // keep appending
    $s=$t;
return$s;
— टाइटस
स्रोत
1

PHP, 156 बाइट्स

टाइटस थैंक यू से बहुत मदद

<?foreach($_GET[t]as$v)if(strstr($v,$s=$_GET[s])==$v)$r[]=$z=$v;for(;$i++<strlen($z);){$s=substr($z,0,$i);foreach($r as$x)if($x[$i]!=$z[$i])break 2;}echo$s;

PHP, 199 बाइट्स

32 बाइट्स array_unique के साथ टाइटस द्वारा बचाता है

<?foreach($_GET[t]as$v)if(strstr($v,$s=$_GET[s])==$v)$r[]=$v;for(;$i++<strlen($r[0]);$a=[]){foreach($r as$x)$a[]=substr($x,0,$i);if(count($r)==count($a)&count(array_unique($a))<2)$s=$a[0];}echo$s;

मुझे पता है कि टाइटस द्वारा रेगेक्स सॉल्यूशन तब तक कम था जब तक कि टाइटस मुझे अपना रास्ता सुधारने में मदद नहीं करता। हो सकता है कि जिस तरह से मैंने पाया है वह आपके लिए दिलचस्प हो

— जार्ग हुल्सरमन
स्रोत
1
1) मामले को ठीक करने के $zसाथ बदलें । 2) अप्रचलित है; आप उस चर का उपयोग नहीं करते हैं। (-2) 3) से छोटा है । (-1) 4) से छोटा है । (-3) 5) आप स्ट्रलेन के अंदर रख सकते हैं । (-5)$sapple, [eat,dine]$l=$i++<$m++$i<=$msubstr($x,0,$i);str_split($x,$i)[0]$r[]=$v
— टाइटस
1
6) <2से छोटा है ==1। (-1) 7) आप strstrपहले लूप में उपयोग कर सकते हैं strstr($v,$s)==$v:। (-3)
— टाइटस
1
मुझे इसे rephrase करने दें: 5) आप कर्ल $r[]=$v;$m=max($m,strlen($v));को जोड़ सकते हैं $m=max($m,strlen($r[]=$v));और छोड़ सकते हैं । यह स्थिति को स्पर्श नहीं करता है।
— टाइटस
1
दूसरे विचार पर, आपको $mबिल्कुल ज़रूरत नहीं है । आप सभी की जरूरत है कि कुछ है> = प्रतिस्थापन की न्यूनतम लंबाई। नई 5) की जगह {$r[]=$v;$m=max($m,strlen($v));}के साथ $r[]=$v;}और <$mसाथ <strlen($r[0])(-13)
— टाइटस
1
महान! और मुझे $r[]=$z=$v;पहले लूप में एक और गोल्फ मिला: 9) और {$s=substr($z,0,$i);foreach($r as$x)if($x[$i]!=$z[$i])break 2;}दूसरे के लिए (-3)
— टाइटस
1

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

^(.*)(\n(?!\1).*)*(\n(\1.*)).*(\n((?!\1)|\4).*)*$
$4
s`\n.*

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

— नील
स्रोत
0

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

def f(s:String,a:Seq[Char]*)=a filter(_ startsWith s)reduceOption(_ zip _ takeWhile(t=>t._1==t._2)map(_._1))getOrElse s

Ungolfed:

def tabComplete(input: String, options: Seq[Char]*) = {
  options.
  filter((x: String) => x.startsWith(input)).
  reduceOption((x: Seq[Char], y: Seq[Char]) =>
    x.zip(y).
    takeWhile((t: (Char, Char)) => t._1 == t._2).
    map((t: (Char, Char)) => t._1)
  ).getOrElse(input)
}

स्पष्टीकरण:

def g(s:String,a:Seq[Char]*)= //define a method g with a string and a vararg array of strings as parameter
  a filter(_ startsWith s)    //filter the options to contains only elements starting with the input
  reduceOption(               //if the filtered array is nonempty, reduce it: 
    _ zip _                     //zip two elements together
    takeWhile(t=>t._1==t._2)    //take the tuples while they contain the same char
    map(_._1)                   //take the first element from each tuple
  )getOrElse s                //else return the input
— corvus_192
स्रोत
0

05AB1E , 14 बाइट्स

ʒIÅ?}€ηøʒË}‚˜θ

इसे ऑनलाइन आज़माएं या सभी परीक्षण मामलों को सत्यापित करें ।

स्पष्टीकरण:

ʒ   }           # Filter the (implicit) input-list
 IÅ?            #  Does it start with the (second) input-string
                #   i.e. ["codex","bla","codegolf"] and "c" → ["codex","codegolf"]
     €η         # Then take the prefixes of every remaining string
                #  → [["c","co","cod","code","codex"],
                #     ["c","co","cod","code","codeg","codego","codegol","codegolf"]]
       ø        # Zip/transpose; swapping rows/columns
                #  → [["c","c"],["co","co"],["cod","cod"],["code","code"],["codex","codeg"]]
        ʒ }     # Filter:
         Ë      #  Only keep sublists which only contain the same substrings
                #   → [["c","c"],["co","co"],["cod","cod"],["code","code"]]
           ‚    # Pair it with the (second implicit) input
                #  → ["c",["c","c"],["co","co"],["cod","cod"],["code","code"]]
                # (workaround if nothing in the input-list starts with the input-string)
            ˜   # Flatten this list
                #  → ["c","c","c","co","co","cod","cod","code","code"]
             θ  # And only leave the last item (which is output implicitly as result)
                #  → "code"
— केविन क्रूज़सेन
स्रोत
0

गैया , 12 बाइट्स

e…¦&⊢…Ė⁇_+ₔ)

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

बी के रूप में इनपुट लेता है, फिर ए।

e		| eval B as list of strings
 …¦		| take prefixes of each string
   &⊢		| reduce by set intersection
     …		| take list prefixes of each.
      Ė⁇	| Keep only those with A as an element
	_	| flatten
	 +ₔ	| add A to the beginning of the list
	   )	| take the last element
— ग्यूसेप
स्रोत
हमारी साइट का प्रयोग करके, आप स्वीकार करते हैं कि आपने हमारी Cookie Policy और निजता नीति को पढ़ और समझा लिया है।
Licensed under cc by-sa 3.0 with attribution required.