उपसर्ग के लिए पाठ खोजें और पाठ में इसके सभी प्रत्ययों को सूचीबद्ध करें

17

मैं "प्रत्यय" का उपयोग यहाँ पर "उपसर्ग का अनुसरण करने वाले किसी उप-स्ट्रिंग" के लिए करता हूँ।

यहां "उपसर्ग" का अर्थ है एक शब्द का स्टार्ट, जहां एक शब्द की शुरुआत या तो स्पेस के बाद या इनपुट टेक्स्ट के पहले कैरेक्टर (पहले शब्द के लिए) के रूप में परिभाषित की जाती है। एक शब्द के बीच में एक "उपसर्ग" को अनदेखा किया जाता है।

उदाहरण के लिए, यदि आपका इनपुट उपसर्ग "आर्म" है और इनपुट टेक्स्ट "डंबलडोर की सेना आसन्न आर्मगेडन के लिए पूरी तरह से सशस्त्र है" तो आउटपुट सूची में (y, ed, mastdon) शामिल हैं।

परीक्षण के मामलों

केस-संवेदी मान लें, स्ट्रिंग्स रिक्त स्थान के बाद समाप्त हो जाती हैं। इनपुट एक स्थान से शुरू नहीं होगा।

डुप्लिकेट को निकालना वैकल्पिक है।

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

विजेता

यह कोड-गोल्फ है , इसलिए सबसे कम बाइट्स जीतता है। :)

किसी भी तरह से काम करने वाले इनपुट्स को स्वीकार कर सकते हैं, जब तक कि आपका कोड टेस्ट मामलों की तरह मनमानी समस्याओं को हल कर सकता है।

code-golf  string  data-structures  search 
— DrQuarius
स्रोत
2
स्पष्ट होने के लिए, उपसर्ग को एक शब्द की शुरुआत में होना चाहिए? यदि दूसरे परीक्षण के मामले में 'विवर्तन' शब्द होता, तो क्या इससे आउटपुट में बदलाव होता?
— सूंदर -
2
https://www.astrotheme.com/astrology/जब यह पहले हो तो उपसर्ग कैसे हो सकता है href="?
— नील
1
क्या प्रत्यय खाली हो सकता है?
— user202729
1
मेरा सुझाव है कि लोगों को अन्य श्वेत-स्थान के साथ-साथ रिक्त स्थान पर भी विभाजित करने की अनुमति दी जाए, जैसा कि कुछ भी वैसे भी कर रहे हैं। मैं यह भी कहना चाहूंगा कि इनपुट में एक पंक्ति में कई स्थान नहीं होंगे (या कुछ हद तक समान रूप से कि खाली शब्दों का अपरिभाषित व्यवहार हो सकता है)। मैं इन दोनों चीजों का सुझाव देता हूं क्योंकि चुनौती का मुख्य भाग शब्दों के भाग में विभाजित नहीं है (मैं सुझाव दूंगा कि केवल शब्दों की एक सूची या इनपुट के रूप में सिर्फ एक शब्द की अनुमति है, लेकिन यह अभी भी 22 उत्तर के साथ बहुत देर हो चुकी है - कुछ ध्यान दें हालांकि भविष्य की चुनौतियों के लिए)।
— जोनाथन एलन
1
-1 अब अन्य व्हाट्सएप पर विभाजन की अनुमति देने के लिए। इस चुनौती के लिए यह समझ में आता है कि मूल रूप से, लेकिन अब बदलने से उत्तर अलग हो जाएंगे जो दो अलग-अलग काम करते हैं। और यह उन मामलों की तरह नहीं है जहां कुछ भाषाएं उदाहरण के लिए संभाल नहीं सकती हैं। 64-बिट नंबर या कुछ और, यहां इसका मतलब है कि थोड़ा (संभवतः) अधिक जटिल मैच को लागू करना, इसलिए यह गलत धारणाओं के साथ सही उत्तर देने के लिए अधिक समझ में आता है और शायद इसके लिए जांच करने के लिए एक परीक्षण मामला भी जोड़ता है।
— सूंदर -

जवाबों:

5

आर , 63 बाइट्स

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

इसे ऑनलाइन आज़माएं!

