在一组字符串中查找最长的公共起始子字符串

时间:2009-12-16 17:22:47

标签: javascript python ruby haskell longest-prefix

对于一个相对微不足道的问题,提出最优雅的JavaScript,Ruby或其他解决方案是一项挑战。

此问题是Longest common substring problem的更具体的情况。我只需要在数组中找到最长的常见起始子字符串。这大大简化了问题。

例如,[interspecies, interstelar, interstate]中最长的子字符串是“inters”。但是,我不需要在[specifics, terrific]中找到“ific”。

我已经通过在JavaScript中快速编写解决方案作为answer about shell-like tab-completiontest page here)的一部分来解决问题。这是解决方案,略有调整:

function common_substring(data) {
  var i, ch, memo, idx = 0
  do {
    memo = null
    for (i=0; i < data.length; i++) {
      ch = data[i].charAt(idx)
      if (!ch) break
      if (!memo) memo = ch
      else if (ch != memo) break
    }
  } while (i == data.length && idx < data.length && ++idx)

  return (data[0] || '').slice(0, idx)
}

这个code is available in this Gist以及Ruby中的类似解决方案。您可以将gist克隆为git repo来试用它:

$ git clone git://gist.github.com/257891.git substring-challenge

我对这些解决方案不太满意。我觉得他们可能会以更优雅和更少的执行复杂性来解决 - 这就是我发布这一挑战的原因。

我将接受作为答案的解决方案,我发现最优雅或简洁。这是一个疯狂的Ruby hack我想出来 - 在String上定义&运算符:

# works with Ruby 1.8.7 and above
class String
  def &(other)
    difference = other.to_str.each_char.with_index.find { |ch, idx|
      self[idx].nil? or ch != self[idx].chr
    }
    difference ? self[0, difference.last] : self
  end
end

class Array
  def common_substring
    self.inject(nil) { |memo, str| memo.nil? ? str : memo & str }.to_s
  end
end

首选JavaScript或Ruby解决方案,但只要您解释正在发生的事情,您就可以在其他语言中展示出聪明的解决方案。请仅使用标准库中的代码。

更新:我最喜欢的解决方案

我选择了JavaScript sorting solution kennebec作为“答案”,因为它让我感到意外和天才。如果我们忽略实际排序的复杂性(让我们想象它是由语言实现无限优化的),解决方案的复杂性只是比较两个字符串。

其他很棒的解决方案:

感谢您的参与!从评论中可以看出,我学到了很多东西(甚至是Ruby)。

31 个答案:

答案 0 :(得分:55)

这是一个品味问题,但这是一个简单的JavaScript版本: 它对数组进行排序,然后查看第一个和最后一个项目。

//数组中最长的公共起始子字符串

function sharedStart(array){
    var A= array.concat().sort(), 
    a1= A[0], a2= A[A.length-1], L= a1.length, i= 0;
    while(i<L && a1.charAt(i)=== a2.charAt(i)) i++;
    return a1.substring(0, i);
}

<强> DEMOS

sharedStart(['interspecies', 'interstelar', 'interstate'])  //=> 'inters'
sharedStart(['throne', 'throne'])                           //=> 'throne'
sharedStart(['throne', 'dungeon'])                          //=> ''
sharedStart(['cheese'])                                     //=> 'cheese'
sharedStart([])                                             //=> ''
sharedStart(['prefix', 'suffix'])                           //=> ''

答案 1 :(得分:38)

在Python中:

>>> from os.path import commonprefix
>>> commonprefix('interspecies interstelar interstate'.split())
'inters'

答案 2 :(得分:9)

Ruby one-liner:

l=strings.inject{|l,s| l=l.chop while l!=s[0...l.length];l}

答案 3 :(得分:9)

你只需要遍历所有字符串直到它们不同,然后将子字符串提升到这一点。

伪代码:

loop for i upfrom 0
     while all strings[i] are equal
     finally return substring[0..i]

Common Lisp:

