Utilizo "sufijo" libremente aquí para referirme a "cualquier subcadena que siga al prefijo".

"Prefijo" aquí significa el INICIO de una palabra, donde el inicio de una palabra se define como después de un espacio o desde el primer carácter del texto de entrada (para la primera palabra). Se ignora un "prefijo" en medio de una palabra.

Por ejemplo, si su prefijo de entrada es "armar" y el texto de entrada es "el ejército de Dumbledore estaba completamente armado para el inminente armageddon", entonces la lista de salida contiene (y, ed, edades).

Casos de prueba

Suponga que las mayúsculas y minúsculas terminan después de los espacios. La entrada no comenzará con un espacio.

Eliminar duplicados es opcional.

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

El ganador

Este es el código de golf , por lo que gana la menor cantidad de bytes. :)

Puede aceptar las entradas de cualquier manera que funcione, siempre que su código pueda resolver problemas arbitrarios como los casos de prueba.

R , 63 bytes

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

Pruébalo en línea!

Desafortunadamente, la implementación de aspecto positivo es 5 bytes más larga debido a la gran regmatches/gregexprcombinación:

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

Jalea , 12 bytes

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

Pruébalo en línea!

Japt , 9 bytes

8 bytes si podemos tomar la entrada como una matriz de palabras.

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

Pruébalo en línea!

Python 2 , 57 56 bytes

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

Pruébalo en línea!

-1 con agradecimiento a @mypetlion

C (gcc) , 113 109 106 105 bytes

-4 bytes gracias a @LambdaBeta!
-3 bytes gracias a @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++);}

Pruébalo en línea!

Japt , 16 12 bytes

Puerto de Arnauld Respuesta

-4 bytes 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

Pruébalo en línea!

05AB1E , 11 bytes

#ʒηså}εsgF¦

Pruébalo en línea! ( Aquí hay una demostración para cadenas multilínea)

¿Como funciona?

# ʒηså} εsgF¦ Programa completo.
# Divide la primera entrada por espacios.
 ʒ} Filtrar las palabras por ...
  ηså ... "¿La segunda entrada ocurre en el prefijo de la palabra?"
      ε Y para cada palabra válida
       sg Recupera la longitud de la segunda entrada.
         F… Y suelte el primer carácter de la palabra esa cantidad de veces.

Stax , 8 bytes

·B¬╤²*6&

Ejecutar y depurarlo

Explicación:

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

También podría usar x%t(longitud de X, recortar desde la izquierda), que es igualmente largo pero tiene 9 bytes .

Retina , 31 bytes

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

Pruébalo en línea! La primera línea debe ser el prefijo deseado, el resto es el texto de entrada. No elimina duplicados. Sería de 25 bytes si algún espacio en blanco fuera un separador válido. Explicación: Queremos enumerar los sufijos de prefijos válidos. El [^ ¶]+coincide con el sufijo en sí. El prefijo de la expresión regular es una mirada retrospectiva que garantiza que el prefijo del sufijo sea el prefijo de entrada. A medida que se evalúa una mirada hacia atrás de derecha a izquierda, esto comienza haciendo coincidir el prefijo (usando el mismo patrón pero dentro de ()s para capturarlo), luego cualquier carácter, antes de finalmente hacer coincidir el prefijo en su propia línea al comienzo de la entrada.

Brachylog , 24 21 bytes

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

Pruébalo en línea!

Podría haber sido unos pocos bytes más cortos si hubiera un intercambio variable con predicados en línea.

La entrada es una matriz con el prefijo como primer elemento y el texto como segundo elemento.

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)

Fórmula IBM / Lotus Notes, 54 bytes

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

Toma su entrada de dos campos llamados ay b. Funciona porque Formula aplicará recursivamente una función a una lista sin la necesidad de un @Forbucle.

No hay TIO disponible, así que aquí hay una captura de pantalla:

APL (Dyalog Unicode) , ^{SBCS de} 23 bytes

Programa completo Solicita texto y prefijo de stdin. Imprime la lista en stdout.

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

Pruébalo en línea!

⎕ mensaje (para texto)

⊢ rendimiento que (se separa '\1'de ⎕)

(… )⎕S'\1' PCRE Busca y devuelve la lista del grupo de captura 1 de la siguiente expresión regular:

 ⎕ indicador (para prefijo)

 '(\w+)\b', anteponer esta cadena (grupo de caracteres de palabra seguido de un límite de palabra)

 5⌽ rotar los primeros 5 caracteres hasta el final; '\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," ")));}

Pruébalo en línea!

Descripción:

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
}

Tiene que ser clang porque gcc segfaults sin #include <string.h>debido a problemas strtok.

MATL, 17 bytes

Yb94ih'(.*)'h6&XX

Pruébalo en MATL Online

¿Cómo?

Yb - Divida la entrada en espacios, coloque los resultados en una matriz de celdas

94- Código ASCII para ^personaje

ih - Obtenga la entrada (diga "frac"), concatene '^' y la entrada

'(.*)'h- Empuje la cadena '(.*)'en la pila, concatene '^ frac' y '(. *)'. Así que ahora tenemos '^frac(.*)una expresión regular que coincide con "frac" al comienzo de la cadena y captura lo que viene después.

6&XX- Ejecute la coincidencia de expresiones regulares, 6&especificando el modo 'Tokens', es decir, los grupos de captura coincidentes se devuelven en lugar de la coincidencia completa.

Salida implícita de los resultados.

Bash + grep, 20 bytes

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

