Schreiben Sie ein Programm, das 2 Zeichenfolgen als Eingabe verwendet und das längste gemeinsame Präfix zurückgibt. Das ist Code-Golf , also gewinnt die Antwort mit der kürzesten Anzahl von Bytes.

Test Case 1:

"global" , "glossary"
"glo"


Test Case 2:

"department" , "depart"
"depart"

Test Case 3:

"glove", "dove"
""

Python 3, 54 Bytes

Vielen Dank an Python für die integrierte Funktion für diese Aufgabe! : D

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

Nimmt die Eingabe als zwei Wörter, die durch ein Leerzeichen wie z glossary global.

Haskell, 29 Bytes

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

Verwendung:

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

Definiert die Binärfunktion rekursiv %durch Mustervergleich. Nimmt bei zwei Zeichenfolgen mit gleichen Anfangsbuchstaben diese Anfangsbuchstaben und stellt sie der Funktion der übrigen Zeichenfolgen voran. Auf alles andere gibt die leere Zeichenfolge.

Pyth, 8 7 Bytes

e@F._MQ

Vielen Dank an @isaacg für 1 Byte aus

Nimmt Eingaben in Anführungszeichen und Komma getrennt, wie "abc", "acc". Dies führt zu einem Fehler (lässt jedoch stdout leer), wenn das Ergebnis die leere Zeichenfolge ist. Wenn dies nicht akzeptabel ist, fügen Sie 2 Bytes für hinzu#e@F._MQq

Test Suite

Erläuterung

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 Bytes

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

Liest zwei Zeichenfolgen aus stdinund druckt das Zeichen an der aktuellen Position aus einer der Zeichenfolgen, während das Zeichen an der aktuellen Position dem Zeichen an derselben Position in der anderen Zeichenfolge entspricht.

Vielen Dank an Zereges für das Speichern eines Bytes.

Haskell, 38 Bytes

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

Anwendungsbeispiel: ( ((map fst.fst.span(uncurry(==))).).zip ) "global" "glossary"-> "glo".

Zippen Sie beide Eingabezeichenfolgen in eine Liste von Zeichenpaaren. Machen Sie zwei Listen daraus: die erste mit allen Paaren von Anfang an, solange beide Zeichen gleich sind, die zweite mit allen Resten. Löschen Sie die zweite Liste und extrahieren Sie alle Zeichen aus der ersten Liste.

CJam, 12 11 9 Bytes

l_q.-{}#<

Dadurch werden die Zeichenfolgen in zwei separaten Zeilen mit einem Zeilenende im Unix-Stil gelesen, d <string>\n<string>\n. H.

Danke an @ MartinBüttner für -1 Byte und an @ jimmy23013 für -2 Byte!

Probieren Sie es online im CJam-Interpreter aus .

Wie es funktioniert

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

Dies ist eine Funktion, die ein Array mit zwei Zeichenfolgen verwendet und das Präfix zurückgibt:

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

AppleScript, 215 Bytes