सकारात्मक regmatches/gregexprसंयोजन के कारण दुर्भाग्य से 5 बाइट्स लंबे संयोजन के कारण लंबे समय तक बने रहते हैं :

function(s,p)regmatches(s,gregexpr(paste0('(?<=',p,')[^ ]*'),s,,T))
— digEmAll
स्रोत
2
एक भोले उप (grep ()) 66 की तलाश में थोड़ा बेहतर है, लेकिन अभी भी startWith () पर अतिक्रमण नहीं करता है। मैं दृष्टिकोण में बदलाव के बिना यहां सुधार के लिए ज्यादा जगह नहीं देखता। इसे ऑनलाइन आज़माएं!
— क्रिमिनल
4

जेली , 12 बाइट्स

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

इसे ऑनलाइन आज़माएं!

— आउटगोल्फ को एरिक करें
स्रोत
कला कर्म। : ') HTML का उपयोग सूचियों में पार्स करने के लिए किया जाएगा, बहुत बहुत धन्यवाद। :)
— DrQuarius
2
@DrQuarius Regex HTML को पार्स नहीं कर सकता है , और इसलिए जेली है।
— user202729
मुझे ठीक काम करने लगता है । यकीन नहीं है कि क्यों?
— ड्रैकुएल जूल
1
@DQuQuarius यह एक प्रसिद्ध मजाक है, और user202729 ने इसे बढ़ाया।
— आउटगोल्फ जूल
4

जाप , 9 बाइट्स

8 बाइट्स अगर हम शब्दों की एक सरणी के रूप में इनपुट ले सकते हैं।

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

इसे ऑनलाइन आज़माएं!

— लीख
स्रोत
बहुत अच्छा है, लेकिन पिछले परीक्षण मामले के लिए काम करने के लिए प्रतीत नहीं होता है । स्ट्रिंग के अंदर उद्धरण चिह्नों के कारण हो सकता है? या नई लाइनें?
— ड्रैकुइल जूल
@DrQuarius आपका आखिरी परीक्षण मामला दोषपूर्ण है, है ना? आपके द्वारा खोजे जा रहे सभी तार शब्दों के बीच में हैं (चारों ओर से घेरे हुए url('')), उनमें से कोई भी शुरुआत में नहीं है।
— लीख
4

C (gcc) , 113 109 106 105 बाइट्स

-4 बाइट्स @LambdaBeta को धन्यवाद!
-3 बाइट्स के लिए @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++);}

इसे ऑनलाइन आज़माएं!

— betseg
स्रोत
1
आप दोनों को हटाकर 4 बाइट्स बचा सकते हैं ^0। बस ;*t;और&&*t;
— LambdaBeta
@LambdaBeta धन्यवाद! मैंने यह खो दिया।
— बाजी
1
मैं इसे एक अलग रणनीति का उपयोग करके 107 में नीचे लाने में सक्षम था , क्षमा करें :)
— लैम्ब्डाटा
@LambdaBeta मैं वास्तव में उस पद्धति के बारे में सोचता था, लेकिन मुझे नहीं लगता कि यह मेरे द्वारा पोस्ट किए गए समाधान से छोटा होता। अच्छा जवाब, upvoted।
— बेट्सग
1
पुशर के बजाय इस्तेमाल किया जाता है, अब 107 है, विभिन्न लाइनों पर आउटपुट: tio.run/…
— विंडमिल कुकीज़
3

जाप , 16 12 बाइट्स

पोर्ट ऑफ अरनौलड उत्तर

@ बग्घी से -4 बाइट्स

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

इसे ऑनलाइन आज़माएं!

— लुइस फेलिप डी जेउस मुनोज़
स्रोत
1
— झबरा
शायद उल्लेख करना चाहिए कि यह अरनुल्ल के समाधान का एक बंदरगाह है। (यह मानते हुए कि यह स्वतंत्र रूप से प्राप्त नहीं हुआ था, निश्चित रूप से)
— झबरा
@ शागिर्द ईमानदारी से मैंने नोटिस नहीं किया, यह वही जवाब था, वैसे भी मैं उसे श्रेय दूंगा। क्षमा करें
— लुइस फेलिप डी जेउस मुनोज
यदि आप इसे आज़माना चाहते हैं तो एक 9 बाइट समाधान है।
— झबरा
@ शगुन क्या आपका मतलब यह था या आपके मन में कुछ अलग था?
— लीख
3

