Trong Windows, khi bạn thực hiện bấm đúp vào một văn bản, từ xung quanh con trỏ của bạn trong văn bản sẽ được chọn.

(Tính năng này có các thuộc tính phức tạp hơn, nhưng chúng sẽ không được yêu cầu thực hiện cho thử thách này.)

Ví dụ, hãy để |con trỏ của bạn vào abc de|f ghi.

Sau đó, khi bạn nhấp đúp chuột, chuỗi con defsẽ được chọn.

Đầu ra đầu vào

Bạn sẽ được cung cấp hai đầu vào: một chuỗi và một số nguyên.

Nhiệm vụ của bạn là trả về chuỗi con từ của chuỗi xung quanh chỉ mục được chỉ định bởi số nguyên.

Con trỏ của bạn có thể ở ngay trước hoặc ngay sau ký tự trong chuỗi ở chỉ mục được chỉ định.

Nếu bạn sử dụng ngay trước đó , xin vui lòng ghi rõ trong câu trả lời của bạn.

Thông số kỹ thuật (Thông số kỹ thuật)

Chỉ số được đảm bảo nằm trong một từ, vì vậy không có trường hợp cạnh nào như abc |def ghihoặc abc def| ghi.

Chuỗi sẽ chỉ chứa các ký tự ASCII có thể in (từ U + 0020 đến U + 007E).

Từ "từ" được xác định bởi regex (?<!\w)\w+(?!\w), trong đó \wđược định nghĩa bởi [abcdefghijklmnopqrstuvwxyzABCDEFGHIJKLMNOPQRSTUVWXYZ0123456789_]hoặc "ký tự chữ và số trong ASCII bao gồm cả dấu gạch dưới".

Chỉ mục có thể là 1 chỉ mục hoặc 0 chỉ mục.

Nếu bạn sử dụng chỉ mục 0, vui lòng chỉ định nó trong câu trả lời của bạn.

Tủ thử

Các testcase được lập chỉ mục 1 và con trỏ ở ngay sau chỉ mục được chỉ định.

Vị trí con trỏ chỉ dành cho mục đích trình diễn, sẽ không bắt buộc phải xuất ra.

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

V , 10, 9 7 byte

À|diwVp

Hãy thử trực tuyến!

Câu trả lời này sử dụng lập chỉ mục dựa trên 1.

Điều này có thể ngắn hơn nếu chúng ta thực hiện chính xác những gì tiêu đề nói: " Chọn từ xung quanh chỉ mục đã cho trong một chuỗi". Chúng ta có thể làm

À|viw

Mà theo nghĩa đen là chọn từ, nhưng thật không may, không thay đổi đầu ra. Vì vậy, chúng ta cần một cách giải quyết nhỏ để làm cho nó hoạt động bằng cách cắt nó vào một thanh ghi, xóa phần còn lại của văn bản, sau đó dán thanh ghi lại.

Giải trình:

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

C, 104 byte

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

Dự kiến ​​đầu vào trên stdin là chỉ mục dựa trên 0, theo sau là một khoảng trắng hoặc dòng mới, theo sau là chuỗi. Độ dài tối đa cho một từ là 99 ký tự. Ví dụ:

2 abc def

C (gcc), 94 byte

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

Không có chỉ mục, định nghĩa một hàm lấy chỉ mục, sau đó là chuỗi.

Võng mạc, 22

(1) + ¶ (? <- 1>.) * \ B | \ W. +

Hãy thử trực tuyến! hoặc xác minh tất cả các trường hợp thử nghiệm . Chương trình thông thường nhận vị trí con trỏ trong unary theo sau là một dòng mới và sau đó là chuỗi. Bộ kiểm tra có mã bổ sung để chạy ở chế độ trên mỗi dòng và sử dụng \như một dấu phân cách và nó sử dụng số thập phân để thuận tiện.

Sử dụng các nhóm cân bằng để tìm vị trí con trỏ, sau đó quay lại lên đến một ranh giới từ. Xóa văn bản lên đến từ, và sau đó từ.

C, 115 byte

Hàm f()yêu cầu chuỗi và chỉ mục (1-index) làm tham số và in kết quả ra thiết bị xuất chuẩn. Con trỏ nên sau ký tự được chỉ định.

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

