Cerca nel testo un prefisso ed elenca tutti i suoi suffissi nel testo

17

Uso qui "suffisso" liberamente per indicare "qualsiasi sottostringa che segue il prefisso".

"Prefisso" qui indica l'inizio di una parola, in cui l'inizio di una parola è definito come dopo uno spazio o dal primo carattere del testo di input (per la prima parola). Un "prefisso" nel mezzo di una parola viene ignorato.

Ad esempio, se il prefisso di input è "arm" e il testo di input è "L'esercito di Silente era completamente armato per l'imminente armageddon", l'elenco di output contiene (y, ed, ageddon).

Casi test

Supponiamo che le stringhe facciano distinzione tra maiuscole e minuscole dopo gli spazi. L'input non inizierà con uno spazio.

La rimozione dei duplicati è facoltativa.

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

Il vincitore

Questo è code-golf , quindi vince il minor numero di byte. :)

Può accettare gli input in qualsiasi modo funzioni, purché il codice sia in grado di risolvere problemi arbitrari come i casi di test.

code-golf  string  data-structures  search 
— DrQuarius
fonte
2
Per essere chiari, il prefisso deve essere all'inizio di una parola? Se il secondo caso di test contenesse la parola "diffrazione", cambierebbe l'output?
— Sundar - Ripristina Monica il
2
Come può https://www.astrotheme.com/astrology/essere un prefisso quando è preceduto da href="?
— Neil,
1
Il suffisso può essere vuoto?
— user202729,
1
Suggerirei di consentire alle persone di dividersi su altri spazi bianchi e su spazi come pochi sembrano farlo comunque. Suggerirei anche di dire che non ci saranno più spazi in una riga nell'input (o in qualche modo equivalentemente che parole vuote potrebbero comportare un comportamento indefinito). Suggerisco entrambe queste cose poiché la parte principale della sfida non è la divisione in parole (suggerirei di consentire solo un elenco di parole o anche solo una parola come input, ma ora è troppo tardi con 22 risposte - qualcosa da notare per sfide future però).
— Jonathan Allan,
1
-1 per consentire la divisione su altri spazi bianchi ora. Avrebbe senso che la sfida fosse quella originaria, ma cambiare ora avrebbe diviso le risposte in quelle che facevano due cose diverse. E questo non è come i casi in cui alcune lingue non sono in grado di gestire ad es. Numeri a 64 bit o qualcosa del genere, qui significa solo implementare una corrispondenza leggermente (forse) più complessa, quindi ha più senso correggere le risposte con ipotesi errate e forse aggiungere un caso di prova per verificare anche questo.
— Sundar - Ripristina Monica il

Risposte:

5

R , 63 byte

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

Provalo online!

L'implementazione con aspetto positivo è purtroppo di 5 byte più lunga a causa dell'enorme regmatches/gregexprcombinazione:

function(s,p)regmatches(s,gregexpr(paste0('(?<=',p,')[^ ]*'),s,,T))
— digEmAll
fonte
2
Un sub ingenuo (grep ()) è leggermente migliore del lookbehind a 66, ma continua a non invadere gli startWith (). Non vedo molto spazio per miglioramenti qui senza un cambio di approccio. Provalo online!
— CriminallyVulgar
4

Japt , 9 byte

8 byte se possiamo prendere l'input come una matrice di parole.

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

Provalo online!

— lendine
fonte
Molto bello, ma non sembra funzionare per l' ultimo caso di test . Potrebbe essere dovuto alle virgolette all'interno della stringa? o nuove linee?
— DrQuarius,
@DrQuarius Il tuo ultimo test case è difettoso, vero? Tutte le stringhe che stai cercando sono nel mezzo delle parole (circondate da url('')), nessuna di esse è all'inizio.
— Nit
4

C (gcc) , 113 109 106 105 105 byte

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

Provalo online!

— betseg
fonte
1
È possibile salvare 4 byte rimuovendo entrambi ^0. Solo ;*t;e&&*t;
— LambdaBeta il
@LambdaBeta grazie! Ho perso questo.
— Betseg,
1
Sono stato in grado di arrivare a 107 usando una strategia diversa, scusa :)
— LambdaBeta,
@LambdaBeta In realtà ho pensato a quel metodo ma non pensavo che sarebbe stato più breve della soluzione che ho pubblicato. Bella risposta, votata.
— Betseg,
1
usato put al posto di putchar, ora è 107, output su diverse linee: tio.run/…
— Windmill Cookies
3

Japt , 16 12 byte

Risposta di Port of Arnauld

-4 byte da @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

Provalo online!

