O preenchimento de tabulação é um recurso útil que conclui automaticamente parcialmente os comandos gravados. Você vai implementá-lo.

Por exemplo, se os comandos disponíveis fossem ['apply','apple','apple pie','eat'], aseria concluído applcomo, como todos os comandos ainiciados com appl.

Entrada / Saída

Você precisa inserir uma sequência A e um conjunto de seqüências B.

Você precisa gerar o prefixo comum mais longo de todos os B que começa com A.

• Se nenhuma das opções começar com A, retorne A
• Você pode assumir que B não é vazio e que todas as cadeias de caracteres são vazias
• Você não pode assumir que qualquer uma das opções comece com A, nem que o prefixo comum seja maior que A
• Você pode fazer distinção entre maiúsculas e minúsculas ou não.
• Você só precisa lidar com ASCII imprimível
• Built-ins que explicitamente executam essa tarefa são permitidos

Casos de teste:

'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 '

Observe o espaço à direita no último caso de teste

Este é um código de golfe , portanto, faça suas respostas o mais curto possível!

JavaScript (ES6), 75 bytes

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

Explicação: Filtra todos os prefixos correspondentes e junta-se a novas linhas e correspondências em uma regex que encontra o prefixo comum mais longo de todas as linhas. Se não houver prefixos, o regex retornará uma string vazia. Nesse caso, simplesmente retornamos a string original.

Geléia , 14 12 bytes

ḣJ$€ċÐff\ṪṪȯ

Experimente online! ou verifique todos os casos de teste .

Como funciona

ḣ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.

Pitão, 14 13 bytes

Obrigado a @isaacg por -1 byte

.xe@F/#z._MQz

Um programa que pega a lista de seqüências de caracteres e, em seguida, a seqüência de caracteres em STDIN e imprime o resultado.

Verifique todos os casos de teste

Como funciona

.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

PowerShell v3 +, 112 bytes

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

Recebe a entrada como uma sequência $ae uma matriz de sequências $b. Usa o -likeoperador para extrair esses elementos $b(sem diferenciação de maiúsculas e minúsculas) $a, convertê-los explicitamente como uma matriz @(...)(já que o resultado pode ser uma correspondência como escalar, caso em que a indexação falha posteriormente) e armazenar essa matriz $c.

Isso forma a ifcláusula. Se não houver nada $c(isto é, nada começa com $a, então a matriz está vazia), em seguida, imprima $acom else. De outra forma ...

Elencamos o primeiro elemento $ccomo char-array e percorremos cada elemento, concatenando $ias strings com o anterior e colocando as strings no pipeline por meio de parênteses de encapsulamento. Aqueles são filtrados através de |?{...}(a Where-Objectcláusula) para verificar se o .countde $cé -equal ao .countde coisas em $cque estão -likea substring (ou seja, o substring combina com tudo em $ c). Como estamos construindo nossas substrings da ordem do menor para o maior, precisamos da última [-1]das seqüências resultantes.

Casos de teste

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

Python 2, 122 bytes

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()

Programa completo; usa string e lista de stdin exatamente como fornecido nos exemplos, exceto que as entradas devem estar em linhas separadas.

Verifique todos os casos de teste

Perl, 54 bytes

Inclui +2 para -Xp(pode ser combinado com -e) e +3 para -i(não pode ser combinado)

Forneça um dicionário sobre STDIN e a palavra após a -iopção, por exemplo:

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

Apenas o código:

/^\Q$^I\E.*?(?{$F[$a{$&}++]=$&})^/}{$_=pop@F||$^I

Perl, 61 bytes

Inclui +2 para -0p

Execute com a primeira palavra seguida pelas palavras do dicionário em STDIN:

tabcompletion.pl
a
apply
apple
apple pie
eat
^D

tabcompletion.pl:

#!/usr/bin/perl -0p
/^(.+)
((?!\1).*
)*(\1.*).*
((?!\1).*
|\3.*
)*$|
/;$_=$3||$`

Python 2, 112 bytes

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]

Haskell, 67 bytes

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

A função auxiliar ?encontra o prefixo comum mais longo de duas cadeias, recursivamente, obtendo o primeiro caractere, desde que seja o mesmo para as duas cadeias e as cadeias não estejam vazias.

A principal função %primeira mantém apenas as cordas na lista que começa com o dado um s, verificado pela maior prefixo comum com ssendo s. Para lidar com a inexistência de competições válidas, ele adiciona sum resultado vazio via max. Em seguida, ele encontra o maior prefixo comum desses ao dobrar a função binária ?.

Python 2, 75 bytes

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

Agradecemos a @xnor por sugerir o built-in, originalmente usado por @BetaDecay nesta resposta .

Para fins de pontuação, ÿpode ser substituído por um byte DEL. Teste em Ideone .

D, 88 bytes

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

Uso:

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

O código simplesmente remove todos os elementos dos qquais não começa p, depois calcula a maior subsequência inicial comum dos elementos restantes.

Os parâmetros de modelo nos salvam duas repetições de stringe uma de auto. O uso indevido da exceção permite evitar a variável temporária e condicional que seriam necessárias para lidar com o caso em que nenhum elemento qinicial p.

Python 2, 107 102 bytes

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

Para fins de pontuação, ÿpode ser substituído por um byte DEL. Teste em Ideone .

Obrigado a @xnor por salvar 5 bytes!

PHP, 167 160 157 152 bytes

<?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;

Eu poderia economizar mais 3 bytes atribuindo variáveis ​​com preg_grepe preg_quote, mas eh.

demolir

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;

PHP, 156 bytes

com muita ajuda de Titus Obrigado

<?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 bytes

32 bytes salvos por Titus com 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;

Eu sei que a solução Regex de Titus foi mais curta até que Titus me ajudasse a melhorar meu caminho. Talvez a maneira que eu encontrei seja interessante para você

Retina, 60 bytes

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

The trailing new line is significant. Takes input as the string on a line and then each word on a separate line (but no trailing newline!). Works in a similar way to my JavaScript answer by matching the longest common prefix of all lines that begin with the string on the first line. If it doesn't find one then it simply deletes all the words.

Scala, 119 bytes

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)
}

Explanation:

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

PowerShell, 101 bytes

Based on Nail's awesome regexp.

if($args-join'
'-cmatch'^(.*)(\n(?!\1).*)*(\n(\1.*)).*(\n((?!\1)|\4).*)*$'){$Matches.4}else{$args[0]}

Try it online!

05AB1E, 14 bytes

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

Try it online or verify all test cases.

Explanation:

ʒ   }           # 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"

Gaia, 12 bytes

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

Try it online!

Takes input as B, then A.

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