编写一个程序，将2个字符串作为输入，并返回最长的公共前缀。这是code-golf，所以最短字节的答案会获胜。

Test Case 1:

"global" , "glossary"
"glo"


Test Case 2:

"department" , "depart"
"depart"

Test Case 3:

"glove", "dove"
""

Python 3，54个字节

感谢Python具有此任务的内置功能！：D

import os;print(os.path.commonprefix(input().split()))

将输入作为两个单词，并用空格分隔，例如glossary global。

Haskell，29个字节

(c:x)%(d:y)|c==d=c:x%y;_%_=""

用法：

>> "global"%"glossary"
"glo"

%通过模式匹配来递归定义二进制函数。在两个首字母相等的字符串上，采用该首字母，并将其附加到其余字符串的功能上。在其他任何东西上，给出空字符串。

Pyth，8个 7字节

e@F._MQ

感谢@isaacg关闭1个字节

接受带引号且逗号分隔的输入，例如"abc", "acc"。当结果为空字符串时，将退出错误（但将stdout留空）。如果那是不可接受的，则添加2个字节用于#e@F._MQq

测试套件

说明

e@F._MQ        : implicit Q = eval(input)
   ._MQ        : Map the prefix operator onto both inputs
 @F            : Fold the setwise intersection operator over those lists
e              : Take the last such element, the prefixes are always made from shortest
               : to longest, so this always gives the longest matching prefix

C ++，101个 100 99字节

#include<iostream>
int i;main(){std::string s,t;std::cin>>s>>t;for(;s[i]==t[i];std::cout<<s[i++]);}

从中读取两个字符串stdin，从其中一个字符串中打印当前位置的字符，而当前位置的字符等于另一字符串中相同位置的字符。

感谢Zereges节省了一个字节。

Haskell，38个字节

((map fst.fst.span(uncurry(==))).).zip

用法示例：( ((map fst.fst.span(uncurry(==))).).zip ) "global" "glossary"-> "glo"。

将两个输入字符串压缩成一个成对的字符列表。从中列出两个清单：第一个清单从头开始所有对，只要两个字符都相等，第二个清单所有其余。删除第二个列表，并从第一个列表中提取所有字符。

CJam，12 11 9字节

l_q.-{}#<

这将读取两行以Unix样式的行结尾的字符串，即<string>\n<string>\n。

感谢-1字节的@MartinBüttner和-2字节的@ jimmy23013！

在CJam解释器中在线尝试。

怎么运行的

l_         e# Read a line (w/o trailing LF) from STDIN and push a copy.
  q        e# Read another line from STDIN (with trailing LF).
           e# The trailing linefeed makes sure that the lines are not equal.
   .-      e# Perform vectorized character subtraction. This yields 0 for equal
           e# characters, a non-zero value for two different characters, and the
           e# characters themselves (truthy) for the tail of the longer string.
     {}#   e# Find the index of the first truthy element.
        <  e# Keep that many characters from the first string.

APL，13

{⊃↓K/⍨=⌿K←↑⍵}

此函数采用两个字符串组成的数组，并返回前缀：

      {⊃↓K/⍨=⌿K←↑⍵}'glossary' 'global'
glo
      {⊃↓K/⍨=⌿K←↑⍵}'department' 'depart'
depart

AppleScript，215字节

我非常努力...;（

设置x为（显示对话框““默认答案”“）的文本返回
设置返回到（显示对话框““默认答案”“）的文本
设置为1
设置为“”
在x的项n = a的项n时重复
将o设置为o＆x的项目n
将n设置为n + 1
结束
Ø

我想看到的AppleScript能如何退出这个功能，并且人是它没有内置字符串比较。

rs，14个字节

(.*).* \1.*/\1

现场演示和测试案例。

这很简单。它只匹配...最长公共前缀，并删除字符串的其余部分。如果没有最长的公共前缀，它将清除所有内容。

sed，18岁

我的想法更长一些，更复杂了，因此可以将这个想法归功于@ kirbyfan64sos。

s/(.*).* \1.*/\1/

包含+1的-rsed选项。

CJam，12 8 26

r:AAr:B.=0#_W={;;ABe<}{<}?

在线尝试。

（在查看了丹尼斯的答案后，最好使用。=代替.-。）

在所有的情况下，对于像我这样的CJam初学者来说，要保持简短就变得很困难。希望这至少适用于所有情况。

C＃， 201个 147字节

using System.Linq;class a{static void Main(string[]a){a[0].Take(a[1].Length).TakeWhile((t,i)=>a[1][i]==t).ToList().ForEach(System.Console.Write);}}

