Écrivez un programme qui prend 2 chaînes en entrée et retourne le préfixe commun le plus long. Il s'agit de code-golf , donc la réponse avec le plus petit nombre d'octets l'emporte.

Test Case 1:

"global" , "glossary"
"glo"


Test Case 2:

"department" , "depart"
"depart"

Test Case 3:

"glove", "dove"
""

Python 3, 54 octets

Merci Python d'avoir une fonction intégrée pour cette tâche! :RÉ

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

Prend la saisie sous la forme de deux mots séparés par un espace tel que glossary global.

Haskell, 29 octets

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

Usage:

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

Définit récursivement la fonction binaire %par correspondance de modèle. Sur deux chaînes avec des premières lettres égales, prend ces premières lettres et les ajoute à la fonction du reste des chaînes. Sur toute autre chose, donne la chaîne vide.

Pyth, 8 7 octets

e@F._MQ

Merci @isaacg pour 1 octet de moins

Prend les entrées entre guillemets et séparées par des virgules, comme "abc", "acc". Cela se termine sur une erreur (mais laisse stdout vide) lorsque le résultat est la chaîne vide. Si cela est inacceptable, ajoutez 2 octets pour#e@F._MQq

Suite de tests

Explication

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 octets

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

Lit deux chaînes de stdin, imprime le caractère à la position actuelle de l'une des chaînes tandis que le caractère à la position actuelle est égal au caractère à la même position dans l'autre chaîne.

Merci à Zereges d' avoir enregistré un octet.

Haskell, 38 octets

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

Exemple d'utilisation: ( ((map fst.fst.span(uncurry(==))).).zip ) "global" "glossary" -> "glo".

Compressez les deux chaînes d'entrée dans une liste de paires de caractères. Faites-en deux listes: la première avec toutes les paires depuis le début tant que les deux caractères sont égaux, la seconde avec tous les autres. Supprimez la deuxième liste et extrayez tous les caractères de la première liste.

CJam, 12 11 9 octets

l_q.-{}#<

Cela lit les chaînes sur deux lignes distinctes avec une fin de ligne de style Unix, c'est-à-dire, <string>\n<string>\n .

Merci à @ MartinBüttner pour -1 octet et à @ jimmy23013 pour -2 octets!

Essayez-le en ligne dans l' interpréteur CJam .

Comment ça marche

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←↑⍵}

Il s'agit d'une fonction qui prend un tableau de deux chaînes et renvoie le préfixe:

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

AppleScript, 215 octets

Et j'ai tellement essayé ...; (

mettre x à (afficher la boîte de dialogue "" réponse par défaut "")
définir le texte de (boîte de dialogue "" réponse par défaut "") renvoyé à
mettre n à 1
mettre o à ""
répéter pendant que l'élément de n n = l'élément de a n
définir o sur o & x l'élément n
définir n sur n + 1
fin
o

Je voulais voir dans quelle mesure AppleScript pouvait réussir cela, et l' homme n'est-il pas conçu pour des comparaisons de chaînes.

rs , 14 octets

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

Démonstration en direct et cas de test.

C'est assez simple. Il correspond simplement au ... préfixe commun le plus long et supprime le reste de la chaîne. S'il n'y a pas de préfixe commun le plus long, il efface simplement tout.

sed, 18

J'avais quelque chose de beaucoup plus long et de plus compliqué à l'esprit, donc le mérite de cette idée revient à @ kirbyfan64sos .

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

Comprend +1 pour l' -roption de sed.

CJam, 12 8 26

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

Essayez-le en ligne.

