Wenn Sie unter Windows auf einen Text doppelklicken, wird das Wort um den Cursor im Text ausgewählt.

(Diese Funktion hat kompliziertere Eigenschaften, für diese Herausforderung ist jedoch keine Implementierung erforderlich.)

Lassen |Sie zum Beispiel Ihren Cursor in sein abc de|f ghi.

Wenn Sie darauf doppelklicken, wird die Teilzeichenfolge defausgewählt.

Input-Output

Sie erhalten zwei Eingaben: eine Zeichenfolge und eine Ganzzahl.

Ihre Aufgabe ist es, den Wortteilstring der Zeichenfolge um den durch die Ganzzahl angegebenen Index zurückzugeben.

Ihr Cursor kann direkt vor oder direkt nach dem Zeichen in der Zeichenfolge am angegebenen Index stehen.

Wenn Sie direkt zuvor verwenden , geben Sie dies bitte in Ihrer Antwort an.

Spezifikationen (Specs)

Der Index ist garantiert innerhalb eines Wortes, also keine Kantenfälle wie abc |def ghioder abc def| ghi.

Die Zeichenfolge enthält nur druckbare ASCII-Zeichen (von U + 0020 bis U + 007E).

Das Wort „Wort“ wird durch die Regex definiert (?<!\w)\w+(?!\w), wo \wdurch definiert ist [abcdefghijklmnopqrstuvwxyzABCDEFGHIJKLMNOPQRSTUVWXYZ0123456789_], oder „alphanumerische Zeichen in ASCII einschließlich Strich“.

Der Index kann 1-indiziert oder 0-indiziert sein.

Wenn Sie 0-indiziert verwenden, geben Sie dies bitte in Ihrer Antwort an.

Testfälle

Die Testfälle sind 1-indiziert und der Cursor befindet sich direkt hinter dem angegebenen Index.

Die Cursorposition dient nur zu Demonstrationszwecken und muss nicht ausgegeben werden.

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 Bytes

À|diwVp

Probieren Sie es online!

Diese Antwort verwendet eine 1-basierte Indizierung.

Dies könnte kürzer sein, wenn wir genau das tun, was der Titel sagt: " Wählen Sie das Wort um den angegebenen Index in einer Zeichenfolge aus". Wir könnten

À|viw

Was das Wort buchstäblich auswählt, aber leider die Ausgabe überhaupt nicht verändert. Wir brauchen also eine kleine Umgehung, um es zum Laufen zu bringen, indem wir es in ein Register schneiden, den Rest des Textes löschen und das Register dann wieder einfügen.

Erläuterung:

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

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

Erwartet, dass die Eingabe für stdin der auf 0 basierende Index gefolgt von einem Leerzeichen oder einer neuen Zeile, gefolgt von der Zeichenfolge, ist. Die maximale Länge eines Wortes beträgt 99 Zeichen. Z.B:

2 abc def

C (gcc) 94 Bytes

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

Nullindexiert, definiert eine Funktion, die zuerst den Index und dann die Zeichenfolge verwendet.

Netzhaut, 22

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

Probieren Sie es online! oder überprüfen Sie alle Testfälle . Das reguläre Programm setzt den Cursor auf unary, gefolgt von einer neuen Zeile und der Zeichenfolge. Die Testsuite verfügt über zusätzlichen Code, der im zeilenweisen Modus ausgeführt werden kann. \Als Begrenzer wird ein und zur Vereinfachung ein Dezimalzeichen verwendet.

Verwendet Bilanzgruppen, um die Cursorposition zu finden, und fährt dann bis zu einer Wortgrenze zurück. Löscht den Text bis zum Wort und anschließend nach dem Wort.

C 115 Bytes

Die Funktion f()benötigt den String und den Index (1-indiziert) als Parameter und gibt das Ergebnis an stdout aus. Der Cursor sollte nach dem angegebenen Zeichen stehen.

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*/)

Schneiden Sie einfach die Zeichenfolge an der Cursorposition (die vor dem mit 0 indizierten Zeichen liegt, was genauso funktioniert wie nach dem mit 1 indizierten Zeichen) und extrahieren und verketten Sie dann die benachbarten Wortfragmente. Gibt sogar dann ein sinnvolles Ergebnis zurück, wenn sich der Cursor am Anfang, Ende oder bei weitem nicht in der Nähe eines Wortes befindet.

Java 8, 86 78 Bytes

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

Ungolfed mit Testfällen:

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

Teilt die Zeichenfolge durch nicht alphanumerische Zeichen und subtrahiert dann die Länge jeder Teilzeichenfolge plus 1 von der angegebenen Position, bis sie negativ wird. Da sich wiederholende nicht-alphanumerische Zeichen als leere Zeichenfolge dargestellt werden, ist die Subtraktionslogik wesentlich einfacher.

Dieser Code wird nicht ausgiebig getestet, daher würde ich gerne sehen, ob jemand dies brechen kann. Wenn man bedenkt, dass dies Java-Code ist, wie ist dies nicht die längste Antwort hier? : P

Pyth, 16 Bytes

+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

Probieren Sie es online aus

Ruby, 41 31 Bytes

Probieren Sie es online!

-10 Bytes von @MartinEnder

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

Pyke, 19 Bytes

#Q;cjmli<i+s)lttjR@

Probieren Sie es hier aus!

Wird Q;als No-Op verwendet, um sicherzustellen, dass die erste Eingabe korrekt platziert wurde

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

Python 2, 70 66 Bytes

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

Teilt die Zeichenfolge nach Nicht-Worttrennzeichen auf, einmal in der ursprünglichen Zeichenfolge bis zum Cursorindex und dann in der Zeichenfolge, die am Cursorindex beginnt. Gibt das letzte Element der linken Aufteilung plus das erste Element der rechten Aufteilung zurück. Vielen Dank an Leaky Nun für das Speichern von 4 Bytes!

