Wie Lücke zwischen zwei Zeichen mit Regex zu füllen

Question

Ich habe einen Datensatz wie folgt. Ich möchte alle Punkte zwischen zwei 1 durch 1 ersetzen, wie im gewünschten Ergebnis gezeigt. Kann ich das mit regex in Basis R tun?

Ich habe versucht:

regexpr("^1\\.1$", my.data$my.string, perl = TRUE) 

Hier ist eine Lösung in C# ist

Characters between two exact characters

Sie für alle Anregungen danken.

my.data <- read.table(text=' 
    my.string       state 
    ................1...............1. A 
    ......1..........................1 A 
    .............1.....2.............. B 
    ......1.................1...2..... B 
    ....1....2........................ B 
    1...2............................. C 
    ..........1....................1.. C 
    .1............................1... C 
    .................1...........1.... C 
    ........1....2.................... C 
    ......1........................1.. C 
    ....1....1...2.................... D 
    ......1....................1...... D 
    .................1...2............ D 
', header = TRUE, na.strings = 'NA', stringsAsFactors = FALSE) 

desired.result <- read.table(text=' 
    my.string       state 
    ................11111111111111111. A 
    ......1111111111111111111111111111 A 
    .............1.....2.............. B 
    ......1111111111111111111...2..... B 
    ....1....2........................ B 
    1...2............................. C 
    ..........1111111111111111111111.. C 
    .111111111111111111111111111111... C 
    .................1111111111111.... C 
    ........1....2.................... C 
    ......11111111111111111111111111.. C 
    ....111111...2.................... D 
    ......1111111111111111111111...... D 
    .................1...2............ D 
', header = TRUE, na.strings = 'NA', stringsAsFactors = FALSE) 

Answer 1

Im Folgenden finden Sie eine Option gsub mit den \G Funktion und Lookarounds Behauptungen verwenden.

> gsub('(?:1|\\G(?<!^))\\K\\.(?=\\.*1)', '1', my.data$my.string, perl = TRUE) 
# [1] "................11111111111111111." "......1111111111111111111111111111" 
# [3] ".............1.....2.............." "......1111111111111111111...2....." 
# [5] "....1....2........................" "1...2............................." 
# [7] "..........1111111111111111111111.." ".111111111111111111111111111111..." 
# [9] ".................1111111111111...." "........1....2...................." 
# [11] "......11111111111111111111111111.." "....111111...2...................." 
# [13] "......1111111111111111111111......" ".................1...2............" 

Die \G Merkmal ist ein Anker, der in einer von zwei Positionen übereinstimmen kann; der Anfang der String-Position oder die Position am Ende des letzten Matches. Da Sie die Punkte am Anfang der Zeichenfolgenposition vermeiden möchten, verwenden wir eine Lookaround-Assertion \G(?<!^), um den Anfang der Zeichenfolge auszuschließen.

Die Escape-Sequenz \K setzt den Startpunkt der gemeldeten Übereinstimmung zurück und alle zuvor verbrauchten Zeichen sind nicht mehr enthalten.

Sie können eine allgemeine Aufschlüsselung finden, die den regulären Ausdruck here erklärt.

Answer 2

Hier ist eine Option, die einen relativ einfachen regulären Ausdruck und die Standardkombination von gregexpr(), regmatches() und regmatches<-() zu identifizieren, Extrakt verwendet, betreiben, und dann, dass die Teilzeichen ersetzen regex entsprechen.

## Copy the character vector 
x <- my.data$my.string 
## Find sequences of "."s bracketed on either end by a "1" 
m <- gregexpr("(?<=1)\\.+(?=1)", x, perl=TRUE) 
## Standard template for operating on and replacing matched substrings 
regmatches(x,m) <- sapply(regmatches(x,m), function(X) gsub(".", "1", X)) 

## Check that it worked 
head(x) 
# [1] "................11111111111111111." "......1111111111111111111111111111" 
# [3] ".............1.....2.............." "......1111111111111111111...2....." 
# [5] "....1....2........................" "1...2............................." 

Answer 3

gsubfn Verwendung, das erste Argument ist ein regulärer Ausdruck, der die 1-en übereinstimmt und die Zeichen zwischen dem 1en und fängt den letzteren. Das zweite Argument ist eine Funktion, ausgedrückt in Formelschreibweise, die gsub verwendet mit 1 jedes Zeichen in den erfassten Zeichenfolge zu ersetzen:

library(gsubfn) 
transform(my.data, my.string = gsubfn("1(.*)1", ~ gsub(".", 1, x), my.string)) 

Wenn es dann "1(.*?)1" als regelmäßige Verwendung mehrere Paare von 1en in einer Zeichenfolge sein kann Ausdruck stattdessen.

Visualisierung Der reguläre Ausdruck ist hier einfach genug, dass es direkt hier verstanden werden kann, ist aber ein debuggex Visualisierung anwyays:

1(.*)1 

Debuggex Demo