How To Make Capital Letter To Small Capital Letter??
How To Make Capital Letter To Small Capital Letter??
example: i am A.I to I AM a.i
below r the program i have done...
Code:
#include<iostream>
#include <cstdlib> // For EXIT_FAILURE and EXIT_SUCCESS
#include <fstream>
#include<string>
using namespace std;
const int MAX=50; // initialize max string size of 50 characters
typedef char StackElement; // define StackElement
typedef char QueueElement; // define QueueElement
class Stack
{
public:
Stack(){top=-1;arr[MAX]=0;} // default stack constructor
void push(StackElement & ch); // push function
StackElement topNpop(); // top and pop functions combined
bool empty() const; // empty function
private:
StackElement arr[MAX]; // define char array
int top; // define int top
};
/*******************************************
FUNCTION: push()
DESCRIPTION: Pushes an element onto the stack
PRECONDITION: Waiting for function call
POSTCONTION: New element character on top of stack
*******************************************/
inline void Stack::push(StackElement & ch)
{
if(top<MAX)
{
top++; // increment top
arr[top]=ch; // push onto stack
}
else
{
cout<<"Stack is full.\n"; // display stack is full
}
}
/*******************************************
FUNCTION: topNpop()
DESCRIPTION: Reads and pops top element off the stack
PRECONDIION: Waiting for function call
POSTCONDITION: One element read and removed fromt he stack
RETURN: Top element from stack
********************************************/
inline StackElement Stack::topNpop()
{
if(top>-1)
{
return(arr[top]); // returns top element
top--; // remove froms stack
}
else
{
cout<<"Stack is empty.\n"; // display stack is empty
return(0);
}
}
/*******************************************
FUNCTION: empty()
DESCRIPTION: returns result value if stack is empty
PRECONDITION: result=false
POSTCONDITION: result may be true or remain false
RETURN: result if true or false
********************************************/
inline bool Stack::empty() const
{
bool result=false; // initialize bool as false
if (top==-1)
{
result=true; // if top is -1 return result true
return(result);
}
else
{
return(result); // else return false
}
}
class Queue // Queue class
{
public:
Queue(){front=0, back=0;arr[MAX]=0;} // Queue default constructor
void addq(QueueElement & ch); // define addq
QueueElement frontNremoveq(); // define frontNremove
private:
QueueElement arr[MAX]; // initialize QueueElement array
int front, back; // initialize int front and back
};
/*******************************************
FUNCTION: addq()
DESCRIPTION: adds an element onto the queue
PRECONDITION: Waiting for element to add
POSTCONDITION: New element now on the queue
********************************************/
inline void Queue::addq(QueueElement &ch)
{
if(front!=(back+1)%MAX)
{
arr[back]=ch; // add element to back of queue
back=(back+1)%MAX;
}
else
{
cerr<<"Error Queue is full\n"; // display queue is full
}
}
/*******************************************
FUNCTION: frontNremoveq()
DESCRIPTION: reads and removes front element from queue
PRECONDITION: front pointing to front of queue
POSTCONDITION: front element is returned and then incremented
********************************************/
inline QueueElement Queue::frontNremoveq()
{
if(front!=back)
{
return(arr[front]); // return front element
front++; // remove front element
}
else
{
cout<<"Queue is empty.\n"; // display queue is empty
return(0);
}
}
/***************************MAIN******************************/
int main()
{
Stack S; // initialize stack
Queue Q; // initialize queue
string s;
int i=0; // initialze int 'i'
char string[MAX]; // initialize char string
bool RESULT=false; // initilize bool RESULT to false
ifstream inside ("palindromeinput.txt");
if (! inside.is_open())
{ cout << "Error opening file"; exit (1); }
while (! inside.eof() )
{
inside.getline (string,100);
cout << string << endl;
}
while(string[i]!=NULL)
{
S.push(string[i]); // push chars individually from string to
Q.addq(string[i]); // stack and queue
i++; // next char
}
while(i>0)
{
if(S.topNpop()==Q.frontNremoveq()) // compare each element from
{ // stack and queue
RESULT=true; // if same for all chars return true
}
else
{
RESULT=false; // if not same for any char break and return false
break;
}
i--;
}
if(RESULT==true)
{
cout<<string<<" is a palindrome\n"; // display if true
}
else
{
cout<<string<<" is not a palindrome\n"; // display if false
}
ofstream outside ("palindromeoutput.txt");
if (outside.is_open())
{
outside << string;
outside<< string;
outside.close();
}
return 0;
}
