给定字符串X和Y，请确定X是否为Y的子序列。空字符串被视为每个字符串的子序列。（例如''和'anna'是的子序列'banana'。）

输入项

• X，可能为空，区分大小写的字母数字字符串
• Y，可能是空的区分大小写的字母数字字符串

输出量

• True或False（或等效项），正确指示X是Y的子序列。

I / O实例

X      Y        output

''     'z00'    True
'z00'  'z00'    True 
'z00'  '00z0'   False
'aa'   'anna'   True
'anna' 'banana' True
'Anna' 'banana' False

标准

• 最短的程序获胜，这取决于源代码的字节数。

示例程序

• 与此相关的帖子中有几种可以改编的程序。

Perl 5、17个字节（+1？），完整程序

s//.*/g;$_=<>=~$_

在线尝试！

与p标志一起调用到perl解释器，如中所示perl -pe 's//.*/g;$_=<>=~$_'。根据最初发布此挑战时已建立的评分规则，此标志会额外增加一个字节。根据最新的 AFAICT 规则，它可能是免费的。

无论哪种方式，输入字符串都应在stdin上以换行符结尾的单独行中提供。1如果第一个输入字符串是第二个输入字符串的子字符串，则输出（到stdout）将是输出，否则则根本不输出。

请注意，两个输入行的末尾都必须换行，否则程序将无法正常运行。另外，您可以l在调用中添加命令行标志，以使perl去除换行符；根据有效的评分规则，这可能会或可能不会花费一个额外的字节。请注意，使用此标志还将在输出中添加换行符。

原始版本（代码段，18字节/字符）

$x=~s//.*/g,$y=~$x

输入是在变量$x和中给出的$y，结果是表达式的值（在标量上下文中）。请注意，$x在此过程中进行了修改。（是的，我知道使用$_代替$x可以让我节省四个字符，但是在一段对我来说太俗气的代码段中这样做。）

它是如何工作的？

第一部分在中的每个字符之间$x=~s//.*/g插入字符串。第二部分视为正则表达式并与其匹配。在Perl正则表达式中，匹配零个或多个任意字符，而所有字母数字字符都方便地匹配自己。.*$x$y=~$x$x$y.*

Ruby，32个字符

s=->x,y{y=~/#{[*x.chars]*".*"}/}

nil如果x不是的子序列，则返回此解决方案，y否则返回一个数字（即与false和等效的红宝石true）。例子：

p s['','z00']        # => 0   (i.e. true)
p s['z00','z00']     # => 0   (i.e. true)
p s['z00','00z0']    # => nil (i.e. false)
p s['anna','banana'] # => 1   (i.e. true)
p s['Anna','banana'] # => nil (i.e. false)

哈斯克尔， 51 37

h@(f:l)%(g:m)=f==g&&l%m||h%m;x%y=x<=y

感谢Hammar的实质性改进。现在它是一个infix函数，但似乎没有理由不这样做。

示范：

GHCi> :{
GHCi| zipWith (%) [""   , "z00", "z00" , "anna"  , "Anna"]
GHCi|             ["z00", "z00", "00z0", "banana", "banana"]
GHCi| :}
[True,True,False,True,False]

Python（48个字符）

import re;s=lambda x,y:re.search('.*'.join(x),y)

与Howard的Ruby回答相同的方法。对于Python是否需要导入regex软件包及其“详细”信息，这太糟糕了lambda。:-)

Python，59个字符

def s(x,y):
 for c in y:
  if x:x=x[c==x[0]:]
 return x==""

我想我的答案会更好地用Python表达。

编辑：添加了res的建议。

GolfScript（22个字符）

