స్ట్రింగ్ కోడింగ్‌లో, స్ట్రింగ్ రివర్సల్ అనేది కీలకమైన అంశం. స్ట్రింగ్‌ని తిప్పికొట్టడానికి అనేక పద్ధతులు కూడా ఉన్నాయి, వీటిలో ప్రతిదానికి భిన్నమైన తర్కం ఉంటుంది. ఈ ఆర్టికల్ అనేక విభిన్న విధానాలను ఉపయోగించడానికి స్ట్రింగ్‌ని ఎలా సరిగ్గా రివర్స్ చేయాలో మరియు ఎలాంటి ప్రీసెట్ ఫంక్షన్‌ల అవసరం లేకుండా మరియు రీజనింగ్‌ని చూపుతుంది. స్ట్రింగ్ టెక్నిక్ యొక్క రివర్సల్ ఒక ప్రత్యేకమైన ప్రత్యేకమైన ఇన్పుట్ స్ట్రింగ్‌లో వర్తింపజేసినప్పుడల్లా, వినియోగదారుడు నిర్దిష్ట క్రమంలో సరఫరా చేసే టెక్స్ట్ పూర్తిగా రివర్స్ చేయబడుతుంది. క్రింద ఉన్న సందర్భంలో, C తో స్ట్రింగ్‌ని రివర్స్ చేయడానికి వివిధ ప్రత్యామ్నాయాలు ఉపయోగించబడ్డాయి.
ఈ గైడ్‌ను అమలు చేస్తున్నప్పుడు, మేము వర్చువల్ బాక్స్‌లో కాన్ఫిగర్ చేయబడిన ఉబుంటు 20.04 లైనక్స్ సిస్టమ్‌పై పని చేస్తున్నాము. లైనక్స్ సిస్టమ్‌పై పని చేస్తున్నప్పుడు, మేము టెర్మినల్ షెల్‌లో మా ఇన్‌స్టాలేషన్‌లు మరియు క్వెరీలను ఎక్కువగా చేసేవాళ్లం. అందువల్ల, Ctrl+Alt+T అనే సత్వరమార్గం ద్వారా టెర్మినల్ షెల్‌ను తెరవండి లేదా ఉబుంటు డెస్క్‌టాప్ యొక్క యాక్టివిటీ ఏరియా కింద అప్లికేషన్ సెర్చ్ బార్ ద్వారా శోధించండి. తగిన అప్‌డేట్ ప్రశ్న ద్వారా ముందుగా మీ సిస్టమ్‌ని అప్‌డేట్ చేయడం అవసరం. నవీకరణను అమలు చేయడానికి ప్రస్తుత వినియోగదారు పాస్‌వర్డ్ కోసం ఇది మిమ్మల్ని అడుగుతుంది. అందువల్ల, పాస్‌వర్డ్‌ను జోడించి, ఎంటర్ బటన్ నొక్కండి.
$ sudo apt అప్‌డేట్
ఉబుంటు 20.04 సిస్టమ్‌లో స్ట్రింగ్‌లను రివర్స్ చేసే భావనను వివరించడానికి మేము సి ప్రోగ్రామింగ్ లాంగ్వేజ్‌ను ఉపయోగిస్తున్నందున, ఒకరు తమ ఉబుంటు సిస్టమ్‌లో సి కంపైలర్‌ని ఇన్‌స్టాల్ చేయాలి. అందువల్ల దిగువ ప్రశ్న ద్వారా మీ సిస్టమ్‌లో GCC కంపైలర్‌ని ఇన్‌స్టాల్ చేశారని నిర్ధారించుకోండి.
$ sudo apt gcc ని ఇన్‌స్టాల్ చేయండి
ఉదాహరణ 01: లూప్ కోసం ఉపయోగించడం
GCC కంపైలర్ యొక్క ఇన్‌స్టాలేషన్ మరియు కాన్ఫిగరేషన్ మరియు apt ప్యాకేజీని అప్‌డేట్ చేసిన తర్వాత, అది కొత్త ఫైల్‌ని సృష్టించడానికి మారుతుంది. ఈ ఫైల్ సి రకం ఉండాలి; అందువల్ల, కింది విధంగా new.c ఫైల్‌ను సృష్టించడానికి టచ్ ఆదేశాన్ని ఉపయోగించండి. రివర్స్ స్ట్రింగ్ ప్రోగ్రామ్‌ల అమలు సమయంలో ఇప్పటి నుండి ఈ ఫైల్ మా కోడ్‌లో ఉపయోగించబడుతుంది.
$ కొత్తగా టచ్ చేయండి.c
ఇప్పుడు మీరు మీ ఉబుంటు 20.04 లైనక్స్ సిస్టమ్‌లో అంతర్నిర్మిత నానో ఎడిటర్ ద్వారా ఎడిటింగ్ లేదా కోడింగ్ కోసం ఈ ఫైల్‌ను తెరవవచ్చు. అందువల్ల, అలా చేయడానికి మీ షెల్‌లోని దిగువ సూచనలను ప్రయత్నించండి.
$ నానో కొత్తది.c
ఉబుంటు 20.04 సిస్టమ్ యొక్క GNU నానో ఎడిటర్‌లో కొత్తగా సృష్టించబడిన C- రకం ఫైల్ కొత్తగా తెరవబడింది. దిగువ స్క్రీన్ షాట్ ఇమేజ్‌లో అందించినట్లుగా మీరు ఇందులో C స్క్రిప్ట్ రాయాలి. మీ మంచి అవగాహన కోసం ఈ కోడ్‌ని వివరిద్దాం. కోడ్ ప్రారంభంలో, మేము రెండు లైబ్రరీలను చేర్చాము. లైబ్రరీ stdio.h ఇన్‌పుట్‌లను తీసుకోవడానికి మరియు అవుట్‌పుట్‌లను ప్రదర్శించడానికి ఉపయోగించబడింది మరియు ఇతర లైబ్రరీ string.h మా కోడ్‌లోని అన్ని రకాల స్ట్రింగ్‌లను ఉపయోగించడానికి ఉపయోగించబడింది. స్ట్రింగ్‌ని తిప్పే పని అంతా C కోడ్ యొక్క ప్రధాన () పద్ధతిలో జరుగుతుంది. మేము సైజు 50 ఉన్న క్యారెక్టర్ టైప్ స్ట్రింగ్ స్ట్ర్‌ని ప్రకటించాము. దీని అర్థం 50 కంటే ఎక్కువ అక్షరాలు ఉన్న స్ట్రింగ్‌ను ఈ కోడ్‌లో అలరించలేము. ఆ తరువాత, మేము రెండు పూర్ణాంక-రకం వేరియబుల్స్ ప్రకటించాము. స్ట్రింగ్ స్ట్రింగ్ యొక్క పొడవును సేకరించడానికి వేరియబుల్ l ఉపయోగించబడింది మరియు, లూప్ కోసం వేరియబుల్ I ఇనిషియలైజర్‌గా ఉపయోగించబడుతుంది. అప్పుడు మేము స్ట్రింగ్ వేరియబుల్‌కు విలువను జోడించమని వినియోగదారుకు చెబుతూ షెల్ ఎంటర్ స్ట్రింగ్‌లో టెక్స్ట్‌ను ప్రింట్ చేయడానికి printf స్టేట్‌మెంట్‌ను ఉపయోగించాము. రన్ టైమ్‌లో యూజర్‌ని ఇన్పుట్ చేయడానికి మరియు ఆ విలువను స్ట్రింగ్ స్ట్రర్‌లో సేవ్ చేయడానికి స్కాన్ఎఫ్ () పద్ధతి ఉపయోగించబడింది. ఫంక్షన్ strlen () రన్ టైమ్‌లో యూజర్ జోడించిన స్ట్రింగ్ స్ట్ర్ యొక్క పొడవును తనిఖీ చేయడానికి మరియు దానిని వేరియబుల్ l లో సేవ్ చేయడానికి ఉపయోగించబడింది. అప్పుడు మేము స్ట్రింగ్ స్ట్రర్‌ను రివర్స్ చేయడానికి ఫర్ ఫర్ లూప్‌ను ప్రారంభించాము. స్ట్రింగ్ దిశను రివర్స్ చేయడానికి ఇనిషియలైజర్ I 'వేరియబుల్ l నుండి విలువను తీసుకుంటున్నట్లు మీరు చూడవచ్చు. అప్పుడు అది స్ట్రింగ్ స్ట్రింగ్ అక్షరాలను ఒక్కొక్కటిగా రివర్సల్‌గా ప్రింట్ చేస్తుంది. చివరిలో, ప్రధాన పద్ధతి ముగిసింది. ఈ ఫైల్‌ని Ctrl+S ఉపయోగించి సేవ్ చేయండి మరియు Ctrl+X ద్వారా నిష్క్రమించండి.
ఇప్పుడు కోడ్‌ను కంపైల్ చేయడానికి మరియు దాని అవుట్‌పుట్ కోసం తనిఖీ చేయడానికి సమయం ఆసన్నమైంది. అందువల్ల, క్రింద పేర్కొన్న gcc ప్రశ్న ద్వారా ఫైల్ new.c. పేరుతో సంకలనం జరిగింది.
$ gcc కొత్తది.cసంకలనం విజయవంతం అయినందున, మా కోడ్‌లో లోపం లేదని అర్థం. షెల్‌లోని a.out ప్రశ్న ద్వారా మా ఫైల్‌ను కింది విధంగా అమలు చేద్దాం:
$/కు.బయటకుఅమలు ప్రక్రియ వినియోగదారుని స్ట్రింగ్‌ను జోడించమని అడుగుతుంది. మేము I-Am-Aqsa-Yasin ని జోడించాము మరియు Enter నొక్కాము. కింది లైన్‌లో స్ట్రింగ్ యొక్క రివర్స్‌ను ఇది తిరిగి ఇవ్వడాన్ని మీరు చూడవచ్చు.
ఉదాహరణ 02: మార్పిడిని ఉపయోగించడం
ఈ ఉదాహరణలో, మేము స్ట్రింగ్ క్రమాన్ని రివర్స్ చేయడానికి మార్పిడి పద్ధతిని ఉపయోగిస్తాము. అందువల్ల నానో ఎడిటర్‌ని ఉపయోగించి new.c ఫైల్‌ను ఈ క్రింది విధంగా తెరవండి:
$ నానో కొత్తది.c 
ఇప్పుడు ఫైల్ GNU నానో ఎడిటర్‌లో తెరవబడింది; స్క్రీన్‌షాట్‌లో దిగువ చూపిన స్క్రిప్ట్‌తో మేము కోడ్ ఫైల్‌ను అప్‌డేట్ చేయాలి. కీవర్డ్ #include ఉపయోగించి ముందుగా మా కోడ్‌లో ప్రామాణిక ఇన్పుట్ మరియు అవుట్‌పుట్ హెడర్ ఫైల్‌ను చేర్చాము. మార్పిడి టెక్నిక్ వినియోగం ప్రకారం మేము రివర్స్ () పద్ధతిని నిర్వచించాము. మేము మూడు పూర్ణాంకాల రకం వేరియబుల్స్ కొత్త, I మరియు స్వాప్‌ని ప్రారంభించాము. స్ట్రింగ్ s ఖాళీగా ఉందా లేదా అని తనిఖీ చేయడానికి మొదటి లూప్ ఉపయోగించబడుతుంది. లూప్ కోసం తదుపరిది పునరుక్తి కోసం ఉపయోగించబడుతుంది మరియు దాని శరీరంలో, మేము కొత్త మరియు స్వాప్ వేరియబుల్స్ ఉపయోగించి విలువలను మార్చుకున్నాము. ఇది ఒక n- పొడవు స్ట్రింగ్‌ని తిప్పడానికి కేవలం n/2 రౌండ్లు పడుతుంది. స్ట్రింగ్స్ మార్చుకున్న తర్వాత, రివర్స్డ్ స్ట్రింగ్‌ను చూపించడానికి మీరు మళ్లీ లూప్ చేయాల్సి ఉంటుంది, మా అప్లికేషన్‌లో లూప్ కోసం మూడవ వంతును ఉపయోగించి మేము చేస్తాము. ఫంక్షన్ రివర్స్ () తప్పనిసరిగా లోపలి ప్రధాన ప్రోగ్రామ్ నుండి పిలవబడాలి. ప్రధాన () సందర్భంలో ప్రింట్‌ఎఫ్‌తో మీ సాఫ్ట్‌వేర్ ఏమి చేస్తుందో మీరు పేర్కొన్నారు. ఆ తర్వాత, మీరు యూజర్ ఇన్పుట్ పొందడానికి scanf () ఉపయోగించారు మరియు రివర్స్ () పద్ధతిని ఉపయోగించారు. ఇప్పుడు Ctrl+S ని ఉపయోగించి ఫైల్‌ను మళ్లీ సేవ్ చేయండి మరియు Ctrl+X షార్ట్‌కట్ ద్వారా నానో ఎడిటర్‌ను వదిలి టెర్మినల్ షెల్‌కు తిరిగి వెళ్లండి.
కింది విధంగా ఒక gcc ప్రశ్న ద్వారా ముందుగా కోడ్‌ను కంపైల్ చేయండి.
$ gcc కొత్తది.cఇప్పుడు అదే ./a.out సూచనల కోడ్ ఫైల్‌ను అమలు చేయండి.
$/కు.బయటకుస్ట్రింగ్ విలువను నమోదు చేయమని ఇది మిమ్మల్ని అడుగుతుంది. మేము AqsaYasin ని జోడించాము మరియు దాని రివర్స్ పొందాము.
ఉదాహరణ 03: పునరావృతాన్ని ఉపయోగించడం
ఈ ఉదాహరణలో, వినియోగదారు జోడించిన స్ట్రింగ్‌ను రివర్స్ చేయడానికి మేము పునరావృతాన్ని ఉపయోగిస్తాము. అందువల్ల ఫైల్‌ను మళ్లీ తెరవండి.
$ నానో కొత్తది.c 
ఈ ప్రోగ్రామ్ ప్రింట్ చేస్తుంది ఒక వాక్యాన్ని నమోదు చేయండి: అప్పుడు రివర్స్ () పద్ధతి ఉపయోగించబడుతుంది. ఒక యూజర్ ఇన్పుట్ చేసిన ప్రారంభ అక్షరం ఈ పద్ధతి ద్వారా c లో సేవ్ చేయబడుతుంది. వాదన n (న్యూలైన్) కాకుండా ఏదైనా ఉంటే రివర్స్ () మళ్లీ అమలు చేయబడుతుంది. వినియోగదారు ఎంటర్ కీని నొక్కే వరకు ఈ విధానం కొనసాగుతుంది. వినియోగదారు నొక్కినప్పుడల్లా, రివర్స్ () పద్ధతి టెక్స్ట్‌ను రివర్స్ ఆర్డర్‌లో ప్రింట్ చేస్తుంది. ఫైల్‌ను సేవ్ చేసి మూసివేయండి.
ముందుగా కోడ్‌ను కంపైల్ చేసి, ఆపై మునుపటి ఆదేశాలను ఉపయోగించి ఈ విధంగా అమలు చేయండి:
$ gcc కొత్తది.c$/కు.బయటకు
ఇది మొత్తం స్ట్రింగ్ వాక్యం వలె వినియోగదారు నుండి ఇన్పుట్ తీసుకుందని మరియు ఆ వాక్యం యొక్క క్రమాన్ని రివర్స్ చేయడాన్ని మీరు చూడవచ్చు.
ముగింపు:
చివరగా, స్ట్రింగ్ టైప్ ఇన్‌పుట్‌ను విభిన్న పద్ధతులతో రివర్స్ చేయడం గురించి వివరించడానికి మేము మూడు ఉదాహరణలు చేసాము, ఉదా., లూప్ కోసం ఉపయోగించడం, పునరావృతం చేయడం మరియు స్వాప్ ఉపయోగించడం.