我知道这并不十分竞争。我只是想看看它会是什么样子。

编辑：感谢Ash Burlakzenko，Berend和Dennis_E

常见的Lisp，39岁

(lambda(a b)(subseq a 0(mismatch a b)))

接受两个字符串参数，确定它们之间不同的索引i，然后返回从0到i的子字符串。

Perl 5中，20个 19 18字节

19个字节，再加上1个-E标志，而不是-e：

say<>=~/^(.*).* \1/

这是从Digital Trauma的sed答案中无耻复制的。它假定输入是几个单词，两个单词之间没有空格（或第一个单词之前），并且它们之间有一个空格。

更新：

不建议使用thisSuitIsBlack-pe，以节省字节（谢谢！）：

($_)=/^(.*).* \1/

然后，Luk Storms建议使用-nE以下方法来保存另一个字节（谢谢！）：

say/^(.*).* \1/

（我数-E为一个字节而不是标准的-e，但-n还是-p两个。我的印象是，这是SOP在这里。）

Python 3、72

多亏了FryAmTheEggman，节省了31个字节。DSM节省了8条。

r=''
for x,y in zip(input(),input()):
 if x==y:r+=x
 else:break
print(r)

Python 3、47

def f(w):[print(end=c[c!=d])for c,d in zip(*w)]

该函数接受w两个单词的列表，并在错误终止之前打印公共前缀。

Python 3的print功能使您可以使用彼此齐平的字符串来打印字符串print(end=c)（感谢Sp3000使用这种较短的语法节省了3个字节）。这会反复从单词中取出两个字母，然后打印第一个字母。索引c[c!=d]产生界外错误，其中c!=d当遇到两个不相等的字母时终止执行。

一个显式的for循环比列表理解长一个char：

def f(w):
 for c,d in zip(*w):print(end=c[c!=d])

Javascript ES6，52个字节

f=(a,b)=>[...a].filter((e,i)=>e==b[i]?1:b='').join``

用法：

>> f("global","glossary")
"glo"

视网膜，14字节

使用与kirbyfan64sos相同的想法。不幸的是，尽管马丁声称最终的“匹配”模式将具有一种打印捕获组的方式，但尚未实现。否则，(.*).* \1可以将其与2个字节一起用于一些尚不存在的配置字符串选项。

(.*).* \1.*
$1

每行将放入其自己的文件，每个其他文件增加1个字节。或者，在带有-s标志的单个文件中运行。

K，24个字节

