किसी दिए गए स्ट्रिंग में दिए गए इंडेक्स के चारों ओर शब्द का चयन करें

Question

विंडोज में, जब आप किसी पाठ में डबल-क्लिक करते हैं, तो पाठ में आपके कर्सर के आसपास का शब्द चुना जाएगा।

(इस विशेषता में अधिक जटिल गुण हैं, लेकिन उन्हें इस चुनौती के लिए लागू करने की आवश्यकता नहीं होगी।)

उदाहरण के लिए, |अपने कर्सर को अंदर जाने दें abc de|f ghi।

फिर, जब आप डबल क्लिक करते हैं, तो सबस्ट्रिंग defका चयन किया जाएगा।

इनपुट आउटपुट

आपको दो इनपुट दिए जाएंगे: एक स्ट्रिंग और एक पूर्णांक।

आपका कार्य पूर्णांक द्वारा निर्दिष्ट सूचकांक के आसपास स्ट्रिंग के शब्द-प्रतिस्थापन को वापस करना है।

आपके कर्सर को निर्दिष्ट सूचकांक में स्ट्रिंग में चरित्र के ठीक पहले या ठीक बाद हो सकता है ।

यदि आप पहले सही उपयोग करते हैं , तो कृपया अपने उत्तर में निर्दिष्ट करें।

निर्दिष्टीकरण (चश्मा)

सूचकांक एक शब्द के अंदर होने की गारंटी है, इसलिए कोई किनारा मामले जैसे abc |def ghiया abc def| ghi।

स्ट्रिंग में केवल मुद्रण योग्य ASCII वर्ण होंगे (U + 0020 से U + 007E तक)।

शब्द "शब्द" को रेगेक्स द्वारा परिभाषित किया गया है (?<!\w)\w+(?!\w), जहां "या अंडरसीकोर सहित एएससीआईआई में अल्फ़ान्यूमेरिक वर्ण" \wद्वारा परिभाषित किया गया है [abcdefghijklmnopqrstuvwxyzABCDEFGHIJKLMNOPQRSTUVWXYZ0123456789_]।

सूचकांक 1-अनुक्रमित या 0-अनुक्रमित हो सकता है।

यदि आप 0-अनुक्रमित का उपयोग करते हैं, तो कृपया इसे अपने उत्तर में निर्दिष्ट करें।

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

Testcases 1-indexed हैं, और निर्दिष्ट सूचकांक के बाद कर्सर सही है ।

कर्सर स्थिति केवल प्रदर्शन उद्देश्य के लिए है, जिसे आउटपुट करने की आवश्यकता नहीं होगी।

string    index     output    cursor position
abc def   2         abc       ab|c def
abc def   5         def       abc d|ef
abc abc   2         abc       ab|c abc
ab cd ef  4         cd        ab c|d ef
ab   cd   6         cd        ab   c|d
ab!cd     1         ab        a|b!cd

Comments

क्या स्ट्रिंग में न्यूलाइन्स हो सकती हैं?

— 15

@orlp प्रिंट करने योग्य ASCII पर इनपुट को प्रतिबंधित करने के लिए चुनौती को संपादित किया गया था ताकि इनपुट में नई लिंक नहीं होंगी।

— FryAmTheEggman

आपके टेस्टकेस में रिक्त स्थान की तुलना में कोई अन्य सीमांकक नहीं होता है। जैसे एक शब्द के बारे में क्या we're?

— orlp

क्या "ab...cd", 3लौटना चाहिए ?

— टाइटस

@Titus "सूचकांक एक शब्द के अंदर रहने की गारंटी है"

— मार्टिन एंडर

Answer 1

वी , 10, 9 7 बाइट्स

À|diwVp

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

यह उत्तर 1-आधारित अनुक्रमण का उपयोग करता है।

यह छोटा हो सकता है यदि हम ठीक वही करते हैं जो शीर्षक कहता है: " एक स्ट्रिंग में दिए गए सूचकांक के चारों ओर शब्द का चयन करें "। हम कर सकते थे

À|viw

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

स्पष्टीकरण:

À|          " Jump the position of argument 1
  diw       " (d)elete (i)nside this (w)ord.
     V      " Select this line
      p     " And replace it with the word we just deleted

Answer 2

सी, 104 बाइट्स

