Arrays - String variables

ఈ పాఠంలో strings, 1-D arrays, 2-D character arrays, వేరే టైప్ 2-D, 3-D arrays గురుంచి నేర్చుకుందాం.
13.1. String variables

ఇంతకుముందు నేర్చుకున్న పాఠాల్లో, character variables గురించి తెలుసుకున్నాం. కొన్ని character లు కలిస్తే, string అవుతుంది. ఉదాహరణకు, “rama”, “Abhi”, “10 Kelso St”, మొదలైనవి. అంటే పేర్లు,చిరునామాలు, తదితర సమాచారాన్ని స్టోర్ చేసేందుకు, ప్రోసెస్ చేసేందుకు, string variables అవసరమవుతాయి. string variablesను 1-D arrays అని కూడా అనవచ్చు. Array అంటే ఒకే రకమైన మెంబర్లు (elements) ఉండేది. ఈ కింద ఇచ్చిన పద్ధతుల్లో string variablesను declare చేయవచ్చు.

ఇక్కడ ‘X’ను one dimensional character array లేదా string variable అని అంటారు. String Variabl size ఎప్పుడూ positive integer constant గా మాత్రమే ఉండాలి. అంటే, 20 బదులు వేరేదైనా integer నంబరును మాత్రమే ఇవ్వాలి. పైన ఇచ్చిన declaration వల్ల twenty bytes ఉండే memory ‘X’కు allocate అవుతుంది.

పైన చూపిన విధంగా, String Variable size ను symbolic constant ద్వారా కూడా చెప్పవచ్చు. పైన ఇచ్చిన declaration వల్ల కూడా twenty bytes ఉండే memory ‘X’కు allocate అవుతుంది.

3. అంతే కాకుండా, string variable ను declare చేస్తూ దానికి ఒక string constantను కూడా కింద చూపిన విధంగా assign చేయవచ్చు.

పైన ఇచ్చిన declaration వల్ల twenty bytes ఉండే memory ‘X’కు allocate అయి, పై బొమ్మలో చూపినట్లు characters ‘R’, ‘A’, ‘M’ ఒక special character ‘\0’ (null character) ఆ memory లో స్టోర్ అవుతాయి. ఏ string కు అయినా ఈ special character ‘\0’ ఆఖరున add అవుతుంది. దీనిని రాకుండా మనం నియత్రించలేం. పైన ఇచ్చిన declaration వల్ల ‘X’కు ఇచ్చిన twenty bytes లో మొదటి 4 bytes లో meaningful information ( అంటే, ‘R’, ‘A’, ‘M’, ‘\0’) ఉంటుంది, మిగిలిన elements లలో garbage ఉంటుంది.

4. ఈ కింద చూపిన విధంగా కూడా string variable ను declare చేస్తూ దానికి ఒక string constantను assign చేయవచ్చు. ఇక్కడ string size ను symbolic constant తో చెప్పాం.

5. ఈ కింద చూపిన విధంగా కూడా String variableను దాని size ఇవ్వకుండా declare చేస్తూ ఒక “String Constant” కు assign చేయవచ్చు.

పైవిధంగా declare చేసిన string కు దానికి assign చేసిన string constant లో ఉన్నcharacters (null తో కలిపి) స్టోర్ చేసేందుకు ఎంత memory కావాలో అంత memory మాత్రమే allocate అవుతుంది. పైన ఇచ్చిన ఉదాహరణలో 4 bytes మాత్రమే allocate అవుతాయి.

ఈ కింద ఇచ్చిన String variables ను declare చేసేటప్పుడు వాడకూడని పద్ధతులు.
1. char X[-170]; /* Negative size */
2. char X[1.780]; /* Float Array Size */
3. char X[“RAM”]; /* size cannot be string */
4. int n = 20; char X[n]; /* size cannot be a variable */
5. char X[ ]; X = “RAM ”; /* default size is not acceptable */

13.1.1 Input/Output string variables using scanf/printf functions

