Ten Typ tak ma - O systemach typów na przykładzie TypeScript’aArtur Skowroński
Systemy typów kojarzą się większości programistów z czymś naprawdę ciężkim, mocno akademickim i trudnym do zrozumienia, dodatkowo nie przydatnym w codziennym życiu developera. Postaram się to zmienić, przynajmniej cześciowo. O ile sam nie wierzę że świetna znajomość systemów typów uczyni Cię znacznie bardziej produktywnym, to postaram się rozwiać mit że jest to coś trudnego i niezrozumiałego. W przystępny i interaktywny sposób przedstawię odrobinę “Computer Science” które może pomóc nam zrozumieć dlaczego niektóre rzeczy w używanych przez nas językach są zaprojektowane tak, a nie inaczej.
Przede wszystkim odpowiemy zaś sobie na prawdę - jak bardzo “Typed” TypeScript tak naprawdę jest?
Artur Skowroński – Ten Typ tak ma - O systemach typów na przykładzie TypeScri...Artur Skowroński
Systemy typów kojarzą się większości programistów z czymś naprawdę ciężkim, mocno akademickim i trudnym do zrozumienia, dodatkowo nie przydatnym w codziennym życiu developera. Postaram się to zmienić, przynajmniej cześciowo. O ile sam nie wierzę że świetna znajomość systemów typów uczyni Cię znacznie bardziej produktywnym, to postaram się rozwiać mit że jest to coś trudnego i niezrozumiałego. W przystępny i interaktywny sposób przedstawię odrobinę “Computer Science” które może pomóc nam zrozumieć dlaczego niektóre rzeczy w używanych przez nas językach są zaprojektowane tak, a nie inaczej.
Przede wszystkim odpowiemy zaś sobie na prawdę - jak bardzo “Typed” TypeScript tak naprawdę jest?
Ten Typ tak ma - O systemach typów na przykładzie TypeScript’aArtur Skowroński
Systemy typów kojarzą się większości programistów z czymś naprawdę ciężkim, mocno akademickim i trudnym do zrozumienia, dodatkowo nie przydatnym w codziennym życiu developera. Postaram się to zmienić, przynajmniej cześciowo. O ile sam nie wierzę że świetna znajomość systemów typów uczyni Cię znacznie bardziej produktywnym, to postaram się rozwiać mit że jest to coś trudnego i niezrozumiałego. W przystępny i interaktywny sposób przedstawię odrobinę “Computer Science” które może pomóc nam zrozumieć dlaczego niektóre rzeczy w używanych przez nas językach są zaprojektowane tak, a nie inaczej.
Przede wszystkim odpowiemy zaś sobie na prawdę - jak bardzo “Typed” TypeScript tak naprawdę jest?
Artur Skowroński – Ten Typ tak ma - O systemach typów na przykładzie TypeScri...Artur Skowroński
Systemy typów kojarzą się większości programistów z czymś naprawdę ciężkim, mocno akademickim i trudnym do zrozumienia, dodatkowo nie przydatnym w codziennym życiu developera. Postaram się to zmienić, przynajmniej cześciowo. O ile sam nie wierzę że świetna znajomość systemów typów uczyni Cię znacznie bardziej produktywnym, to postaram się rozwiać mit że jest to coś trudnego i niezrozumiałego. W przystępny i interaktywny sposób przedstawię odrobinę “Computer Science” które może pomóc nam zrozumieć dlaczego niektóre rzeczy w używanych przez nas językach są zaprojektowane tak, a nie inaczej.
Przede wszystkim odpowiemy zaś sobie na prawdę - jak bardzo “Typed” TypeScript tak naprawdę jest?
Data structuresUsing java language and develop a prot.pdfarmyshoes
Data structures:
****Using java language and develop a prototype for a demo program that reads in strings that
look like:
Using the infix to postfix code below:
A = 3; // your code should store A and 3 as a key-value pair
B = 4; // your code should store B and 4 as a key-value pair
A; // your code should now look-up A and then display its value
later we (you) will add the ability to write
Y = A * B + 3;
Y; // your code should show 16
Using this code
// infix.java
// converts infix arithmetic expressions to postfix
// to run this program: C>java InfixApp
import java.io.*; // for I/O
////////////////////////////////////////////////////////////////
class StackX {
private int maxSize;
private char[] stackArray;
private int top;
// --------------------------------------------------------------
public StackX(int s) // constructor
{
maxSize = s;
stackArray = new char[maxSize];
top = -1;
}
// --------------------------------------------------------------
public void push(char j) // put item on top of stack
{
stackArray[++top] = j;
}
// --------------------------------------------------------------
public char pop() // take item from top of stack
{
return stackArray[top--];
}
// --------------------------------------------------------------
public char peek() // peek at top of stack
{
return stackArray[top];
}
// --------------------------------------------------------------
public boolean isEmpty() // true if stack is empty
{
return (top == -1);
}
// -------------------------------------------------------------
public int size() // return size
{
return top + 1;
}
// --------------------------------------------------------------
public char peekN(int n) // return item at index n
{
return stackArray[n];
}
// --------------------------------------------------------------
public void displayStack(String s) {
System.out.print(s);
System.out.print(\"Stack (bottom-->top): \");
for (int j = 0; j < size(); j++) {
System.out.print(peekN(j));
System.out.print(\' \');
}
System.out.println(\" \");
}
// --------------------------------------------------------------
} // end class StackX
////////////////////////////////////////////////////////////////
class InToPost // infix to postfix conversion
{
private StackX theStack;
private String input;
private String output = \"\";
// --------------------------------------------------------------
public InToPost(String in) // constructor
{
input = in;
int stackSize = input.length();
theStack = new StackX(stackSize);
}
// --------------------------------------------------------------
public String doTrans() // do translation to postfix
{
for (int j = 0; j < input.length(); j++) {
char ch = input.charAt(j);
theStack.displayStack(\"For \" + ch + \" \"); // *diagnostic*
switch (ch) {
case \'+\': // it’s + or -
case \'-\':
gotOper(ch, 1); // go pop operators
break; // (precedence 1)
case \'*\': // it’s * or /
case \'/\':
gotOper(ch, 2); // go pop operators
break; // (precedence 2)
case \'(\': // it’s a left paren
theStack.push(.
java write a program to evaluate the postfix expressionthe program.pdfarjuntelecom26
java write a program to evaluate the postfix expression
the program should ask users for input and show the postfix epression and then the result.
and to have a try and catch exception since we have an empty stack
Solution
Postfix.java
import java.util.Scanner;
public class Postfix
{
/**
* Reads and evaluates multiple postfix expressions.
*/
public static void main (String[] args)
{
String expression, again;
int result;
try
{
Scanner in = new Scanner(System.in);
do
{
PostfixEvaluator evaluator = new PostfixEvaluator();
System.out.println (\"Enter a valid postfix expression: \");
expression = in.nextLine();
result = evaluator.evaluate (expression);
System.out.println();
System.out.println (\"That expression equals \" + result);
System.out.print (\"Evaluate another expression [Y/N]? \");
again = in.nextLine();
System.out.println();
}
while (again.equalsIgnoreCase(\"y\"));
}
catch (Exception IOException)
{
System.out.println(\"Input exception reported\");
}
}
}
PostfixEvaluator.java
//import datastructures.ArrayStack;
import java.util.StringTokenizer;
public class PostfixEvaluator
{
/** constant for addition symbol */
private final char ADD = \'+\';
/** constant for subtraction symbol */
private final char SUBTRACT = \'-\';
/** constant for multiplication symbol */
private final char MULTIPLY = \'*\';
/** constant for division symbol */
private final char DIVIDE = \'/\';
/** the stack */
private ArrayStack stack;
/**
* Sets up this evaluator by creating a new stack.
*/
public PostfixEvaluator()
{
stack = new ArrayStack();
}
/**
* Evaluates the specified postfix expression. If an operand is
* encountered, it is pushed onto the stack. If an operator is
* encountered, two operands are popped, the operation is
* evaluated, and the result is pushed onto the stack.
* //param expr String representation of a postfix expression
* //return int value of the given expression
*/
public int evaluate (String expr)
{
int op1, op2, result = 0;
String token;
StringTokenizer tokenizer = new StringTokenizer (expr);
while (tokenizer.hasMoreTokens())
{
token = tokenizer.nextToken();
if (isOperator(token))
{
op2 = (stack.pop()).intValue();
op1 = (stack.pop()).intValue();
result = evalSingleOp (token.charAt(0), op1, op2);
stack.push (new Integer(result));
}
else
stack.push (new Integer(Integer.parseInt(token)));
}
return result;
}
/**
* Determines if the specified token is an operator.
* //param token String representing a single token
* //return boolean true if token is operator
*/
private boolean isOperator (String token)
{
return ( token.equals(\"+\") || token.equals(\"-\") ||
token.equals(\"*\") || token.equals(\"/\") );
}
/**
* Performs integer evaluation on a single expression consisting of
* the specified operator and operands.
* //param operation operation to be performed
* //param op1 the first operand
* //param op2 the second operand
* //return int value of the expression
*/
private int evalSingleOp (char operation, int op1, int op2)
{
int result = 0;
switch .
Data structure Stack presentation for university student .this presentation created by "Sheikh-Monirul-Hasan " in Department of computer science at Green University of Bangladesh.
operating system ubuntu,linux,MacProgram will work only if you g.pdfaptcomputerzone
//operating system ubuntu,linux,Mac
Program will work only if you give command like
sum 2 3 or
sum 4 (sub 4 3)
#include
#include
#include
#include
/*Sum function implementation*/
int sum(int number1,int number2){
return number1+number2;
}
/*sub function implementation*/
int sub(int number1,int number2){
return number1-number2;
}
/*mul function implementation*/
int mul(int number1,int number2){
return number1*number2;
}
/*divide function implementation*/
float divide(int number1,int number2){
if(number2==0){
printf(\"We can not divide by 0 \ \");
return 0.0f;
}
return (float)(number1/number2);
}
char *substring(char *string, int position, int length)
{
char *pointer;
int c;
pointer = malloc(length+1);
if (pointer == NULL)
{
printf(\"Unable to allocate memory.\ \");
exit(1);
}
for (c = 0 ; c < length ; c++)
{
*(pointer+c) = *(string+position-1);
string++;
}
*(pointer+c) = \'\\0\';
return pointer;
}
/*Main Function start*/
int main(int argc, char *argv[]){
/*Variable declarations*/
int number1,number2;
char *operator,*str1,*str2;
char line[50];
char s[2] = \" \";
int errorFlag=0;// checking if user entered more then one operands
while(1){
/*User input*/
printf(\"Please Enter the command \");
gets(line);
int len=0;
for(int i=0; line[i]!=\'\\0\'; ++i){len++;}
if(len==0){
return 1;
}
/*Spliting into Tokens*/
operator = strtok(line, \" \");
if(strcmp(operator,\"bye\")==0){
break;
}
/*String to integer --- token1*/
number1=atoi(strtok(NULL, s));
/*Removing ( and ) from String*/
str2=strtok(NULL, s);
char *content;int length=0;
for(int i=0; str2[i]!=\'\\0\'; ++i){length++;}
if(str2[0]==\'(\'){
content=substring(str2,2,length-1);
char *opr=content;
int n1=atoi(strtok(NULL, s));
int n2=atoi(strtok(NULL, s));
/*If user entered more then two operands then it will return some token otherwise it will
return NULL pointer*/
if(strtok(NULL, s)!=NULL){
printf(\"You need to enter operator operand1 operand2 \ \");
errorFlag=1;
}else{
if(strcmp(opr,\"sum\")==0){
number2=sum(n1,n2);
}else if(strcmp(opr,\"sub\")==0){
number2=sub(n1,n2);
}else if(strcmp(opr,\"mul\")==0){
number2=mul(n1,n2);
} else if(strcmp(opr,\"div\")==0){
number2=divide(n1,n2);
}
}
}else{
number2=atoi(str2);
/*If user entered more then two operands then it will return some token otherwise it will return
NULL pointer*/
if(strtok(NULL, s)!=NULL){
printf(\"You need to enter operator operand1 operand2 \ \");
errorFlag=1;
}
}
if(errorFlag!=1){
/*Checking operator by strcmp function*/
if(strcmp(operator,\"sum\")==0){
printf(\"Result %d \ \",sum(number1,number2));
}else if(strcmp(operator,\"sub\")==0){
printf(\"Result %d \ \",sub(number1,number2));
}else if(strcmp(operator,\"mul\")==0){
printf(\"Result %d \ \",mul(number1,number2));
} else if(strcmp(operator,\"div\")==0){
printf(\"Result %.2f \ \",divide(number1,number2));
}
}
}
return 0;
}
/*******************Output***********************/
gopal@gopal:~/Desktop/chegg$ gcc Calculator.c
Calculator.c: In function ‘main’:
Calculator.c:67:3: warning: implici.
#include
#include
using namespace std;
class twoStacks
{
int *arr;
int size;
int top1, top2;
public:
twoStacks(int n) // constructor
{
size = n;
arr = new int[n];
top1 = -1;
top2 = size;
}
// Method to push an element x to stack1
void push1(int x)
{
// There is at least one empty space for new element
if (top1 < top2 - 1)
{
top1++;
arr[top1] = x;
}
else
{
cout << \"Stack Overflow\";
exit(1);
}
}
// Method to push an element x to stack2
void push2(int x)
{
// There is at least one empty space for new element
if (top1 < top2 - 1)
{
top2--;
arr[top2] = x;
}
else
{
cout << \"Stack Overflow\";
exit(1);
}
}
// Method to pop an element from first stack
int pop1()
{
if (top1 >= 0 )
{
int x = arr[top1];
top1--;
return x;
}
else
{
cout << \"Stack UnderFlow\";
exit(1);
}
}
// Method to pop an element from second stack
int pop2()
{
if (top2 < size)
{
int x = arr[top2];
top2++;
return x;
}
else
{
cout << \"Stack UnderFlow\";
exit(1);
}
}
};
/* Driver program to test twStacks class */
int main()
{
twoStacks ts(5);
ts.push1(5);
ts.push2(10);
ts.push2(15);
ts.push1(11);
ts.push2(7);
cout << \"Popped element from stack1 is \" << ts.pop1();
ts.push2(40);
cout << \"\ Popped element from stack2 is \" << ts.pop2();
return 0;
}
#include
#include
using namespace std;
class twoStacks
{
int *arr;
int size;
int top1, top2;
public:
twoStacks(int n) // constructor
{
size = n;
arr = new int[n];
top1 = -1;
top2 = size;
}
// Method to push an element x to stack1
void push1(int x)
{
// There is at least one empty space for new element
if (top1 < top2 - 1)
{
top1++;
arr[top1] = x;
}
else
{
cout << \"Stack Overflow\";
exit(1);
}
}
// Method to push an element x to stack2
void push2(int x)
{
// There is at least one empty space for new element
if (top1 < top2 - 1)
{
top2--;
arr[top2] = x;
}
else
{
cout << \"Stack Overflow\";
exit(1);
}
}
// Method to pop an element from first stack
int pop1()
{
if (top1 >= 0 )
{
int x = arr[top1];
top1--;
return x;
}
else
{
cout << \"Stack UnderFlow\";
exit(1);
}
}
// Method to pop an element from second stack
int pop2()
{
if (top2 < size)
{
int x = arr[top2];
top2++;
return x;
}
else
{
cout << \"Stack UnderFlow\";
exit(1);
}
}
};
/* Driver program to test twStacks class */
int main()
{
twoStacks ts(5);
ts.push1(5);
ts.push2(10);
ts.push2(15);
ts.push1(11);
ts.push2(7);
cout << \"Popped element from stack1 is \" << ts.pop1();
ts.push2(40);
cout << \"\ Popped element from stack2 is \" << ts.pop2();
return 0;
}
Solution
#include
#include
using namespace std;
class twoStacks
{
int *arr;
int size;
int top1, top2;
public:
twoStacks(int n) // constructor
{
size = n;
arr = new int[n];
top1 = -1;
top2 = size;
}
// Method to push an element x to stack1
void push1(int x)
{
// There is at least one empty space for new element
if (top1 < top2 - 1)
{
top1++;
arr[top1] = x;
}
else
{
cout << \"Stack Overflow\";
exit(1);
}
}
// Method to push an element x to stack2
void push2(int x)
{
// There is at least one empty space for new element
if (top1 < top2 - 1)
{.
Neuro-symbolic is not enough, we need neuro-*semantic*Frank van Harmelen
Neuro-symbolic (NeSy) AI is on the rise. However, simply machine learning on just any symbolic structure is not sufficient to really harvest the gains of NeSy. These will only be gained when the symbolic structures have an actual semantics. I give an operational definition of semantics as “predictable inference”.
All of this illustrated with link prediction over knowledge graphs, but the argument is general.
Generating a custom Ruby SDK for your web service or Rails API using Smithyg2nightmarescribd
Have you ever wanted a Ruby client API to communicate with your web service? Smithy is a protocol-agnostic language for defining services and SDKs. Smithy Ruby is an implementation of Smithy that generates a Ruby SDK using a Smithy model. In this talk, we will explore Smithy and Smithy Ruby to learn how to generate custom feature-rich SDKs that can communicate with any web service, such as a Rails JSON API.
Smart TV Buyer Insights Survey 2024 by 91mobiles.pdf91mobiles
91mobiles recently conducted a Smart TV Buyer Insights Survey in which we asked over 3,000 respondents about the TV they own, aspects they look at on a new TV, and their TV buying preferences.
GraphRAG is All You need? LLM & Knowledge GraphGuy Korland
Guy Korland, CEO and Co-founder of FalkorDB, will review two articles on the integration of language models with knowledge graphs.
1. Unifying Large Language Models and Knowledge Graphs: A Roadmap.
https://arxiv.org/abs/2306.08302
2. Microsoft Research's GraphRAG paper and a review paper on various uses of knowledge graphs:
https://www.microsoft.com/en-us/research/blog/graphrag-unlocking-llm-discovery-on-narrative-private-data/
Securing your Kubernetes cluster_ a step-by-step guide to success !KatiaHIMEUR1
Today, after several years of existence, an extremely active community and an ultra-dynamic ecosystem, Kubernetes has established itself as the de facto standard in container orchestration. Thanks to a wide range of managed services, it has never been so easy to set up a ready-to-use Kubernetes cluster.
However, this ease of use means that the subject of security in Kubernetes is often left for later, or even neglected. This exposes companies to significant risks.
In this talk, I'll show you step-by-step how to secure your Kubernetes cluster for greater peace of mind and reliability.
JMeter webinar - integration with InfluxDB and GrafanaRTTS
Watch this recorded webinar about real-time monitoring of application performance. See how to integrate Apache JMeter, the open-source leader in performance testing, with InfluxDB, the open-source time-series database, and Grafana, the open-source analytics and visualization application.
In this webinar, we will review the benefits of leveraging InfluxDB and Grafana when executing load tests and demonstrate how these tools are used to visualize performance metrics.
Length: 30 minutes
Session Overview
-------------------------------------------
During this webinar, we will cover the following topics while demonstrating the integrations of JMeter, InfluxDB and Grafana:
- What out-of-the-box solutions are available for real-time monitoring JMeter tests?
- What are the benefits of integrating InfluxDB and Grafana into the load testing stack?
- Which features are provided by Grafana?
- Demonstration of InfluxDB and Grafana using a practice web application
To view the webinar recording, go to:
https://www.rttsweb.com/jmeter-integration-webinar
Key Trends Shaping the Future of Infrastructure.pdfCheryl Hung
Keynote at DIGIT West Expo, Glasgow on 29 May 2024.
Cheryl Hung, ochery.com
Sr Director, Infrastructure Ecosystem, Arm.
The key trends across hardware, cloud and open-source; exploring how these areas are likely to mature and develop over the short and long-term, and then considering how organisations can position themselves to adapt and thrive.
Slack (or Teams) Automation for Bonterra Impact Management (fka Social Soluti...Jeffrey Haguewood
Sidekick Solutions uses Bonterra Impact Management (fka Social Solutions Apricot) and automation solutions to integrate data for business workflows.
We believe integration and automation are essential to user experience and the promise of efficient work through technology. Automation is the critical ingredient to realizing that full vision. We develop integration products and services for Bonterra Case Management software to support the deployment of automations for a variety of use cases.
This video focuses on the notifications, alerts, and approval requests using Slack for Bonterra Impact Management. The solutions covered in this webinar can also be deployed for Microsoft Teams.
Interested in deploying notification automations for Bonterra Impact Management? Contact us at sales@sidekicksolutionsllc.com to discuss next steps.
Builder.ai Founder Sachin Dev Duggal's Strategic Approach to Create an Innova...Ramesh Iyer
In today's fast-changing business world, Companies that adapt and embrace new ideas often need help to keep up with the competition. However, fostering a culture of innovation takes much work. It takes vision, leadership and willingness to take risks in the right proportion. Sachin Dev Duggal, co-founder of Builder.ai, has perfected the art of this balance, creating a company culture where creativity and growth are nurtured at each stage.
Leading Change strategies and insights for effective change management pdf 1.pdf
Stack prgs
1. 1)‘C’ Program
/************************************************************
Program for implementing a stack using arrays.It involves
various operations such as push,pop,stack empty,stack full and
display.
*************************************************************/
#include<stdio.h>
#include<conio.h>
#include<stdlib.h>
#define size 5
/* stack structure*/
struct stack {
int s[size];
int top;
}st;
/*
The stfull Function
Input:none
Output:returns 1 or 0 for stack full or not
Called By:main
Calls:none
*/
int stfull()
{
if(st.top>=size-1)
return 1;
else
return 0;
}
/*
The push Function
Input:item which is to be pushed
Output:none-simply pushes the item onto the stck
Called By:main
Calls:none
*/
void push(int item)
{
st.top++;
st.s[st.top] =item;
}
/*
The stempty Function
Input:none
Output:returns 1 or 0 for stack empty or not
Called By:main
Calls:none
*/
int stempty()
{
if(st.top==-1)
return 1;
else
return 0;
2. }
/*
The pop Function
Input:none
Output:returns the item which is popped from the stack
Called By:main
Calls:none
*/
int pop()
{
int item;
item=st.s[st.top];
st.top – –;
return(item);
}
/*
The display Function
Input:none
Output:none-displys the contents of the stack
Called By:main
Calls:none
*/
void display()
{
int i;
if(stempty())
printf(―n Stack Is Empty!‖);
else
{
for(i=st.top;i>=0;i– –)
printf(―n%d‖,st.s[i]);
}
}
/*
The main Function
Input:none
Output:none
Called By:O.S.
Calls:push,pop,stempty,stfull,display
*/
void main(void)
{
int item,choice;
char ans;
st.top=-1;
clrscr();
printf(―ntt Implementation Of Stack‖);
do
{
printf(―n Main Menu‖);
printf(―n1.Pushn2.Popn3.Displayn4.exit‖);
printf(―n Enter Your Choice‖);
scanf(―%d‖,&choice);
switch(choice)
3. {
case 1:printf(―n Enter The item to be pushed‖);
scanf(―%d‖,&item);
if(stfull())
printf(―n Stack is Full!‖);
else
push(item);
break;
case 2:if(stempty())
printf(―n Empty stack!Underflow !!‖);
else
{
item=pop();
printf(―n The popped element is %d‖,item);
}
break;
case 3:display();
break;
case 4:exit(0);
}
printf(―n Do You want To Continue?‖);
ans=getche();
}while(ans ==‘Y‘ ||ans ==‘y‘);
getch();
}
/******************** End Of Program ************************/
2)‘C’ Program
/************************************************************
Program to evaluate a given postfix expression. The program
handles postfix expressions with only binary arithmatic
operators +,-,*,/ and ^. Operands are single digit numbers
between 0-9.
*************************************************************/
/* List of include files */
#include <stdio.h>
#include <conio.h>
#include <process.h>
#include <stdlib.h>
#include <string.h>
#include <ctype.h>
#include <math.h>
/* List of defined constants */
#define size 80
/* Global declarations */
struct stack
{ double s[size];
int top;
}st;
enum Type { operand, oprtor };
/* The Push function
Input : A value to be pushed on global stack
Output: None, modifies global stack and its top
Parameter Passing Method :By Value
Called By : Post()
4. Calls :none
*/
void Push(double Val)
{
if ( st.top+1 >= size )
printf(―Error: Stack is Fulln‖);
st.top++;
st.s[st.top] = Val;
}
/* The Pop function
Input : None, uses global stack and top
Output: Returns the value on top of stack
Parameter Passing Method :None
Called By : post()
Calls :none
*/
double Pop()
{
double Val;
if ( st.top == -1 )
printf(―Error: Stack is Emptyn‖);
Val = st.s[st.top];
st.top—;
return(Val);
}
/* The gettokn function
Input : Given infix expression
Output: Returns the next character from the expression
Parameter Passing Method : By reference
Called By : post()
Calls : None
*/
char gettokn( char exp[])
{
static int i = 0;
char ch;
ch = exp[i];
i++;
return ch;
}
/* The Gettype function
Input : A character from infix expression
Output: Returns the token type as operand or oprtor
Parameter Passing Method : By value
Called by : post()
Calls : none
*/
enum Type Gettype(char ch)
{
ch = toupper(ch); /* convert to upper case */
if ( ch >= ‗0‘ && ch <= ‗9‘)
return operand;
if ( ch == ‗+‘|| ch == ‗-‘||
ch == ‗*‘|| ch == ‗/‘ ||
5. ch == ‗^‘ )
return oprtor;
/* Error */
printf(―Invalid operatorn‖);
}
/* The post function which contains major logic of
the program.
Input : A post Expression of single digit operand
Output: Resultant value after evaluating the expression
Parameter Passing Method :by reference
Called By : main()
Calls :gettoken(), Push(), Pop() and
Gettype()
*/
double post( char exp[])
{
char ch,type;
double result, Val, Op1, Op2;
st.top = 0;
ch = gettokn(exp);
while ( ch != ‗$‘ )
{
type = Gettype(ch);
if( type ==operand)
{
Val = ch - 48;
Push( Val);
}
else
if ( type == oprtor)
{
Op2 = Pop();
Op1 = Pop();
switch(ch)
{
case ‗+‘ : result = OP1 + Op2;
break;
case ‗–‘ : result = Op1 – Op2;
break;
case ‗*‘ : result = Op1 * Op2;
break;
case ‗/‘ : result = Op1 / Op2;
break;
case ‗^‘ : result = pow (Op1 – Op2;
break;
}/* switch */
Push (result);
}
ch = gettokn(exp);
}/* while */
result = Pop();
return(result);
}
/* The main function
6. Input : None
Output : None
Parameter Passing Method : None
called By : OS
Calls : post()
*/
void main ()
{
/* Local declarations */
char exp[size];
int len;
double Result;
clrscr();
printf(―‖Enter the postfix Expressionn");
scanf(―%S‖,exp);
len = strlen(exp);
exp[len] = ‗‘; /* Append at the end */
Result = post(exp);
printf(―The Value of the expression is %fn‖, Result);
getch();
exit(0);
}
/ ************** End of the Program ***************** /
3) ‘C’ Program
/ **********************************************************
Program for conversion of Infix expression to Postfix form.
************************************************************/
#include<stdio.h>
#include<conio.h>
#include<alloc.h>
char inf[40],post[40];
int top=0,st[20];
void postfix();
void push(int);
char pop();
/*
The main Function
Input:none
Output:none
Called BY:O.S.
Calls:postfix
*/
void main(void)
{
clrscr();
printf(―ntEnter the infix expression :: nntt‖);
scanf(―%s‖, inf);
postfix();
getch();
}
/*
The postfix Function
Input:none
Output:none
7. Called By:main
Calls:push,pop
*/
void postfix()
{
int i,j=0;
for(i=0;inf[i]!=‘0‘;i++)
{
switch(inf[i])
{
case ‗+‘ : while(st[top] > = 1)
post[j++] = pop();
push(1)
break;
case ‗–‘ : while(st[top] >=1)
post[j++] = pop();
push(2);
break;
case ‗*‘ : while(st[top] >=3)
pos[j++] = pop();
push(3)
break;
case ‗/‘ : while(st[top] > = 3)
post[j++] = pop();
push(4);
break;
case ‗^‘ : while(st[top] >=4)
post[j++] = pop();
push(5);
break;
case ‗(‗ : push(0);
break;
case ‗)‘ : while(st[top] ! = 0
post[j++] = pop();
top —;
break;
default : post[j++] = inf[i];
}
}
while(top>0)
post[j++] = pop();
print(―ntPostfix expression is = > nntt %s‖, post);
}
/*
The push Function
Input:ele-the element which is to be pushed onto the stack
Output:none
Called By:postfix
Calls:none
*/
void push(int ele)
{
top++;
st[top] = ele;
8. }
/*
The pop Function
Input:none
Output:e-the popped element
Called By:postfix
Calls:none
*/
char pop()
{
int el;
char e;
el = st[top];
top—;
switch(el)
{
case 1 : e = ‗+‘;
break;
case 2 : e = ‗–‘;
break;
case 3 : e = ‗*‘;
break;
case 4 : e = ‗/‘;
break;
case 5 : e = ‗^‘;
break;
}
return(e);
}
/**************** end of program ********************/
4)C Program
/************************************************************
Program for checking the well formedness of the parenthesis.
*************************************************************/
#include<stdio.h>
#include<conio.h>
#include<stdlib.h>
#define size 5
/* stack structure*/
struct stack {
char s[size];
int top;
}st;
/*
The push Function
Input:item which is to be pushed
Output:none-simply pushes the item onto the stck
Called By:main
Calls:none
*/
void push(char item)
{
9. st.top++;
st.s[st.top] =item;
}
/*
The stempty Function
Input:none
Output:returns 1 or 0 for stack empty or not
Called By:main
Calls:none
*/
int stempty()
{
if(st.top==-1)
return 1;
else
return 0;
}
/*
The pop Function
Input:none
Output:returns the item which is popped from the stack
Called By:main
Calls:none
*/
char pop()
{
char item;
item=st.s[st.top];
st.top—;
return(item);
}
/*
The main Function
Input:none
Output:none
Called By:O.S.
Calls:push,pop,stempty
*/
void main(void)
{
char item;
char ans,bracket[10];
int i;
st.top=-1;
clrscr();
printf(―ntt Enter The expression and put $ at the end‖);
scanf(―%s‖,bracket);
i=0;
if(bracket[i]==‘)‘)
printf(―n The expression is invalid‖);
else
{
do
{
10. while(bracket[i]==‘(‗)
{
push(bracket[i]);
i++;
}
while(bracket[i]==‘)‘)
{
item=pop();
i++;
}
}while(bracket[i]!=‘$‘);
if(!stempty())
printf(―n The expression is invalid‖);
else
printf(―n The expression has well formed parenthesis‖);
}
getch();
}
5)C Program
/*************************************************************
Program for converting decimal number to binary number
*************************************************************/
#include<stdio.h>
#include<conio.h>
#include<stdlib.h>
#define size 5
/* stack structure*/
struct stack {
int s[size];
int top;
}st;
/*
The push Function
Input:item which is to be pushed
Output:none-simply pushes the item onto the stck
Called By:main
Calls:none
*/
void push(int item)
{
st.top++;
st.s[st.top] =item;
}
/*
The stempty Function
Input:none
Output:returns 1 or 0 for stack empty or not
Called By:main
Calls:none
*/
int stempty()
{
11. if(st.top==-1)
return 1;
else
return 0;
}
/*
The pop Function
Input:none
Output:returns the item which is popped from the stack
Called By:main
Calls:none
*/
int pop()
{
int item;
item=st.s[st.top];
st.top—;
return(item);
}
/*
The main Function
Input:none
Output:none
Called By:O.S.
Calls:push,pop,stempty
*/
void main(void)
{
int item,i,num;
st.top=-1;
clrscr();
printf(―n Program For Decimal TO Binary Conversion‖);
printf(―ntt Enter The number‖);
scanf(―%d‖,&num);
while(num>=1)
{
item=num%2;
push(item);
num=num/2
}
while(!stempty())
printf("%d",pop());
getch();
}
6)C Program
/*************************************************************
Program for reversing the given string using stack
*************************************************************/
#include<stdio.h>
#include<conio.h>
#include<stdlib.h>
#include<string.h>
#define size 10
12. /* stack structure*/
struct stack {
char s[size];
int top;
}st;
/*
The push Function
Input:item which is to be pushed
Output:none-simply pushes the item onto the stck
Called By:main
Calls:none
*/
void push(char item)
{
st.top++;
st.s[st.top] =item;
}
/*
The stempty Function
Input:none
Output:returns 1 or 0 for stack empty or not
Called By:main
Calls:none
*/
int stempty()
{
if(st.top==-1)
return 1;
else
return 0;
}
/*
The pop Function
Input:none
Output:returns the item which is popped from the stack
Called By:main
Calls:none
*/
char pop()
{
char item;
item=st.s[st.top];
st.top—;
return(item);
}
/*
The main Function
Input:none
Output:none
Called By:O.S.
Calls:push,pop,stempty
*/
void main(void)
13. {
char item,string[10];
int i;
st.top=-1;
clrscr();
printf(―n Program For reversing a given string‖);
printf(―ntt Enter The string:‖);
scanf(―%s‖,&string);
i=0;
while(string[i]!=‘0‘)
{
push(string[i]);
i++;
}
printf(―ttt‖);
while(!stempty())
{
item=pop();
printf(―%c‖,item);
}
getch();
}
7)‘C’ Program
/*************************************************************
Program to implement multiple stacks using single array
*************************************************************/
#include<stdio.h>
#include<conio.h>
#include<stdlib.h>
#define MAX 20
int stack[MAX];
int size[MAX],lb,ub;
/* set_stack Function
It is for defining the upper limit and lower limit of each stack
Input:the index,which indicates the stack number
Output:none,It sets the upper and lower boundries of the stack
Called By:stempty,stfull,display,display_all
Calls:none
Parameter passing method:By value
*/
void set_stack(int index)
{
int sum,i;
if(index==1)
{
lb=1;
ub=size[index];
}
else
{
sum=0;
for(i=1;i<index;i++)
sum=sum+size[i];
14. lb=sum+1;
ub=sum+size[index];
}
}
/* stfull Function
It checks whether the stack is full or not
Input:the index,which indicates the stack number
Output:1 if stack is full otherwise 0
Called By:main
Calls:set_stack
Parameter passing method:By value
*/
int stfull(int index)
{
int top,i,sum;
set_stack(index);
for(top=lb;top<=ub;top++)
{
if(stack[top]==-1)
break;
}
if(top-1==ub)
return 1;
else
return 0;
}
/* stempty Function
It checks whether the stack is empty or not
Input:the index,which indicates the stack number
Output:1 if stack is empty otherwise 0
Called By:main
Calls:set_stack
Parameter passing method:By value
*/
int stempty(int index)
{
int top;
set_stack(index);
for(top=lb;top<=ub;top++)
{
if(stack[top]!=-1)
return 0;
return 1;
}
}
/* push Function
Input:the item which is to be pushed onto the stack
Output:none
Called By:main
Calls:
Parameter passing method:By value
*/
void push(int item)
{
15. int top;
for(top=lb;top<=ub;top++)
if(stack[top]==-1)
break;
stack[top]=item;
return;
}
/* pop Function
It pops the element from desired stack
Input:none
Output:item,popped element
Called By:main
Calls:none
*/
int pop()
{
int top,item;;
for(top=lb;top<=ub;top++)
if(stack[top]==-1)
break;
top—;
item=stack[top];
stack[top]=-1;
return item;
}
/* display Function
It displays only desired stack
Input:the index,which indicates the stack number
Output:none
Called By: main
Calls:set_stack
Parameter passing method:By value
*/
void display(int index)
{
int top;
set_stack(index);
for(top=lb;top<=ub;top++)
{
if(stack[top]!=-1)
printf(―%d‖,stack[top]);
}
}
/* display_all Function
It displays all the stacks in the array
Input:the n,which indicates total number of stacks
Output:none
Called By:main
Calls:set_stack
Parameter passing method:By value
*/void display_all(int n)
{
int top,index;
16. for(index=1;index<=n;index++)
{
printf(―nstack number %d is‖,index);
set_stack(index);
for(top=lb;top<=ub;top++)
{
if(stack[top]!=-1)
printf(― %d‖,stack[top]);
}
}
}
/* main Function
Input:none
Output:none
Called By:O.S.
Calls:stfull,push,stempty,pop,display,display_all
Parameter passing method:
*/
void main(void)
{
int n,index,i,item,choice;
char ans;
clrscr();
ans=‘y‘;
for(i=1;i<=MAX;i++)
stack[i]=-1;/*for initialization of the entire array of stacks*/
printf(―nt Program For multiple stacks using single array‖);
printf(―n Enter how many stacks are there‖);
scanf(―%d‖,&n);
printf(―n Enter the size for each stack‖);
for(i=1;i<=n;i++)
{
printf(―n size for stack %d is‖,i);
scanf(― %d‖,&size[i]);
}
do
{
printf(―ntt Main Menu‖);
printf(―n 1.Push n2.Pop n3.Display n4.Dispaly all‖);
printf(―n Enter Your choice‖);
scanf(―%d‖,&choice);
switch(choice)
{
case 1:printf(―n Enter the item to be pushed‖);
scanf(―%d‖,&item);
printf(―n In Which stack?‖);
scanf(―%d‖,&index);
if(stfull(index))
printf(―n Stack %d is Full,can not Push‖,index);
else
push(item);
break;
case 2:printf(―n From Which stack?‖);
scanf(―%d‖,&index);
17. if(stempty(index))
printf(―n Stack number %d is empty!‖,index);
else
{
item=pop();
printf(―n %d is popped from stack %d‖,item,index);
}
break;
case 3:printf(―n Which stack has to be displayed?‖);
scanf(―%d‖,&index);
display(index);
break;
case 4:display_all(n);
break;
default:printf(―n Exitting‖);
}
printf(―n Do you wish to continue?‖);
ans=getch();
}while(ans==‘y‘||ans==‘Y‘);
getch();
}
/********************* End Of Program**********************/
8)C Program
/*******************************************************************************************
Program for finding out the factorial for any given number.
*************************************************************/
#include<stdio.h>
#include<stdlib.h>
#include<conio.h>
/* The fact function
Input:the numer n
Output: factorial of n
Called By:main
Calls:itself
*/
int fact(int n)
{
int x,y;
if(n<0)
{
printf(―The negative parameter in the factorial function‖);
exit(0);
}
if(n==0)
return 1;
x=n-1;
y=fact(x);
return(n*y);
}
/* The main function
Input:none
Output:none
Called By:O.S.
18. Calls:fact
*/
void main(void)
{
int n,f;
clrscr();
printf(―ntt Program For finding the factorial of n‖);
printf(―nn Enter the number for finding the factorial‖);
scanf(―%d‖,&n);
f=fact(n);
printf(―n the factorial of %d is %d‖,n,f);
getch();
}
/********************** End Of Program **********************/
9)C Program
/*************************************************************
Program for computing the number in the fibonacci series at
certain location.For e.g.the sixth number in fibonacci series
will be 8.The fibonacci series is 1 1 2 3 5 8 13 21 34...
*************************************************************/
/*header files*/
#include<stdio.h>
#include<conio.h>
/*
The fib Function.
Input:the location n.
Output:the value at that location in fibonacci series.
Called By:main.
Calls:itself.
*/
int fib(int n)
{
int x,y;
if(n<=1)
return n;
x=fib(n-1);
y=fib(n-2);
return (x+y);
}
/*
The main function
Input:none
Output:none
Called By:o.s
Calls:fib-the fibonacci function.
*/
void main(void)
{
int n,num;
clrscr();
printf(―n Enter location in fibonacci series‖);
scanf(―%d‖,&n);
num=fib(n);
printf(―n The number at %dth position is %d in fibonacci
19. series‖,n,num);
getch();
}
/********************** End of Program ***********************/
10)C Program
/*************************************************************
Program for Multiplication Of natural numbers.The multiplication
two numbers is considerd.This is program uses the recurssive
definition.
*************************************************************/
/*header files*/
#include<stdio.h>
#include<conio.h>
/*************************************************************
mul Function
Input:two numbers a,b
Output:returns the multiplication result
Called by:main
Calls:mul i.e.itself
*************************************************************/
mul(int a,int b)
{
if(b==1)
return a;
else
return(mul(a,b-1)+ a);
}
/*************************************************************
main Function
Input:none
Output:none
Called by:O.S.
Calls:mul
*************************************************************/
main()
{
int a,b,result=0;
clrscr();
printf(―n Enter the values of a and b‖);
scanf(―%d%d‖,&a,&b);
result=mul(a,b);
printf(―The multiplication is =%d‖,result);
getch();
}
11)C Program
/*************************************************************
Program to find out the greatest common divisor of the two
integers.
*************************************************************/
#include<stdio.h>
#include<conio.h>
#include<stdlib.h>
int gcd(int a,int b)
{
20. int temp,ans;
if(b<=a &&a%b ==0)
return b;
else
{
if(b<a)
{
temp = a;
a = b; /*interchanging the a and b values*/
b = temp;
}
ans = a%b;
return(gcd(b,ans));
}
}
void main(void)
{
int a,b,ans;
clrscr();
printf(―ntt GCD Of two integers‖);
printf(―nn Enter the two numbers‖);
scanf(―%d %d‖,&a,&b);
ans=gcd(a,b);
printf(―n The gcd of %d and %d is = %d‖,a,b,ans);
getch();
}
/********************** End of program *******************/
12)C Program
/*******************************************************************
Conversion of postfix expression to infix form
*******************************************************************/
#include<stdio.h>
#include<conio.h>
#include<string.h>
#include<process.h>
typedef struct node
{
char str[25];
}node;
node stack[20];
int top = –1;
char input[100];
void post2in();
void push(char *op)
{
if(top == 20)
{
printf("nStack full");
exit(0);
}
top++;
![1)‘C’ Program
/************************************************************
Program for implementing a stack using arrays.It involves
various operations such as push,pop,stack empty,stack full and
display.
*************************************************************/
#include<stdio.h>
#include<conio.h>
#include<stdlib.h>
#define size 5
/* stack structure*/
struct stack {
int s[size];
int top;
}st;
/*
The stfull Function
Input:none
Output:returns 1 or 0 for stack full or not
Called By:main
Calls:none
*/
int stfull()
{
if(st.top>=size-1)
return 1;
else
return 0;
}
/*
The push Function
Input:item which is to be pushed
Output:none-simply pushes the item onto the stck
Called By:main
Calls:none
*/
void push(int item)
{
st.top++;
st.s[st.top] =item;
}
/*
The stempty Function
Input:none
Output:returns 1 or 0 for stack empty or not
Called By:main
Calls:none
*/
int stempty()
{
if(st.top==-1)
return 1;
else
return 0;](https://image.slidesharecdn.com/stackprgs-111024104153-phpapp01/85/Stack-prgs-1-320.jpg)
![}
/*
The pop Function
Input:none
Output:returns the item which is popped from the stack
Called By:main
Calls:none
*/
int pop()
{
int item;
item=st.s[st.top];
st.top – –;
return(item);
}
/*
The display Function
Input:none
Output:none-displys the contents of the stack
Called By:main
Calls:none
*/
void display()
{
int i;
if(stempty())
printf(―n Stack Is Empty!‖);
else
{
for(i=st.top;i>=0;i– –)
printf(―n%d‖,st.s[i]);
}
}
/*
The main Function
Input:none
Output:none
Called By:O.S.
Calls:push,pop,stempty,stfull,display
*/
void main(void)
{
int item,choice;
char ans;
st.top=-1;
clrscr();
printf(―ntt Implementation Of Stack‖);
do
{
printf(―n Main Menu‖);
printf(―n1.Pushn2.Popn3.Displayn4.exit‖);
printf(―n Enter Your Choice‖);
scanf(―%d‖,&choice);
switch(choice)](data:image/gif;base64,R0lGODlhAQABAIAAAAAAAP///yH5BAEAAAAALAAAAAABAAEAAAIBRAA7)