Eu uso "sufixo" vagamente aqui para significar "qualquer sub-string que segue o prefixo".

"Prefixo" aqui significa o INÍCIO de uma palavra, onde o início de uma palavra é definido como após um espaço ou a partir do primeiro caractere do texto de entrada (para a primeira palavra). Um "prefixo" no meio de uma palavra é ignorado.

Por exemplo, se o seu prefixo de entrada é "arm" e o texto de entrada é "O exército de Dumbledore estava totalmente armado para o iminente armageddon", a lista de saída contém (y, ed, ageddon).

Casos de teste

Suponha que maiúsculas e minúsculas diferenciam maiúsculas de minúsculas. A entrada não começará com um espaço.

A remoção de duplicatas é 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")

O vencedor

Isso é código-golfe , então o menor número de bytes vence. :)

Pode aceitar as entradas de qualquer maneira que funcione, desde que o seu código possa resolver problemas arbitrários, como os casos de teste.

R , 63 bytes

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

Experimente online!

Infelizmente, a implementação positiva é de 5 bytes devido à enorme regmatches/gregexprcombinação:

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

Gelatina , 12 bytes

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

Experimente online!

Japonês , 9 bytes

8 bytes se pudermos receber a entrada como uma matriz de palavras.

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

Experimente online!

Python 2 , 57 56 bytes

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

Experimente online!

-1 com agradecimentos a @mypetlion

C (GCC) , 113 109 106 105 bytes

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

Experimente online!

Japt , 16 12 bytes

Porto de Arnauld Resposta

-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

Experimente online!

05AB1E , 11 bytes

#ʒηså}εsgF¦

Experimente online!( aqui está uma demonstração para seqüências de linhas múltiplas)

Como funciona?

# ʒηså} εsgF¦ Programa completo.
# Divida a primeira entrada por espaços.
 Filter} Filtre as palavras por ...
  ηså ... "A segunda entrada ocorre no prefixo da palavra?"
      ε E para cada palavra válida
       sg Recupere o comprimento da segunda entrada.
         F… E solte o primeiro caractere da palavra esse número de vezes.

Stax , 8 bytes

·B¬╤²*6&

Execute e depure

Explicação:

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

Eu também poderia usar x%t(comprimento de X, aparar da esquerda), que é igualmente longo, mas comporta 9 bytes .

Retina , 31 bytes

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

Experimente online! A primeira linha deve ser o prefixo desejado, o restante é o texto de entrada. Não remove duplicatas. Seriam 25 bytes se algum espaço em branco fosse um separador válido. Explicação: Queremos listar os sufixos de prefixos válidos. O [^ ¶]+corresponde ao próprio sufixo. O prefixo do regexp é um lookbehind que garante que o prefixo do sufixo seja o prefixo de entrada. Como um lookbehind é avaliado da direita para a esquerda, isso começa combinando o prefixo (usando o mesmo padrão, mas dentro de ()s para capturá-lo) e, em seguida, qualquer caractere, antes de finalmente corresponder o prefixo em sua própria linha no início da entrada.

Braquilog , 24 21 bytes

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

Experimente online!

Poderia ter sido alguns bytes mais curto se houvesse compartilhamento de variáveis ​​com predicados em linha.

Entrada é uma matriz com o prefixo como o primeiro elemento e o texto como o 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);""))

Obtém a entrada de dois campos nomeados aeb . Funciona porque Formula aplicará recursivamente uma função a uma lista sem a necessidade de um @Forloop.

Nenhum TIO disponível, então aqui está uma captura de tela:

APL (Dyalog Unicode) , 23 bytes ^SBCS

Programa completo. Solicita texto e prefixo de stdin. Imprime a lista em stdout.

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

Experimente online!

⎕ prompt (para texto)

⊢ rendimento que (separa '\1'de ⎕)

(… )⎕S'\1' PCRE Pesquise e retorne a lista do grupo de captura 1 a partir do seguinte regex:

 ⎕ prompt (para prefixo)

 '(\w+)\b', preceda esta sequência (grupo de caracteres de palavra seguido por um limite de palavra)

 5⌽ gire os 5 primeiros caracteres até o fim; '\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," ")));}

Experimente online!

Descrição:

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
}

Tem que ser clangido porque o gcc segfaults sem #include <string.h>devido a problemas strtok.

MATL, 17 bytes

Yb94ih'(.*)'h6&XX

Experimente no MATL Online

Quão?

Yb - Divida a entrada em espaços, coloque os resultados em uma matriz de células

94- código ASCII para ^caractere

ih - Obtenha a entrada (diga "frac"), concatene '^' e a entrada

'(.*)'h- Empurre a corda '(.*)'para a pilha, concatene '^ frac' e '(. *)'. Portanto, agora temos '^frac(.*)um regex que corresponde a "frac" no início da string e captura o que vem depois.

6&XX- Execute a correspondência regexp, 6&especificando o modo 'Tokens', ou seja, os grupos de captura correspondentes são retornados em vez da correspondência inteira.

Implica implicitamente os resultados.