05AB1E , 11 बाइट्स

#ʒηså}εsgF¦

इसे ऑनलाइन आज़माएं! ( यहां मल्टीलाइन स्ट्रिंग्स के लिए एक डेमो है)

यह कैसे काम करता है?

# #så} εsgFʒη पूर्ण कार्यक्रम।
# रिक्त स्थान द्वारा पहला इनपुट विभाजित करें।
 ʒ} शब्दों को फ़िल्टर करके ...
  theså ... "क्या शब्द के उपसर्ग में दूसरा इनपुट होता है?"
      ε और प्रत्येक वैध शब्द के लिए
       sg दूसरे इनपुट की लंबाई को पुनः प्राप्त करें।
         F और उस संख्या के शब्द का पहला वर्ण छोड़ें।
— मिस्टर एक्सकोडर
स्रोत
:) बहुत अच्छा, मल्टीलाइन डेमो के लिए धन्यवाद! मुझे लगता है कि अन्य कार्यक्रमों के लिए समस्या पैदा कर रहा था।
— ड्रैकुइल
3

स्टैक्स , 8 बाइट्स

·B¬╤²*6&

इसे चलाएं और डीबग करें

स्पष्टीकरण:

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

मैं भी इस्तेमाल कर सकता हूं x%t(एक्स की लंबाई, बाएं से ट्रिम), जो समान रूप से लंबा है लेकिन 9 बाइट्स के लिए पैक है ।

— wastl
स्रोत
सुंदर। :) मुझे लगता है कि यह विजेता हो सकता है। सबसे कम बाइट स्कोर के दावेदार तीसरे टेस्ट मामले को पार्स नहीं कर पाए हैं। :)
— DrQuarius
आह ... लेकिन मैं देखती हूं कि आपने इसे अभी कैसे किया है, आपको कार्यक्रम को यह बताने देना होगा कि स्ट्रिंग में उद्धरण चिह्न कार्यक्रम का हिस्सा नहीं थे। मुझे लगता है कि यह ठीक है। इसके अलावा, तुम्हारा अब भी सबसे छोटा है। :)
— DrQuarius
3

रेटिना , 31 बाइट्स

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

इसे ऑनलाइन आज़माएं! पहली पंक्ति वांछित उपसर्ग होनी चाहिए, बाकी इनपुट टेक्स्ट है। डुप्लिकेट नहीं निकालता है। 25 बाइट्स होंगे यदि कोई सफेद स्थान वैध सेप्रेटर था। स्पष्टीकरण: हम मान्य उपसर्गों के प्रत्ययों को सूचीबद्ध करना चाहते हैं। [^ ¶]+प्रत्यय ही मेल खाता है। Regexp का उपसर्ग एक लुकअप है जो यह सुनिश्चित करता है कि प्रत्यय का उपसर्ग इनपुट उपसर्ग है। जैसा कि एक लुकबाइंड का मूल्यांकन राइट-टू-लेफ्ट के रूप में किया जाता है, यह उपसर्ग के मिलान (उसी पैटर्न का उपयोग करके, लेकिन ()इसे कैप्चर करने के लिए एस के अंदर ) से शुरू होता है , फिर किसी भी वर्ण, अंत में इनपुट की शुरुआत में अपनी लाइन पर उपसर्ग से मेल खाता है।