p[99];i,d;main(l){for(scanf("%d",&i);scanf("%[^a-zA-Z0-9_]%[a-zA-Z0-9_]%n",&d,&p,&l),i>l;i-=l);puts(p);}

स्टड पर इनपुट की उम्मीद है कि 0-आधारित सूचकांक के बाद एक स्थान या न्यूलाइन होगा, इसके बाद स्ट्रिंग। एक शब्द के लिए अधिकतम लंबाई 99 वर्ण है। उदाहरण के लिए:

2 abc def

Comments

यह एक स्ट्रिंग आधारित चुनौती पर बंधे सी और पर्ल को देखने के लिए वास्तव में अच्छा है। :D

— DJMcMayhem

क्या इनपुट स्ट्रिंग में 100 से अधिक अक्षर हो सकते हैं?

— लीक नन

@LeakyNun हां, लेकिन एक शब्द 100 वर्णों से अधिक लंबा नहीं हो सकता है।

— orlp

क्या आप अपने उत्तर के अंदर उस आवश्यकता को डालने का मन करते हैं?

— लीक नून

@DrGreenEggsandIronMan बहुत बुरा मुझे अपना जवाब तय करना पड़ा क्योंकि यह

— व्हाट्सएप

Answer 3

सी (जीसीसी), 94 बाइट्स

f(n,p)char*p;{for(p+=n-1;isalnum(*p)|*p==95&&n--;--p);for(;isalnum(*++p)|*p==95;putchar(*p));}

शून्य-अनुक्रमित, सूचकांक लेने वाले एक फ़ंक्शन को परिभाषित करता है, फिर स्ट्रिंग।

Comments

मुझे लगता isalnum(*++p)|*p==95है कि अपरिभाषित व्यवहार है।

— उल्लू

@owacoder यह है, लेकिन क्या मायने रखता है कि gcc एक निष्पादन योग्य है जो काम करता है। *++p^95?isalnum(*p):1अब एक बाइट है, लेकिन हर कंपाइलर पर काम करता है।

— orlp

मुझे लगता है कि प्रमुख स्थान एक टाइपो है? इसके अलावा, यहाँ एक आलसी IDEone लिंक है।

— FryAmTheEggman

isalnum(*++p)||*p==95एक अतिरिक्त बाइट के लिए भी काम करता है।

— उल्लू

@FryAmTheEggman हाँ, यह अभी तय है।

— १

Answer 4

रेटिना, २२

(1) + ¶ - * \ b (<1>?।) | \ डब्ल्यू +

इसे ऑनलाइन आज़माएं! या सभी परीक्षण मामलों को सत्यापित करें । नियमित कार्यक्रम एक नई रेखा और उसके बाद स्ट्रिंग में कर्सर की स्थिति को एकात्मकता में लेता है। परीक्षण सूट में प्रति पंक्ति मोड में चलाने के लिए अतिरिक्त कोड है, और \एक सीमांकक के रूप में उपयोग करता है , और यह सुविधा के लिए दशमलव का उपयोग करता है।

कर्सर की स्थिति का पता लगाने के लिए संतुलन समूहों का उपयोग करता है, फिर एक शब्द सीमा तक पीछे जाता है। पाठ को शब्द तक हटाता है, और फिर शब्द के बाद।

Answer 5

सी, 115 बाइट्स

फ़ंक्शन f()को पैरामीटर के रूप में स्ट्रिंग और इंडेक्स (1-अनुक्रमित) की आवश्यकता होती है और परिणाम को स्टडआउट करने के लिए प्रिंट करता है। निर्दिष्ट चरित्र के बाद कर्सर होना चाहिए।

f(char*p,int n){char*s=p+n;for(;s>=p&&isalnum(*s)+(*s==95);--s);for(p=s+1;*p&&isalnum(*p)+(*p==95);putchar(*p++));}

Answer 6

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

f=(s,n)=>s.slice(0,n).match(/\w*$/)+s.slice(n).match(/\w*/)

बस स्ट्रिंग को कर्सर बिंदु पर स्लाइस करता है (जो कि 0-अनुक्रमित वर्ण से पहले है, जो 1-अनुक्रमित वर्ण के बाद के समान ही काम करता है), फिर आसन्न शब्द टुकड़े को अर्क और समेटता है। यहां तक ​​कि जब एक शब्द के शुरू में, अंत में, या कहीं नहीं होता है, तो समझदार परिणाम देता है।

Comments