JavaScript (ES6), 57 byte

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

Đơn giản chỉ cần cắt chuỗi tại điểm con trỏ (nằm trước ký tự 0 được lập chỉ mục, hoạt động giống như sau ký tự 1 chỉ mục), sau đó trích xuất và ghép các đoạn từ liền kề. Thậm chí trả về một kết quả hợp lý khi con trỏ ở đầu, cuối hoặc không ở gần một từ.

Java 8, 86 78 byte

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

Ung dung với các trường hợp thử nghiệm:

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

Tách chuỗi bằng các ký tự không chữ và số, sau đó tiếp tục trừ độ dài của mỗi chuỗi con, cộng với 1, từ vị trí đã chỉ định, cho đến khi nó trở thành âm. Vì bất kỳ số không chữ và số lặp lại nào được biểu diễn dưới dạng chuỗi rỗng, logic trừ sẽ dễ dàng hơn đáng kể.

Mã này không được thử nghiệm rộng rãi, vì vậy tôi muốn xem ai đó có thể phá vỡ mã này không. Ngoài ra, xem xét rằng đây là mã Java, làm thế nào đây không phải là câu trả lời dài nhất ở đây? : P

Bình thường, 16 byte

+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

Dùng thử trực tuyến

Ruby, 41 31 byte

Hãy thử trực tuyến!

-10 byte từ @MartinEnder

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

Pyke, 19 byte

#Q;cjmli<i+s)lttjR@

Hãy thử nó ở đây!

Sử dụng Q;như một lệnh cấm để đảm bảo đầu vào đầu tiên được đặt chính xác

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

Python 2, 70 66 byte

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

Tách chuỗi bằng các dấu tách không từ, một lần trên chuỗi gốc lên đến chỉ mục con trỏ, sau đó trên chuỗi bắt đầu ở chỉ mục con trỏ. Trả về phần tử cuối cùng của phần tách trái cộng với phần tử đầu tiên của phần tách phải. Cảm ơn Leaky Nun vì đã tiết kiệm 4 byte!

Clojure, 92 byte

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

Đầu tiên, chia chuỗi đầu vào tại vị trí kthành hai chuỗi. Sau đó, cho các chuỗi này tìm sự xuất hiện của "\w+"và trả về chúng như danh sách. Sau đó nối phần tử cuối cùng của danh sách thứ nhất và phần tử đầu tiên của danh sách thứ hai.

Xem trực tuyến: https://ideone.com/Dk2FIs

JavaScript (ES6), 52 byte