— नील
स्रोत
व्हाइट स्पेस अर्थ स्पेस और / या लाइन ब्रेक? मुझे लगता है कि यदि ऐसा है तो एक वैध समाधान है, लेकिन सभी के लिए उचित होने के नाते मैं समस्या को बताऊंगा।
— DrQuarius
— नील
रेटिना वह पहली भाषा थी जो पोस्ट देखने के बाद मेरे दिमाग में आई (हालाँकि मुझे अभी तक भाषा नहीं पता है)। मैंने सोचा कि यह हालांकि कम होगा। क्या मैं आपको स्पष्टीकरण के लिए परेशान कर सकता हूं? उदाहरण के लिए। डॉक्स का कहना है कि यह एक नया चरित्र है, लेकिन मैं यह पता नहीं लगा सकता कि यहां इतने सारे की आवश्यकता क्यों है।
— सूंदर -
@sundar क्षमा करें मैं उस समय थोड़ी भीड़ में था। पहले सुनिश्चित करता है कि पूरी पहली पंक्ति उपसर्ग से मेल खाती है। दूसरे की जरूरत है क्योंकि यह नहीं पता है कि कितनी मध्यवर्ती लाइनें हैं। अंतिम दो एस उसी तरह से काम करते हैं - नकारात्मक चरित्र वर्ग में आम तौर पर नए अंक शामिल होते हैं लेकिन हम यहां नहीं चाहते हैं।
— नील
कोई समस्या नहीं है, इसे जोड़ने के लिए धन्यवाद। "आम तौर पर नई सूचियों में शामिल हैं, लेकिन हम यहां नहीं चाहते हैं" <- अगर मैं सही ढंग से समझता हूं, तो हम यहां चाहते हैं। ओपी सख्ती से निर्दिष्ट करता है कि केवल रिक्त स्थान ही विभाजक के रूप में गिना जाता है, उपसर्ग शुरू होते हैं और प्रत्यय रिक्त स्थान पर समाप्त होते हैं। इसलिए उदाहरण के लिए। "dif \ nfractional" "फ़्रेक" के लिए मेल नहीं खाना चाहिए, क्योंकि उपसर्ग एक नई रेखा के बाद आता है, एक स्थान नहीं। इसी तरह "फ्रैक्चर- \ nrelated" को प्रत्यय "ture- \ nrelated" वापस करना चाहिए। जो मुझे लगता है कि अच्छी खबर है, क्योंकि आप कम से कम एक को हटा सकते हैं , संभवतः अधिक।
— सूंदर -
3

ब्रेकीलॉग , 24 21 बाइट्स

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

इसे ऑनलाइन आज़माएं!

अगर इनलाइन विधेयकों के साथ परिवर्तनीय साझाकरण होता तो कुछ बाइट्स कम हो सकते थे।

इनपुट एक उपसर्ग है जिसमें पहले तत्व के रूप में और दूसरे तत्व के रूप में टेक्स्ट है। 

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 - मोनिका को बहाल करना
स्रोत
2

आईबीएम / लोटस नोट्स फॉर्मूला, 54 बाइट्स

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

यह नाम दिया है aऔर से दो क्षेत्रों से इनपुट है b। काम करता है क्योंकि फॉर्मूला @Forलूप की आवश्यकता के बिना किसी सूची में एक फ़ंक्शन को पुन: लागू करेगा ।

कोई TIO उपलब्ध नहीं है तो यहां स्क्रीनशॉट है:

enter image description here

— ElPedro
स्रोत
2

एपीएल (Dyalog यूनिकोड) , 23 बाइट्स SBCS

पूरा कार्यक्रम। टेक्स्ट के लिए संकेत और स्टड से उपसर्ग। प्रिंट सूची स्टडआउट के लिए।

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

इसे ऑनलाइन आज़माएं!

⎕ शीघ्र (पाठ के लिए)

⊢ कि (अलग उपज '\1'से ⎕)

(… )⎕S'\1' निम्नलिखित रेगेक्स से कब्जा समूह 1 की पीसीआरई खोज और वापसी सूची:

 ⎕ शीघ्र (उपसर्ग के लिए)

 '(\w+)\b', इस स्ट्रिंग को प्रीपेन्ड करें (शब्द अक्षर का समूह जिसके बाद शब्द सीमा होती है)

 5⌽ पहले 5 वर्णों को अंत तक घुमाएं; '\bPREFIX(\w+)'

— एडम
स्रोत
2

सी (क्लैंग) , 107 बाइट्स

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

इसे ऑनलाइन आज़माएं!

विवरण:

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
}

#include <string.h>क्लैंग होना चाहिए क्योंकि स्ट्रॉक की समस्याओं के बिना जीसीसी सेगफुल्स।

— LambdaBeta
स्रोत
— सीलिंगकैट
2

