J'utilise ici "suffixe" pour désigner "toute sous-chaîne qui suit le préfixe".

"Préfixe" signifie ici le DÉBUT d'un mot, où le début d'un mot est défini soit après un espace, soit à partir du premier caractère du texte saisi (pour le premier mot). Un "préfixe" au milieu d'un mot est ignoré.

Par exemple, si votre préfixe d'entrée est "arm" et le texte d'entrée est "L'armée de Dumbledore était entièrement armée pour l'imminence de l'armageddon", alors la liste de sortie contient (y, ed, ageddon).

Cas de test

Supposons que les chaînes respectent la casse, les terminaisons après les espaces. L'entrée ne commencera pas par un espace.

La suppression des doublons est facultative.

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

Le gagnant

C'est du code-golf , donc le moins d'octets gagne. :)

Peut accepter les entrées de n'importe quelle manière qui fonctionne, tant que votre code peut résoudre des problèmes arbitraires comme les cas de test.

R , 63 octets

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

Essayez-le en ligne!

L'implémentation positive-lookbehind est malheureusement de 5 octets de plus en raison de l'énorme regmatches/gregexprcombinaison:

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

Gelée , 12 octets

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

Essayez-le en ligne!

Japt , 9 octets

8 octets si nous pouvons prendre l'entrée comme un tableau de mots.

¸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.

Essayez-le en ligne!

Python 2 , 57 56 octets

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

Essayez-le en ligne!

-1 avec merci à @mypetlion

C (gcc) , 113 109 106 105 octets

-4 octets grâce à @LambdaBeta!
-3 octets grâce à @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++);}

Essayez-le en ligne!

Japt , 16 12 octets

Port d'Arnauld Answer

-4 octets de @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

Essayez-le en ligne!

05AB1E , 11 octets

#ʒηså}εsgF¦

Essayez-le en ligne! ( voici une démo pour les chaînes multilignes)

Comment ça marche?

# ʒηså} εsgF¦ Programme complet.
# Divisez la première entrée par des espaces.
 ʒ} Filtrer les mots par ...
  ηså ... "La deuxième entrée apparaît-elle dans le préfixe du mot?"
      ε Et pour chaque mot valide
       sg Récupère la longueur de la seconde entrée.
         F¦ Et déposez le premier caractère du mot autant de fois.

Stax , 8 octets

·B¬╤²*6&

Exécuter et déboguer

Explication:

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

Je pourrais également utiliser x%t(longueur de X, découpage à partir de la gauche), qui est tout aussi long mais qui contient 9 octets .

Rétine , 31 octets

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

Essayez-le en ligne! La première ligne doit être le préfixe souhaité, le reste est le texte d'entrée. Ne supprime pas les doublons. Serait de 25 octets si un espace blanc était un séparateur valide. Explication: Nous voulons répertorier les suffixes des préfixes valides. Le [^ ¶]+correspond au suffixe lui-même. Le préfixe de l'expression rationnelle est un lookbehind qui garantit que le préfixe du suffixe est le préfixe d'entrée. Comme un lookbehind est évalué de droite à gauche, cela commence par faire correspondre le préfixe (en utilisant le même modèle mais à l'intérieur de ()s pour le capturer), puis tous les caractères, avant de finalement faire correspondre le préfixe sur sa propre ligne au début de l'entrée.

Brachylog , 24 21 octets

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

Essayez-le en ligne!

Cela aurait pu être plus court de quelques octets s'il y avait un partage variable avec des prédicats en ligne.

L'entrée est un tableau avec le préfixe comme premier élément et le texte comme deuxième élément.

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)

Formule IBM / Lotus Notes, 54 octets

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

Prend sa saisie à partir de deux champs nommés aet b. Fonctionne car Formula appliquera récursivement une fonction à une liste sans avoir besoin d'une @Forboucle.

Pas de TIO disponible alors voici une capture d'écran:

APL (Dyalog Unicode) , 23 octets ^SBCS

Programme complet. Demande le texte et le préfixe de stdin. Imprime la liste sur la sortie standard.

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

Essayez-le en ligne!

⎕ invite (pour le texte)

⊢ rendement qui (se sépare '\1'de ⎕)

(… )⎕S'\1' PCRE Recherche et retourne la liste du groupe de capture 1 à partir de l'expression rationnelle suivante:

 ⎕ invite (pour le préfixe)

 '(\w+)\b', ajouter cette chaîne (groupe de caractères de mot suivi d'une limite de mot)

 5⌽ faites pivoter les 5 premiers caractères jusqu'à la fin; '\bPREFIX(\w+)'

C (clang) , 107 octets

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

Essayez-le en ligne!

La description:

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
}

Doit être clang parce que gcc segfaults sans en #include <string.h>raison de problèmes strtok.

MATL, 17 octets

Yb94ih'(.*)'h6&XX

Essayez-le sur MATL Online

Comment?

Yb - Divisez l'entrée aux espaces, placez les résultats dans un tableau de cellules

94- Code ASCII pour le ^caractère

ih - Récupère l'entrée (disons "frac"), concatène '^' et l'entrée

'(.*)'h- Poussez la chaîne '(.*)'dans la pile, concaténez '^ frac' et '(. *)'. Nous avons donc maintenant '^frac(.*), une expression régulière qui correspond à "frac" au début de la chaîne et capture tout ce qui vient après.

6&XX- Exécutez la correspondance d'expressions régulières, en 6&spécifiant le mode «jetons», c'est-à-dire que les groupes de capture correspondants sont renvoyés à la place de la correspondance entière.

Afficher implicitement les résultats.

Frapper + grep, 20 octets

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

Le préfixe est donné comme paramètre de ligne de commande et le texte d'entrée est canalisé via stdin.