(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>

Lua, 71 67 byte

Woohoo, Lua không phải là giải pháp dài nhất! Vẫn còn một byte phía sau con trăn, nhưng không biết làm thế nào để đánh bại nó. Các chỉ mục là 1 dựa trên.

Cảm ơn @LeakyNun nhắc nhở tôi về sự tồn tại của string.match, đã lưu 4 byte

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

71 tuổi

Lưu ý: các giải thích vẫn dựa trên cái này, bởi vì nó cũng áp dụng cho cái mới, nhưng chứa một số thông tin bổ sung về gmatch

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

Giải trình

Đầu tiên, chúng tôi giải nén các đối số vào gvà hvì chúng ngắn hơnarg[x]

g,h=...

Sau đó, chúng tôi xây dựng đầu ra của chúng tôi, đó là sự sắp xếp của phần trước con trỏ và sau nó.

Phần đầu tiên của chuỗi là

g:sub(1,h)

Chúng tôi muốn tìm từ ở cuối từ này, vì vậy chúng tôi sử dụng chức năng string.gmatch

:gmatch"[%a_]*$"

Mẫu này khớp với 0..nbộ ký tự của bảng chữ cái + dấu gạch dưới ở cuối chuỗi. gmatchtrả về một trình vòng lặp trong danh sách khớp của nó dưới dạng hàm (sử dụng nguyên tắc đóng), vì vậy chúng tôi thực hiện nó một lần để có được phần đầu tiên của từ

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

Chúng tôi có được phần thứ hai của từ của chúng tôi theo cùng một cách

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

Sự khác biệt duy nhất là chúng tôi không phải chỉ định chúng tôi muốn khớp khi bắt đầu chuỗi (sử dụng [^%a_]*), vì đó sẽ là trận đấu được lặp lại bởi iterator khi nó được gọi lần đầu tiên.

Javascript (sử dụng thư viện bên ngoài) (168 byte)

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

Liên kết đến lib: https://github.com/mvegh1/Enumerable/blob/master/linq.js

Giải thích về mã: Thư viện chấp nhận một chuỗi, được phân tích cú pháp thành một mảng char. Nó được ánh xạ tới một đối tượng lưu trữ chỉ mục và char. Trình tự được chia thành các phần sau mỗi lần xuất hiện của "". Các chuỗi con được lọc bằng cách kiểm tra xem chỉ mục con trỏ có được chứa trong chỉ số tối thiểu và tối đa của chuỗi con không. Sau đó, chúng tôi thực hiện lần đầu tiên. Sau đó, chúng tôi chuyển đổi trở lại chỉ là một mảng char. Sau đó, chúng tôi ghép tất cả các ký tự với "" làm dấu phân cách. Sau đó, chúng tôi xác nhận chống lại regex từ. Sau đó, chúng tôi có trận đấu đầu tiên.

Perl 6 , 34 byte

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

Hãy thử trực tuyến!

Codeblock ẩn danh mà mất đầu vào, như f(n)(string).

Giải trình:

->\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

Ruby , 30 byte

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

Hãy thử trực tuyến!

Một cách tiếp cận khác, chỉ ngắn hơn 1 byte và 3 năm sau. Tại sao không?

APL (NARS), 58 ký tự, 116 byte

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

{1: m∊⍨⍵⊃⍺: - 1⋄⍵ + 1} ⍺ tìm nơi bắt đầu chuỗi ... Cách sử dụng và kiểm tra:

  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 

MATL , 16 15 byte

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

Con trỏ là 1 chỉ mục và sau ký tự (như trong các trường hợp thử nghiệm).

Hãy thử trực tuyến! Hoặc xác minh tất cả các trường hợp thử nghiệm .

'\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

PowerShell v3 +, 103 101 byte

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

Một loại giải pháp ngớ ngẩn, nhưng một cách tiếp cận khác với những cách khác.

Lấy đầu vào $alà chỉ số dựa trên 0 của chuỗi $n. Sau đó, chúng tôi tìm thấy ranh giới của từ của chúng tôi. Mặc dù chúng tôi chưa đi đến cuối chuỗi và / hoặc chúng tôi vẫn khớp các ký tự từ, chúng tôi ++$a. Sau đó, vì hàng rào, chúng tôi thiết lập $i=$a--. Tiếp theo, chúng tôi bò về phía sau, giảm dần $acho đến khi nó 0hoặc chúng tôi nhấn một ký tự không phải từ. Sau đó, chúng tôi cắt chuỗi đầu vào dựa trên hai ranh giới đó (với một số tăng / giảm để tính cho OBOE) và -joinkết hợp nó để tạo ra kết quả.

Ví dụ

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

PHP, 98 byte

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

• chia chuỗi bằng các ký tự không phải từ, ghi nhớ vị trí của chúng ( 4== PREG_SPLIT_OFFSET_CAPTURE), lặp qua các từ cho đến khi đạt được vị trí.
• Các chuỗi PHP được lập chỉ mục 0, con trỏ trước ký tự, nhưng có thể là trước hoặc sau từ

Python 3, 112 140 byte

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

Chỉ số 0.

Tìm kiếm ngược về ký tự chữ và số đầu tiên từ chỉ mục, sau đó chuyển tiếp đến ký tự chữ và số cuối cùng sau chỉ mục. Có lẽ có một cách thông minh hơn để làm điều này.

Thử nó

JavaScript (ES 6), 43 42 byte

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

JavaScript (ES 3), 65 byte

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

05AB1E , 14 byte

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

Cảng @AndersKaseorg 's Pyth câu trả lời .

1 - được lập chỉ mục như các trường hợp thử thách.

Hãy thử trực tuyến hoặc xác minh tất cả các trường hợp thử nghiệm .

Giải trình:

ð«              # 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)