— Luis Felipe De Jesus Munoz
fonte
1
— Shaggy,
Dovrebbe probabilmente menzionare che questa è una soluzione portuale di Arnauld. (Supponendo che non fosse derivato indipendentemente, ovviamente)
— Shaggy,
@Shaggy Onestamente non ho notato che questa era la stessa risposta, comunque gli darò credito. scusate
— Luis felipe De jesus Munoz,
C'è una soluzione a 9 byte se vuoi provarla.
— Shaggy,
@Shaggy Intendevi questo o avevi in ​​mente qualcosa di diverso?
— Nit
3

05AB1E , 11 byte

#ʒηså}εsgF¦

Provalo online! ( ecco una demo per stringhe multilinea)

Come funziona?

# ʒηså} εsgF¦ Programma completo.
# Dividi il primo input per spazi.
 ʒ} Filtra le parole per ...
  ηså ... "Il secondo input si verifica nel prefisso della parola?"
      ε E per ogni parola valida
       sg Recupera la lunghezza del secondo input.
         F¦ E rilascia il primo carattere della parola quel numero di volte.
— Mr. Xcoder
fonte
:) Molto bello, grazie per la demo multilinea! Penso che causasse problemi per altri programmi.
— DrQuarius,
3

Stax , 8 byte

·B¬╤²*6&

Esegui ed esegui il debug

Spiegazione:

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

Potrei anche usare x%t(lunghezza di X, taglio da sinistra), che è ugualmente lungo ma pacco a 9 byte .

— Wastl
fonte
Bellissimo. :) Penso che questo potrebbe essere il vincitore. La maggior parte dei contendenti con il punteggio di byte più basso non è stata in grado di analizzare il terzo caso di test. :)
— DrQuarius,
Ahhh ... ma vedo come l'hai fatto adesso, dovevi far sapere al programma che le virgolette nella stringa non facevano parte del programma. Penso che vada bene. Inoltre, il tuo è ancora il più breve a prescindere. :)
— DrQuarius,
3

Retina , 31 byte

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

Provalo online! La prima riga dovrebbe essere il prefisso desiderato, il resto è il testo di input. Non rimuove i duplicati. Sarebbe 25 byte se uno spazio bianco fosse un separatore valido. Spiegazione: Vogliamo elencare i suffissi di prefissi validi. L' [^ ¶]+corrisponde al suffisso stesso. Il prefisso di regexp è un lookbehind che garantisce che il prefisso del suffisso sia il prefisso di input. Poiché un lookbehind viene valutato da destra a sinistra, questo inizia abbinando il prefisso (usando lo stesso modello ma dentro ()s per catturarlo), quindi qualsiasi carattere, prima di abbinare finalmente il prefisso sulla propria riga all'inizio dell'input.

— Neil
fonte
Spazio bianco che significa spazi e / o interruzioni di riga? Penso che sia una soluzione valida in tal caso, ma per essere onesti con tutti lascerò il problema come indicato.
— DrQuarius,
@DrQuarius No, qualsiasi spazio bianco include schede, avanzamenti e persino ellissi .
— Neil,
Retina è stata la prima lingua che mi è venuta in mente quando ho visto il post (anche se non conosco ancora la lingua). Ho pensato che sarebbe stato più breve però. Potrei disturbarti per una spiegazione? Per es. la documentazione dice che è un personaggio newline, ma non riesco a capire perché così tanti sono necessari qui.
— Sundar - Ripristina Monica il
@sundar Mi dispiace, ero un po 'di fretta in quel momento. Il primo assicura che l'intera prima riga sia abbinata al prefisso. Il secondo è necessario perché non si sa quante linee intermedie ci siano. Gli ultimi due funzionano allo stesso modo: le classi di caratteri negate normalmente includono nuove righe ma qui non lo vogliamo.
— Neil,
Nessun problema, grazie per averlo aggiunto. "Normalmente includi le nuove righe ma non lo vogliamo qui" <- Se ho capito bene, lo vogliamo qui. OP specifica rigorosamente che solo gli spazi contano come separatori, che i prefissi iniziano e i suffissi terminano negli spazi. Quindi per es. "dif \ nfractional" non dovrebbe corrispondere a "frac" perché il prefisso segue una nuova riga, non uno spazio. Allo stesso modo "frattura- \ nrelated" dovrebbe restituire il suffisso "ture- \ nrelated". Questa è una buona notizia, credo, perché puoi rimuoverne almeno una , forse di più.
— Sundar - Ripristina Monica il
3

Brachylog , 24 21 byte

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

Provalo online!

Avrebbe potuto essere più breve di qualche byte se ci fosse stata una condivisione variabile con predicati inline.

L'input è un array con il prefisso come primo elemento e il testo come secondo 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)
— Sundar - Ripristina Monica
fonte
2

Formula IBM / Lotus Notes, 54 byte

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