MATL, 17 बाइट्स

Yb94ih'(.*)'h6&XX

इसे MATL ऑनलाइन पर आज़माएं

कैसे?

Yb - रिक्त स्थान पर इनपुट को विभाजित करें, परिणामों को सेल सरणी में रखें

94- ^चरित्र के लिए ASCII कोड

ih - इनपुट प्राप्त करें ("फ़्रेक" कहें), '^' और इनपुट प्राप्त करें

'(.*)'h- '(.*)'स्टैक में स्ट्रिंग पुश करें , '^ फ़्रेक' और '(*। *)' को मिलाएं। तो अब हमारे पास '^frac(.*)एक रेगीक्स है जो स्ट्रिंग की शुरुआत में "फ़्रेक" से मेल खाता है और जो भी आता है उसे पकड़ लेता है।

6&XX- रनगेक्सप मैचिंग, 6&'टोकन' मोड को निर्दिष्ट करने के साथ, अर्थात, मिलान किए गए कैप्चर समूह पूरे मैच के बजाय वापस कर दिए जाते हैं।

परिणामों को स्पष्ट रूप से आउटपुट करें।

— sundar - मोनिका को बहाल करना
स्रोत
तो वही 'Tokens'करता है; जानकार अच्छा लगा!
— लुइस मेन्डो
1
Haha। मुझे इस बात का कोई अंदाजा नहीं था, इस जवाब के लिए इसे परीक्षण और त्रुटि द्वारा सुलझा लिया गया।
— सूंदर -
2

पावरशेल 3.0, 60 62 59 बाइट्स

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

Cmatch आउटपुट को दबाने वाले कुछ बाइट्स खो दिए। एक जानलेवा समाधान था जो जानबूझकर डुप्लिकेट के कारण कुछ प्राप्त करता था। लेकिन यह भी सुर्खियों में फेंक दिया अगर यह पहले मैच पर नहीं था, लेकिन यह अब ठीक नहीं है कि मैं इसके बारे में सोचता हूं। +2 बाइट्स हालांकि इसे ठीक करने के लिए।

— Veskah
स्रोत
60 बाइट्स के साथ समाधान कुछ मामलों में दोहरा जवाब देता है king, tals, ted, tional, tional, tionally, tioned, tioned, tious, tostratic, tures,tures,tures, tures, asऔर He1inउदाहरण पर सूचकांक त्रुटि दिखाता है । पॉवर्सशेल 5.1, 6.0.2। 62 बाइट्स के साथ समाधान ठीक है।
— माज़ी
1
@mazzy मुझे पता था कि, मैं बस "डुप्लिकेट की अनुमति दे रहा था" गालियां दे रहा था, क्योंकि यह बिना किसी मैच के पूरे होने पर और अधिक डुप्लिकेट को वापस करने के लिए होता है और एक नो-मैच 1 पुनरावृत्ति पर लाल फेंक देता है।
— 19
1

जावास्क्रिप्ट (ईएस 6), 57 बाइट्स

करी सिंटैक्स में इनपुट लेता है (text)(prefix)। डुप्लिकेट नहीं निकालता है।

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

इसे ऑनलाइन आज़माएं!

— Arnauld
स्रोत
1

भूसी , 11 बाइट्स

बहुत ही हास्केल जवाब का सिर्फ एक बंदरगाह :

m↓L⁰foΠz=⁰w

इसे ऑनलाइन आज़माएं!

व्याख्या

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"]
— ბიმო
स्रोत
1

जेली ,  11  9 बाइट्स

Ḳœṣ€ḢÐḟj€

दाईं ओर पाठ (वर्णों की एक सूची) और दाईं ओर उपसर्ग (वर्णों की एक सूची) को स्वीकार करने वाला एक डाईडिक लिंक जो वर्णों की सूची (परिणामित प्रत्ययों) की एक सूची देता है।

इसे ऑनलाइन आज़माएं!(फुटर रिक्त स्थान के साथ जुड़ता है, पूर्ण-कार्यक्रम के धूमिल होने से बचने के लिए)
नोट: मैंने ओपी में स्ट्रिंग के लिए तीन एज केस जोड़े - शुरुआत में अनफ्रेंडली और नोफ्रैफ्रैचरमेट करें, जो अंत में आउटपुट और फ़्रेक्फ़िट को आउटपुट नहीं करना चाहिए जो कि फ़्रास्किट का उत्पादन करना चाहिए।