Essayez-le en ligne!

PowerShell 3.0, 60 62 59 octets

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

Perte de quelques octets supprimant la sortie de cmatch. Avait une solution loufoque qui a gagné en provoquant délibérément des doublons. Mais il a également jeté des lignes rouges s'il ne correspondait pas au premier mais ce n'est pas bien maintenant que j'y pense. +2 octets pour le réparer cependant.

JavaScript (ES6), 57 octets

Prend une entrée dans la syntaxe de curry (text)(prefix). Ne supprime pas les doublons.

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

Essayez-le en ligne!

JavaScript (Node.js) , 64 59 octets

-5 octets de @Shaggy

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

Essayez-le en ligne!

Haskell , 51 octets

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

Essayez-le en ligne!

Décortiquer , 11 octets

À peu près juste un port de la réponse Haskell :

m↓L⁰foΠz=⁰w

Essayez-le en ligne!

Explication

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

Gelée ,  11  9 octets

Ḳœṣ€ḢÐḟj€

Un lien dyadique acceptant le texte (une liste de caractères) à gauche et le préfixe (une liste de caractères) à droite qui donne une liste de listes de caractères (les suffixes résultants).

Essayez-le en ligne! (le pied de page se joint aux espaces pour éviter l'écrasement implicite du programme complet)
Remarque: J'ai ajouté trois cas de bord à la chaîne dans l'OP - unfrackled et nofracfracheremate au début, qui ne devrait pas sortir et fracfracit à la fin qui devrait sortir fracit.

Comment?

Ḳœṣ€ḢÐḟ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"]

11 octets précédents:

Ḳs€L}Ḣ⁼¥ƇẎ€

Également un lien dyadique comme ci-dessus.

Essayez-le en ligne!

Perl 5 avec -asE, 23 22 21 octets (?)

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

Essayez-le en ligne!

Peut être exécuté en ligne de commande à une ligne comme perl -asE 'say/^$b(.*)/ for@F' -- -b=frac -, ou avec un nom de fichier à la place du dernier -.
Ou à partir d'un fichier de script, par exempleperl -as -M5.010 script.pl -b=frac - (merci à @Brad Gilbert b2gills pour le lien TIO qui le démontre).

Le code lui-même fait 18 octets, j'ai ajouté 3 octets pour l' -b=option qui affecte sa valeur (l'entrée de préfixe) à une variable nommée $bdans le code. Cela semblait être une exception au consensus habituel "les drapeaux ne sont pas comptés".

-adivise chaque ligne d'entrée en espaces et place le résultat dans le tableau @F. -sest un moyen raccourci d'assigner un argument de ligne de commande en tant que variable, en donnant un nom sur la ligne de commande. Voici l'argument -b=fracqui place le préfixe "frac" dans une variable $b.

/^$b(.*)/- Correspond à la valeur de $bau début de la chaîne. .*est tout ce qui vient après cela, jusqu'à la fin du mot, et les parenthèses environnantes capturent cette valeur. Les valeurs capturées sont automatiquement renvoyées, pour être imprimées par say. Itérer à travers des mots séparés par des espaces for @Fsignifie que nous n'avons pas à vérifier les espaces initiaux ou finaux.

Perl 6 , 30 octets

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

Essaye-le

Étendu:

{  # 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 octets

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

Essayez-le en ligne ici .

Non golfé:

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
}

Petit de base , 242 octets

Un script qui ne prend aucune entrée et ne sort pas vers l' TextWindowobjet

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

Essayez-le sur SmallBasic.com! Nécessite IE / Silverlight

Python 2 , 53 octets

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

Essayez-le en ligne!

Brachylog , 12 octets

hṇ₁∋R&t;.cR∧

Essayez-le en ligne!

Prend l'entrée comme [text, prefix]via la variable d'entrée et génère chaque mot via la variable de sortie. C'était à l'origine la réponse de sundar, que j'ai commencé à essayer de jouer au golf après avoir lu qu'elle "aurait pu être plus courte de quelques octets s'il y avait un partage variable avec des prédicats en ligne", ce qui est possible maintenant. Il s'avère que la sortie du générateur économise encore plus d'octets.

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

Mes deux premières tentatives de golf, en utilisant des fonctionnalités assez nouvelles du langage:

Avec les variables globales espérées: hA⁰&tṇ₁{∧A⁰;.c?∧}ˢ (18 octets)

Avec le métaprédicat à appliquer en tête: ṇ₁ᵗz{tR&h;.cR∧}ˢ (16 octets)

Et ma solution originale:

Brachylog , 15 octets

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

Essayez-le en ligne!

Même E / S. Il s'agit essentiellement d'un générateur de mots avec le préfixe,, ṇ₁ʰ⟨∋a₀⟩modifié pour supprimer le préfixe.

                   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.

Un prédicat très différent avec le même nombre d'octets:

Brachylog , 15 octets

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

Essayez-le en ligne!

Même E / S.

   ∋               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.

Rouge , 62 octets

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

Essayez-le en ligne!

Pyth , 21 20 18 17 16 octets

AQVcH)IqxNG0:NG"

Essayez-le en ligne!

-1 en utilisant Vau lieu de FNcar Vdéfinit implicitementN

-2 après quelques lectures supplémentaires sur les options de découpage de chaîne

-1 en utilisant x pour vérifier la présence de la sous-chaîne à l'index 0

-1 en utilisant remplacer par "" pour obtenir la fin de la chaîne

Je suis sûr que cela pourrait utiliser du golf sérieux, mais en tant que débutant Pyth, le faire fonctionner était un bonus.

Comment ça marche?

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 octets

Prend l'entrée comme préfixe [A1]et les valeurs [B1]et les sorties vers la console.

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