^{这个问题是基于我用西班牙语问的一个问题。是的，我要求使用西班牙语的算法。:)}

在西班牙，当前的车牌具有以下模式：

1234 XYZ

其中XYZ是从全套西班牙辅音中选取的三个辅音（我认为“Ñ”除外）。

有时候，和我妻子一起旅行时，我们会玩游戏。当我们看到一个车牌时，我们将其三个辅音词拼成一个单词，其中包含这三个辅音词，其顺序与车牌中的顺序相同。示例（西班牙语）：

BCD
    BoCaDo (valid)
    CaBezaDa (not valid)
FTL
    FaTaL (valid)
    FLeTar (not valid)
FTR
    FleTaR (valid, wins)
    caFeTeRa (valid, loses)

如上一个示例所示，获胜者是使用最少字符的人。

挑战

编写最短的程序或函数，该程序或函数接收单词列表和一组三个辅音，并在包含相同顺序的三个辅音的列表中找到最短的单词。就本游戏而言，大小写无关紧要。

• 单词列表（第一个参数）的输入将是您的语言string类型的数组。第二个参数（三个辅音）将是另一个string。如果对您的语言更好，请string与三个辅音一起放在整个参数列表的最后一项。输出将是另一个string。
• 单词列表中的单词不会被发明，也不会是无限的单词，它们会出现在任何标准词典中。如果需要限制，请假设单词列表中的单词长度不能超过50个字符。
• 如果有多个长度相同的单词可能是有效答案，则可以返回其中任何一个。只要确保您只返回一个单词，或者如果没有单词匹配三个辅音的模式，则返回一个空字符串。
• 您可以在组中重复辅音，因此三个辅音的有效输入均为FLR和GGG。
• 西班牙辅音与英语完全相同，但加了“Ñ”。元音与重读元音的附加词相同：“áéíóúü”。不会有其他类型的标记，例如“-”或“'”。
• 您可以假设单词列表和三个辅音的大小写始终相同。

如果要使用西班牙语单词的真实集合来测试算法，则可以从Dropbox下载一百万个单词以上的文件（15.9 MB）。

测试用例

Input: 'psr', {'hola' 'repasar' 'pasarais' 'de' 'caída' 'pequeñísimo' 'agüeros'}
Output: 'repasar'

Input: 'dsd', {'dedos' 'deseado' 'desde' 'sedado'}
Output: 'desde'

Input: 'hst', {'hastío' 'chest'}
Output: 'chest'

这是代码高尔夫，所以最短的程序可以帮助我永远击败我的妻子。:)

05AB1E，10 8字节

由于Leo，节省了2个字节

ʒæså}éR`

在线尝试！

说明

ʒ         # filter list, keep only members for which the following is true
  så      # input is in the
 æ        # powerset of the current word
    }     # end filter
     é    # sort by length
      R   # reverse
       `  # push separately (shortest on top)

我本来会用head一个字节来保存，但是如果没有匹配项，它将输出一个空列表。

MATL，30 29字节

xtog!s2$S"1G!'.*'Yc!@gwXXn?@.

在线尝试！

说明

x         % Implicitly take first input (string with three letters). Delete.
          % Gets copied into clipboard G, level 1
t         % Implicitly take second input (cell array of strings defining the
          % words). Duplicate
o         % Convert to numeric array of code points. This gives a matrix where
          % each string is on a row, right-padded with zeros
g         % Convert to logical: nonzeros become 1
!s        % Sum of each row. This gives the length of each word
2$S       % Two-input sort: this sorts the array of strings according to their
          % lengths in increasing order
"         % For each word in the sorted array
  1G      %   Push first input, say 'xyz'
  !       %   Transpose into a column vector of chars
  '.*'Yc  %   Concatenate this string on each row
  !       %   Transpose. This gives a char array which, when linearized in
          %   column-major order, corresponds to 'x.*y.*z.*'
  @g      %   Push corrent word
  w       %   Swap
  XX      %   Regexp matching. Gives a cell array with substrings that match
          %   the pattern 'x.*y.*z.*'
  n       %   Number of matchings
  ?       %   If non-zero
    @     %     Push cell array with current word, to be displayed as output
    .     %     Break loop
          %   Implicit end (if)
          % Implicit end (for)
          % Implicitly display stack