कैसे?

Ḳœṣ€ḢÐḟ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 बटर:

Ḳs€L}Ḣ⁼¥ƇẎ€

इसके अलावा ऊपर के रूप में एक dyadic लिंक।

इसे ऑनलाइन आज़माएं!

— जोनाथन एलन
स्रोत
1

पर्ल 5 के साथ -EE, 23 22 21 बाइट्स (?)

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

इसे ऑनलाइन आज़माएं!

आखिरी के स्थान पर कमांड लाइन वन-लाइनर के रूप perl -asE 'say/^$b(.*)/ for@F' -- -b=frac -में या फ़ाइल नाम के साथ चलाया जा सकता है -।
या एक स्क्रिप्ट फ़ाइल से, कहते हैंperl -as -M5.010 script.pl -b=frac - (यह प्रदर्शित करने वाले TIO लिंक के लिए @Brad Gilbert b2gills के लिए धन्यवाद)।

कोड स्वयं 18 बाइट्स है, मैंने उस -b=विकल्प के लिए 3 बाइट्स जोड़े हैं जो $bकोड में नामित चर के लिए इसका मूल्य (उपसर्ग इनपुट) प्रदान करता है । यह महसूस किया कि सामान्य "झंडे को गिना नहीं जाता है" आम सहमति के अपवाद के रूप में।

-aरिक्त स्थान पर प्रत्येक इनपुट लाइन को विभाजित करता है और परिणाम को सरणी में रखता है @F। -sएक कमांड-लाइन तर्क को एक चर के रूप में असाइन करने का एक शॉर्टकट तरीका है, कमांड-लाइन पर एक नाम देकर। यहाँ तर्क है -b=frac, जो उपसर्ग "फ़्रेक" को एक चर में रखता है $b।

/^$b(.*)/- $bस्ट्रिंग की शुरुआत में मूल्य से मेल खाता है । .*उसके बाद जो भी आता है, शब्द के अंत तक, और आसपास के पैरेन्थेस इस मूल्य पर कब्जा कर लेते हैं। पकड़े गए मान स्वचालित रूप से वापस आ जाते हैं, द्वारा मुद्रित किया जाना है say। अंतरिक्ष से अलग शब्दों के माध्यम से Iterating का for @Fमतलब है कि हमें प्रारंभिक या अंतिम स्थानों की जांच करने की आवश्यकता नहीं है।

— sundar - मोनिका को बहाल करना
स्रोत
— ब्रैड गिल्बर्ट b2gills
1

पर्ल 6 , 30 बाइट्स

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

झसे आज़माओ

विस्तारित:

