Ich verwende "Suffix" hier lose, um "jede Unterzeichenfolge zu bedeuten, die dem Präfix folgt".

"Präfix" bedeutet hier den START eines Wortes, wobei der Start eines Wortes entweder nach einem Leerzeichen oder ab dem ersten Zeichen des eingegebenen Textes (für das erste Wort) definiert wird. Ein "Präfix" in der Mitte eines Wortes wird ignoriert.

Wenn Ihr Eingabepräfix beispielsweise "arm" und der Eingabetext "Dumbledores Armee war für das bevorstehende Armageddon vollständig gerüstet" lautet, enthält die Ausgabeliste (y, ed, ageddon).

Testfälle

Angenommen, Groß- und Kleinschreibung wird beachtet, Zeichenfolgen enden nach Leerzeichen. Die Eingabe beginnt nicht mit einem Leerzeichen.

Das Entfernen von Duplikaten ist optional.

Input prefix: "1"

Input text:

"He1in aosl 1ll j21j 1lj2j 1lj2 1ll l1j2i"

Output: (ll, lj2j, lj2) - in any permutation

Input prefix: "frac"

Input text: 

"fracking fractals fracted fractional currency fractionally fractioned into fractious fractostratic fractures causing quite a fracas"

Output: (king, tals, ted, tional, tionally, tioned, tious, tostratic, tures, as)

Input prefix: "href="https://www.astrotheme.com/astrology/"

Input text: 

"(div style="padding: 0; background: url('https://www.astrotheme.com/images/site/arrondi_450_hd.png') no-repeat; text-align: left; font-weight: bold; width: 450px; height: 36px")
  (div class="titreFiche" style="padding: 5px 0 0 6px")(a href="https://www.astrotheme.com/astrology/Nolwenn_Leroy" title="Nolwenn Leroy: Astrology, birth chart, horoscope and astrological portrait")Nolwenn Leroy(br /)
(/div)
  (div style="text-align: right; border-left: 1px solid #b2c1e2; border-right: 1px solid #b2c1e2; width: 446px; padding: 1px 1px 0; background: #eff8ff")
    (table style="width: 100%")(tr)(td style="width: 220px")
(div style="padding: 0; background: url('https://www.astrotheme.com/images/site/arrondi_450_hd.png') no-repeat; text-align: left; font-weight: bold; width: 450px; height: 36px")
  (div class="titreFiche" style="padding: 5px 0 0 6px")(a href="https://www.astrotheme.com/astrology/Kim_Kardashian" title="Kim Kardashian: Astrology, birth chart, horoscope and astrological portrait")Kim Kardashian(br /)(span style="font-weight: normal; font-size: 11px")Display her detailed horoscope and birth chart(/span)(/a)(/div)
(/div)
(div style="padding: 0; background: url('https://www.astrotheme.com/images/site/arrondi_450_hd.png') no-repeat; text-align: left; font-weight: bold; width: 450px; height: 36px")
  (div class="titreFiche" style="padding: 5px 0 0 6px")(a href="https://www.astrotheme.com/astrology/Julia_Roberts" title="Julia Roberts: Astrology, birth chart, horoscope and astrological portrait")Julia Roberts(br /)(span style="font-weight: normal; font-size: 11px")Display her detailed horoscope and birth chart(/span)(/a)(/div)
    (td id="cfcXkw9aycuj35h" style="text-align: right")
  (/div)"

Output: (Nolwenn_Leroy", Kim_Kardashian", Julia_Roberts")

Der Gewinner

Dies ist Code-Golf , so dass die wenigsten Bytes gewinnen. :)

Kann die Eingaben auf irgendeine Weise akzeptieren, die funktioniert, solange Ihr Code beliebige Probleme wie die Testfälle lösen kann.

R , 63 Bytes

function(s,p,z=el(strsplit(s,' ')))sub(p,'',z[startsWith(z,p)])

Probieren Sie es online!

Die positiv aussehende Implementierung ist aufgrund der riesigen regmatches/gregexprKombination leider 5 Bytes länger :

function(s,p)regmatches(s,gregexpr(paste0('(?<=',p,')[^ ]*'),s,,T))

Gelee , 12 Bytes

Ḳfṛ"€¥Ḋ€ṫ€L}

Probieren Sie es online!

Japt , 9 Bytes

8 Bytes, wenn wir die Eingabe als Array von Wörtern annehmen können.

¸kbV msVl
¸         // Shorthand for `qS`, split into words.
 kbV      // Filter the words, selecting only those that start with the prefix.
     msVl // For each remaining word, remove prefix length chars from the start.

Probieren Sie es online!