X[0]+Y{1$(@={\}*;}/0=!

假定将输入作为两个预定义变量X和Y，尽管这在GolfScript中是很不常见的。叶1为真或0堆栈上的虚假。

C（52个字符）

s(char*x,char*y){return!*x||*y&&s(*x-*y?x:x+1,y+1);}

测试用例

滑稽（6个字符）

Burlesque中的6个字符：（ R@\/~[ 假设x和y在堆栈中。请参见此处的操作。）

C，23：

while(*y)*x-*y++?0:x++;

导致* x

http://ideone.com/BpITZ

PHP，90个字符

<?function s($x,$y){while($a<strlen($y))if($y[$a++]==$x[0])$x=substr($x,1);return $x=="";}

Scala 106：

def m(a:String,b:String):Boolean=(a.size==0)||((b.size!=0)&&((a(0)==b(0)&&m(a.tail,b.tail))||m(a,b.tail)))

CoffeeScript 112 100 95 89

我第一次尝试打码高尔夫...希望我不要让我的家人感到羞耻！

z=(x,y)->a=x.length;return 1if!a;b=y.indexOf x[0];return 0if!++b;z x[1..a],y[b..y.length]

编辑：事实证明，Coffeescript比空白所想象的要宽容得多。

感谢res和Peter Taylor提供的一些技巧，使其变得更时尚

C ＃， 70 113 107 90个字符

static bool S(string x,string y){return y.Any(c=>x==""||(x=x.Remove(0,c==x[0]?1:0))=="");}

Mathematica 19 17 27

LongestCommonSequence返回两个字符串中最长的非连续子序列。（请勿与混淆LongestCommonSubsequence，它会返回最长的连续子序列。

下面检查最长的连续子序列是否是两个字符串中的第一个。（因此，您必须输入较短的字符串，然后输入较大的字符串。）

LongestCommonSequence@##==#& 

例子

LongestCommonSequence@## == # &["", "z00"]
LongestCommonSequence@## == # &["z00", "z00"]
LongestCommonSequence@## == # &["anna", "banana"]
LongestCommonSequence@## == # &["Anna", "banana"]

正确正确正确错误

关键测试是第三个测试，因为“香蕉”不连续地包含在“香蕉”中。

Python 3.8（预发布），42字节

lambda a,b:''in[a:=a[a[:1]==c:]for c in b]

在线尝试！

Python 3.8（预发布），48字节

lambda a,b,j=0:all((j:=1+b.find(c,j))for c in a)

在线尝试！

Python 2，48个字节

lambda a,b:re.search('.*'.join(a),b)>0
import re

在线尝试！

复制自 林恩的回答中。>0如果只输出正确/错误，则可以省略。

Python 2个字节

f=lambda a,b:b and f(a[a[:1]==b[0]:],b[1:])or''==a

在线尝试！

Python 2个字节

lambda a,b:reduce(lambda s,c:s[c==s[:1]:],b,a)==''

在线尝试！

C - -74 71 64

这没有超越Peter Taylor的解决方案，但我认为这很有趣（而且，这是一个完整的工作程序，而不仅仅是一个功能）

main(int c,char**v){for(;*v[1]!=0;++v[1])v[2]+=*v[1]==*v[2];return*v[2];}

main(int c,char**v){for(;*v[1];++v[1])v[2]+=*v[1]==*v[2];return*v[2];}

main(c,v)char**v;{while(*v[1])v[2]+=*v[1]++==*v[2];return*v[2];}

和无高尔夫球场：

main(int argc, char** argv){
   char * input = argv[1];
   char * test  = argv[2];

   // advance through the input string. Each time the current input
   // character is equal to the current test character, increment
   // the position in the test string.

   for(; *input!='\0'; ++input) test += *input == *test;

   // return the character that we got to in the test string.
   // if it is '\0' then we got to the end of the test string which
   // means that it is a subsequence, and the 0 (EXIT_SUCCESS) value is returned
   // otherwise something non-zero is returned, indicating failure.
   return *test;
}

要测试它，您可以执行以下操作：

./is_subsequence banana anna && echo "yes" || echo "nope"    
# yes
./is_subsequence banana foobar && echo "yes" || echo "nope"    
# nope

蟒蛇， 66 62 59 58个字符

一种有趣的解决方案，绝对是一个整洁的问题。

def f(n,h,r=0):
 for c in h:r+=n[r:r+1]==c
 return r==len(n)

红宝石32 30 28

f=->a,b{b.match a.tr'','.*'}

MatchData如果a为b或的子序列，则将返回实例nil。

查找子字符串而不是子序列的旧版本

红宝石15

f=->a,b{!!b[a]}

使用String#[](str)方法，该方法返回str，如果str是的子串self和!!返回Boolean如果返回的值可以是可作为布尔型（和不需要是true或false），那么它可以是只有13个字符：

f=->a,b{b[a]}

nil如果a不是的子字符串，它将返回b。

SWI-Prolog，SICStus

SICStus 的内置谓词sublist / 2检查第一个列表中的所有项是否也出现在第二个列表中。该谓词也可通过兼容性库在SWI-Prolog中获得，该库可由查询加载[library(dialect/sicstus/lists)].。

样品运行：

25 ?- sublist("","z00").
true.

26 ?- sublist("z00","z00").
true .

27 ?- sublist("z00","00z0").
false.

28 ?- sublist("aa","anna").
true .

29 ?- sublist("anna","banana").
true .

30 ?- sublist("Anna","banana").
false.

从技术上讲，字节数可以为0，因为我们在这里所做的只是查询，就像我们如何运行程序并为其提供输入一样。

PHP，41字节

打印1为真，否为假

<?=!levenshtein($argv[1],$argv[2],0,1,1);

如果仅从单词1到单词2进行插入，则对于真实情况，计数为零

莱文施泰因

在线尝试！

PHP，57字节

打印1表示true，0表示false

创建一个正则表达式

<?=preg_match(_.chunk_split($argv[1],1,".*")._,$argv[2]);

在线尝试！

Brachylog，2个字节

⊆ᵈ

在线尝试！

与这个答案一样， ⊆是一个内置谓词，声明输入和输出变量之间的关系，并且ᵈ是一个元谓词，对其进行修改以声明输入变量的第一和第二元素之间的相同关系（并统一）。输出变量和第二个元素，但这是一个决策问题，在这里并没有关系。X⊆Y断言X是Y的子序列，因此也是如此[X,Y]⊆ᵈ。

此谓词（当然，通过打印true.或false.在程序运行时的）将输入作为两个字符串的列表。如果输入更灵活...

Brachylog，1个字节

⊆

在线尝试！

将字符串X作为输入变量，并将字符串Y作为输出变量。和以前一样，通过成功或失败输出。如果以完整程序运行，则将 X作为输入，并将Y作为第一个命令行参数。

CoffeeScript 73

这是一个替代的CoffeeScript答案，使用正则表达式而不是递归：

z=(x,y)->a='.*';a+=c+'.*'for c in x;b=eval('/'+a+'/');(y.replace b,'')<y

如果干草堆与用针构造的非常贪婪的正则表达式匹配，则将其替换为空字符串。如果干草堆比开始的时候要短，则说明针是一个子序列。

当x和y均为空字符串。想想我们需要一个哲学家来告诉我们一个空字符串是否是它本身的子序列！

（作为与我以前的答案分开发布的答案，因为感觉足以证明它的合理性）。

PowerShell，38岁

$args[1]-clike($args[0]-replace'','*')

当然，任何此类基于正则表达式或模式匹配的解决方案在使用更长的字符串时都存在严重的性能问题。但是由于短缺是标准...

一种产生Y的所有子序列的反解：

Python 93

l=len(y)
print x in[''.join(c for i,c in zip(bin(n)[2:].rjust(l,'0'),y)if i=='1')for n in range(2**l)]

APL（31）

APL中缺少字符串处理。

{(⊂'')∊N←⍵↓⍨¨1,⍨=/⊃¨⍵:~×⍴⊃N⋄∇N}

用法：

      {（⊂''）∊N←⍵↓⍨¨，⍨= /⊃¨⍵：〜×⍴⊃N⋄∇N}'anna''banana'
1个
      {（⊂''）∊N←⍵↓⍨¨，⍨= /⊃¨⍵：〜×⍴⊃N⋄∇N}'Anna''banana'
0
      {（⊂''）∊N←⍵↓⍨¨，⍨= /⊃¨⍵：〜×⍴⊃N⋄∇N}''香蕉'
1个

Python 132

类似于Daniero的。这不是最简单的解决方案，但是尝试很有趣。我是Python的新手，所以如果我知道更多一点，我敢肯定我可以缩短它的时间。

def f(i):
    s=x;j=0
    while j<len(s):t=~i%2;s=[s[:j]+s[j+1:],s][t];j+=t;i>>=1
    return s==y
print True in map(f,range(1,2**len(x)))

蟒蛇-72

def f(a,b):
 c=len(a)
 for i in b:a=a.replace(i,"",1)
 print len(a+b)==c

巨蟒（75 52）

s=lambda a,b:a==''or b>''and s(a[a[0]==b[0]:],b[1:])

简单的递归解决方案。第一次打高尔夫球，因此不胜感激的任何提示都值得赞赏:)

经过以下测试：

assert s('anna', 'banana') == True
assert s('oo0', 'oFopp0') == True
assert s 'this', 'this is a string') == True
assert s('that', 'this hat is large') == True
assert s('cba', 'abcdefg') == False

感谢@lirtosiast提供了一些聪明的布尔技巧。

PHP，75 65 64字节

for(;$p=@strpos(_.$argv[2],$c=$argv[1][$i++],$p+1););echo""==$c;

从命令行参数获取输入；打印1为true的字符串，为false的空字符串。用运行-r。

说明：

• strposfalse如果针$c不在干草堆中$argv[2]（在位置之后$p），则返回，
  从而导致循环中断。
• strpos也返回false空针，在的末尾中断循环$argv[1]。
• 如果$argv[1]是的子序列$argv[2]，$c则在循环中断时将为空。
• strpos需要@抑制Empty needle警告。

斯威夫特27岁

print(Y.range(of:X) != nil)