PHP，111字节

$y=array_map(str_split,preg_grep("#".chunk_split($_GET[1],1,".*")."#",$_GET[0]));sort($y);echo join($y[0]??[]);

在线尝试！

果冻， 12 11  10 字节

ŒPċðÐfLÞḣ1

一个完整的程序，它接受小写字符列表（单词）和小写字符列表（字母）的列表，并打印包含与字母相等的子序列的最短单词的第一个（如果不存在，则不包含任何子序列） ）。

在线尝试！

怎么样？

ŒPċðÐfLÞḣ1 - Main link: words; characters
   ðÐf     - filter keep words for which this is truthy:
ŒP         -   the power-set (all sub-sequences of the word in question)
  ċ        -   count (how many times the list of characters appears)
           - ...note 0 is falsey while 1, 2, 3, ... are truthy
       Þ   - sort by:
      L    -  length
        ḣ1 - head to index 1 (would use Ḣ but it yields 0 for empty lists)
           - implicit print (smashes together the list of lists (of length 1))

Pyth- 22 21 19 12 11字节

h+f/yTQlDEk

-1感谢Maltysen。

取2行作为输入。第一个是3个字母的字符串（小写），第二个是小写的单词列表。

在这里尝试

说明：

h+f/yTQlDEk
       lDE   # Sort word list by length
  f          # Filter elements T of the word list...
    yT       # by taking the powerset...
   /  Q      # and checking whether the 3-letter string Q is an element of that.
 +        k  # Add empty string to the list (in case no results found)
h            # And take the first result (the shortest)

旧的19字节解决方案：

h+olNf/-T"aeiou"QEk                       

Brachylog v2，11个字节

tlᵒ∋.&h⊆.∨Ẹ

在线尝试！

功能提交。（TIO链接具有命令行参数，可以像运行完整程序一样运行函数。）

说明

再次只是规范的直接翻译…

tlᵒ∋.&h⊆.∨Ẹ
t            The last element of {standard input}
   ∋.        contains the return value as an element
     &       and
      h      the first element of {standard input}
       ⊆.    is a subsequence of the return value
         ∨   alternate behaviour if no solution is found:
          Ẹ  return empty string
  ᵒ          tiebreak override: favour answers that have a low
 l           length

实际上，您几乎可以用以下方式回答h⊆.&t∋-交换评估顺序意味着Brachylog将默认选择最短的答案（因为它看到的第一个约束是⊆，它具有相对方便的“最短”作为默认抢七）-但是在这种情况下，Bracylog的如果未真正找到答案，评估算法将不幸进入无限循环。因此，几乎一半的答案专用于处理没有适当答案的情况。即使这样，lᵒ抢七式抢占（从技术上讲也是一种∋首选元素靠近列表开头的默认抢七只有两个字节；另外三个是由于需要特别在找不到输出时输出一个空字符串，这与Brachylog的默认“ no solutions”哨兵值相反（因为.如果我们不必紧随其后，则最终值将是隐式的∨）。

有趣的是，以前在Brachylog中实现的功能可以在此处节省一个字节。在一个点上，你可以使用提取的输入参数的元素?₁，?₂等语法; 这样您就可以将程序重新排列为tlᵒ∋.⊇?₁∨Ẹ，只有10个字节。不幸的是，所使用的实现实际上并没有工作（并且导致许多其他正在运行的程序中断），因此将其还原。但是，您可以认为该程序“概念上”长10个字节。

哈斯克尔 129 125 74字节

import Data.List
l#w=sortOn length[p|p<-w,isInfixOf l$filter(`elem`l)p]!!0

信用@nimi

Perl，53个字节

48个字节的代码+ 5个-paF。

$"=".*";($_)=sort{$a=~y///c-length$b}grep/@F/,<>

这利用了以下事实：插值到m//运算符中的列表利用$"变量将初始输入字符串更改psr为p.*s.*r，然后将其与每个其他单词进行匹配并排序length。

在线尝试！

JavaScript（ES6），77 75 72字节

以curry语法取3个辅音c和单词列表。在相同情况下，两种输入均应预期。l(c)(l)

c=>l=>l.map(w=>x=!w.match([...c].join`.*`)||!x[w.length]&&x?x:w,x='')&&x