Prende l'input da due campi denominati a e b. Funziona perché Formula applicherà ricorsivamente una funzione a un elenco senza la necessità di a@For ciclo.

Nessun TIO disponibile quindi ecco uno screenshot:

enter image description here

— ElPedro
fonte
2

APL (Dyalog Unicode) , 23 byte SBCS

Programma completo. Richiede testo e prefisso da stdin. Stampa l'elenco su stdout.

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

Provalo online!

⎕ prompt (per il testo)

⊢ cedere che (separa '\1'da ⎕)

(… )⎕S'\1' PCRE Cerca e restituisce l'elenco del gruppo di acquisizione 1 dalla seguente regex:

 ⎕ prompt (per prefisso)

 '(\w+)\b', anteporre questa stringa (gruppo di caratteri di parole seguiti da un limite di parole)

 5⌽ ruota i primi 5 caratteri fino alla fine; '\bPREFIX(\w+)'

— Adamo
fonte
2

C (clang) , 107 byte

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

Provalo online!

Descrizione:

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
}

Deve essere un clang perché gcc segfaults senza a #include <string.h>causa di problemi strtok.

— LambdaBeta
fonte
— ceilingcat,
2

MATL, 17 byte

Yb94ih'(.*)'h6&XX

Provalo su MATL online

Come?

Yb - Dividi l'input negli spazi, posiziona i risultati in un array di celle

94- Codice ASCII per ^carattere

ih - Ottieni l'input (dì "frac"), concatena '^' e l'input

'(.*)'h- Inserire la stringa '(.*)'nello stack, concatenare '^ frac' e '(. *)'. Quindi ora abbiamo '^frac(.*)una regex che corrisponde a "frac" all'inizio della stringa e cattura tutto ciò che viene dopo.

6&XX- Esegui la corrispondenza regexp, 6&specificando la modalità "Token", ovvero i gruppi di acquisizione corrispondenti vengono restituiti anziché l'intera corrispondenza.

Emissione implicita dei risultati.

— Sundar - Ripristina Monica
fonte
Quindi è quello che 'Tokens'fa; buono a sapersi!
— Luis Mendo,
1
Haha. Neanche io ne avevo idea, l'ho capito con prove ed errori per questa risposta.
— Sundar - Ripristina Monica il
2

Bash + grep, 20 byte

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

Il prefisso viene fornito come parametro della riga di comando e il testo di input viene reindirizzato tramite stdin.

Provalo online!

— Trauma digitale
fonte
2

PowerShell 3.0, 60 62 59 byte

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

Persi alcuni byte sopprimendo l'output di cmatch. Aveva una soluzione stravagante che ha guadagnato alcuni causando intenzionalmente duplicati. Ma ha anche lanciato redline se non corrispondeva al primo, ma non va bene ora che ci penso. +2 byte per risolverlo però.

— Veskah
fonte
La soluzione con 60 byte restituisce una doppia risposta in alcuni casi king, tals, ted, tional, tional, tionally, tioned, tioned, tious, tostratic, tures,tures,tures, tures, ase mostra un errore dell'indice He1insull'esempio. Powershell 5.1, 6.0.2. La soluzione con 62 byte è ok.
— mazzy,
1
@mazzy Lo sapevo, stavo solo abusando del bit "I duplicati sono consentiti" per far sì che restituisca ancora più duplicati quando si imbatte in una mancata corrispondenza e getta rosso in una prima ripetizione senza corrispondenza.
— Veskah
1

JavaScript (ES6), 57 byte

Accetta input nella sintassi del curry (text)(prefix). Non rimuove i duplicati.

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

Provalo online!

— Arnauld
fonte
1

Buccia , 11 byte

Praticamente solo un porto della risposta Haskell :

m↓L⁰foΠz=⁰w

Provalo online!

Spiegazione

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"]
— ბიმო
fonte
1

Gelatina ,  11  9 byte

Ḳœṣ€ḢÐḟj€

Un collegamento diadico che accetta il testo (un elenco di caratteri) a sinistra e il prefisso (un elenco di caratteri) a destra che produce un elenco di elenchi di caratteri (i suffissi risultanti).

Provalo online!(il piè di pagina si unisce agli spazi per evitare lo smashing implicito del programma completo)
Nota: ho aggiunto tre casi limite alla stringa nell'OP - unfrackled e nofracfracheremate all'inizio, che non dovrebbe essere emesso e fracfracit alla fine che dovrebbe produrre fracit.

Come?

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

precedente 11 byte:

Ḳs€L}Ḣ⁼¥ƇẎ€

Anche un collegamento diadico come sopra.

Provalo online!

— Jonathan Allan
fonte
1

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

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

Provalo online!