Python 2 , 57 56 Bytes

lambda i,j:[w[len(i):]for w in j.split()if w.find(i)==0]

Probieren Sie es online!

-1 danke an @mypetlion

C (GCC) , 113 109 106 105 Bytes

-4 Bytes dank @LambdaBeta!
-3 Bytes dank @WindmillCookies!

i;f(char*s,char*t){for(i=strlen(s);*t;t++)if(!strncmp(t,s,i))for(t+=i,puts("");*t^32&&*t;)putchar(*t++);}

Probieren Sie es online!

Japt , 16 12 Bytes

Hafen von Arnauld Antwort

-4 Bytes von @Shaggy

iS qS+V Å®¸g

iS                  Insert S value (S = " ") at beginning of first input (Implicit)
   q                split using
    S+V             S + Second input
        Å           slice 1
         ®          map
          ¸         split using S
           g        get first position

Probieren Sie es online!

05AB1E , 11 Bytes

#ʒηså}εsgF¦

Probieren Sie es online! ( hier ist eine Demo für mehrzeilige Strings)

Wie funktioniert es?

# ʒηså} εsgF¦ Volles Programm.
# Teilen Sie die erste Eingabe durch Leerzeichen.
 ʒ} Wörter filtern nach ...
  ηså ... "Tritt die zweite Eingabe im Präfix des Wortes auf?"
      ε Und für jedes gültige Wort
       sg Ruft die Länge der zweiten Eingabe ab.
         F… und lassen Sie das erste Zeichen des Wortes so oft fallen.

Stax , 8 Bytes

·B¬╤²*6&

Führen Sie es aus und debuggen Sie es

Erläuterung:

j{x:[fmx|- Full program, implicit input: On stack in order, 1st input in X register
j          Split string on spaces
 {   f     Filter:
  x:[        Is X a prefix?
      m    Map passing elements:
       x|-   Remove all characters in X the first time they occur in the element
             Implicit output

Ich könnte auch verwenden x%t(Länge von X, Beschnitt von links), die gleich lang ist, sich aber auf 9 Bytes packt .

Retina , 31 Bytes

L`(?<=^\2¶(.|¶)*([^ ¶]+))[^ ¶]+

Probieren Sie es online! Die erste Zeile sollte das gewünschte Präfix sein, der Rest ist der Eingabetext. Entfernt keine Duplikate. Wäre 25 Byte, wenn ein Leerzeichen ein gültiger Trenner wäre. Erläuterung: Wir möchten die Suffixe gültiger Präfixe auflisten. Das [^ ¶]+stimmt mit dem Suffix selbst überein. Das Präfix des regulären Ausdrucks ist ein Lookbehind, der sicherstellt, dass das Präfix des Suffix das Eingabepräfix ist. Wenn ein Lookbehind von rechts nach links ausgewertet wird, beginnt dies mit dem Abgleichen des Präfixes (unter Verwendung desselben Musters, aber innerhalb von ()s, um es zu erfassen) und aller Zeichen, bevor schließlich das Präfix in einer eigenen Zeile am Anfang der Eingabe abgeglichen wird .

Brachylog , 24 21 Bytes

tṇ₁W&h;Wz{tR&h;.cR∧}ˢ

Probieren Sie es online!

Hätte ein paar Bytes kürzer sein können, wenn Variablen mit Inline-Prädikaten geteilt worden wären.

Die Eingabe ist ein Array mit dem Präfix als erstem Element und dem Text als zweitem Element.

tṇ₁W                    % Split the text at spaces, call that W
    &h;Wz               % Zip the prefix with each word, to give a list of pairs
         {         }ˢ   % Select the outputs where this predicate succeeds:
          tR            % Call the current word R
            &h;.c       % The prefix and the output concatenated
                 R      % should be R
                  ∧     % (No more constraints on output)

IBM / Lotus Notes-Formel, 54 Byte

c:=@Explode(b);@Trim(@If(@Begins(c;a);@Right(c;a);""))

Übernimmt die Eingabe aus zwei Feldern mit dem Namen aund b. Funktioniert, weil Formula eine Funktion rekursiv auf eine Liste anwendet, ohne dass eine @ForSchleife erforderlich ist.

Kein TIO verfügbar. Hier ist ein Screenshot:

APL (Dyalog Unicode) , 23 Byte ^SBCS

Volles Programm. Fordert zur Eingabe von Text und Präfix von stdin auf. Druckt die Liste nach Standard.

(5⌽'(\w+)\b',⎕)⎕S'\1'⊢⎕

Probieren Sie es online!

⎕ Eingabeaufforderung (für Text)

⊢ ergeben, dass (trennt sich '\1'von ⎕)

(… )⎕S'\1' PCRE-Suche und Rückkehrliste der Erfassungsgruppe 1 aus dem folgenden regulären Ausdruck:

 ⎕ Eingabeaufforderung (für Präfix)

 '(\w+)\b', voranstellen (Gruppe von Wortzeichen, gefolgt von einer Wortgrenze)

 5⌽ Drehe die ersten 5 Zeichen bis zum Ende. '\bPREFIX(\w+)'

C (clang) , 107 Bytes

i;f(s,t,_)char*s,*t,*_;{i=strlen(s);_=strtok(t," ");while((strncmp(_,s,i)||puts(_+i))&&(_=strtok(0," ")));}

Probieren Sie es online!

Beschreibung:

i;f(s,t,_)char*s,*t,*_;{   // F takes s and t and uses i (int) and s,t,u (char*)
    i=strlen(s);           // save strlen(s) in i
    _=strtok(t," ");       // set _ to the first word of t
    while(                 // while loop
        (strncmp(_,s,i)||  // short-circuited if (if _ doesn't match s to i places)
         puts(_+i))        // print _ starting at the i'th character
        &&                 // the previous expression always returns true
        (_=strtok(0," "))) // set _ to the next word of t
    ;                      // do nothing in the actual loop
}

Muss wegen gcc segfaults klingeln, ohne dass #include <string.h>es zu strtok Problemen kommt.

MATL, 17 Bytes

Yb94ih'(.*)'h6&XX

Probieren Sie es auf MATL Online aus

Wie?

Yb - Teilen Sie die Eingabe in Leerzeichen und platzieren Sie die Ergebnisse in einem Zellenarray

94- ASCII-Code für ^Zeichen

ih - Holen Sie sich die Eingabe (sagen Sie "frac"), verketten Sie '^' und die Eingabe

'(.*)'h- Schieben Sie den String '(.*)'in den Stack, verketten Sie '^ frac' und '(. *)'. Jetzt haben wir also '^frac(.*)einen regulären Ausdruck, der mit "frac" am Anfang der Zeichenfolge übereinstimmt und erfasst, was danach kommt.

6&XX- Führen Sie einen regulären Ausdrucksvergleich durch, 6&indem Sie den Modus "Tokens" angeben, dh, die übereinstimmenden Erfassungsgruppen werden anstelle der gesamten Übereinstimmung zurückgegeben.

Die Ergebnisse implizit ausgeben.

Bash + grep, 20 Bytes

grep -Po "\b$1\K\S*"

Das Präfix wird als Befehlszeilenparameter angegeben, und der Eingabetext wird über stdin weitergeleitet.

Probieren Sie es online!

PowerShell 3.0, 60 62 59 Bytes

param($p,$s)-split$s|%{if($_-cmatch"^$p(.*)"){$Matches[1]}}

Einige Bytes verloren, die die cmatch-Ausgabe unterdrücken. Hatte eine ruckelige Lösung, die einige durch absichtliche Verursachung von Duplikaten gewann. Aber es hat auch Redlines ausgelöst, wenn es beim ersten Mal nicht gepasst hat, aber das ist nicht gut, jetzt, wo ich darüber nachdenke. +2 Bytes, um das Problem zu beheben.

JavaScript (ES6), 57 Byte

Übernimmt Eingaben in der Currying-Syntax (text)(prefix). Entfernt keine Duplikate.

s=>p=>(' '+s).split(' '+p).slice(1).map(s=>s.split` `[0])

Probieren Sie es online!

JavaScript (Node.js) , 64 59 Bytes

-5 Bytes von @Shaggy

a=>b=>b.match(eval(`/\\b${a}\\w*/g`)).map(x=>x.split(a)[1])

Probieren Sie es online!

Haskell , 51 Bytes

p#x=[length p`drop`y|y<-words x,and$zipWith(==)p y]

Probieren Sie es online!

Schale , 11 Bytes

So ziemlich nur eine Portierung der Haskell-Antwort :

m↓L⁰foΠz=⁰w

Probieren Sie es online!

Erläuterung

m↓L⁰f(Πz=⁰)w  -- prefix is explicit argument ⁰, the other one implicit. eg: ⁰ = "ab" and implicit "abc def"
           w  -- words: ["abc","def"]
    f(    )   -- filter by (example w/ "abc"
       z=⁰    -- | zip ⁰ and element with equality: [1,1]
      Π       -- | product: 1
              -- : ["abc"]
m             -- map the following
 ↓            -- | drop n elements
  L⁰          -- | n being the length of ⁰ (2)
              -- : ["c"]

Jelly ,  11  9 Bytes

Ḳœṣ€ḢÐḟj€

Ein dyadischer Link, der den Text (eine Liste von Zeichen) auf der linken Seite und das Präfix (eine Liste von Zeichen) auf der rechten Seite akzeptiert und eine Liste von Zeichenlisten (die resultierenden Suffixe) ergibt.

Probieren Sie es online!(Die Fußzeile wird mit Leerzeichen
verknüpft , um das implizite Zertrümmern des gesamten Programms zu vermeiden.) Hinweis: Ich habe der Zeichenfolge im OP drei Kantenfälle hinzugefügt - unfrackled und nofracfracheremate am Anfang, die nicht ausgegeben werden sollen, und fracfracit am Ende, die fracit ausgegeben werden sollen.

Wie?

Ḳœṣ€ḢÐḟj€ - Link: text, prefix                        e.g. "fracfracit unfracked", "frac"
Ḳ         - split (text) at spaces -> list of words        ["fracfracit", "unfracked"]
   €      - for each (word):
 œṣ       -   split around sublists equal to (prefix)       ["","","it"]  ["un","ked"]
     Ðḟ   - filter discard items for which this is truthy:
    Ḣ     -   head
          -   -- Crucially this modifies the list:             ["","it"]       ["ked"]
          -   -- and yields the popped item:                 ""            "un"
          -   -- and only non-empty lists are truthy:       kept          discarded
          -            ...so we end up with the list:      [["","it"]]
        € - for each (remaining list of lists of characters):
       j  -   join with the prefix                          "fracit"                                             
          -                                                ["fracit"]

vorherige 11 byter:

Ḳs€L}Ḣ⁼¥ƇẎ€

Auch ein dyadischer Link wie oben.

Probieren Sie es online!

Perl 5 mit -asE, 23 22 21 Bytes (?)

say/^$b(.*)/ for@F

Probieren Sie es online!

Können als Kommandozeilen - Einzeiler laufen als perl -asE 'say/^$b(.*)/ for@F' -- -b=frac -oder mit einem Dateinamen anstelle der letzten -.
Oder etwa aus einer Skriptdateiperl -as -M5.010 script.pl -b=frac - (danke an @Brad Gilbert b2gills für den TIO-Link, der dies demonstriert).

Der Code selbst ist 18 Bytes, ich habe 3 Bytes für die hinzugefügt -b= Option , die einer $bim Code benannten Variablen ihren Wert (die Präfix-Eingabe) zuweist . Das schien eine Ausnahme zu dem üblichen Konsens zu sein, dass Flaggen nicht gezählt werden.

-aTeilt jede Eingabezeile in Leerzeichen und platziert das Ergebnis im Array @F.-sDies ist eine Abkürzung, um ein Befehlszeilenargument als Variable zuzuweisen, indem Sie in der Befehlszeile einen Namen eingeben. Hier ist das Argument -b=frac, welches das Präfix "frac" in eine Variable setzt $b.

/^$b(.*)/- Entspricht dem Wert $bam Anfang der Zeichenfolge. .*Was auch immer danach kommt, bis zum Ende des Wortes, und die umgebenden Klammern erfassen diesen Wert. Die erfassten Werte werden automatisch zurückgegeben und von gedruckt say. Durchlaufen von durch Leerzeichen getrennten Wörtern mit for @Fbedeutet, dass wir nicht nach anfänglichen oder endgültigen Leerzeichen suchen müssen.

Perl 6 , 30 Bytes

{$^t.comb: /[^|' ']$^p <(\S+/}

Probier es aus

Erweitert:

{  # bare block lambda with placeholder params $p, $t

  $^t.comb:    # find all the substrings that match the following
  /
    [ ^ | ' ' ] # beginning of string or space
    $^p        # match the prefix
    <(         # don't include anything before this
    \S+        # one or more non-space characters (suffix)
  /
}

Java 10, 94 Bytes

p->s->{for(var w:s.split(" "))if(w.startsWith(p))System.out.println(w.substring(p.length()));}

Probieren Sie es hier online aus .

Ungolfed:

p -> s -> { // lambda taking prefix and text as Strings in currying syntax
    for(var w:s.split(" ")) // split the String into words (delimited by a space); for each word ...
        if(w.startsWith(p)) //  ... test whether p is a prefix ...
            System.out.println(w.substring(p.length())); // ... if it is, output the suffix
}

Kleines Basic , 242 Bytes

Ein Skript, das keine Ein- und Ausgaben für die TextWindow Objekt vornimmt

c=TextWindow.Read()
s=TextWindow.Read()
i=1
While i>0
i=Text.GetIndexOf(s," ")
w=Text.GetSubText(s,1,i)
If Text.StartsWith(w,c)Then
TextWindow.WriteLine(Text.GetSubTextToEnd(w,Text.GetLength(c)+1))
EndIf
s=Text.GetSubTextToEnd(s,i+1)
EndWhile

Probieren Sie es bei SmallBasic.com! Benötigt IE / Silverlight

Python 2 , 53 Bytes

lambda i,j:[w.split()[0]for w in j.split(i)if len(w)]

Probieren Sie es online!

Brachylog , 12 Bytes

hṇ₁∋R&t;.cR∧

Probieren Sie es online!

Übernimmt Eingaben wie [text, prefix]über die Eingabevariable und generiert jedes Wort über die Ausgabevariable. Dies war ursprünglich Sundars Antwort, die ich zu spielen begann, nachdem ich gelesen hatte, dass sie "ein paar Bytes kürzer sein könnte, wenn eine variable Freigabe mit Inline-Prädikaten gegeben wäre", was jetzt möglich ist. Es stellt sich heraus, dass die Generatorausgabe noch mehr Bytes spart.

    R           R
   ∋            is an element of
h               the first element of
                the input
 ṇ₁             split on spaces,
     &          and the input
      t         's last element
         c      concatenated
       ;        with
        .       the output variable
          R     is R
           ∧    (which is not necessarily equal to the output).

Meine ersten beiden Versuche, es mit relativ neuen Sprachfeatures abzuspielen:

Mit den erhofften globalen Variablen: hA⁰&tṇ₁{∧A⁰;.c?∧}ˢ(18 Bytes)

Mit dem Apply-to-Head-Metapredikat: ṇ₁ᵗz{tR&h;.cR∧}ˢ(16 Byte)

Und meine ursprüngliche Lösung:

Brachylog , 15 Bytes

ṇ₁ʰlᵗ↙X⟨∋a₀⟩b↙X

Probieren Sie es online!

Gleiche I / O. Dies ist im Wesentlichen ein Generator für Wörter mit dem Präfix ṇ₁ʰ⟨∋a₀⟩, der geändert wurde, um das Präfix zu entfernen.

                   The input variable
  ʰ                with its first element replaced with itself
ṇ₁                 split on spaces
    ᵗ              has a last element
   l               the length of which
     ↙X            is X,
       ⟨   ⟩       and the output from the sandwich
       ⟨∋  ⟩       is an element of the first element of the modified input
       ⟨ a₀⟩       and has the last element of the input as a prefix.
                   The output variable
       ⟨   ⟩       is the output from the sandwich
            b      with a number of characters removed from the beginning
             ↙X    equal to X.

Ein ganz anderes Prädikat mit der gleichen Byteanzahl:

Brachylog , 15 Bytes

hṇ₁∋~c₂Xh~t?∧Xt

Probieren Sie es online!

Gleiche I / O.

   ∋               An element of
h                  the first element of
                   the input variable
 ṇ₁                split on spaces
    ~c             can be un-concatenated
      ₂            into a list of two strings
       X           which we'll call X.
        h          Its first element
         ~t        is the last element of
           ?       the input variable,
            ∧      and
             Xt    its last element is
                   the output variable.

Rot , 62 Bytes

func[p s][parse s[collect[any[p keep to[" "| end]| thru" "]]]]

Probieren Sie es online!

Pyth , 21 20 18 17 16 Bytes

AQVcH)IqxNG0:NG"

Probieren Sie es online!

-1 durch Verwendung von Vstatt FNweil Vimplizit setztN

-2 nach etwas weiterem Lesen über die Optionen zum Aufteilen von Strings

-1 mit x , um das Vorhandensein der Teilzeichenfolge am Index 0 zu überprüfen

-1 mit "" ersetzen, um das Ende der Zeichenkette zu erhalten

Ich bin mir sicher, dass dies ernsthaftes Golfen gebrauchen könnte, aber als Pyth-Anfänger war es ein Bonus, es einfach zum Laufen zu bringen.

Wie funktioniert es?

assign('Q',eval_input())
assign('[G,H]',Q)
for N in num_to_range(chop(H)):
    if equal(index(N,G),0):
        imp_print(at_slice(N,G,""))

Excel VBA, 86 Bytes

Übernimmt Eingaben als Präfix [A1]und Werte als Ein- [B1]und Ausgaben an die Konsole.

For each w in Split([B1]):?IIf(Left(w,[Len(A1)])=[A1],Mid(w,[Len(A1)+1])+" ","");:Next