(defun longest-common-starting-substring (&rest strings)
  (loop for i from 0 below (apply #'min (mapcar #'length strings))
     while (apply #'char=
                  (mapcar (lambda (string) (aref string i))
                          strings))
     finally (return (subseq (first strings) 0 i))))

答案 4 :(得分:9)

我的Haskell单线:

import Data.List

commonPre :: [String] -> String
commonPre = map head . takeWhile (\(x:xs)-> all (==x) xs) . transpose
编辑:barkmadley对下面的代码做了很好的解释。我还要补充一点,haskell使用懒惰评估,所以我们对transpose的使用很懒惰;它只会在必要时转置我们的列表以找到公共前缀的结尾。

答案 5 :(得分:6)

另一种方法:使用正则表达式贪婪。

words = %w(interspecies interstelar interstate)
j = '='
str = ['', *words].join(j)
re = "[^#{j}]*"

str =~ /\A
    (?: #{j} ( #{re} ) #{re} )
    (?: #{j}    \1     #{re} )*
\z/x

p $1

单行,礼貌的mislav(50个字符):

p ARGV.join(' ').match(/^(\w*)\w*(?: \1\w*)*$/)[1]

答案 6 :(得分:4)

在Python中我不会使用除了我在另一个答案中显示的现有commonprefix函数以外的任何函数,但我无法重新发明轮:P。这是我基于迭代器的方法:

>>> a = 'interspecies interstelar interstate'.split()
>>>
>>> from itertools import takewhile, chain, izip as zip, imap as map
>>> ''.join(chain(*takewhile(lambda s: len(s) == 1, map(set, zip(*a)))))
'inters'

编辑:解释其工作原理。

zip一次生成a项中的一项,生成元素元组:

In [6]: list(zip(*a))  # here I use list() to expand the iterator
Out[6]:
[('i', 'i', 'i'),
 ('n', 'n', 'n'),
 ('t', 't', 't'),
 ('e', 'e', 'e'),
 ('r', 'r', 'r'),
 ('s', 's', 's'),
 ('p', 't', 't'),
 ('e', 'e', 'a'),
 ('c', 'l', 't'),
 ('i', 'a', 'e')]

通过将set映射到这些项目上,我得到了一系列独特的字母:

In [7]: list(map(set, _))  # _ means the result of the last statement above
Out[7]:
[set(['i']),
 set(['n']),
 set(['t']),
 set(['e']),
 set(['r']),
 set(['s']),
 set(['p', 't']),
 set(['a', 'e']),
 set(['c', 'l', 't']),
 set(['a', 'e', 'i'])]
当谓词为True时,

takewhile(predicate, items)从中获取元素;在这种特殊情况下,当set s有一个元素时,即所有单词在该位置都有相同的字母:

In [8]: list(takewhile(lambda s: len(s) == 1, _))
Out[8]:
[set(['i']),
 set(['n']), 
 set(['t']), 
 set(['e']), 
 set(['r']), 
 set(['s'])]

此时我们有一组可迭代的集合,每个集合包含我们正在寻找的前缀的一个字母。为了构造字符串,我们将它们chain分成一个迭代,从中我们将join的字母放到最后的字符串中。

使用迭代器的神奇之处在于所有项目都是按需生成的,因此当takewhile停止询问项目时,拉链会在此时停止,并且不会执行任何不必要的工作。我的单行中的每个函数调用都有隐式for和隐式break

答案 7 :(得分:3)

结合 kennebec Florian F jberryman 的答案会产生以下Haskell单行:

commonPrefix l = map fst . takeWhile (uncurry (==)) $ zip (minimum l) (maximum l)

使用Control.Arrow可以获得无点形式:

commonPrefix = map fst . takeWhile (uncurry (==)) . uncurry zip . (minimum &&& maximum)

答案 8 :(得分:3)

这可能不是最简洁的解决方案(取决于你是否已经有了这个库),但一种优雅的方法是使用trie。我在我的Scheme解释器中使用try来实现tab完成:

http://github.com/jcoglan/heist/blob/master/lib/trie.rb

例如:

tree = Trie.new
%w[interspecies interstelar interstate].each { |s| tree[s] = true }
tree.longest_prefix('')
#=> "inters"

我还使用它们来匹配Bayeux协议的通配符和通配符;看到这些:

http://github.com/jcoglan/faye/blob/master/client/channel.js

http://github.com/jcoglan/faye/blob/master/lib/faye/channel.rb

答案 9 :(得分:3)

基于@Svante's algorithm的javascript版本:

function commonSubstring(words){
    var iChar, iWord,
        refWord = words[0],
        lRefWord = refWord.length,
        lWords = words.length;
    for (iChar = 0; iChar < lRefWord; iChar += 1) {
        for (iWord = 1; iWord < lWords; iWord += 1) {
            if (refWord[iChar] !== words[iWord][iChar]) {
                return refWord.substring(0, iChar);
            }
        }
    }
    return refWord;
}

答案 10 :(得分:3)

只是为了它的乐趣,这是一个用(SWI-)PROLOG编写的版本:

common_pre([[C|Cs]|Ss], [C|Res]) :-
  maplist(head_tail(C), [[C|Cs]|Ss], RemSs), !,
  common_pre(RemSs, Res).
common_pre(_, []).

head_tail(H, [H|T], T).

跑步:

?- S=["interspecies", "interstelar", "interstate"], common_pre(S, CP), string_to_list(CPString, CP).

给出:

CP = [105, 110, 116, 101, 114, 115],
CPString = "inters".

说明:

(SWI-)PROLOG将字符串视为字符代码(数字)列表。所有谓词{{​​1}}都是递归模式匹配,以从所有列表列表中的第一个列表(字符串,common_pre/2)的头部选择第一个代码(C)(全部字符串,[C|Cs]),并将匹配代码[[C|Cs]|Ss]附加到结果 iff ,它对所有列表(字符串)的所有(剩余)头部都是通用的,否则它会终止。

漂亮,干净,简单而有效...... :)

答案 11 :(得分:2)

Python 2.6 (r26:66714, Oct  4 2008, 02:48:43) 

>>> a = ['interspecies', 'interstelar', 'interstate']

>>> print a[0][:max(
        [i for i in range(min(map(len, a))) 
            if len(set(map(lambda e: e[i], a))) == 1]
        ) + 1]

inters
  • i for i in range(min(map(len, a))),最大查找次数不能大于最短字符串的长度;在此示例中,这将评估为[0, 1, 2, 3, 4, 5, 6, 7, 8, 9]

  • len(set(map(lambda e: e[i], a))),1)为列表中的每个字符串创建一个i-th字符数组; 2)制作一套; 3)确定集合的大小

  • [i for i in range(min(map(len, a))) if len(set(map(lambda e: e[i], a))) == 1],仅包含字符集,其中集合的大小为1(该位置的所有字符都相同..);在这里,它将评估为[0, 1, 2, 3, 4, 5]

  • 最后选择max,添加一个,然后获取子字符串......