Può essere eseguito come una linea di comando one-liner come perl -asE 'say/^$b(.*)/ for@F' -- -b=frac -, o con un nome al posto del l'ultimo -.
O da un file di script, diciamoperl -as -M5.010 script.pl -b=frac - (grazie a @Brad Gilbert b2gills per il collegamento TIO che lo dimostra).

Il codice stesso è di 18 byte, ho aggiunto 3 byte per l' -b=opzione che assegna il suo valore (input prefisso) a una variabile denominata $bnel codice. Sembrava un'eccezione al consueto consenso "le bandiere non sono contate".

-adivide ogni riga di input negli spazi e posiziona il risultato nella matrice @F. -sè un modo rapido di assegnare un argomento della riga di comando come variabile, assegnando un nome alla riga di comando. Qui l'argomento è -b=frac, che inserisce il prefisso "frac" in una variabile $b.

/^$b(.*)/- Corrisponde al valore $ball'inizio della stringa. .*è qualunque cosa venga dopo, fino alla fine della parola, e le paratie circostanti catturano questo valore. I valori acquisiti vengono automaticamente restituiti, per essere stampati da say. Scorrendo le parole separate da spazio con i for @Fmezzi non dobbiamo controllare gli spazi iniziali o finali.

— Sundar - Ripristina Monica
fonte
— Brad Gilbert b2gills
1

Perl 6 , 30 byte

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

Provalo

Allargato:

{  # 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)
  /
}
— Brad Gilbert b2gills
fonte
@sundar fisso
— Brad Gilbert b2gills
Sembra che tu abbia uno spazio aggiuntivo tra 'p' e '<' btw.
— Sundar - Ripristina Monica il
@sundar Lo spazio tra ped <(è necessario, altrimenti potrebbe essere visto come $v<…>abbreviato $v{qw '…'}.
— Brad Gilbert b2gills
1
Sembra funzionare senza di esso, almeno in questo caso.
— Sundar - Ripristina Monica il
1
@sundar Tecnicamente avverte, ma non mi piace scrivere codice che avverta quando è solo un byte diverso dal codice che non avvisa.
— Brad Gilbert b2gills
1

Java 10, 94 byte

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

Provalo online qui .

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
}
— OOBalance
fonte
1

Piccolo di base , 242 byte

Uno script che non accetta input e output TextWindowsull'oggetto

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

Provalo su SmallBasic.com! Richiede IE / Silverlight

— Taylor Scott
fonte
1

Brachylog , 12 byte

hṇ₁∋R&t;.cR∧

Provalo online!

Prende l'input come [text, prefix]attraverso la variabile di input e genera ogni parola attraverso la variabile di output. Questa era originariamente la risposta di Sundar, che ho iniziato a provare a giocare a golf dopo aver letto che "avrebbe potuto essere più breve di qualche byte se ci fosse stata una condivisione variabile con predicati inline", che ora è possibile. Si scopre che l'uscita del generatore consente di risparmiare ancora più byte.

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

I miei primi due tentativi di giocare a golf, usando funzionalità abbastanza nuove della lingua:

Con le variabili globali che erano state sperate: hA⁰&tṇ₁{∧A⁰;.c?∧}ˢ (18 byte)

Con il metapredicate applica-a-testa: ṇ₁ᵗz{tR&h;.cR∧}ˢ (16 byte)

E la mia soluzione originale:

Brachylog , 15 byte

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

Provalo online!

Stesso I / O. Questo è essenzialmente un generatore di parole con il prefisso ṇ₁ʰ⟨∋a₀⟩, modificato per rimuovere il prefisso.

                   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 predicato molto diverso con lo stesso numero di byte:

Brachylog , 15 byte

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

Provalo online!

Stesso 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.
— Stringa non correlata
fonte
0

Pyth , 21 20 18 17 16 byte

AQVcH)IqxNG0:NG"

Provalo online!

-1 usando Vinvece di FNperché Vimposta implicitamenteN

-2 dopo ulteriori letture sulle opzioni di taglio delle stringhe

-1 utilizzando x per verificare la presenza della sottostringa all'indice 0

-1 usando sostituisci con "" per ottenere la fine della stringa

Sono sicuro che questo potrebbe usare un po 'di golf serio, ma come principiante di Pyth, farlo funzionare è stato un vantaggio.

Come funziona?

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,""))
— ElPedro
fonte
0

Excel VBA, 86 byte

Accetta input come prefisso, [A1]valori in [B1]e output sulla console.

For each w in Split([B1]):?IIf(Left(w,[Len(A1)])=[A1],Mid(w,[Len(A1)+1])+" ","");:Next
— Taylor Scott
fonte
Utilizzando il nostro sito, riconosci di aver letto e compreso le nostre Informativa sui cookie e Informativa sulla privacy.
Licensed under cc by-sa 3.0 with attribution required.