Und ich habe es so sehr versucht ...; (

setze x auf (zeige den Dialog "" Standardantwort "")
set a to (Dialogfeld "" Standardantwort "" anzeigen) Der zurückgegebene Text
setze n auf 1
setze o auf ""
wiederhole, während xs Item n = as Item n ist
setze o auf o & xs Item n
setze n auf n + 1
Ende
O

Ich wollte sehen, wie gut AppleScript das schaffen kann, und Mann, es ist nicht für Zeichenkettenvergleiche gebaut.

rs , 14 bytes

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

Live-Demo und Testfälle.

Das ist ziemlich einfach. Es stimmt nur mit dem längsten gemeinsamen Präfix überein und entfernt den Rest der Zeichenfolge. Wenn es kein längstes gemeinsames Präfix gibt, wird einfach alles gelöscht.

sed, 18

Ich hatte etwas viel längeres und komplizierteres im Sinn, daher geht die Anerkennung für diese Idee an @ kirbyfan64sos .

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

Beinhaltet +1 für die -rOption zum Sedieren.

CJam, 12 8 26

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

Probieren Sie es online.

(Habe die Idee,. = Anstelle von .- zu verwenden, nachdem ich Dennis 'Antwort gelesen habe.)

Bei all den Randfällen wurde es für einen CJam-Anfänger wie mich zu schwierig, es kurz zu halten. Hoffentlich funktioniert das zumindest in allen Fällen.

C #, 201 147 Bytes

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

Ich weiß, dass es nicht sehr wettbewerbsfähig ist. Ich wollte nur sehen, wie es aussehen würde.

EDIT: Danke Ash Burlakzenko, Berend und Dennis_E

Common Lisp, 39

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

Nimmt zwei Zeichenfolgenargumente, bestimmt den Index i, in dem sie sich unterscheiden, und gibt eine Teilzeichenfolge von 0 bis i zurück .

Perl 5, 20 19 18 Bytes

19 Bytes plus 1 für das -EFlag anstelle von -e:

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

Dies wird schamlos kopiert Digital - Trauma ‚s sed Antwort . Es wird davon ausgegangen, dass die Eingabe ein paar Wörter ohne Leerzeichen (oder vor dem ersten) und mit einem Leerzeichen dazwischen ist.

Aktualisieren:

ThisSuitIsBlackNot schlug vor, -pewie folgt zu verwenden, um ein Byte zu speichern (danke!):

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

Und dann schlug Luk Storms vor, -nEwie folgt vorzugehen, um ein weiteres Byte zu speichern (danke!):

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

(Ich zähle -Eals ein Byte anstelle des Standards -e, aber -noder -pals zwei. Mein Eindruck ist, dass das hier SOP ist.)

Python 3, 72

31 Bytes dank FryAmTheEggman gespart. 8 dank DSM gespeichert.

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

Eine Funktion, die eine Liste wmit zwei Wörtern verwendet und das gemeinsame Präfix druckt, bevor sie mit einem Fehler beendet wird.

Mit der printFunktion von Python 3 können Sie Zeichenfolgen bündig gegeneinander print(end=c)ausgeben (dank Sp3000 für das Speichern von 3 Bytes mit dieser kürzeren Syntax). Dies nimmt wiederholt zwei Buchstaben aus den Wörtern und druckt den ersten der Buchstaben. Die Indizierung c[c!=d]führt zu einem Fehler außerhalb der Grenzen, bei dem c!=ddie Ausführung abgebrochen wird, wenn zwei ungleiche Buchstaben auftreten.

Eine explizite for-Schleife ist ein Zeichen länger als das Listenverständnis:

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

Javascript ES6, 52 Bytes

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

Verwendung:

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

Retina , 14 Bytes

Verwendet die gleiche Idee wie kirbyfan64sos . Trotz Martins Behauptung, dass der Match-Modus möglicherweise das Drucken von Erfassungsgruppen ermöglicht, wurde er leider noch nicht implementiert. Andernfalls kann (.*).* \1diese Option zusammen mit etwa 2 Byte für eine noch nicht vorhandene Konfigurationszeichenfolge verwendet werden.

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

Jede Zeile wird in einer eigenen Datei abgelegt, wobei pro zusätzlicher Datei 1 Byte hinzugefügt wird. Alternativ können Sie auch eine einzelne Datei mit dem -sFlag ausführen .

K, 24 Bytes

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

Finden Sie das Minimum der Länge jeder Zeichenfolge. ( (&/#:'x)). Kürzen Sie jede Zeichenfolge auf diese Länge ( #'x). Vergleichen, schmieren und summieren Sie dann die resultierende Sequenz:

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

Nehmen Sie zum Schluss so viele Zeichen aus der ersten der angegebenen Zeichenfolgen ( #*x).

In Aktion:

 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

Vergleichen Sie die Zeichenfolgen und verkleinern Sie die erste, bis sie entweder übereinstimmt (print and exit) oder die Zeichenfolge null ist und die Schleife endet.

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

Behebung eines Problems (bei den hohen Kosten von 14 Bytes) dank xnor!

C99, 73 Bytes

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

Ähnlich wie diese Antwort , aber kürzer und erfüllt die Spezifikation (Eingabe von stdin).

MATLAB, 50 bis 40 Bytes

Definiert eine Funktion, die 2 Zeichenfolgen als Eingabe akzeptiert und an das Befehlsfenster ausgibt

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

Diese Lösung funktioniert für alle Zeichenfolgen und Ausgaben

ans =

   Empty string: 1-by-0

wenn keine Übereinstimmung vorliegt.

Kann unter Verwendung eines Skripts anstelle einer Funktion (unter Verwendung der lokalen Variablen a, b) (-16 Byte) gespielt werden.

also immer 34 Bytes

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

Der Funktionsstil (der der akzeptierte Stil zu sein scheint) ergibt

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

(Danke @Stewie Griffin)

Perl 6 , 28 Bytes

Ich habe zwei gefunden, deren Werte aus STDIN stammen und auf der Perl 5-Antwort basieren.

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

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

Das erste erfordert genau ein Leerzeichen zwischen den Eingaben, während das andere mindestens ein Leerzeichen zwischen den Eingaben erfordert.

Das ist ziemlich viel kürzer als das erste, was ich ausprobiert habe und das die Werte von der Kommandozeile übernimmt.

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

oder sogar die Lambda-Version davon:

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

Dies ist jedoch viel einfacher einzustellen, so dass eine beliebige Anzahl von Eingabezeichenfolgen auf Kosten von nur einem Strich akzeptiert werden.

{[~] 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 ist eine verkürzte Version von Ja vaScri pt .Dolmetscher

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

(Die Zeichenfolgen werden folgendermaßen in das Eingabefeld eingefügt: "global" "glossary" )

Dieser Code entspricht genau dem folgenden JS:

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

Ich habe noch keine anonymen Funktionen implementiert, wofür das $...$ist: Alles zwischen den Dollarzeichen bleibt beim Wechsel zu JS unberührt. Nachdem ich Funktionen hinzugefügt habe, reicht dieser 21-Byte-Code aus:

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

Und nachdem ich ein paar weitere Features implementiert habe, sind es im Idealfall 18 Bytes:

UmXY{AxX=VgY ?X:AP

Vorschläge willkommen!

Es stellt sich also heraus, dass dieses Programm in modernem Japt nur 15 Bytes umfasst:

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

Probieren Sie es online!

MATL , 11 9 Bytes

y!=XdYpf)

Probieren Sie es online!

(-2 Bytes dank 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))""))

Ziemlich einfach. Leider sind die Leerzeichen um die Parameter-Destrukturierung notwendig (das ist das [a & b]Zeug). Nicht die kürzeste, aber ich habe einige andere Antworten in Sprachen geschlagen, die gerne mit ihrer Kürze angeben, also poste ich sie.

Python 2, 50 Bytes

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

Eingang

Die Eingabe erfolgt als zwei Zeichenfolgen:

"global", "glossary"

Ausgabe

Die Ausgabe ist jedes Zeichen, gefolgt von einem Leerzeichen. Das ist hoffentlich kein Problem. Wenn dies jedoch der Fall ist, bearbeite ich meine Antwort.

g l o 

TeaScript, 16 Bytes 20

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

Nimmt jede Eingabe durch ein Leerzeichen getrennt.

PHP, 52 Bytes

Nicht spektakulär, aber macht den Job:

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

Nimmt zwei Befehlszeilenargumente an:

php prefix.php department depart