注意:上述内容不适用于a = ['intersyate', 'intersxate', 'interstate', 'intersrate'],但这样会:

 >>> index = len(
         filter(lambda l: l[0] == l[1], 
             [ x for x in enumerate(
                 [i for i in range(min(map(len, a))) 
                     if len(set(map(lambda e: e[i], a))) == 1]
         )]))
 >>> a[0][:index]
 inters

答案 12 :(得分:2)

这个与Roberto Bonvallet的解决方案非常相似,除了ruby。

chars = %w[interspecies interstelar interstate].map {|w| w.split('') }
chars[0].zip(*chars[1..-1]).map { |c| c.uniq }.take_while { |c| c.size == 1 }.join

第一行用chars数组替换每个单词。接下来,我使用zip来创建此数据结构:

[["i", "i", "i"], ["n", "n", "n"], ["t", "t", "t"], ...

mapuniq将此缩减为[["i"],["n"],["t"], ...

take_while将字符拉出数组,直到找到一个大小不是一个的字符(意味着并非所有字符都相同)。最后,我join他们一起回来。

答案 13 :(得分:2)

accepted solution已被破坏(例如,它会为a等字符串返回['a', 'ba']。修复非常简单,您只需更改3个字符(从indexOf(tem1) == -1indexOf(tem1) != 0),该函数将按预期工作。

不幸的是,当我尝试编辑修复拼写错误的答案时,SO告诉我“编辑必须至少6个字符”。通过改进命名和可读性,我可以改变那些3个字符,但感觉有点太多了。

因此,以下是肯尼贝克解决方案的固定和改进版(至少从我的观点来看):

function commonPrefix(words) {
  max_word = words.reduce(function(a, b) { return a > b ? a : b });
  prefix   = words.reduce(function(a, b) { return a > b ? b : a }); // min word

  while(max_word.indexOf(prefix) != 0) {
    prefix = prefix.slice(0, -1);
  }

  return prefix;
}

(在jsFiddle上)

注意,它使用reduce方法(JavaScript 1.8)来查找字母数字max / min,而不是对数组进行排序,然后获取它的第一个和最后一个元素。

答案 14 :(得分:2)

在阅读所有花哨的函数式编程,排序和正则表达式以及诸如此类的东西的同时,我只是想到:C中有什么错误?所以,这是一个看起来很愚蠢的小程序。

#include <stdio.h>

int main (int argc, char *argv[])
{
  int i = -1, j, c;

  if (argc < 2)
    return 1;

  while (c = argv[1][++i])
    for (j = 2; j < argc; j++)
      if (argv[j][i] != c)
        goto out;

 out:
  printf("Longest common prefix: %.*s\n", i, argv[1]);
}

编译它,用你的字符串列表作为命令行参数运行它,然后请求我使用goto

答案 15 :(得分:2)

如果你不太关心最终表现,那似乎并不复杂:

def common_substring(data)
  data.inject { |m, s| s[0,(0..m.length).find { |i| m[i] != s[i] }.to_i] }
end

注入的一个有用特性是能够预先对种子的第一个元素进行预处理。这可以避免零备忘录检查。

puts common_substring(%w[ interspecies interstelar interstate ]).inspect
# => "inters"
puts common_substring(%w[ feet feel feeble ]).inspect
# => "fee"
puts common_substring(%w[ fine firkin fail ]).inspect
# => "f"
puts common_substring(%w[ alpha bravo charlie ]).inspect
# => ""
puts common_substring(%w[ fork ]).inspect
# => "fork"
puts common_substring(%w[ fork forks ]).inspect
# => "fork"

更新:如果高尔夫是这里的游戏,那么67个字符:

def f(d)d.inject{|m,s|s[0,(0..m.size).find{|i|m[i]!=s[i]}.to_i]}end

答案 16 :(得分:1)

高尔夫JS解决方案只是为了好玩:

w=["hello", "hell", "helen"];
c=w.reduce(function(p,c){
    for(r="",i=0;p[i]==c[i];r+=p[i],i++){}
    return r;
});

答案 17 :(得分:1)

这是红宝石的有效解决方案。我基于高/低猜谜游戏策略的想法,你迭代地将最长的前缀归零。

如果我错了,有人会纠正我,但我认为复杂度为O(n log n),其中n是最短字符串的长度,字符串数被视为常量。

def common(strings)
  lo = 0
  hi = strings.map(&:length).min - 1
  return '' if hi < lo

  guess, last_guess = lo, hi

  while guess != last_guess
    last_guess = guess
    guess = lo + ((hi - lo) / 2.0).ceil

    if strings.map { |s| s[0..guess] }.uniq.length == 1
      lo = guess
    else
      hi = guess
    end
  end

  strings.map { |s| s[0...guess] }.uniq.length == 1 ? strings.first[0...guess] : ''
end

有些检查它有效:

>> common %w{ interspecies interstelar interstate }
=> "inters"

>> common %w{ dog dalmation }
=> "d"

>> common %w{ asdf qwerty }
=> ""

>> common ['', 'asdf']
=> ""

答案 18 :(得分:1)

有趣的替代Ruby解决方案:

def common_prefix(*strings)
  chars  = strings.map(&:chars)
  length = chars.first.zip( *chars[1..-1] ).index{ |a| a.uniq.length>1 }
  strings.first[0,length]
end

p common_prefix( 'foon', 'foost', 'forlorn' ) #=> "fo"
p common_prefix( 'foost', 'foobar', 'foon'  ) #=> "foo"
p common_prefix( 'a','b'  )                   #=> ""

如果使用chars = strings.sort_by(&:length).map(&:chars),它可能有助于提高速度,因为第一个字符串越短,zip创建的数组越短。但是,如果你关心速度,你可能不应该使用这个解决方案。 :)

答案 19 :(得分:1)

我的Java解决方案:

public static String compute(Collection<String> strings) {
    if(strings.isEmpty()) return "";
    Set<Character> v = new HashSet<Character>();
    int i = 0;
    try {
        while(true) {
            for(String s : strings) v.add(s.charAt(i));
            if(v.size() > 1) break;
            v.clear();
            i++;
        }
    } catch(StringIndexOutOfBoundsException ex) {}
    return strings.iterator().next().substring(0, i);
}

答案 20 :(得分:1)

这是在Ruby中使用正则表达式的解决方案:

def build_regex(string)
  arr = []
  arr << string.dup while string.chop!
  Regexp.new("^(#{arr.join("|")})")
end

def substring(first, *strings)
  strings.inject(first) do |accum, string|
    build_regex(accum).match(string)[0]
  end
end

答案 21 :(得分:1)

通常使用成熟的开源库而不是自己编辑它会更优雅。然后,如果它不能完全满足您的需求,您可以对其进行扩展或修改以改进它,并让社区决定它是否属于库中。

diff-lcs是一个很好的Ruby gem,用于最不常见的子串。

答案 22 :(得分:1)

您可以只获取字符串的最小值和最大值,而不是排序。

对我来说,计算机程序的优雅是速度和简单的平衡。 它不应该做不必要的计算,它应该足够简单,以使其正确性明显。

我可以将排序解决方案称为“聪明”,但不是“优雅”。

答案 23 :(得分:1)

我会做以下事情:

  1. 将数组的第一个字符串作为初始起始子字符串
  2. 获取数组的下一个字符串并比较字符,直到到达其中一个字符串的末尾或找到不匹配的字符串。如果发现不匹配,请将起始子串减少到找到不匹配的长度。
  3. 重复步骤2,直到所有字符串都经过测试。
  4. 这是一个JavaScript实现:

    var array = ["interspecies", "interstelar", "interstate"],
        prefix = array[0],
        len = prefix.length;
    for (i=1; i<array.length; i++) {
        for (j=0, len=Math.min(len,array[j].length); j<len; j++) {
            if (prefix[j] != array[i][j]) {
                len = j;
                prefix = prefix.substr(0, len);
                break;
            }
        }
    }
    

答案 24 :(得分:0)

基于@Svante算法的ruby版本。运行速度是我第一次的3倍。

 def common_prefix set 
   i=0
   rest=set[1..-1]
   set[0].each_byte{|c|
     rest.each{|e|return set[0][0...i] if e[i]!=c}
     i+=1
   }
   set
 end

答案 25 :(得分:0)

这不是代码高尔夫,但你要求有点优雅,我倾向于认为递归很有趣。 Java的。

/** Recursively find the common prefix. */
public String findCommonPrefix(String[] strings) {

    int minLength = findMinLength(strings);

    if (isFirstCharacterSame(strings)) {
        return strings[0].charAt(0) + findCommonPrefix(removeFirstCharacter(strings));
    } else {
        return "";
    }
}

/** Get the minimum length of a string in strings[]. */
private int findMinLength(final String[] strings) {
    int length = strings[0].size();
    for (String string : strings) {
        if (string.size() < length) {
            length = string.size();
        }
    }
    return length;
}

/** Compare the first character of all strings. */
private boolean isFirstCharacterSame(String[] strings) {
    char c = string[0].charAt(0);
    for (String string : strings) {
        if (c != string.charAt(0)) return false;
    }

    return true;
}

/** Remove the first character of each string in the array, 
    and return a new array with the results. */
private String[] removeFirstCharacter(String[] source) {
    String[] result = new String[source.length];
    for (int i=0; i<result.length; i++) {
        result[i] = source[i].substring(1); 
    }
    return result;
}

答案 26 :(得分:0)

Javascript克隆AShelly的优秀答案。

只需要在Firefox中支持Array#reduce

var strings = ["interspecies", "intermediate", "interrogation"]
var sub = strings.reduce(function(l,r) { 
    while(l!=r.slice(0,l.length)) {  
        l = l.slice(0, -1);
    }
    return l;
});

答案 27 :(得分:0)

这绝不是优雅的,但如果你想简明扼要:

Ruby,71个字符

def f(a)b=a[0];b[0,(0..b.size).find{|n|a.any?{|i|i[0,n]!=b[0,n]}}-1]end

如果您想要展开它,它看起来像这样:

def f(words)
  first_word = words[0];
  first_word[0, (0..(first_word.size)).find { |num_chars|
    words.any? { |word| word[0, num_chars] != first_word[0, num_chars] }
  } - 1]
end

答案 28 :(得分:0)

我的 Javascript 解决方案:

IMOP,使用排序太棘手了。 我的解决方案是通过循环数组逐个字母进行比较。 如果字母没有被打印,则返回字符串。

这是我的解决方案:

var longestCommonPrefix = function(strs){
    if(strs.length < 1){
        return '';
    }

    var p = 0, i = 0, c = strs[0][0];

    while(p < strs[i].length && strs[i][p] === c){
        i++;
        if(i === strs.length){
            i = 0;
            p++;
            c = strs[0][p];
        }
    }

    return strs[0].substr(0, p);
};

答案 29 :(得分:0)

意识到这种情况变成code golf的匹配(或意图是什么?)的风险,这是我使用sed的解决方案,从my answer复制到另一个SO问题并缩短到36个字符(其中30个是实际的sed表达式)。它期望字符串(每个在单独的行上)在标准输入或作为附加参数传递的文件中提供。

sed 'N;s/^\(.*\).*\n\1.*$/\1\n\1/;D'

shebang行中带有sed的脚本的重量为45个字符:

#!/bin/sed -f
N;s/^\(.*\).*\n\1.*$/\1\n\1/;D

脚本的测试运行(名为longestprefix),字符串作为“此处文档”提供:

$ ./longestprefix <<EOF
> interspecies
> interstelar
> interstate
> EOF
inters
$

答案 30 :(得分:0)

<强>红宝石

require 'abbrev'

ar = ["interspecies", "interstelar", "interstate"]
ar.abbrev.keys.min_by(&:size).chop # => "inters"

给定一组字符串,abbrev计算这些字符串的明确缩写集,并返回一个散列,其中键是所有可能的缩写(并且值是完整的字符串)。最短的键减去最后一个字符将是公共前缀。