{(+/&\=/(&/#:'x)#'x)#*x}

找到每个字符串的最小长度。（(&/#:'x)）。将每个字符串修剪到该长度（#'x）。然后比较，涂抹和求和结果序列：

  =/("globaa";"glossa")
1 1 1 0 0 1
  &\=/("globaa";"glossa")
1 1 1 0 0 0
  +/&\=/("globaa";"glossa")
3

最后，从提供的字符串（#*x）的第一个中提取那么多字符。

实际上：

 f: {(+/&\=/(&/#:'x)#'x)#*x};
 f'(("global";"glossary")
    ("department";"depart")
    ("glove";"dove")
    ("aaa";"aaaaa")
    ("identical";"identical")
    ("aca";"aba"))
("glo"
 "depart"
 ()
 "aaa"
 "identical"
 ,"a")

Powershell，65个字节

比较字符串，缩小第一个字符串，直到匹配（打印并退出），或者字符串为null并终止循环。

param($a,$b)while($a){if($b-like"$a*"){$a;exit}$a=$a-replace".$"}

朱莉娅62字节

f(a,b)=(c="";for(i,j)=zip(a,b) i!=j?break:(c*=string(i))end;c)

取消高尔夫：

function f(a::AbstractString, b::AbstractString)
    # Initialize an output string
    c = ""

    # Iterate over the pairs of characters in a and b,
    # truncated to the shorter of the two lengths
    for (i, j) in zip(a, b)
        if i == j
            # If they match, append to the output string
            c *= string(i)
        else
            # Otherwise stop everything!
            break
        end
    end

    return c
end

由于xnor，解决了一个问题（付出了14字节的巨额费用）！

C99，73个字节

main(int c,char *a[]){for(char *x=a[1],*y=a[2];*x==*y++;putchar(*x++));}

与此答案类似，但更短且符合规范（从stdin输入）。

MATLAB，50 40字节

定义一个接受2个字符串作为输入，输出到命令窗口的函数

function t(a,b);a(1:find([diff(char(a,b)) 1],1)-1)

此解决方案适用于任何字符串，输出

ans =

   Empty string: 1-by-0

如果没有给出匹配。

可以使用脚本而不是函数（使用局部变量a，b）（-16字节）来打高尔夫球。

所以得到34个字节

a(1:find([diff(char(a,b)) 1],1)-1)

函数样式（似乎是公认的样式）产生

@(a,b)a(1:find([diff(char(a,b)) 1],1)-1)

（感谢@Stewie Griffin）

Perl 6，28个字节

我想出了两个基于STDIN的值，它们基于Perl 5的答案。

lines~~/(.*).*' '$0/;say ~$0

lines~~/:s(.*).* $0/;say ~$0

第一个在输入之间恰好需要一个空格，而另一个在输入之间至少需要一个空格字符。

这比我尝试从命令行获取值的第一件事要短得多。

say [~] map ->($a,$b){$a eq$b&&$a||last},[Z] @*ARGS».comb # 58 bytes

甚至是lambda版本：

{[~] map ->($a,$b){$a eq$b&&$a||last},[Z] @_».comb} # 52 bytes

尽管这很容易调整，以使其接受任意数量的输入字符串，但仅需一次敲击。

{[~] map ->@b {([eq] @b)&&@b[0]||last},[Z] @_».comb} # 53 bytes
#          ┗━┛ ┗━━━━━━━┛  ┗━━━┛

my &common-prefix = {[~] map ->@b {([eq] @b)&&@b[0]||last},[Z] @_».comb}

say common-prefix <department depart>; # "depart"
say common-prefix; # ""
say common-prefix <department depart depot deprecated dependant>; # "dep"

# This code does not work directly with a single argument, so you have
# to give it an itemized List or Array, containing a single element.

say common-prefix $('department',); # "department"

# another option would be to replace `@_` with `(@_,)`

Japt，27个字节

Japt是Ja vaScri pt的缩写。口译员

Um$(X,Y)=>$A&&X==VgY ?X:A=P

（字符串进入输入框，如下所示： "global" "glossary"）

此代码与以下JS完全等效：

A=10;(U,V)=>U.split``.map((X,Y)=>A&&X==V[Y]?X:A="").join``

我还没有实现匿名功能，这就是$...$它的用途：在切换到JS时，美元符号之间的任何内容都保持不变。添加函数后，此21字节的代码就足够了：

UmXY{A&&X==VgY ?X:A=P

在实现更多功能之后，理想情况下将为18个字节：

UmXY{AxX=VgY ?X:AP

建议欢迎！

因此事实证明，该程序在现代Japt中只有15个字节：

¡A©X¥VgY ?X:A=P

在线尝试！

MATL，11 9字节

y!=XdYpf)

在线尝试！

（-2字节，感谢Giuseppe）

 y  % implicitly input the two strings, then duplicate the
    %  first one into the stack again
    %  stack: ['department' 'deported' 'department']
 !  % transpose the last string into a column vector
 =  % broadcast equality check - gives back a matrix comparing
    %  every letter in first input with the letters in the second
 Xd % diagonal of the matrix - comparison result of each letter with
    %  only corresponding letter in the other string
    %  stack: ['department' [1; 1; 1; 0; 1; 1; 0; 0;]]
 Yp % cumulative product (so only initial sequence of 1s remains
    %  1s, others become 0)
    %  stack: ['department' [1; 1; 1; 0; 0; 0; 0; 0;]]
 f  %  find the indices of the 1s
 )  % index at those elements so we get those letters out
    % (implicit) convert to string and display

Clojure / ClojureScript，51

(defn f[[a & b][c & d]](if(= a c)(str a(f b d))""))

非常简单。不幸的是，参数解构周围的空格是必需的（就是这些[a & b]东西）。不是最短的，但我打败了其他一些喜欢夸口其简洁性的语言的答案，因此我将其发布。

Python 2，50个字节

for a,b in zip(*input()):print(1/0if a!=b else a),

输入值

输入被视为两个字符串：

"global", "glossary"

输出量

输出是每个字符后跟一个空格；希望这不是问题。但是，如果是这样，我将编辑答案。

g l o 

TeaScript，16字节20

xf»l¦y[i]?1:b=0)

取每个输入，并用空格分隔。

PHP，52字节

并不壮观，但能胜任：

$a=$argv;while($a[1][$i]==$a[2][$i])echo$a[1][$i++];

接受两个命令行参数：

php prefix.php department depart