Clojure, 92 Bytes

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

Teilt zuerst die Eingabezeichenfolge an der Position kin zwei Zeichenfolgen auf. Dann finden Sie für diese Zeichenfolgen Vorkommen von "\w+"und geben sie als Liste zurück. Verketten Sie dann das letzte Element der ersten Liste und das erste Element der zweiten Liste.

Sehen Sie es online: 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 Bytes

Woohoo, Lua ist nicht die längste Lösung! Noch ein Byte hinter Python, aber ich weiß nicht, wie ich Golf spielen soll. Indizes basieren auf 1.

Dank @LeakyNun erinnerte mich die Existenz von string.match, 4 Bytes gespeichert

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

Alt 71

Hinweis: Die Erläuterungen basieren immer noch auf dieser, da sie auch für die neue gelten, aber einige zusätzliche Informationen zu enthalten gmatch

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

Erläuterung

Zuerst packen wir die Argumente in gund aus, hweil sie kürzer als sindarg[x]

g,h=...

Dann konstruieren wir unsere Ausgabe, die die Konkatanation des Teils vor und nach dem Cursor darstellt.

Der erste Teil der Zeichenfolge ist

g:sub(1,h)

Wir wollen das Wort am Ende dieses Wortes finden, also benutzen wir die Funktion string.gmatch

:gmatch"[%a_]*$"

Dieses Muster stimmt mit 0..ndem Zeichensatz aus Alphabet + Unterstrich am Ende der Zeichenfolge überein . gmatchGibt einen Iterator auf seiner Übereinstimmungsliste in Form einer Funktion zurück (nach dem Prinzip des Abschlusses), sodass wir ihn einmal ausführen, um den ersten Teil unseres Wortes zu erhalten

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

Wir bekommen den zweiten Teil unseres Wortes auf die gleiche Weise

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

Der einzige Unterschied besteht darin, dass wir nicht angeben müssen, dass eine Übereinstimmung am Anfang der Zeichenfolge (mit [^%a_]*) erfolgen soll, da dies die Übereinstimmung ist, die der Iterator beim ersten Aufruf zurückgibt.

Javascript (mit externer Bibliothek) (168 Bytes)

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

Link zu lib: https://github.com/mvegh1/Enumerable/blob/master/linq.js

Erklärung des Codes: Library akzeptiert einen String, der in ein char-Array zerlegt wird. Es wird einem Objekt zugeordnet, in dem der Index und das Zeichen gespeichert sind. Die Sequenz wird bei jedem Auftreten von "" in Teilsequenzen aufgeteilt. Die Untersequenzen werden gefiltert, indem geprüft wird, ob der Cursorindex im Min- und Max-Index der Untersequenz enthalten ist. Dann nehmen wir die erste Untersequenz. Dann wandeln wir uns zurück in ein Zeichen-Array. Dann verketten wir alle Zeichen mit "" als Trennzeichen. Dann validieren wir gegen das Wort Regex. Dann nehmen wir das erste Spiel.

Perl 6 , 34 Bytes

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

Probieren Sie es online!

Anonymer Codeblock, der Eingaben wie gewohnt entgegennimmt f(n)(string).

Erläuterung:

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

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

Probieren Sie es online!

Ein anderer Ansatz, nur 1 Byte kürzer und 3 Jahre später. Warum nicht?

APL (NARS), 58 Zeichen, 116 Byte

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

⍵ {⍵≤1: ⍵⋄m⍵⋄: ⍺∇⍵-1⋄⍵ + 1} ⍺ finde, wo der String anfängt ... Wie man es benutzt und testet:

  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 Bytes

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

Der Cursor ist 1-indiziert und steht nach dem Zeichen (wie in den Testfällen).

Probieren Sie es online! Oder überprüfen Sie alle Testfälle .

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

Eine Art doofe Lösung, aber ein anderer Ansatz als andere.

Übernimmt die Eingabe $a als 0-basierten Index der Zeichenfolge $n. Dann finden wir die Grenzen unseres Wortes. Obwohl wir das Ende der Zeichenkette noch nicht erreicht haben und / oder immer noch nach Wortzeichen suchen, haben wir ++$a. Dann setzten wir uns wegen der Zaunpfosten $i=$a--. Als nächstes kriechen wir rückwärts und dekrementieren, $abis entweder 0ein Nicht-Wort-Zeichen getroffen wird. Wir schneiden dann die Eingabezeichenfolge auf der Grundlage dieser zwei Abgrenzungen (mit einigen Inkrementen / Dekrementen, um OBOE zu berücksichtigen) und -joinsie zusammen, um das Ergebnis zu erzeugen.

Beispiele

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 Bytes

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

• teilt die Zeichenkette nach Nicht-Wort-Zeichen und merkt sich ihre Position (4 == PREG_SPLIT_OFFSET_CAPTURE). Durchläuft die Wörter, bis die Position erreicht ist.
• PHP-Strings sind 0-indiziert, Cursor vor dem Zeichen, können aber vor oder nach dem Wort stehen

Python 3, 112 140 Bytes

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

Springt rückwärts zum ersten alphanumerischen Zeichen im Index und springt dann vorwärts zum letzten alphanumerischen Zeichen nach dem Index. Es gibt wahrscheinlich einen intelligenteren Weg, dies zu tun.

Versuch es

JavaScript (ES 6), 43 42 Bytes

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

JavaScript (ES 3), 65 Bytes

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

05AB1E , 14 Bytes

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

Hafen von @AndersKaseorg Pyth-Antwort .

1-indiziert wie die Challenge-Testfälle.

Probieren Sie es online aus oder überprüfen Sie alle Testfälle .

Erläuterung:

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