ఉదాహరణ 1: R లో Grep() ఫంక్షన్‌ని ఉపయోగించి స్ట్రింగ్ నుండి నమూనా యొక్క స్థానాన్ని పొందండి
స్ట్రింగ్ నుండి పేర్కొన్న నమూనా యొక్క స్థానాన్ని సంగ్రహించడానికి, R యొక్క grep() ఫంక్షన్ ఉపయోగించబడుతుంది.
grep('i+', c('fix', 'split', 'corn n', 'paint'), perl=TRUE, value=FALSE)ఇక్కడ, మేము grep() ఫంక్షన్‌ని ఉపయోగిస్తాము, ఇక్కడ “+i” నమూనా స్ట్రింగ్‌ల వెక్టర్‌లో సరిపోలడానికి ఆర్గ్యుమెంట్‌గా పేర్కొనబడింది. మేము నాలుగు స్ట్రింగ్‌లను కలిగి ఉన్న అక్షర వెక్టర్‌లను సెట్ చేసాము. ఆ తర్వాత, మేము 'perl' ఆర్గ్యుమెంట్‌ను TRUE విలువతో సెట్ చేసాము, ఇది R ఒక పెర్ల్ అనుకూల రెగ్యులర్ ఎక్స్‌ప్రెషన్ లైబ్రరీని ఉపయోగిస్తుందని సూచిస్తుంది మరియు మూలకాల సూచికలను తిరిగి పొందడానికి ఉపయోగించే 'FALSE' విలువతో 'విలువ' పరామితి పేర్కొనబడుతుంది. నమూనాతో సరిపోలే వెక్టర్‌లో.
వెక్టార్ అక్షరాల యొక్క ప్రతి స్ట్రింగ్ నుండి “+i” నమూనా స్థానం క్రింది అవుట్‌పుట్‌లో ప్రదర్శించబడుతుంది:
ఉదాహరణ 2: R లో Gregexpr() ఫంక్షన్‌ని ఉపయోగించి సరళిని సరిపోల్చండి
తరువాత, మేము gregexpr() ఫంక్షన్‌ని ఉపయోగించి R లోని నిర్దిష్ట స్ట్రింగ్ పొడవుతో పాటు సూచిక స్థానాన్ని తిరిగి పొందుతాము.
char_vec <- c('PROGRAMMINGLANGUAGE','RSCRIPT')
gregexpr('GRAMM', char_vec, useBytes = TRUE)
ఇక్కడ, మేము 'char_vect' వేరియబుల్‌ని సెట్ చేసాము, అక్కడ స్ట్రింగ్‌లు వేర్వేరు అక్షరాలతో అందించబడతాయి. ఆ తర్వాత, “char_vec”లో నిల్వ చేయబడిన స్ట్రింగ్‌లతో సరిపోలడానికి “GRAMM” స్ట్రింగ్ నమూనాను తీసుకునే gregexpr() ఫంక్షన్‌ని మేము నిర్వచించాము. అప్పుడు, మేము “TRUE” విలువతో useBytes పరామితిని సెట్ చేస్తాము. ఈ పరామితి అక్షరం వారీగా కాకుండా బైట్-బైట్‌గా సరిపోలికను సాధించాలని సూచిస్తుంది.
gregexpr() ఫంక్షన్ నుండి తిరిగి పొందబడిన క్రింది అవుట్‌పుట్ సూచికలు మరియు వెక్టార్ స్ట్రింగ్స్ రెండింటి పొడవును సూచిస్తుంది:
ఉదాహరణ 3: R లో Nchar() ఫంక్షన్‌ని ఉపయోగించి స్ట్రింగ్‌లోని మొత్తం అక్షరాలను లెక్కించండి
కింది వాటిలో మేము అమలు చేసే nchar() పద్ధతి స్ట్రింగ్‌లో ఎన్ని అక్షరాలు ఉన్నాయో గుర్తించడానికి కూడా అనుమతిస్తుంది:
Res <- nchar('ప్రతి అక్షరాన్ని లెక్కించండి')ప్రింట్ (రెలు)
ఇక్కడ, మేము 'Res' వేరియబుల్లో సెట్ చేయబడిన nchar() పద్ధతిని పిలుస్తాము. nchar() పద్ధతి nchar() పద్ధతి ద్వారా లెక్కించబడే దీర్ఘకాల అక్షరాలతో అందించబడుతుంది మరియు పేర్కొన్న స్ట్రింగ్‌లోని కౌంటర్ అక్షరాల సంఖ్యను అందిస్తుంది. అప్పుడు, మేము nchar() పద్ధతి యొక్క ఫలితాలను చూడటానికి “Res” వేరియబుల్‌ను ప్రింట్() పద్ధతికి పాస్ చేస్తాము.
పేర్కొన్న స్ట్రింగ్‌లో 20 అక్షరాలు ఉన్నాయని చూపే కింది అవుట్‌పుట్‌లో ఫలితం పొందబడింది:
ఉదాహరణ 4: R లోని సబ్‌స్ట్రింగ్() ఫంక్షన్‌ని ఉపయోగించి స్ట్రింగ్ నుండి సబ్‌స్ట్రింగ్‌ను సంగ్రహించండి
మేము స్ట్రింగ్ నుండి నిర్దిష్ట సబ్‌స్ట్రింగ్‌ను సంగ్రహించడానికి “ప్రారంభం” మరియు “ఆపు” ఆర్గ్యుమెంట్‌లతో సబ్‌స్ట్రింగ్() పద్ధతిని ఉపయోగిస్తాము.
str <- సబ్‌స్ట్రింగ్('ఉదయం', 2, 4)ముద్రణ (str)
ఇక్కడ, మనకు “str” వేరియబుల్ ఉంది, ఇక్కడ సబ్‌స్ట్రింగ్() పద్ధతిని పిలుస్తారు. సబ్‌స్ట్రింగ్() పద్ధతి “మార్నింగ్” స్ట్రింగ్‌ను మొదటి ఆర్గ్యుమెంట్‌గా తీసుకుంటుంది మరియు స్ట్రింగ్ నుండి రెండవ క్యారెక్టర్‌ని ఎక్స్‌ట్రాక్ట్ చేయాలని సూచించే “2” విలువ రెండవ ఆర్గ్యుమెంట్‌గా తీసుకుంటుంది మరియు “4” ఆర్గ్యుమెంట్ విలువ దానిని సూచిస్తుంది నాల్గవ పాత్రను సంగ్రహించాలి. సబ్‌స్ట్రింగ్() పద్ధతి పేర్కొన్న స్థానానికి మధ్య ఉన్న స్ట్రింగ్ నుండి అక్షరాలను సంగ్రహిస్తుంది.
కింది అవుట్‌పుట్ స్ట్రింగ్‌లోని రెండవ మరియు నాల్గవ స్థానానికి మధ్య ఉన్న సంగ్రహించిన సబ్‌స్ట్రింగ్‌ను ప్రదర్శిస్తుంది:
ఉదాహరణ 5: R లోని పేస్ట్() ఫంక్షన్‌ని ఉపయోగించి స్ట్రింగ్‌ను సంగ్రహించండి
R లోని పేస్ట్() ఫంక్షన్ స్ట్రింగ్ మానిప్యులేషన్ కోసం కూడా ఉపయోగించబడుతుంది, ఇది డీలిమిటర్‌లను వేరు చేయడం ద్వారా పేర్కొన్న స్ట్రింగ్‌లను సంగ్రహిస్తుంది.
msg1 <- 'కంటెంట్'msg2 <- 'వ్రాయడం'
పేస్ట్ (msg1, msg2)
ఇక్కడ, మేము వరుసగా “msg1” మరియు “msg2” వేరియబుల్స్‌కు స్ట్రింగ్‌లను నిర్దేశిస్తాము. అప్పుడు, అందించిన స్ట్రింగ్‌ను ఒకే స్ట్రింగ్‌గా కలపడానికి R యొక్క పేస్ట్() పద్ధతిని ఉపయోగిస్తాము. పేస్ట్() పద్ధతి స్ట్రింగ్స్ వేరియబుల్‌ను ఆర్గ్యుమెంట్‌గా తీసుకుంటుంది మరియు స్ట్రింగ్‌ల మధ్య డిఫాల్ట్ స్పేస్‌తో సింగిల్ స్ట్రింగ్‌ను అందిస్తుంది.
పేస్ట్() పద్ధతిని అమలు చేసిన తర్వాత, అవుట్‌పుట్ దానిలోని ఖాళీతో ఒకే స్ట్రింగ్‌ను సూచిస్తుంది.
ఉదాహరణ 6: R లోని సబ్‌స్ట్రింగ్() ఫంక్షన్‌ని ఉపయోగించి స్ట్రింగ్‌ని సవరించండి
ఇంకా, కింది స్క్రిప్ట్‌ని ఉపయోగించి సబ్‌స్ట్రింగ్() ఫంక్షన్‌ని ఉపయోగించి స్ట్రింగ్‌లో సబ్‌స్ట్రింగ్ లేదా ఏదైనా అక్షరాన్ని జోడించడం ద్వారా కూడా మేము స్ట్రింగ్‌ను అప్‌డేట్ చేయవచ్చు:
str1 <- 'హీరోలు'సబ్‌స్ట్రింగ్(str1, 5, 6) <- 'ic'
పిల్లి(' మాడిఫైడ్ స్ట్రింగ్:', str1)
మేము 'హీరోస్' స్ట్రింగ్‌ను 'str1' వేరియబుల్లో సెట్ చేసాము. అప్పుడు, సబ్‌స్ట్రింగ్ యొక్క “స్టార్ట్” మరియు “స్టాప్” ఇండెక్స్ విలువలతో పాటు “str1” పేర్కొనబడిన సబ్‌స్ట్రింగ్() పద్ధతిని మేము అమలు చేస్తాము. సబ్‌స్ట్రింగ్() పద్ధతి 'iz' సబ్‌స్ట్రింగ్‌తో కేటాయించబడుతుంది, ఇది ఇచ్చిన స్ట్రింగ్ కోసం ఫంక్షన్‌లో పేర్కొన్న స్థానంపై ఉంచబడుతుంది. ఆ తర్వాత, మేము నవీకరించబడిన స్ట్రింగ్ విలువను సూచించే R యొక్క cat() ఫంక్షన్‌ని ఉపయోగిస్తాము.
స్ట్రింగ్‌ని ప్రదర్శించే అవుట్‌పుట్ సబ్‌స్ట్రింగ్ () పద్ధతిని ఉపయోగించి కొత్త దానితో అప్‌డేట్ చేయబడింది:
ఉదాహరణ 7: R లోని ఫార్మాట్() ఫంక్షన్‌ని ఉపయోగించి స్ట్రింగ్‌ను ఫార్మాట్ చేయండి
అయినప్పటికీ, R లోని స్ట్రింగ్ మానిప్యులేషన్ ఆపరేషన్‌లో స్ట్రింగ్‌ను తదనుగుణంగా ఫార్మాట్ చేయడం కూడా ఉంటుంది. దీని కోసం, మేము స్ట్రింగ్‌ను సమలేఖనం చేయగల ఫార్మాట్() ఫంక్షన్‌ని ఉపయోగిస్తాము మరియు నిర్దిష్ట స్ట్రింగ్ యొక్క వెడల్పును సెట్ చేస్తాము.
ప్లేస్‌మెంట్1 <- ఫార్మాట్('ప్రోగ్రామ్‌లు', వెడల్పు = 10, జస్టిఫై = 'ఎల్')ప్లేస్‌మెంట్2 <- ఫార్మాట్('ప్రోగ్రామ్‌లు', వెడల్పు = 10, జస్టిఫై = 'ఆర్')
ప్లేస్‌మెంట్3 <- ఫార్మాట్('ప్రోగ్రామ్‌లు', వెడల్పు = 10, జస్టిఫై = 'సి')
ప్రింట్ (ప్లేస్‌మెంట్1)
ప్రింట్ (ప్లేస్‌మెంట్2)
ప్రింట్ (ప్లేస్‌మెంట్3)
ఇక్కడ, మేము ఫార్మాట్() పద్ధతితో అందించబడిన “ప్లేస్‌మెంట్1” వేరియబుల్‌ని సెట్ చేసాము. మేము ఫార్మాట్() పద్ధతికి ఫార్మాట్ చేయడానికి “ప్రోగ్రామ్‌లు” స్ట్రింగ్‌ను పాస్ చేస్తాము. వెడల్పు సెట్ చేయబడింది మరియు స్ట్రింగ్ యొక్క అమరిక 'జస్టిఫై' ఆర్గ్యుమెంట్ ఉపయోగించి ఎడమవైపుకి సెట్ చేయబడింది. అదేవిధంగా, మేము “ప్లేస్‌మెంట్2” మరియు “ప్లేస్‌మెంట్2” అనే మరో రెండు వేరియబుల్‌లను సృష్టిస్తాము మరియు అందించిన స్ట్రింగ్‌ను తదనుగుణంగా ఫార్మాట్ చేయడానికి ఫార్మాట్() పద్ధతిని వర్తింపజేస్తాము.
అవుట్‌పుట్ ఎడమ, కుడి మరియు మధ్య అమరికలతో సహా క్రింది చిత్రంలో ఒకే స్ట్రింగ్ కోసం మూడు ఫార్మాటింగ్ శైలులను ప్రదర్శిస్తుంది:
ఉదాహరణ 8: స్ట్రింగ్‌ను R లో లోయర్ మరియు అప్పర్ కేస్‌లుగా మార్చండి
అదనంగా, మేము క్రింది విధంగా tolower() మరియు toupper() ఫంక్షన్‌లను ఉపయోగించి స్ట్రింగ్‌ను లోయర్ కేస్ మరియు అప్పర్ కేస్‌లో కూడా మార్చవచ్చు:
s1 <- 'మంచి ఆహారం మంచి జీవితం'ఫలితం1 <- tolow(s1)
ప్రింట్ (ఫలితం1)
s2 <- 'ది ఆర్ ప్రోగ్రామింగ్ లాంగ్వేజ్ ఇన్'
ఫలితం2 <- టప్పర్(s2)
ప్రింట్ (ఫలితం2)
ఇక్కడ, మేము పెద్ద మరియు చిన్న అక్షరాలను కలిగి ఉన్న స్ట్రింగ్‌ను అందిస్తాము. ఆ తరువాత, స్ట్రింగ్ 's1' వేరియబుల్లో ఉంచబడుతుంది. అప్పుడు, మేము tolower() పద్ధతిని పిలుస్తాము మరియు స్ట్రింగ్‌లోని అన్ని అక్షరాలను చిన్న అక్షరంలో మార్చడానికి దానిలోని “s1” స్ట్రింగ్‌ను పాస్ చేస్తాము. అప్పుడు, మేము 'ఫలితం1' వేరియబుల్లో నిల్వ చేయబడిన tolower() పద్ధతి యొక్క ఫలితాలను ముద్రిస్తాము. తరువాత, మేము 's2' వేరియబుల్లో మరొక స్ట్రింగ్‌ని సెట్ చేసాము, ఇది చిన్న అక్షరాలలో అన్ని అక్షరాలను కలిగి ఉంటుంది. మేము ఇప్పటికే ఉన్న స్ట్రింగ్‌ను పెద్ద అక్షరంలోకి మార్చడానికి ఈ “s2” స్ట్రింగ్‌కు toupper() పద్ధతిని వర్తింపజేస్తాము.
అవుట్‌పుట్ కింది చిత్రంలో పేర్కొన్న సందర్భంలో రెండు స్ట్రింగ్‌లను ప్రదర్శిస్తుంది:
ముగింపు
స్ట్రింగ్ మానిప్యులేషన్‌గా సూచించబడే స్ట్రింగ్‌లను నిర్వహించడానికి మరియు విశ్లేషించడానికి మేము వివిధ మార్గాలను నేర్చుకున్నాము. మేము స్ట్రింగ్ నుండి పాత్ర యొక్క స్థానాన్ని సంగ్రహించాము, విభిన్న స్ట్రింగ్‌లను సంగ్రహించాము మరియు స్ట్రింగ్‌ను పేర్కొన్న కేస్‌గా మార్చాము. అలాగే, మేము స్ట్రింగ్‌ను ఫార్మాట్ చేసాము, స్ట్రింగ్‌ను సవరించాము మరియు స్ట్రింగ్‌ను మార్చటానికి ఇక్కడ అనేక ఇతర కార్యకలాపాలు నిర్వహించబడతాయి.