regex

Question

के साथ दो वर्णों के बीच अंतर को भरने के लिए मेरे पास डेटा जैसा सेट है। वांछित.result में दिखाए गए अनुसार, मैं दो बिंदुओं के बीच 1 के बीच सभी बिंदुओं को प्रतिस्थापित करना चाहता हूं। क्या मैं आधार पर regex के साथ ऐसा कर सकता हूं?

मैंने कोशिश की:

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

यहाँ C#

Characters between two exact characters

किसी भी सुझाव के लिए धन्यवाद में एक समाधान है।

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

नीचे \G सुविधा और lookaround वक्तव्य दिये gsub का उपयोग कर एक विकल्प है।

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

\G सुविधा एक लंगर है कि दो स्थानों में से एक में से मिलान कर सकते है; अंतिम मैच के अंत में स्ट्रिंग स्थिति या स्थिति की शुरुआत। चूंकि ऐसा लगता है कि आप स्ट्रिंग स्थिति की शुरुआत में बिंदुओं से बचना चाहते हैं, इसलिए हम स्ट्रिंग की शुरुआत को बाहर करने के लिए एक लुकराऊ दावे \G(?<!^) का उपयोग करते हैं।

\K भागने अनुक्रम रिपोर्ट किए गए मैच के शुरुआती बिंदु को रीसेट करता है और पहले से उपभोग वाले वर्णों को अब शामिल नहीं किया जाता है।

आप एक समग्र ब्रेकडाउन पा सकते हैं जो नियमित अभिव्यक्ति here बताती है।

Answer 2

यहाँ एक विकल्प एक अपेक्षाकृत सरल regex और gregexpr(), regmatches(), और regmatches<-() के मानक संयोजन की पहचान करने के लिए, निकालने, पर काम करते हैं, और फिर उस regex मिलान सबस्ट्रिंग की जगह उपयोग करता है।

## 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 का उपयोग करना, पहले तर्क के लिए रेगुलर एक्सप्रेशन से मेल खाता है जो 1 है और 1 के बीच वर्ण और बाद कब्जा है।

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

अगर वहाँ 1 के एक से अधिक जोड़े हो सकता है एक स्ट्रिंग में तो नियमित रूप "1(.*?)1" का उपयोग करें: दूसरा तर्क एक समारोह है, सूत्र अंकन, जो gsub का उपयोग करता है 1 साथ कब्जा कर लिया स्ट्रिंग में प्रत्येक चरित्र को बदलने के लिए में व्यक्त किया इसके बजाय अभिव्यक्ति।

दृश्य नियमित अभिव्यक्ति यहाँ काफी सरल है कि यह सीधे समझा जा सकता है, लेकिन यहाँ एक debuggex दृश्य anwyays है:

1(.*)1 

Debuggex Demo