{  # 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)
  /
}
— ब्रैड गिल्बर्ट b2gills
स्रोत
तय @sundar
— ब्रैड गिल्बर्ट b2gills
आपको 'p' और '<' btw के बीच एक अतिरिक्त स्थान प्रतीत होता है।
— सूंदर -
@sundar के बीच की जगह pऔर <(अन्यथा के रूप में यह रूप में देखा जा सकता है के लिए आवश्यक है $v<…>के लिए कम है जो $v{qw '…'}।
— ब्रैड गिल्बर्ट 2
1
इसके बिना काम करने लगता है, हालांकि कम से कम इस मामले में।
— सूंदर -
1
@sundar तकनीकी रूप से यह सिर्फ चेतावनी देता है, लेकिन मुझे ऐसा कोड लिखना पसंद नहीं है जो चेतावनी देता हो कि यह कोड से केवल एक बाइट अलग है जो चेतावनी नहीं देता है।
— ब्रैड गिल्बर्ट b2gills
1

जावा 10, 94 बाइट्स

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

इसे यहाँ ऑनलाइन आज़माएँ ।

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
स्रोत
1

छोटा बेसिक , 242 बाइट्स

एक स्क्रिप्ट जो TextWindowऑब्जेक्ट के लिए कोई इनपुट और आउटपुट नहीं लेती है

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

SmallBasic.com पर इसे आज़माएं! आईई / सिल्वरलाइट की आवश्यकता है

— टेलर स्कॉट
स्रोत
1

पायथन 2 , 53 बाइट्स

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

इसे ऑनलाइन आज़माएं!

— राफेल कोट
स्रोत
दिलचस्प विचार है, लेकिन पहले परीक्षण के मामले में विफल रहता है, इनपुट: "1", "हे 1 ओनोस 1 एल जे 21 जे 1 एलजे 2 जे 1 एलजे 2 1 एल एल जे 2 आई"
— चेस ब्राउन
ठीक है, मैं इसके साथ बेला करने की कोशिश करूँगा। मुझे यकीन है कि मैं कुछ कर रहा हूँ ...
— राफेल कोट
1

Brachylog , 12 बाइट्स

hṇ₁∋R&t;.cR∧

इसे ऑनलाइन आज़माएं!

[text, prefix]इनपुट चर के माध्यम से इनपुट लेता है , और प्रत्येक शब्द उत्पन्न करता है आउटपुट चर के माध्यम से । यह मूल रूप से सूंदर का जवाब था, जिसे मैंने पढ़ने के बाद गोल्फ से कोशिश करना शुरू कर दिया कि "अगर इनलाइन विधेयकों के साथ चर साझा करना हो तो यह कुछ बाइट्स कम हो सकता था", जो अब संभव है। पता चलता है कि जनरेटर का उत्पादन और भी अधिक बाइट बचाता है।

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

भाषा की काफी नई विशेषताओं का उपयोग करते हुए इसे नीचे उतारने के मेरे पहले दो प्रयास:

उन वैश्विक चरों के साथ जिनकी आशा की गई थी: hA⁰&tṇ₁{∧A⁰;.c?∧}ˢ (18 बाइट्स)

लागू करने के लिए सिर के साथ metapredicate: ṇ₁ᵗz{tR&h;.cR∧}ˢ (16 बाइट्स)

और मेरा मूल समाधान:

ब्रेकीलॉग , 15 बाइट्स

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

इसे ऑनलाइन आज़माएं!

वही आई / ओ। यह मूल रूप से उपसर्ग के साथ शब्दों के लिए एक जनरेटर है, उपसर्ग ṇ₁ʰ⟨∋a₀⟩को हटाने के लिए संशोधित किया गया है।

                   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.

एक ही बाइट गिनती के साथ एक बहुत अलग विधेय:

ब्रेकीलॉग , 15 बाइट्स

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

इसे ऑनलाइन आज़माएं!

वही आई / ओ।

   ∋               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.
— असंबंधित स्ट्रिंग
स्रोत
0

पायथ , 21 20 18 17 16 बाइट्स

AQVcH)IqxNG0:NG"

इसे ऑनलाइन आज़माएं!

-1 के Vबजाय का उपयोग करके FNक्योंकि Vनिहित सेटN

-2 कुछ आगे स्ट्रिंग स्लाइसिंग विकल्पों के बारे में पढ़ने के बाद

-1 का उपयोग कर xइंडेक्स 0 में सबरिंग की उपस्थिति के लिए जाँच करने के लिए करना

-1 स्ट्रिंग के अंत को पाने के लिए "" के साथ प्रतिस्थापित करें

मुझे यकीन है कि यह कुछ गंभीर गोल्फ का उपयोग कर सकता है, लेकिन पायथ शुरुआत के रूप में, बस काम करने के लिए यह एक बोनस था।

यह कैसे काम करता है?

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
स्रोत
0

एक्सेल VBA, 86 बाइट्स

इनपुट को उपसर्ग के रूप में [A1]और मान [B1]को कंसोल में और आउटपुट में ले जाता है।

For each w in Split([B1]):?IIf(Left(w,[Len(A1)])=[A1],Mid(w,[Len(A1)+1])+" ","");:Next
— टेलर स्कॉट
स्रोत
हमारी साइट का प्रयोग करके, आप स्वीकार करते हैं कि आपने हमारी Cookie Policy और निजता नीति को पढ़ और समझा लिया है।
Licensed under cc by-sa 3.0 with attribution required.