El prefijo se proporciona como un parámetro de línea de comandos y el texto de entrada se canaliza a través de stdin.

Pruébalo en línea!

PowerShell 3.0, 60 62 59 bytes

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

Perdió algunos bytes suprimiendo la salida de cmatch. Tenía una solución irregular que ganó algo al causar duplicados a propósito. Pero también arrojó líneas rojas si no coincidía con el primero, pero eso no está bien ahora que lo pienso. Sin embargo, +2 bytes para arreglarlo.

JavaScript (ES6), 57 bytes

Toma entrada en la sintaxis de curry (text)(prefix) . No elimina duplicados.

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

Pruébalo en línea!

JavaScript (Node.js) , 64 59 bytes

-5 bytes de @Shaggy

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

Pruébalo en línea!

Haskell , 51 bytes

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

Pruébalo en línea!

Cáscara , 11 bytes

Casi solo un puerto de la respuesta de Haskell :

m↓L⁰foΠz=⁰w

Pruébalo en línea!

Explicación

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

Jalea ,  11  9 bytes

Ḳœṣ€ḢÐḟj€

Un enlace diádico que acepta el texto (una lista de caracteres) a la izquierda y el prefijo (una lista de caracteres) a la derecha que produce una lista de listas de caracteres (los sufijos resultantes).

Pruébalo en línea!(el pie de página se une con espacios para evitar la destrucción implícita del programa completo)
Nota: Agregué tres casos de borde a la cadena en el OP: sin empaquetar y nofracfracheremate al principio, que no debería generar y fracfracit hasta el final, que debería generar un fracit.

¿Cómo?

Ḳœṣ€ḢÐḟ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 byter anterior:

Ḳs€L}Ḣ⁼¥ƇẎ€

También un enlace diádico como el anterior.

Pruébalo en línea!

Perl 5 con -asE, 23 22 21 bytes (?)

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

Pruébalo en línea!

Se puede ejecutar como línea de comandos de una sola línea como perl -asE 'say/^$b(.*)/ for@F' -- -b=frac -, o con un nombre de archivo en lugar del último -.
O de un archivo de script, digamosperl -as -M5.010 script.pl -b=frac - (gracias a @Brad Gilbert b2gills por el enlace TIO que demuestra esto).

El código en sí es de 18 bytes, agregué 3 bytes para la -b=opción que asigna su valor (la entrada del prefijo) a una variable nombrada $ben el código. Eso se sintió como una excepción al consenso habitual de "no se cuentan las banderas".

-adivide cada línea de entrada en espacios y coloca el resultado en la matriz @F. -ses una forma abreviada de asignar un argumento de línea de comando como variable, dando un nombre en la línea de comando. Aquí el argumento es -b=frac, que coloca el prefijo "frac" en una variable $b.

/^$b(.*)/- Coincide con el valor $bal principio de la cadena. .*es lo que viene después de eso, hasta el final de la palabra, y las paréntesis circundantes capturan este valor. Los valores capturados se devuelven automáticamente, para ser impresos por say. Iterando a través de palabras separadas por espacios for @Fsignifica que no tenemos que verificar los espacios iniciales o finales.

Perl 6 , 30 bytes

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

Pruébalo

Expandido:

{  # 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()));}

Pruébalo en línea aquí .

Sin 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
}

Pequeño Básico , 242 bytes

Un script que no toma entradas y salidas al TextWindow objeto

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

¡Pruébelo en SmallBasic.com! Requiere IE / Silverlight

Python 2 , 53 bytes

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

Pruébalo en línea!

Brachylog , 12 bytes

hṇ₁∋R&t;.cR∧

Pruébalo en línea!

Toma la entrada como a [text, prefix]través de la variable de entrada y genera cada palabra a través de la variable de salida. Esta fue originalmente la respuesta de Sundar, que comencé a tratar de jugar golf después de leer que "podría haber sido unos pocos bytes más cortos si hubiera un intercambio variable con predicados en línea", lo cual es posible ahora. Resulta que la salida del generador ahorra aún más bytes.

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

Mis dos primeros intentos de jugar golf, utilizando características bastante nuevas del lenguaje:

Con las variables globales que se esperaban: hA⁰&tṇ₁{∧A⁰;.c?∧}ˢ (18 bytes)

Con el metapredicado de aplicar a la cabeza: ṇ₁ᵗz{tR&h;.cR∧}ˢ (16 bytes)

Y mi solución original:

Brachylog , 15 bytes

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

Pruébalo en línea!

La misma E / S. Esto es esencialmente un generador de palabras con el prefijo,ṇ₁ʰ⟨∋a₀⟩ , modificado para eliminar el prefijo.

                   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 predicado muy diferente con el mismo número de bytes:

Brachylog , 15 bytes

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

Pruébalo en línea!

La misma 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.

Rojo , 62 bytes

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

Pruébalo en línea!

Pyth , 21 20 18 17 16 bytes

AQVcH)IqxNG0:NG"

Pruébalo en línea!

-1 utilizando en Vlugar de FNporqueV establece implícitamenteN

-2 después de leer más sobre las opciones de segmentación de cadenas

-1 usando x para verificar la presencia de la subcadena en el índice 0

-1 usando reemplazar con "" para obtener el final de la cadena

Estoy seguro de que esto podría usar un poco de golf serio, pero como principiante de Pyth, solo ponerlo a trabajar fue una ventaja.

¿Como funciona?

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

Toma la entrada como prefijo [A1]y los valores [B1]y las salidas a la consola.

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