测试用例

let f =

c=>l=>l.map(w=>x=!w.match([...c].join`.*`)||!x[w.length]&&x?x:w,x='')&&x

console.log(f('psr')(['hola', 'repasar', 'pasarais', 'de', 'caída', 'pequeñísimo', 'agüeros'])) // 'repasar'
console.log(f('dsd')(['dedos', 'deseado', 'desde', 'sedado'])) // 'desde'

R，101个字节

第一次打高尔夫球！我相信这可以通过某种方式浓缩

接受字符串x和可能输入的字符向量y

w=pryr::f((b=y[sapply(gsub(paste('[^',x,']'),'',y),function(l)regexpr(x,l))>0])[which.min(nchar(b))])

在线尝试！

编辑：我的版本是135，感谢Scrooble为-34！

视网膜 58字节

O#$^`¶.+
$.&
s`^((.)(.)(.).*¶(?-s:(.*\2.*\3.*\4.*)))?.*
$5

在线尝试！在一行上获取三个辅音，然后在所有后续行上获取单词列表。说明：O对列表进行排序，但¶.+不包括用#数字$键输入$.&长度的第一行。然后寻求匹配以依次包括三个辅音的行。如果存在比最后一行（即最短）合适的行，则该行成为输出，否则输出为空。在?-s:暂时关闭的影响s`，以便只有一个线匹配。

点，17字节

@:qJ`.*`N_FI#_SKg

将单词列表作为命令行参数，并将stdin中的辅音作为。 在线尝试！

说明

                   g is list of cmdline args (implicit)
              SKg  Sort g using this key function:
            #_      Length of each item (puts shortest words first)
          FI       Filter on this function:
  q                 Line of input
   J`.*`            joined on regex .* (turns "psr" into `p.*s.*r`)
        N_          Count regex matches in item (keeps only words that match)
@:                 Get first element of result (using : meta-operator to lower precedence)
                   If the list is empty, this will give nil, which results in empty output

爪哇8，132个 126字节

s->a->{String r="";for(String x:a)r=(x.length()<r.length()|r.isEmpty())&x.matches(r.format(".*%s.*%s.*%s.*",s))?x:r;return r;}

-6个字节，感谢@Nevay。

说明：

在线尝试。

s->a->{              // Method with two String-array parameters and String return-type
  String r="";       //  Result-String, starting empty
  for(String x:a)    //  Loop over the words
    r=(x.length()<r.length()
                     //   If a word is smaller than the current `r`,
      |r.isEmpty())  //   or `r` is still empty
      &x.matches(r.format(".*%s.*%s.*%s.*",s))?
                     //   And if the word is valid
       x             //    Change `r` to the current word
      :              //   Else:
       r;            //    Leave `r` the same
  return r;}         //  Return the result

Python，77个字节

import re
lambda s,a:min([x for x in a if re.search('.*'.join(s),x)],key=len)

在线尝试！

MATL，28 27 26字节

x"l1G@g3XNXm/@gn*v]&X<2Gw)

在线尝试！

x-隐式接受第一个输入（带有三个字母的字符串）并将其删除。自动复制到剪贴板G，级别1（这部分内容受@Luis Mendo的回答启发）。

" -隐式获取第二个输入（单词的单元格数组），对其进行迭代。

l -按1以备后用

1G -推送第一个输入（例如“ psr”）

@g -将当前单词推送为数组

3XN-- nchoosek从单词中获取3个字母的所有组合

Xm-查看车牌代码“ psr”是否为这些组合之一。返回0代表false，1代表true。

/-用这个结果除以1（我们之前推过的）。将0更改为Infs

@gn -获取当前单词的长度

*-长度乘以除法结果。返回单词包含三个字符时的长度，否则返回Inf

v -将这些结果垂直合并为一个数组

] -闭环

&X< -从该数组获取最小值的索引，即找到包含字母且长度最小的单词的索引

2G -再次按下第二个输入

w -将最小索引带回到堆栈顶部

) -使用最小索引对单词数组进行索引，以最小长度返回有效单词

（隐式输出。）

较旧：

x"@g1Gy3XNXm1w/wn*v]&X<2Gw)

x"@g1Gy3XNXm1w/wn*v]2Gw2$S1)