C లాంగ్వేజీలో arrays names ఒక రకంగా memory ను point చేస్తాయి, అంటే memory address ను indicate చేస్తాయి. అందువల్ల, “scanf ” ద్వారా “String Variables” లోపలికి input తీసుకునేటప్పుడు address operator(&) string variablesకు అప్లై చేయాల్సిన అవసరం లేదు. దీని గురించి pointers chapter లో వివరంగా తెలుసుకుందాం. scanf, printf functions రెండింటిలోనూ string ను రీడ్ లేదా ప్రింట్ చేసేందుకు %s అనేది format string లో వాడుతాం.

ఉదాహరణ 1: ఈ కింది ప్రోగ్రాం scanf(), printf() functions ద్వారా ఒక string ను రీడ్ చేసి ఎలా ప్రింట్ చేయాలో చూపిస్తుంది. ఇక్కడ, %sను వాడి scanf కు ఒక string ను రీడ్ చేయమని చెబుతున్నాం. అది, space లేదా TAB లేదా \n (newline)వచ్చేంతవరకు charactersను తీసుకుంటుంది. అంటే, మనం “Rama is a good boy” అని keyboard నుంచి ఇస్తే Rama మాత్రమే తీసుకొని scanf() లో ఇచ్చిన string variableలో స్టోర్ చేస్తుంది. అలాగే, “Rama” ఇస్తే Rama ను తీసుకుంటుంది. అంతేకాకుండా ఎన్ని characters తీసుకుంటుంది అనేది string variable size మీద ఆధారపడి ఉంటుంది; keyboard నుంచి string declare చేసిన size - 1 కంటే ఎక్కువ characters ఎప్పుడూ తీసుకోదు.

#include
int main()
{
char x[20];
printf(“Enter a string\n”);
scanf(“%s”, x);
printf(“%s”, x);
return (0);
}
పైన ఇచ్చిన ప్రోగ్రాం రన్ చేసినప్పుడు కంప్యూటరు మీద ఇలా ఉంటుంది.

ఉదాహరణ 2: ఈ ప్రోగ్రాం ఒక line full of text ను keyboard నుంచి ఒక string variable లోపలికి తీసుకుని దానినే ప్రింట్ చేస్తుంది. ఇక్కడ scanf() format stringలో %[^\n] అనే దాన్ని line full of text ను keyboard నుంచి రీడ్ చేయమని చెప్పేందుకు వాడుతున్నాం. ఇక్కడ, %[^\n] దాని అర్ధం, scanf కు newline(enter or return key) ను కీబోర్డు నుంచి user ప్రెస్ చేసేంతవరకు characters ను తీసుకోమని చెబుతున్నట్లు అర్థం. అలాగే, మనం ఒక specified character ఇచ్చేంతవరకు charactersను తీసుకోమని చెప్పడానికి ఇలాంటి format string ను వాడవచ్చు. ఉదాహరణకు, character g ఇచ్చేటంతవరకు charactersను తీసుకోమని చెప్పడానికి format string %[^g]ను వాడతాం. ఇలాంటి format string, printf functionలో వాడలేం. కానీ, %s తోనే మనం రీడ్ చేసిన line full of textను printf తో ప్రింట్ చేయవచ్చు.

#include
int main()
{
char x[80];
printf(“Enter a series of characters followed by enter key\n”);
scanf(“%[^\n]”, x);
printf(“%s\n”, x);
return (0);
}
పైన ఇచ్చిన ప్రోగ్రాంను రన్ చేసినప్పుడు కంప్యూటరు మీద ఇలా ఉంటుంది.

13.1.2 Manipulating Strings As a whole

Strings ను ప్రోసెస్ చేయడానికి చాలా readymade function లు ఉన్నాయి. వాటిని వాడాలంటే ముందుగా string.h ను మన ప్రోగ్రాంలో include చేయాలి. ఉదాహరణకు, strlen అనే function ఒక string తీసుకొని దానిలో ఉన్న characters (null character కాకుండా) ఎన్నో ఇస్తుంది.