Bash + grep, 20 bytes

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

O prefixo é fornecido como um parâmetro da linha de comando e o texto de entrada é inserido via stdin.

Experimente online!

PowerShell 3.0, 60 62 59 bytes

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

Perdeu alguns bytes suprimindo a saída cmatch. Teve uma solução irregular que ganhou alguns por causar propositalmente duplicatas. Mas também lançou linhas vermelhas se não corresponder ao primeiro, mas isso não está bom agora que penso nisso. +2 bytes para corrigi-lo.

JavaScript (ES6), 57 bytes

Recebe entrada na sintaxe de currying (text)(prefix). Não remove duplicatas.

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

Experimente online!

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

Experimente online!

Haskell , 51 bytes

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

Experimente online!

Casca , 11 bytes

Praticamente apenas uma porta da resposta Haskell :

m↓L⁰foΠz=⁰w

Experimente online!

Explicação

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éia ,  11  9 bytes

Ḳœṣ€ḢÐḟj€

Um link diádico que aceita o texto (uma lista de caracteres) à esquerda e o prefixo (uma lista de caracteres) à direita, que produz uma lista de listas de caracteres (os sufixos resultantes).

Experimente online!(o rodapé se une aos espaços para evitar o esmagamento implícito do programa completo)
Nota: Adicionei três casos de borda à string no OP - sem quebra de linha e nofracfracheremate no início, que não deve ser exibido e fracfracado até o final, que deve ser emitido fracitamente.

Quão?

Ḳœṣ€ḢÐḟ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}Ḣ⁼¥ƇẎ€

Também um link diádico como acima.

Experimente online!

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

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

Experimente online!

Pode ser executado como um comando de uma linha como perl -asE 'say/^$b(.*)/ for@F' -- -b=frac -, ou com um nome de arquivo no lugar do passado -.
Ou a partir de um arquivo de script, digamosperl -as -M5.010 script.pl -b=frac - (obrigado a Brad Gilbert b2gills pelo link do TIO que demonstra isso).

O código em si é de 18 bytes, adicionei 3 bytes para a -b=opção que atribui seu valor (a entrada do prefixo) a uma variável nomeada $bno código. Isso parecia uma exceção ao consenso usual de "bandeiras não são contadas".

-adivide cada linha de entrada em espaços e coloca o resultado na matriz @F. -sé uma maneira de atalho para atribuir um argumento da linha de comando como uma variável, fornecendo um nome na linha de comando. Aqui está o argumento -b=frac, que coloca o prefixo "frac" em uma variável $b.

/^$b(.*)/- Corresponde ao valor de $bno início da string. .*é o que vier depois disso, até o final da palavra, e os parênteses circundantes capturam esse valor. Os valores capturados são retornados automaticamente, para serem impressos por say. Iterando através de palavras separadas por espaço, for @Fsignifica que não precisamos verificar espaços iniciais ou finais.

Perl 6 , 30 bytes

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

Teste-o

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

Experimente online aqui .

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
}

Small Basic , 242 bytes

Um script que não leva entrada e saída para o TextWindowobjeto

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

Experimente no SmallBasic.com! Requer IE / Silverlight

Python 2 , 53 bytes

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

Experimente online!

Braquilog , 12 bytes

hṇ₁∋R&t;.cR∧

Experimente online!

Toma entrada como [text, prefix]através da variável de entrada e gera cada palavra através da variável de saída. Essa foi originalmente a resposta da sundar, que comecei a tentar jogar golfe depois de ler que "poderia ter sido alguns bytes mais curto se houvesse compartilhamento de variáveis ​​com predicados em linha", o que é possível agora. Acontece que a saída do gerador economiza ainda mais 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).

Minhas duas primeiras tentativas de jogar golfe, usando recursos bastante novos do idioma:

Com as variáveis ​​globais que se esperavam: hA⁰&tṇ₁{∧A⁰;.c?∧}ˢ (18 bytes)

Com o metapredicado de aplicar à cabeça: ṇ₁ᵗz{tR&h;.cR∧}ˢ (16 bytes)

E minha solução original:

Braquilog , 15 bytes

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

Experimente online!

Mesma E / S. Este é essencialmente um gerador de palavras com o prefixo,, ṇ₁ʰ⟨∋a₀⟩modificado para remover o prefixo.

                   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.

Um predicado muito diferente com a mesma contagem de bytes:

Braquilog , 15 bytes

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

Experimente online!

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

Vermelho , 62 bytes

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

Experimente online!

Pitão , 21 20 18 17 16 bytes

AQVcH)IqxNG0:NG"

Experimente online!

-1 usando em Vvez de FNporqueV define implicitamenteN

-2 após algumas leituras adicionais sobre as opções de corte de cadeia

-1 usando x para verificar a presença da substring no índice 0

-1 usando replace com "" para obter o final da string

Tenho certeza de que isso poderia ser um jogo sério, mas como iniciante no Pyth, apenas fazê-lo funcionar era um bônus.

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

Recebe entrada como prefixo [A1]e valores [B1]e saídas para o console.

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