(J'ai eu l'idée d'utiliser. = Au lieu de .- après avoir regardé la réponse de Dennis.)

Avec tous les cas de bord, il est devenu difficile pour un débutant CJam comme moi de rester bref. Espérons que cela fonctionne au moins pour tous les cas.

C #, 201 147 octets

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

Je sais que ce n'est pas terriblement compétitif. Je voulais juste voir à quoi ça ressemblerait.

EDIT: Merci Ash Burlakzenko, Berend et Dennis_E

Lisp commun, 39

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

Prend deux arguments de chaîne, détermine l'index i où ils diffèrent et renvoie une sous-chaîne de 0 à i .

Perl 5, 20 19 18 octets

19 octets, plus 1 pour le -Edrapeau au lieu de -e:

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

Ceci est copié sans vergogne du numérique Trauma de réponse sed . Il suppose que l'entrée est un couple de mots sans espaces (ou avant le premier) et avec un espace entre eux.

Mise à jour:

ThisSuitIsBlackNot a suggéré d'utiliser -pecomme suit, pour enregistrer un octet (merci!):

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

Et puis Luk Storms a suggéré d'utiliser -nEcomme suit pour enregistrer un autre octet (merci!):

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

(Je compte -Ecomme un octet au lieu de la norme -e, mais -nou -pcomme deux. Mon impression est que ce SOP est ici.)

Python 3, 72

31 octets économisés grâce à FryAmTheEggman. 8 sauvés grâce à DSM.

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

Une fonction qui prend une liste wde deux mots et imprime le préfixe commun avant de se terminer par une erreur.

La printfonction de Python 3 vous permet d'imprimer les chaînes les unes contre les autres print(end=c)(grâce au Sp3000 pour avoir économisé 3 octets avec cette syntaxe plus courte). Cela prend à plusieurs reprises deux lettres des mots et imprime la première des lettres. L'indexation c[c!=d]donne une erreur hors limites où c!=d, mettant fin à l'exécution lorsque deux lettres inégales sont rencontrées.

Une boucle for explicite est un caractère plus long que la compréhension de la liste:

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

Javascript ES6, 52 octets

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

Usage:

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

Rétine , 14 octets

Uses the same idea as kirbyfan64sos. Unfortunately, despite Martin's claim that eventually Match mode will feature a way to print capturing groups, it hasn't been implemented yet. Otherwise, (.*).* \1 could be used along with 2 bytes or so for some not-yet-existing configuration string option.

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

Each line would go in its own file, with 1 byte added per additional file. Alternatively, run in a single file with the -s flag.

K, 24 bytes

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

Find the minimum of the length of each string. ((&/#:'x)). Trim each string to that length (#'x). Then compare, smear and sum the resulting sequence:

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

Finally, take that many characters from the first of the strings provided (#*x).

In action:

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

Powershell, 65 bytes

Compare the strings, shrinking the first until it either matches (print and exit) or the string is null and the loop terminates.

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

Julia, 62 bytes

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

Ungolfed:

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

Fixed an issue (at the hefty cost of 14 bytes) thanks to xnor!

C99, 73 bytes

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

Similar to this answer, but shorter and meets spec (takes input from stdin).

MATLAB, 50 40 bytes

Defines a function that accepts 2 strings as input, outputs to command window

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

This solution will work for any string, outputs

ans =

   Empty string: 1-by-0

if no match is given.

Can be golfed by using a script instead of a function (using local variables a, b) (-16 bytes).

so getting 34 Bytes

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

The function style (which seems to be the accepted style), yields

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

(Thanks @Stewie Griffin)

Perl 6, 28 bytes

I came up with two that take their values from STDIN which are based on the Perl 5 answer.

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

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

The first requires exactly one space between the inputs, while the other requires at least one whitespace character between the inputs.

That is quite a bit shorter than the first thing I tried which takes the values from the command line.

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

or even the lambda version of it:

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

Though this is much easier to adjust so that it accepts any number of input strings, at the cost of only one stroke.

{[~] 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 bytes

Japt is a shortened version of JavaScript. Interpreter

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

(The strings go into the Input box like so: "global" "glossary")

This code is exactly equivalent to the following JS:

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

I have not yet implemented anonymous functions, which is what the $...$ is for: anything between the dollar signs is left untouched in the switch to JS. After I add functions, this 21-byte code will suffice:

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

And after I implement a few more features, it will ideally be 18 bytes:

UmXY{AxX=VgY ?X:AP

Suggestions welcome!

So it turns out that this program is only 15 bytes in modern Japt:

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

Try it online!

MATL, 11 9 bytes

y!=XdYpf)

Try it online!

(-2 bytes thanks to 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))""))

Pretty straightforward. Unfortunately the spaces around the parameter destructuring are necessary (that's the [a & b] stuff). Not the shortest but I beat some other answers in languages that like to brag about their terseness so I'll post it.

Python 2, 50 bytes

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

Input

The input is taken as two strings:

"global", "glossary"

Output

The output is each character followed by a space; which, hopefully, isn't a problem. However, if it is, I'll edit my answer.

g l o 

TeaScript, 16 bytes 20

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

Takes each input separated by a space.

PHP, 52 bytes

Not spectacular but does the job:

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

Takes two command line arguments:

php prefix.php department depart