ఉదాహరణ 3: ఈ ప్రోగ్రాం strlen అనే functionను ఎలా వాడాలో తెలుపుతుంది. ఈ function లోపలికి, ఒక string ను పంపాలి, అంటే string variable లేదా string constant ఏదైనా పంపవచ్చని చెప్పడమే ఈ ప్రోగ్రాం ముఖ్య ఉద్దేశం.

#include
#include
int main()
{
int i, j, k;
char x[80], y[20]= “Ram”;
printf(“Enter a string \n”);
scanf(“%s”, x);
i = strlen(x);
j = strlen(y);
k = strlen(“Ram”);
printf(“%d%d%d\n”, i, j, k);
return (0);
}

పైన ఇచ్చిన ప్రోగ్రాం రన్ చేసినప్పుడు కంప్యూటరు మీద ఇలా ఉంటుంది.

Function strcpy: ఒక string లో ఉండే character లను వేరొకదానిలోకి కాపీ చేయడానికి, strcpyను వాడతాం. దీనికి మనం రెండు stringలు ఇస్తే రెండో దానిలో ఉండే characters మొదటి దాని లోపలికి కాపీ చేస్తుంది. దీనిని ఈ కింద చూపిన విధంగా వాడుతాం .

ఉదాహరణ 4: ఈ ప్రోగ్రాం కొన్ని stringలను రీడ్ చేసి, వాటిలో పెద్ద string నుప్రింట్ చేస్తుంది.
Solution: మొదటగా ఎన్ని stringలు input గా ఇవ్వాలని అనుకుంటున్నారో, అది n అనే variable లోపలికి రీడ్ చేస్తాం. ఆ తర్వాత, n సార్లు రన్ అవుతూ ప్రతీసారీ ఒక string ను రీడ్ చేసేటట్లు ఒక లూప్ ను రాశాం. తీసుకున్న string length ను max అనే variableతో పోల్చిచూస్తాం. అది max కంటే ఎక్కువ అయితే దానిని max కు ఇచ్చి, ఇచ్చిన string ను ఇంకో string variable(y)లో strcpy function సహాయంతో స్టోర్ (copy) చేస్తాం. లూప్ లోనుంచి బయటకు వచ్చిన తర్వాత, y లో ఉన్న ఫలితం ను ప్రింట్ చేస్తాం.