क्या आपको अंतिम रेगेक्स में * की आवश्यकता है?

— चार्ली व्यान

@CharlieWynn हाँ, अन्यथा दूसरा टेस्टकेस केवल वापस आ जाएगा de।

— नील

हूप्स, मेरे द्वारा चलाए गए परीक्षणों से बदकिस्मत हो गए

— चार्ली व्यान

Answer 7

जावा 8, 86 78 बाइट्स

(s,p)->{for(String t:s.split("\\W"))if((p-=t.length()+1)<0)return t;return"";}

परीक्षण के मामलों के साथ असंगत:

class Indexer {
    public static String f(String s, int p) {
        for(String t : s.split("\\W"))
            if((p -= t.length()+1) < 0)
                return t;
        return "";
    }

    public static void main(String[] args) {
        System.out.println(f("abc def",2));
        System.out.println(f("abc def",5));
        System.out.println(f("abc abc",2));
        System.out.println(f("ab cd ef",4));
        System.out.println(f("ab   cd",6));
        System.out.println(f("ab!cd",1));
    }
}

गैर-अल्फ़ान्यूमेरिक वर्णों द्वारा स्ट्रिंग को विभाजित करता है, फिर प्रत्येक प्रतिस्थापन की लंबाई, प्लस 1 को निर्दिष्ट स्थिति से घटाता रहता है, जब तक कि यह नकारात्मक नहीं हो जाता। चूंकि किसी भी दोहराए जाने वाले गैर-अल्फ़ान्यूमेरिक्स को रिक्त स्ट्रिंग के रूप में दर्शाया जाता है, घटाव तर्क काफी आसान है।

इस कोड का बड़े पैमाने पर परीक्षण नहीं किया गया है, इसलिए मैं यह देखना चाहूंगा कि क्या कोई इसे तोड़ सकता है। इसके अलावा, यह देखते हुए कि यह जावा कोड है, यह यहां सबसे लंबा उत्तर कैसे नहीं है? : पी

Comments

मुझे पता है कि यह लगभग तीन साल का है, लेकिन एक करीबी लैम्ब्डा अभिव्यक्ति (यानी ) का उपयोग करके (s,p)->हो सकता s->p->है java.util.function.Function<String, java.util.function.Function<String, String>> f। इसके अलावा, अब Stringहो सकता varहै अगर जावा 10 पर स्विच किया जाए, हालांकि यह पाठ्यक्रम के समय उपलब्ध नहीं था। भले ही, अच्छा जवाब। मुझे लगता है कि मैंने पहले ही इसे अतीत में कहीं अद्यतन कर दिया है। :)

— केविन क्रूज़सेन

Answer 8

पायथ, 16 बाइट्स

+e=:.<+QbE"\W"3h

       Q            first input (string)
      + b           plus newline
    .<   E          rotate left by second input (number)
   :      "\W"3     split on regex \W, non-word characters
  =                 assign to Q
 e                  last element
+              hQ   plus first element

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

Answer 9

रूबी, 41 31 बाइट्स

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

-10 बाइट @MartinEnder से

->s,i{s[/\w*(?<=^.{#{i}})\w*/]}

Answer 10

पाइके, 19 बाइट्स

#Q;cjmli<i+s)lttjR@

यहाँ कोशिश करो!

Q;यह सुनिश्चित करने के लिए कि पहला इनपुट सही तरीके से रखा गया है, नो-ऑप के रूप में उपयोग करता है

#          )   -  first where
   c           -       input.split()
    ml         -      map(len, ^)
      i<       -     ^[:i]
        i+     -    ^+[i]
          s    -   sum(^)
            lt - len(^)-2

Comments

आपके लिंक पर क्लिक करने पर मुझे 504 त्रुटि हो रही है।

— लीक

@LeakyNun हाँ, मैंने इसे गलती से मार दिया, जबकि यह लिखना कि मेरे पास लोकलहोस्ट लिंक क्यों था, यह वापस आ जाएगा

— ब्लू

यहाँ कोशिश करो!

— लीक नून

ऐसा लगता है कि आपका प्रोग्राम N को आउटपुट कर रहा है जहाँ Nth शब्द चयनित है, लेकिन हमें पूरा शब्द चाहिए

— Value Ink

Answer 11

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

import re
f=lambda x,y,r=re.split:r('\W',x[:y])[-1]+r('\W',x[y:])[0]

गैर-शब्द विभाजकों द्वारा स्ट्रिंग को विभाजित करता है, एक बार मूल सूचकांक पर कर्सर इंडेक्स पर, फिर स्ट्रिंग इंडेक्स पर कर्सर इंडेक्स पर। बाएं विभाजन का अंतिम तत्व और दाएं विभाजन का पहला तत्व लौटाता है। 4 बाइट बचाने के लिए लीक नून को धन्यवाद!

Answer 12

क्लोजर, 92 बाइट्स

(fn[x k](let[[u i](map #(re-seq #"\w+"(apply str %))(split-at k x))](str(last u)(nth i 0))))

सबसे पहले, इनपुट स्ट्रिंग kको दो तारों में स्थिति में विभाजित करता है । फिर इन तारों के होने का पता लगाते हैं "\w+"और उन्हें सूची के रूप में वापस करते हैं। फिर पहली सूची के अंतिम तत्व और दूसरी सूची के पहले तत्व को संक्षिप्त करें।

इसे ऑनलाइन देखें: https://ideone.com/Dk2FIs

Answer 13

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

(s,n)=>RegExp(`^.{0,${n}}(\\W+|^)(\\w+)`).exec(s)[2]

const F = (s,n) => RegExp(`^.{0,${n}}(\\W+|^)(\\w+)`).exec(s)[2]

class Test extends React.Component {
    constructor(props) {
        super(props);
        const input = props.input || '';
        const index = props.index || 0;
        this.state = {
            input,
            index,
            valid: /\w/.test(input),
        };
    }
    onInput = () => {
        const input = this.refs.input.value;
        const index = Math.min(+this.refs.index.value, input.length);
        this.setState({
            input,
            index,
            valid: /\w/.test(input),
        });
    }
    render() {
        const {input, index, valid} = this.state;
        return (
            <tr>
                <td>{ this.props.children }</td>
                <td>
                    <input ref="input" type="text" onInput={this.onInput} value={input} />
                    <input ref="index" type="number" onInput={this.onInput} min="1" max={input.length} value={index} />
                </td> 
                {valid && [
                    <td>{F(input, index)}</td>,
                    <td><pre>{input.slice(0, index)}|{input.slice(index)}</pre></td>,
                ]}
            </tr>
        );
    }
}

class TestList extends React.Component {
    constructor(props) {
        super(props);
        this.tid = 0;
        this.state = {
            tests: (props.tests || []).map(test => Object.assign({
                key: this.tid++
            }, test)),
        };
    }
    addTest = () => {
        this.setState({
            tests: [...this.state.tests, { key: this.tid++ }],
        });
    }
    removeTest = key => {
        this.setState({
            tests: this.state.tests.filter(test => test.key !== key),
        });
    }
    
    render() {
        return (
            <div>
                <table>
                    <thead>
                        <th/>
                        <th>Test</th>
                        <th>Output</th>
                        <th>Diagram</th>
                    </thead>
                    <tbody>
                        {
                            this.state.tests.map(test => (
                                <Test key={test.key} input={test.input} index={test.index}>
                                    <button onClick={() => this.removeTest(test.key)} style={{
                                        verticalAlign: 'middle',
                                    }}>-</button>
                                </Test>
                            ))
                        }
                    </tbody>
                    <tfoot>
                        <td/>
                        <td>
                            <button onClick={this.addTest} style={{
                                width: '100%',
                            }}>Add test case</button>
                        </td>
                    </tfoot>
                </table>
            </div>
        );
    }
}

ReactDOM.render(<TestList tests={[
    { input: 'abc def', index: 2 },
    { input: 'abc def', index: 5 },
    { input: 'abc abc', index: 2 },
    { input: 'ab cd ef', index: 4 },
    { input: 'ab   cd', index: 6 },
    { input: 'ab!cd', index: 1 },
]} />, document.body);

input[type="number"] {
  width: 3em;
}
table {
  border-spacing: 0.5em 0;
  border-collapse: separate;
  margin: 0 -0.5em ;
}
td, input {
    font-family: monospace;
}
th {
  text-align: left;
}
tbody {
  padding: 1em 0;
}
pre {
  margin: 0;
}

<script src="https://cdnjs.cloudflare.com/ajax/libs/react/15.1.0/react.min.js"></script>
<script src="https://cdnjs.cloudflare.com/ajax/libs/react/15.1.0/react-dom.min.js"></script>

Comments

क्यों (\\W+|^)नहीं(\\W|^)

— l4m2

Answer 14

लूआ, 71 67 बाइट्स

Woohoo, Lua सबसे लंबा समाधान नहीं है! फिर भी अजगर के पीछे एक बाइट है, लेकिन यह कैसे नीचे गोल्फ के लिए पता नहीं है। इंडेक्स 1-आधारित हैं।

@LeakyNun की बदौलत मुझे अस्तित्व की याद दिलाई string.match, 4 बाइट्स बचाए

g,h=...print(g:sub(1,h):match"[%a_]*$"..g:sub(h+1):match("[%a_]+"))

पुराना 71१

नोट: स्पष्टीकरण अभी भी इस पर आधारित हैं, क्योंकि यह नए पर भी लागू होता है, लेकिन इसमें कुछ अतिरिक्त संकेत शामिल हैं gmatch

g,h=...print(g:sub(1,h):gmatch"[%a_]*$"()..g:sub(h+1):gmatch"[%a_]*"())

व्याख्या

सबसे पहले, हम तर्कों को अनपैक करते हैं gऔर hक्योंकि वे इससे छोटे हैंarg[x]

g,h=...

फिर, हम अपने आउटपुट का निर्माण करते हैं, जो कि कर्सर से पहले और उसके बाद के भाग का संघटन होता है।

स्ट्रिंग का पहला भाग है

g:sub(1,h)

हम इस एक के अंत में शब्द ढूंढना चाहते हैं, इसलिए हम फ़ंक्शन का उपयोग करते हैं string.gmatch

:gmatch"[%a_]*$"

यह पैटर्न 0..nस्ट्रिंग के अंत में वर्णमाला + अंडरस्कोर के वर्ण सेट से मेल खाता है । gmatchएक फ़ंक्शन के रूप में मैच की अपनी सूची पर एक पुनरावृत्ति देता है (बंद करने के सिद्धांत का उपयोग करके), इसलिए हम अपने शब्द का पहला भाग प्राप्त करने के लिए इसे एक बार निष्पादित करते हैं

g:sub(1,h):gmatch"[%a_]*$"()

हम अपने शब्द का दूसरा भाग भी इसी तरह प्राप्त करते हैं

g:sub(h+1):gmatch"[%a_]*"())

एकमात्र अंतर यह है कि हमें यह निर्दिष्ट करने की आवश्यकता नहीं है कि हम स्ट्रिंग (प्रारंभ [^%a_]*) का उपयोग करके मिलान करना चाहते हैं , क्योंकि यह पहली बार कॉल करने पर पुनरावृत्तिकर्ता द्वारा दिया गया मैच होगा।

Comments

g:sub(h+1):match"^[%a_]*"?

— लीक नन

@LeakyNun पूरी तरह से match\ o के अस्तित्व को भूल गया / बहुत सारे बाइट्स बचाता है, धन्यवाद

— कैटेन्को

-1 "अनुक्रमित" के लिए

— लीक नन

@LeakyNun दोनों इंडेक्स और इंडेक्स सही हैं ^ ^

— काटनेंको

मुझे परवाह नहीं है, अभी भी "अनुक्रमित" के लिए -1।

— लीक नून

Answer 15

जावास्क्रिप्ट (बाहरी पुस्तकालय का उपयोग करके) (168 बाइट्स)

(n,w)=> _.From(w).Select((x,i)=>({i:i,x:x})).Split((i,v)=>v.x==" ").Where(a=>a.Min(i=>i.i)<=n-1&&a.Max(i=>i.i)>=n-2).First().Select(i=>i.x).Write("").match(/^\w*^\w*/)[0]

लिंक करने के लिए लिंक: https://github.com/mvegh1/Enumerable/blob/master/linq.js

कोड का स्पष्टीकरण: लाइब्रेरी एक स्ट्रिंग को स्वीकार करता है, जो एक चार सरणी में पार्स हो जाता है। यह एक वस्तु के लिए मैप किया जाता है जिसमें सूचकांक और चार को संग्रहीत किया जाता है। अनुक्रम "" की हर घटना के बाद के क्रम में विभाजित हो जाता है। यदि बाद में कर्सर सूचकांक न्यूनतम और अधिकतम सूचकांक के भीतर समाहित है, तो जाँच द्वारा फ़िल्टर किए जाते हैं। फिर हम पहले बाद में लेते हैं। फिर हम सिर्फ एक चार सरणी में बदल देते हैं। फिर हम सीमांकक के रूप में "" सभी वर्णों को समेटते हैं। फिर हम शब्द रेगेक्स के खिलाफ मान्य करते हैं। फिर हम पहला मैच लेते हैं।

Comments

शब्द "शब्द" को रेगेक्स द्वारा परिभाषित किया गया है (?<!\w)\w+(?!\w), जहां "या अंडरसीकोर सहित एएससीआईआई में अल्फ़ान्यूमेरिक वर्ण" \wद्वारा परिभाषित किया गया है [abcdefghijklmnopqrstuvwxyzABCDEFGHIJKLMNOPQRSTUVWXYZ0123456789_]।

— लीक नून

जब मैं regex101.com पर ab! Cd के खिलाफ उस रेगेक्स को चलाता हूं तो मुझे यह मिलता है: कोई मैच ग्रुप नहीं निकाला गया। इसका मतलब है कि आपका पैटर्न मेल खाता है, लेकिन इसमें (कैप्चरिंग (समूह)) नहीं थे जो विषय स्ट्रिंग में कुछ भी मेल खाते हों। शायद मैं कहीं गलती कर रहा हूँ ...

— Applejacks01

मुझे कुछ भी कैप्चर करने की आवश्यकता क्यों होगी?

— लीक नून

मुझे पता है कि यह सीखने की जगह नहीं है, लेकिन मैं कह रहा हूं कि जब मैं अबे के खिलाफ रेगेक्स चलाता हूं, तो मुझे कुछ भी नहीं मिलता है। तो 'ab' सही आउटपुट क्यों होगा?

— Applejacks01

regex101.com/r/sC5oY0/1

— लीक नून

Answer 16

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

->\b{&{first *.to>b,m:g/<<\w+>>/}}

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

अनाम कोडब्लॉक, जो इनपुट क्यूरेड लेता है, जैसे f(n)(string)।

स्पष्टीकरण:

->\b{                            }   # Anonymous code block that takes a number
     &{                         }    # And returns another code block that
       first       ,m:g/<<\w+>>/     # Finds the first word in the input
             *.to>b                  # Where the start is after the number

Answer 17

रूबी , 30 बाइट्स

->s,n{s[/.{#{n}}\w+/][/\w+$/]}

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

एक अलग दृष्टिकोण, केवल 1 बाइट छोटा और 3 साल बाद। क्यों नहीं?

Answer 18

एपीएल (एनएआरएस), 58 वर्ण, 116 बाइट्स

{m←⎕A,⎕a,⎕D,'_'⋄↑v⊂⍨m∊⍨v←⍵↓⍨¯1+⍵{⍵≤1:⍵⋄m∊⍨⍵⊃⍺:⍺∇⍵-1⋄⍵+1}⍺}

⍵ {⍺∇⍵1: ⍵⋄m∊⍨⍵⊃⍺: ⋄⍵-1 1 + 1} ⍵≤ यह पता लगाएं कि स्ट्रिंग कहाँ से शुरू होती है ... उपयोग और परीक्षण कैसे करें:

  f←{m←⎕A,⎕a,⎕D,'_'⋄↑v⊂⍨m∊⍨v←⍵↓⍨¯1+⍵{⍵≤1:⍵⋄m∊⍨⍵⊃⍺:⍺∇⍵-1⋄⍵+1}⍺}
  2 f 'abc def'
abc
  5 f 'abc def'
def
  2 f 'abc abc'
abc
  4 f 'ab cd ef'
cd
  1 f 'ab!cd'
ab
  6 f 'ab   cd'
cd 

Answer 19

MATL , 16 15 बाइट्स

'\w+'5B#XXi>)1)

कर्सर 1-अनुक्रमित और चरित्र के बाद (जैसा कि परीक्षण मामलों में) है।

इसे ऑनलाइन आज़माएं! या सभी परीक्षण मामलों को सत्यापित करें ।

'\w+'    % Push string to be used as regex pattern
5B#XX    % Take input string implicitly. Apply regex. Push matches and ending indices
i>       % Take input number. Compare with obtained ending indices. Gives true for
         % ending indices that exceed the input number
)        % Use as logical index to select the corresponding matches
1)       % Select the first match. Implicitly display

Answer 20

PowerShell v3 +, 103 101 बाइट्स

param($a,$n)for(;$n[++$a]-match'\w'){}$i=$a--;for(;$n[--$a]-match'\w'-and$a-ge0){}-join$n[++$a..--$i]

एक नासमझ समाधान की तरह, लेकिन दूसरों की तुलना में एक अलग दृष्टिकोण।

इनपुट $aको स्ट्रिंग के 0-आधारित सूचकांक के रूप में लेता है $n। फिर, हम अपने शब्द की सीमाओं का पता लगाते हैं। हालांकि हम स्ट्रिंग के अंत तक नहीं पहुंचे हैं और / या हम अभी भी शब्द-वर्णों का मिलान कर रहे हैं, हम ++$a। फिर, बाड़ लगाने के कारण, हम सेट करते हैं $i=$a--। अगला, हम पीछे की ओर क्रॉल करते हैं, $aतब तक डीट्रैक्शनिंग करते हैं जब तक कि यह 0या तो हम एक गैर-शब्द-चरित्र को हिट नहीं करते हैं। फिर हम उन दो सीमांकनों (कुछ वृद्धि / गिरावट के साथ OBOE के लिए खाते में) के आधार पर इनपुट स्ट्रिंग को स्लाइस करते हैं, और -joinयह परिणाम उत्पन्न करने के लिए एक साथ होता है।

उदाहरण

PS C:\Tools\Scripts\golfing> .\select-the-word-around-the-index.ps1 2 'This!test'
This

PS C:\Tools\Scripts\golfing> .\select-the-word-around-the-index.ps1 5 'This!test'
test

Comments

select-the-word-around-the-index.ps1

— लीकी नून

Answer 21

PHP, 98 बाइट्स

function f($s,$p){foreach(preg_split('#\W+#',$s,-1,4)as$m)if($m[1]+strlen($m[0])>=$p)return$m[0];}

• गैर-शब्द-वर्णों द्वारा स्ट्रिंग को विभाजित करता है, उनकी स्थिति ( 4== PREG_SPLIT_OFFSET_CAPTURE) को याद करते हुए , शब्दों के माध्यम से लूप करता है जब तक कि स्थिति तक नहीं पहुंच जाता है।
• PHP के तार 0-अनुक्रमित हैं, चरित्र से पहले कर्सर, लेकिन शब्द से पहले या बाद में हो सकता है

Answer 22

पायथन 3, 112 140 बाइट्स

from string import*
p='_'+printable[:62]
def f(s,h,r=''):
 while s[h]in p and h>-1:h-=1
 while h+1<len(s)and s[h]in p:h+=1;r+=s[h]
 return r

0 अनुक्रमित।

सूचकांक से पहले अल्फ़ान्यूमेरिक वर्ण के लिए पीछे की ओर देखता है, फिर इंडेक्स के बाद अंतिम अल्फ़ान्यूमेरिक वर्ण के लिए आगे बढ़ता है। ऐसा करने का शायद एक स्मार्ट तरीका है।

कोशिश करो

Comments

@LeakyNun _जोड़ा गया था, मुझे यकीन नहीं है कि मुझे इसके लिए कोई त्रुटि क्यों मिलेगी f('abc',1)।

— एटलसोलॉजिस्ट

Answer 23

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

s=>n=>s.replace(/\w*/g,(x,y)=>y<n?s=x:0)&&s

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

function(s,n){s.replace(/\w*/g,function(x,y){y<n?s=x:0});alert(s)}

Answer 24

05AB1E , 14 बाइट्स

ð«._DžjмS¡Á2£J

पोर्ट ऑफ @AndersKaseorg का पाइथ उत्तर ।

1-चुनौती परीक्षण के मामलों की तरह अनुक्रमित।

इसे ऑनलाइन आज़माएं या सभी परीक्षण मामलों को सत्यापित करें ।

स्पष्टीकरण:

ð«              # Append a space to the (implicit) input-String
  ._            # Rotate this string the (implicit) input-integer amount of times
                #  towards the left
     D          # Duplicate this string
      žjм       # Remove [a-zA-Z0-9_] from the string
         S¡     # Split the rotated string by each of the remaining characters
           Á    # Rotate the resulting list once towards the right
            2£J # And only leave the first two items, joined together
                # (which is output implicitly)