#include
#include
int main()
{
char x[80],y[80];
int i, n, m, max = 0;
printf(“Enter number of strings\n”);
scanf(“%d”, &n);
i=0;
while(i {
printf(“Enter a string \n”);
scanf(“%s”, x);
m = strlen(x);
if(m>max)
{
max = m;
strcpy(y,x);
}
i++;
}
printf(“\n\nLargest String=%s\n”,y);
return (0);
}
ఈ కింద ఇచ్చిన పట్టిక, ఈ ప్రోగ్రాం ఎలా పని చేస్తుందో విశదీకరిస్తుంది.

చివరగా Ravin ప్రింట్ అవుతుంది.
పైన ఇచ్చిన ప్రోగ్రాం రన్ చేసినప్పుడు కంప్యూటరు మీద ఇలా ఉంటుంది.

Function strcmmp: రెండు stringలను పోల్చిచూసేందుకు దీనిని ఉపయోగిస్తాం.. దీనికి మనం రెండు stringలు ఇస్తే ఇది మనకు ఒక integerను ఇస్తుంది. మనం పంపిన string లు రెండూ ఒకటే అయితే సున్నా ఇస్తుంది, అలాకాకుండా మొదటిది dictionary order ప్రకారం ముందువస్తే negative సంఖ్య రిజల్ట్ ఇస్తుంది, లేదా positive సంఖ్య ఇస్తుంది. దీనిని కింద చూపిన విధంగా వాడతాం.

ఉదాహరణ 5: ఈ ప్రోగ్రాం కొన్ని string లను రీడ్ చేసి, వాటిలో dictionary order ప్రకారం ముందువచ్చే string ను ప్రింట్ చేస్తుంది.
Solution: దీనిలోకూడా, మొదటగా ఎన్ని string లు inputగా ఇవ్వాలనుకుంటున్నారో, అది n అనే variable లోపలికి రీడ్ చేస్తాం. ఆ తర్వాత, n సార్లు రన్ అవుతూ ప్రతీసారీ ఒక string ను రీడ్ చేసేటట్లు ఒక లూప్ ను రాశాం. మొదటసారి (i=0 అయినప్పుడు) తీసుకొన్న stringను y లోపలికి కాపీ చేశాం. ఆ తర్వాత తీసుకొన్న ప్రతీ stringను y తో పోల్చిచూస్తే అది dictionary order ప్రకారం ముందు వస్తే దానిని y లోపలికి strcpy function సహాయంతో స్టోర్(copy) చేస్తాం. లూప్ లోనుంచి బయటకు వచ్చిన తర్వాత, yను ఉన్న ఫలితం ను ప్రింట్ చేస్తాం..

#include
#include
int main()
{
char x[80], y[80];
int i, n;
printf(“Enter number of strings\n”);
scanf(“%d”, &n);
for(i=0;i {
printf(“Enter a string\n”);
scanf(“%s”, x);
if(i==0||(strcmp(y,x)>0)) strcpy(y,x);
}
printf(“\n\nResult=%s\n”, y);
return (0);
}

ఈ కింద ఇచ్చిన పట్టిక, ఈ ప్రోగ్రాం ఎలా పని చేస్తుందో విశదీకరిస్తుంది.

చివరిగా Abhinav ప్రింట్అవుతుంది.
పైన ఇచ్చిన ప్రోగ్రాం రన్ చేసినప్పుడు కంప్యూటరు మీద ఇలా ఉంటుంది.

13.1.3 Manipulating Strings Character by Character

ఇంతకు ముందు చెప్పినట్లుగా, string variable లో character లు elements గా ఉంటాయి. మనం string variables ను character (element) స్థాయుల్లో కూడా ప్రోసెస్ చేయవచ్చు. X అనేది ఒక string variable అయితే ‍X[0], X[1], X[2], మొదలైన వాటిని అందులో ఉండే first, second, and third charactersగా చెప్పవచ్చు. మొదటి element index ఎప్పుడైనా 0 గా ఉంటుంది. దీనిని మనం మార్చలేం.

ఉదాహరణ 6: ఈ కింది ప్రోగ్రాం strlen() function వాడకుండా ఇచ్చిన string length ను ప్రింట్ చేస్తుంది.
Solution: ఒక string రీడ్ చేసి, ఒక్కో character ను null character వచ్చే వరకు ఒక లూప్ వాడి traverse చేస్తాం. ఆఖరున, loop control variable i విలువ string length ను చూపిస్తుంది. దాన్ని ప్రింట్ చేస్తాం.

#include
int main()
{
char x[20];
int i;
printf(“Enter a string\n”);
scanf(“%s”, x);
i=0;
while(x[i]!=’\0’)
{
i++;
}
printf(“Length=%d\n”, i);
return (0);
}
మనం RAMA ను input గా ఇస్తే పై ప్రోగ్రాంలోని లూప్ ఎలా రన్ అవుతుందో కింద ఇచ్చాం.

పైన ఇచ్చిన ప్రోగ్రాం రన్ చేసినప్పుడు కంప్యూటరు మీద ఇలా ఉంటుంది.

ఉదాహరణ 7: ఈ కింది ప్రోగ్రాం, మనం ఇచ్చిన stringలో ఎన్ని “Vowels” ఉన్నాయో ప్రింట్ చేస్తుంది.
Solution: ఒక string రీడ్ చేసి, ఒక్కో characterను null characterవచ్చే వరకు ఒక లూప్ వాడి traverse చేస్తాం. ప్రతీ character ను toupper function వాడి upper case లోనికి convert చేసి switch ద్వారా Vowel అవుతుందేమో చెక్ చేసి, అయితే n విలువను ఒకటి పెంచుతాం. లూప్ లోపలి నుంచి బయటకు వచ్చిన తర్వాత, n విలువను ప్రింట్ చేస్తాం.

#include
#include
int main()
{
char x[20];
int i, n = 0;
printf(“Enter a string\n”);
scanf(“%s”, x);
i=0;
while(x[i]!=’\0’)]
{
switch(toupper(x[i])){
case ‘A’:
case ‘E’:
case ‘I’:
case ‘O’:
case ‘U’: n++;
break;
}
i++;
}
printf(“No of Vowels=%d\n”, n);
return (0);
}

పైన ఇచ్చిన ప్రోగ్రాం రన్ చేసినప్పుడు కంప్యూటరు మీద ఇలా ఉంటుంది.

ఉదాహరణ 8: ఈ ప్రోగ్రాం ఒక string ను రీడ్ చేసి అది “Palindrome” అయితే Yes అని లేకుంటే No అని ప్రింట్ చేస్తుంది.
Solution: Palindrome string అంటే దాని reverse దానిలాగే ఉంటుంది. ఉదాహరణలు: “deed”, “madam”, “malayalam”. దీనిని మనం ఇలా చేద్దాం. ఫస్ట్ characterను చివరి character తో పోల్చిచూస్తాం. అవి రెండూ ఒకటే అయితే రెండో character ను చివరి character కు ముందు ఉండే character తో పోల్చిచూస్తాం., అవి రెండూ కూడా ఒకటే అయితే next వాటిని పోల్చిచేస్తాం. ఎప్పుడైనా ఇలా మనం తీసుకొన్న ఏ రెండు character లు అయినా ఒకేలాంటివి కానట్లయితే అది Palindrome కాదని అక్కడే చెబుతాం. String length n అయితే, n/2 character pairsను పోల్చిచూసుకోవాలి. అన్నీ మ్యాచ్అయితే, string ను Palindrome అని చెబుతాం.

#include
#include
int main()
{
char x[20];
int i, j, n;

printf(“Enter a string\n”);
scanf(“%s”, x);

/*checking whether given string is palindrome or not*/
n = strlen(x);
i=0;
j=n-1;
while(i {
if(x[i]!= x[j]) break;
i++;
j--;
}
(i==n/2)?printf(“Yes\n”): printf(“No\n”);
return (0);
}

ఉదాహరణకు ఈ కింద ఇచ్చిన ప్రోగ్రాం tracingలను గమనించండి. రెండింటిలోనూ అన్ని (2) character pairs మ్యాచ్అవుతున్నాయి కాబట్టి ఇచ్చింది Palindrome అని వస్తుంది.

పైన ఇచ్చిన ప్రోగ్రాం రన్ చేసినప్పుడు కంప్యూటరు మీద ఇలా ఉంటుంది.

13.1.4 Processing Line Full of Text

ఉదాహరణ 9: ఈ ప్రోగ్రాం ఒక line full of text ను రీడ్ చేసి దానిలో ఎన్ని పదాలు ఉన్నాయో ప్రింట్ చేస్తుంది.
Solution: ఒక పదంలో దాని చివరి character తర్వాత space అయినా TAB అయినా \0 అయినా ఉండవచ్చు. ఈ logicను ఉపయోగిస్తూ ఇచ్చిన stringను traverse చేస్తూ ఎన్ని పదాలున్నాయో కనుగొందాం. ఇక్కడ space function ను వాడతాం. ఒక non-space character, దాని పక్కన space character (లేదా null) ఉంటే అది word ending. అప్పుడు ఒక variable, nw, విలువను ఒకటి పెంచుతాం. చివరిలో, nw విలువ ఇచ్చిన లైనులో ఎన్ని పదాలున్నాయో తెలుపుతుంది.

#include
#include
int main()
{
char x[80];
int i, nw=0;
printf(“Enter a line full of text \n”);
scanf(“%[^\n]”, x);
i=0;
while(x[i]!=‘\0’)
{
if((!isspace(x[i]))&&(isspace(x[i+1])||(x[i+1]==‘\0’))) nw++;
i++;
}
printf(“No of words=%d\n”, nw);
return (0);
}

ఈ కింది పట్టికను పరిశీలిస్తే ఈ ప్రోగ్రాం ఎలా పని చేస్తుందో బాగా అర్ధమవుతుంది. ఈ కింద ఇచ్చిన దాన్ని input గా అనుకుందాం.