14 April 2014

Algoritmul Bellman - Ford Program C language

void bellman_ford(int a[50][50])
{
int z,s,v,k,u,d[50],q[50];
printf("\n\nStart: ");
scanf("%d",&s);
printf("n= %d",n);
for(i=1;i<=n;i++)
{
q[i]=99;
if(i==s)
q[i]=0;
}
printf("\nVectorul Q:\n");
for(i=1;i<=n;i++)
printf(" %d ",q[i]);
for(i=1;i<=n;i++)
for(u=1;u<=n;u++)
for(v=1;v<=n;v++)
if(q[v]>q[u]+a[u][v])
q[v]=q[u]+a[u][v];
printf("\nVectorul Q:\n");
for(i=1;i<=n;i++)
printf(" %d ",q[i]);
}

main + citire fisier:

Citire + afisare matrice Program C language

#include "STDLIB.h"
#include "stdio.h"
#include "conio.h"
#include "iostream.h"
#include "VALUES.H"

int S=0;
int i,j,n,m;

void fread(int a[50][50]) // Functia de citire din fisier
{
FILE *f=fopen("in.txt","r");
fscanf(f,"%d",&n);
for(i=1;i<=n;i++)
for(j=1;j<=n;j++)
fscanf(f,"%d",&a[i][j]);
fclose(f);
printf(" S-a citit Fisierul");
printf("\n\nPress any key to continue...");
}

void print(int a[50][50]) // Functia de afisare pe ecran
{ printf("\n\n\tAFISARE\n\n");
for(i=1;i<=n;i++)
{
printf("\n");
for(j=1;j<=n;j++)
printf("%3d",a[i][j]);
}
}

void main()
{ clrscr();
int a[50][50];
fread(a);
print(a);
getch();
}

07 April 2014

Algoritmul Roy-Floyd program C language

void rfloyd(int a[50][50])
{ int k;
for(k=1;k<=n;k++)
for(i=1;i<=n;i++)
for(j=1;j<=n;j++)
if(i!=j && i!=k && j!=k)
a[i][j]=min(a[i][j],a[i][k]+a[k][j]);
print(a);
}

06 April 2014

LFATC Terminale - Neterminale C language

void neterminale()
    {int nr=0,k;
    printf("\nNeterminale: ");
    for(i=1;i < =n;i++)
        {for(k=0;k < strlen(p[i].st);k++)
            if(isupper(p[i].st[k])&& !strchr(N,p[i].st[k]))
                {N[nr]=p[i].st[k];
                nr++;}
        for(k=0;k < strlen(p[i].dr);k++)
            if(isupper(p[i].dr[k])&& !strchr(N,p[i].st[k]))
                {N[nr]=p[i].dr[k];
                nr++;}
        }
    N[nr]='\0';
    for(i=0;i < =nr;i++)
            printf("%c ",N[i]);
    }

void terminale()
    { int nrt=0,k;
    printf("\nTerminale: ");
    for(i=1;i < =n;i++)
        {for(k=0;k < strlen(p[i].st);k++)
            if(p[i].st[k]!=lambda && !strchr(N,p[i].st[k]) && !strchr(T,p[i].st[k]))
                {T[nrt]=p[i].st[k];
                nrt++;}
        for(k=0;k < strlen(p[i].dr);k++)
            if(p[i].dr[k]!=lambda && !strchr(N,p[i].dr[k]) && !strchr(T,p[i].dr[k]))
                {T[nrt]=p[i].dr[k];
                nrt++;}
        }
    T[nrt]='\0';
    for(i=0;i < =nrt;i++)
            printf("%c ",T[i]);
    }

Limbaje formale, asamblare si tehnici de compilare 2 Programe C Language

#include "string.h"
#include "iostream.h"
#include "stdio.h"
#include "conio.h"
#include "ctype.h"
#include "STDLIB.H"
#include "values.h"

int i,j,n;
char S,s[100];
struct productie
{ char st[10],dr[15];
} p[30];

void interval()
{
int nr[100];
FILE *f=fopen("numere.txt","r");
char v[100][20],*pch;
int a,b,p,k;
i=0;
while(!feof(f))
{
    fgets(s,50,f);
      printf("Sirul este: ");
puts(s);
    pch=strtok(s," :;,.\n");
while(pch!=NULL)
    {
    strcpy(v[i],pch);
    i++;
    pch=strtok(NULL," :;,.\n");
    }
}
int n=i-1;
printf("\nNumerele sunt: \n");
for(j=0;j < i;j++)
    puts(v[j]);
cout < < "\na= ";
cin>>a;
cout < < "\nb= ";
cin>>b;
for(i=0;i < =n;i++)
    nr[i]=atoi(v[i]);
printf("\nNumerele Sunt: \n");
for(i=0;i < =n;i++)
    printf("%d ",nr[i]);
cout < < "\nIn Interval: \n";
for(i=0;i < =n;i++)
    if(nr[i]>a && nr[i] < b)
      printf(" %d ",nr[i]);
fclose(f);
}

void neterminale()
    {int nr=0,k;
    printf("\nNeterminale: ");
    for(i=1;i < =n;i++)
        {for(k=0;k < strlen(p[i].st);k++)
            if(isupper(p[i].st[k])&& !strchr(N,p[i].st[k]))
                {N[nr]=p[i].st[k];
                nr++;}
        for(k=0;k < strlen(p[i].dr);k++)
            if(isupper(p[i].dr[k])&& !strchr(N,p[i].st[k]))
                {N[nr]=p[i].dr[k];
                nr++;}
        }
    N[nr]='\0';
    for(i=0;i < =nr;i++)
            printf("%c ",N[i]);
    }

void terminale()
    { int nrt=0,k;
    printf("\nTerminale: ");
    for(i=1;i < =n;i++)
        {for(k=0;k < strlen(p[i].st);k++)
            if(p[i].st[k]!=lambda && !strchr(N,p[i].st[k]) && !strchr(T,p[i].st[k]))
                {T[nrt]=p[i].st[k];
                nrt++;}
        for(k=0;k < strlen(p[i].dr);k++)
            if(p[i].dr[k]!=lambda && !strchr(N,p[i].dr[k]) && !strchr(T,p[i].dr[k]))
                {T[nrt]=p[i].dr[k];
                nrt++;}
        }
    T[nrt]='\0';
    for(i=0;i < =nrt;i++)
            printf("%c ",T[i]);
    }

/*
void gramatica()
{
int i,n,j;
char neterm[10];
char term[10];
char start,s[100];
*/
FILE *f=fopen("lfatc.txt","r");
FILE *g=fopen("out0.txt","w");

void citire_simbol()
{ //Citire simbol de start , nr de proiectii
S=fgetc(f);
fscanf(f,"%d\n",&n);
printf("\nSimbolul de start este: %c",S);
printf("\nNr de productii este: %d\n",n);
printf("Productiile sunt:\n ");
for(i=1;i < =n;i++)
    {
    strset(s,'\0');
    fgets(s,99,f);
//    puts(s);
    int k=0;
    while(s[k]!='-')
      {
      p[i].st[k]=s[k];//st[k++]=s[i++]
      k++;
      }
    p[i].st[k]='\0';
    k+=2;
    int j=0;
    while(k < strlen(s))
      {
      p[i].dr[j]=s[k];
      k++;
      j++;
      }
    p[i].dr[j]='\0';
    }
    for(i=1;i < =n;i++)
      printf("\n%s-->%s",p[i].st,p[i].dr);
}

void nerealizabili()
{ char realiz[99];
int modif,wr;
strcpy(realiz,);
do{
    modif=0;
    for(i=1;i < =n;i++)
      if(!strchr(realiz,p[i].st[0]))
      {
      wr=1;
      for (j=1;j < =n;j++)
    if(!strchr(realiz.p[i].st[0])
    {
    wr=0;
    break;
    }
      if(wr=1)
    {
    modif=1;
    realiz=realiz;
    }
while(modif=0);
Vn=realiz;
}

void main()
{ clrscr();
// interval();
// gramatica();
citire_simbol();
getch();
}

Limbaje formale, asamblare si tehnici de compilare 1 Programe C Language

#include "string.h"
#include #include "stdio.h"
#include "conio.h"
#include "ctype.h"
#include "STDLIB.H"
#include "values.h"

void majuscule()
{ clrscr();
char sir[30];
int i,nr=0;
gets(sir);
cout<<"\n Sirul e:";
puts(sir);

for (i=0; i < strlen(sir); i++) // prelucrare sir
    if (isupper(sir[i])!=0)
      {
      cout<<"\n Caracterul: "<      nr++;
      }
cout< <"\n Numarul de Majuscule este: "< < nr;
getch();
}

int sumacifre()
{
clrscr();
char sir[30],y[10];
int i,s=0,x;
gets(sir);
cout<<"\n Sirul e:";
puts(sir);
for (i=0;i < strlen(sir);i++)
    if (isdigit(sir[i])!=0)
      {
      s+=sir[i]-48;
      }
return s;
}

void sumanr()
{
FILE *f=fopen("lfatc.txt","r");
char s[100];
int i,suma=0,t=0;
fgets(s,100,f);
fclose(f);
for(i=0;i < strlen(s);i++)
    { t=0;
      while(isdigit(s[i]))
    {
    t=t*10+s[i]-48;
    i++;
    }
      suma=suma+t;
      }
      cout< < "Suma" < < suma;
}

void delspace()
{
FILE *f=fopen("lfatc.txt","r");
char s[100];
int i;
fgets(s,100,f);
fclose(f);
for(i=0;i < strlen(s);i++)
    {
    if(isspace(s[i]))
      i++;
    printf("%c",s[i]);
    }
}

void maxlength()
{ int max=-MAXINT;
FILE *f=fopen("lfatc.txt","r");
char s[100],v[100][20],*pch;
int p,i=0,j,k;
while(!feof(f))
{
    fgets(s,50,f);
      printf("Sirul este: ");
puts(s);
    pch=strtok(s," :;,.\n");
while(pch!=NULL)
    {
    strcpy(v[i],pch);
    i++;
    pch=strtok(NULL," :;,.\n");
    }
}
strset(v[i],'\0');
printf("Cuvintele sunt: \n");
for(j=0;j    puts(v[j]);
for(j=0;j    {
    p=strlen(v[j]);
    if(p>max)
      {
      max=p;
      k=j;
      }
    }
printf("The longest word in this file is: %s ",v[k]);
}

void operatii()
{
FILE *f1=fopen("lfatc1.txt","r");
FILE *f2=fopen("lfatc2.txt","r");
char s1[100],s2[100],r[200];
int i,j;
fgets(s1,100,f1);
fgets(s2,100,f2);
fclose(f1);
fclose(f2);
for(i=0;i < strlen(s1);i++)
    for(j=0;j < strlen(s2);j++)
      if(s1[i]!=s2[j]) ;
    //r[i]==

}

void main()
{ clrscr();
// sumanr();
// delspace();
// maxlength();
maxlength();
getch();
}

Algoritmica Grafurilor (Set 2) Programe C language

/* Setul 2
   1 -
*/

#include "STDLIB.h"
#include "stdio.h"
#include "conio.h"
#include "iostream.h"
#include "VALUES.H"

int S=0;
int i,j,n,m;

void fread(int a[50][50]) // Functia de citire din fisier
{
FILE *f=fopen("in.txt","r");
fscanf(f,"%d",&n);
for(i=1;i<=n;i++)
    for(j=1;j<=n;j++)
      fscanf(f,"%d",&a[i][j]);
fclose(f);
printf("   S-a citit Fisierul");
printf("\n\nPress any key to continue...");
}

void fprint(int a[50][50]) // Functia de scriere in fisier
{
FILE *f=fopen("out.txt","w");
for(i=1;i<=n;i++)
    for(j=1;j<=n;j++)
      fprintf(f,"%3d",a[i][j]);
      fprintf(f,"\n");
}

void print(int a[50][50]) // Functia de afisare pe ecran
{ printf("\n\n\tAFISARE\n\n");
for(i=1;i<=n;i++)
    {
    printf("\n");
    for(j=1;j<=n;j++)
      printf("%3d",a[i][j]);
    }
}

void vecin(int a[50][50])
{ int v;
FILE *f=fopen("vecin.txt","w");
printf("\n\n\tVECIN\n\n");
printf("\n Varful: ");
scanf("%d",&v);
for(i=1;i<=n;i++)
    if(a[v][i]==1 && v!=i)
      {
      printf("\n Vecin: %d",i);
      fprintf(f,"\n Vecin: %d",i);
      }
}
/*
void subgraf(int a[50][50]) //subgraf
{ int b[50][50];
printf("\n\n\tSUBGRAF\n\n");
FILE *g=fopen("in2.txt","r");
fscanf(g,"%d",&m);
for(i=1;i<=m;i++)
    for(j=1;j<=m;j++)
      fscanf(g,"%d",&b[i][j]);
fclose(g);
printf("\n\n   S-a citit Fisierul 2 \n\n");
printf("\n\nAfisam Matricea 2\n\n");
print(b);
// INCOMPLET
}
*/

int min(int X,int Y)
{ int MIN;
if(X    MIN=X;
else
    MIN=Y;
return MIN;
}

void RW(int a[50][50])
{ int k,i,j;
for(k=1;k<=n;k++)
    for(i=1;i<=n;i++)
      for(j=1;j<=n;j++)
    if(a[i][j]==0 && i!=k && j!=k)
    a[i][j]=min(a[i][k],a[k][j]);

print(a);

}

int conex(int a[50][50])
{ int i,j,c=1;
RW(a);
for(i=1;i<=n;i++)
    for(j=1;j<=n;j++)
      if(a[i][j]==0)
    c=0;
if(c==1)
    printf("\n\nGraf Conex\n");
else
    printf("\n\nGraful Nu-i Conex\n");
return c;
}

void mcrit(int a[50][50])
{ int x,y,c;
printf("\nMuchia dintre: x si y ");
scanf("%d %d",&x,&y);
a[x][y]=a[y][x]=0;
c=conex(a);
if (c==0)
    printf("\n\nMuchia e Critica\n");
else
    printf("\n\nMuchia nu-i critica\n");
}

void pcrit(int a[50][50])
{ int k,i,j,v,c;
printf("\nVarful: ");
scanf("%d",&v);
for(i=1;i<=n;i++)
    a[v][i]=a[i][v]=0;
printf("\n Matricea rezultata:\n");
print(a);
for(k=1;k<=n;k++)
    for(i=1;i<=n;i++)
      for(j=1;j<=n;j++)
    if(a[i][j]==0 && i!=k && j!=k && i!=v && j!=v)
    a[i][j]=min(a[i][k],a[k][j]);

print(a);
conex(a);

/*
c=conex(a);
if(c==1)
    printf("\n\nVarful %d NECritic\n",v);
else
    printf("\n\nVarful %d Critic\n",v);
*/
}

void main()
{ clrscr();
int a[50][50];
fread(a);
print(a);
// vecin(a);
// subgraf(a);
// RW(a);
// conex(a);
// mcrit(a);
pcrit(a);
getch();
}

Algoritmica Grafurilor (Set 1) Programe C Language

/*
1 - 7, 10;
*/

#include "stdio.h"
#include "conio.h"
#include "iostream.h"

int a[60][60],S=0;
int i,j,n,m;

void read() // Functia de citire de la tastatura
{
printf("Nr de linii si coloane: "); scanf("%d",&n);
for (i=1;i<=n;i++)
    for (j=1;j<=n;j++)
      {
      printf("Legatura intre %d - %d ? ",i,j);
      scanf("%d",&a[i][j]);
      }
}

void print() // Functia de afisare pe ecran
{
for(i=1;i<=n;i++)
    {
    printf("\n");
    for(j=1;j<=n;j++)
      printf("%3d",a[i][j]);
    }
}

void fread() // Functia de citire din fisier
{
FILE *f=fopen("in.txt","r");
fscanf(f,"%d",&n);
for(i=1;i<=n;i++)
    for(j=1;j<=n;j++)
      fscanf(f,"%d",&a[i][j]);
fclose(f);
printf("   S-a citit Fisierul");
printf("\n\nPress any key to continue...");
}

void fprint() // Functia de scriere in fisier
{
FILE *f=fopen("out.txt","w");
for(i=1;i<=n;i++)
    for(j=1;j<=n;j++)
      fprintf(f,"%3d",a[i][j]);
      fprintf(f,"\n");
}

void exit(int x) // Exterior
{
FILE *f=fopen("exit.txt","w");
printf("\n\n Exit: \n");
for(j=1;j<=n;j++)
    {
    if(a[x][j]==1 && x!=j)
      {
      printf("\n %d-%d - %d",x,j,a[x][j]);
      fprintf(f,"\n %d-%d - %d",x,j,a[x][j]);
      }
    }
}

void enter(int x) // Interior
{
FILE *f=fopen("enter.txt","w");
printf("\n\n Enter: \n");
for(i=1;i<=n;i++)
    {
    if(a[i][x]==1 && x!=i)
      {
      printf("\n %d-%d - %d",i,x,a[i][x]);
      fprintf(f,"\n %d-%d - %d",i,x,a[i][x]);
      }
    }
}

void grad() // Gradul Minim, Maxim si Mediu
{ int g[100],gr=0,k=1;
int aux;
g[k]=0;
FILE *f=fopen("grad.txt","w");
for(k=1;k<=n*2;)
for(i=1;i<=n;i++)
    {
    for(j=1;j<=n;j++)
      {
      g[k]=a[i][j];
      k++;
      }
    }
for(i=1;i<=n*n;i++)
    gr+=g[i];
printf("\n\nGradul Maxim: %d ",gr);
fprintf(f,"\n\nGradul Maxim: %d ",gr);
for(i=1;i<=n*n;i++)
    for(j=1;j<=n*n;j++)
      if(g[i]    {
    aux=g[i];
    g[i]=g[j];
    g[j]=aux;
    }
printf("\n\nGradul minim: %d",aux);
fprintf(f,"\n\nGradul minim: %d",aux);
float med;
med=(float(gr)/(n*n));
printf("\n\nGradul mediu: %3.2f",med);
fprintf(f,"\n\nGradul mediu: %3.2f",med);

}

void simetric() // Tipul Grafului: Simetric
{ int f,g,k,x=0,s1[100],s2[100],y=0;
FILE *z=fopen("simetric.txt","w");
// Calculeaza numarul de puncte de deasupra si de sub diagonala
for(i=1;i    x+=i;
// Deasupra diagonalei principale
for(k=1;k<=x;)
    for(j=2;j<=n;j++)
      for(i=1;i    {
    s1[k]=a[i][j];
    k++;
    }
// Sub diagonala principala
for(k=1;k<=x;)
    for(f=2;f<=n;f++)
      for(g=1;g<=f-1;g++)
    {
    s2[k]=a[f][g];
    k++;
    }
// Afisare S1
// for(k=1;k<=x;k++)
//    printf("%3d",s1[k]);
// printf("\n");
// Afisare S2
// for(k=1;k<=x;k++)
//    printf("%3d",s2[k]);
// Comparare
for(k=1;k<=x;k++)
    if(s1[k]!=s2[k])
      y++;
// Decizia: Simetric
if(y!=0)
    {
    printf("\n\tNu-i Simetric\n");
    fprintf(z,"\n\tNu-i Simetric\n");
    }
else
    {
    printf("\n\tSIMETRIC\n");
    fprintf(z,"\n\tSIMETRIC\n");
    }
}

void complet()
{ int x=1;
FILE *f=fopen("complet.txt","w");
for(i=1;i<=n;i++)
    for(j=1;j<=n;j++)
      if(a[i][j]==0 && i!=j)
    x=0;
if(x==0)
    {
    printf("\n Nu-i complet \n");
    fprintf(f,"\n Nu-i complet");
    }
else
    {
    printf("\n Ii Complet \n");
    fprintf(f," Ii Complet \n");
    }
fclose(f);
}

void tranzitiv()
{ int x=1,k;
FILE *f=fopen("tranzitiv.txt","w");
for(i=1;i<=n;i++)
    for(j=1;j<=n;j++)
      for(k=1;k<=n;k++)
    if(a[i][j]==1 && a[j][k]==1 && a[i][k]==0)
       x=0;
if(x==0)
    {
    printf("\n Nu-i tranzitiv \n");
    fprintf(f,"\n Nu-i tranzitiv ");
    }
else
    {
    printf("\n Ii Tranzitiv \n");
    fprintf(f," Ii Tranzitiv \n");
    }
fclose(f);
}

void antisimetric() // Tipul Grafului: Simetric
{ int f,g,k,x=1,s1[100],s2[100];
FILE *z=fopen("antisimetric.txt","w");
for(i=1;i<=n;i++)
    for(j=1;j<=n;j++)
      if(a[i][j]==1 && a[j][i]==1)
    x=0;
// Decizia Finala: Antisimetric
if(x!=0)
    {
    printf("\n\tNu-i AntiSimetric\n");
    fprintf(z,"\n\tNu-i AntiSimetric\n");
    }
else
    {
    printf("\n\tANTISIMETRIC\n");
    fprintf(z,"\n\tANTISIMETRIC\n");
    }
}

void regulat() // Gradul Minim, Maxim si Mediu
{ int g[100],k=0,x=0;
int aux=0;
g[k]=0;
FILE *f=fopen("regulat.txt","w");
    for(i=1;i<=n;i++)
      {
      for(j=1;j<=n;j++)
    {
    if(i!=j)
          x+=a[i][j];
    }
    g[k]=x;
    x=0;
    k++;
      }
    k--;
    printf("\nk= %d",k);
for(i=0;i<=k;i++)
    {
    printf("\n g[%d]= %d",i,g[i]);
    if(g[i]!=k)
      aux++;
    }
if(aux==0)
    {
    printf("\n\nGraf regulat de grad %d",k);
    fprintf(f,"\n\nGraf regulat de grad %d",k);
    }
else
    {
    printf("\n\nGraf neregulat");
    fprintf(f,"\n\nGraf Neregulat");
    }
}

void p-graf()
{
//etc...;

}

void main()
{ int x;
clrscr();
fread();
getch();
clrscr();
// printf("\nNodul: ");
// scanf("%d",&x);
printf("\n");
print();
printf("\n");
fprint();
// exit(x);
// enter(x);
// grad();
// simetric();
// complet();
// tranzitiv();
// antisimetric();
// regulat();
getch();
}

05 April 2014

Programare Procedurala Curs

1. Concepte de baza in informatica.

Concepte de baza. Data, informatie, calculator, informatica.

- Prin data, se intelege un numar, marime, relatie, reprezentarea unui fenomen, lucru sau fapt susceptibil de a fi transformat.

In sens larg, informatia desemneaza un element nou , necunoscut anterior. In sens restrans, informatia poate fi definita ca o masura a incertitudinii inlaturate prin realizarea unui eveniment printr-un set de elemente posibile.

- Informatica este stiinta pluridisciplinara ce are ca scop proiectarea, dezvoltarea si exploatarea unor tehnici si sisteme pentru organizarea, memorarea si distribuirea mai eficienta a informatiei.

- Calculatorul este sistemul fizic ce prelucreaza datele introduce intr-o forma prestabilita si furnizeaza rezultate intr-o forma accesibila utilizatorului fie ca semnale destinate actionarii unor echipamente.

- Evolutia calculatoarelor; scurt istoric:

Abac -> primul dispozitiv de calcul

Masini de calculat bazate pe roti dintate

B. Pascal, Gottfried Wilhem, Charles Babbagee.

1801, Joseph Jacquard inventeaza cartela perforata

1890 Hermann Holleritch

1924 -> IBM (International Business Machines Corporation)

Mark I -> calculator ce utilizeaza relee mecanice comandate electronic

Eniac -> primul calculator electronic (Electronic Numerical Integrator And Calculator) -20000 tuburi electronice, ocupa 160m2, greutate ≅ 30t

1945 -> John Van Neumann a construit un calculator ce reprezenta primul calculator cu proiectare secventiala a instructiunilor si datelor memorate impreuna intro zona speciala numita memoria calculatorului.

2. Arhitectura seriala a calculatoarelor.

Un calculator este alcatuit din trei tipuri de resurse:

• Fizice (procesoare, memorii, dispozitive periferice de intrare-iesire) sau Hard

• Logice (sisteme de operare, programe utilitare, programe utiliator) sau Soft

• Informationale (date organizate si memorate pe suporti de memorie externi)

Functionarea calculatorului devine posibila prin activarea unui anumit tip de conexiuni existente intre unitatile sale cu destinatie speciala numite unitati functionale.

A. Arhitectura seriala (John Von Newmann)

Exista 5 unitati functionale

a. Un mediu de intrare UI

b. Un mediu de iesire UE

c. Un mediu de memorare UM (mediu de memorare)

d. Un element de comanda si control UCC (unitate de comanda si control)

e. Un element de executie UAL (unitatea aritmetica si logica)

3. Arhitectura Unitatii de memorie (Interna si Externa)

Memoria

Interna (primara, principala)

· Poate fi privita ca un ansamblu de locatii (celule) de memorie identificabile prin adrese. Se spune ca memoria este adresabila.

· Componenta fizica de baza a memoriei este bistabilul (perechea de stari perforat-neperforar; perechea de stari aprins-stins, magnetizat-nemagnetizat, inchis-deschis; perechea de tensiuni 0V – 5V). Din punct de vedere matematic un bistabil se reprezinta prin perechea 0-1.

· Perechea 0-1 reprezinta un bit (binary digit)

· 8 biti consecutivi formeaza un byte (octet)

· Bitul reprezinta cea mai mica unitate de datecare poate fi reprezentata si prelucrata. Byte-ul reprezinta cea mai mica unitate de data care poate fi adresata. Memoria interna a calculatorului este reprezentata de o succesiune de octeti.

· 2, 3 sau patru octeti consecutivi formeaza un cuvant de memorie

· Accesul la memorie este aleator sau direct in sensul ca ma duc direct pe adresa respectiva, fara sa parcurg celelalte adrese

0 1 2

Memoria interna este de tip:

i. RAM (random access memory)- memorie volatila

ii. ROM (read only memory)- memorie nevolatila

Multiplii:

Ø 1Kb = 1024 b - 2¹⁰

Ø 1 Mb = 1024 Kb

Ø 1 Gb = 1024 MB

Ø 1 TB= 1024 GB

Ø 1 PB

Ø 1 EB

Tuburi catodice, diode si condensatori, inele de ferita, iar in epoca moderna circuite integrate (LSI- large scale integration si VLSI – very large scale integration)

4. Memoria Externa (secundara, auxiliara)

Benzi magnetice

Accesul este secvential – pentru a ajunge la blocul k trebuie sa parcurg blocurile anterioare.

§ Discuri magnetice

§ Floppy disk

§ Hard disk

Accesul este atat secvential, cat si direct.

Discuri optice - CD (compact disk)

La discurile magnetice informatia este dispusa concentric, iar la Cd, in spirala.

5. Calculatoare paralele

Actualmente, viteza de procesare a datelor pentru arhitectura seriala este de 10⁹ op/sec si se apreciaza ca limita fizica este de 10¹⁰ op/sec.

Arhitectura paralela reprezinta o colectie de procesoare, de regula de acelasi tip, interconectate intr-o anumita retea, care permite coordonarea activitatilor si schimbul de date.

Performanța calculatorului paralel apare in primul rand din posibilitatea de a se executa simultan mai multe operatii. Un calculator paralel nu este obligatoriu mai scump decat un calculator serial.

În ciuda performantelor sale calculatorul paralel nu a patruns suficient pe piata calculatoarelor. Motivul principal nu-l reprezinta neaparat pretul, ci mai degraba complexitatea softului cu care trebuie echipat un astfel de calculator.

Primele calculatoare cu arhitectura paralela s-au materializat in Statele Unite in anii 1970 cand au fost inventate calculatoarele Cray si Ciber.

Clasificarea lui Flynn:

1. SISD (Single Instruction Single Data)

2. SIMD(Single Instruction Multiple Data)

3. MISD(Multiple Instruction SIngle Data)

4. MIMD(Multiple Instruction Multiple Data)

Clasificare dupa granulatie:

1) Fina (apox. 1000 de procesoare)

2) Medie (aprox. 64 de procesoare)

3) Grosiera (aprox 16 procesoare performante)

Topologie

1) Liniara

2) Inel

3) Grila

4) Arborescent

5) Pe structura de hipercub

6. Generatii de calculatoare:

Generatia I (51-58) bazata pe circuite de procesare si de memorare construite cu ajutorul tuburilor electronice.

Caracteristici: fiabilitate redusa masurata in ore de functionare; consum mare de energie electrica; necesita climatizare; capacitatea memoriei interne mica; viteza de executie de ordinal sutelor de operatii pe secunda; intrarile se fac de pe cititoare de cartel, iar iesirie se fac la imprimanta.

Generatia a IIa (59-63) se bazeaza pe tehnologia tranzistorilor si a diodelor semi-conducatoare. Circuitele sunt mult mai sigure (fiabilitate = zile de functionare); mai mici ca volum; necesita mai putina energie; viteze = mii de operatii / sec; memorie interna = zeci de mii de caractere; pt memoria externa se foloseste banda magnetic si discurile magnetice.

Generatia a IIIa (74-79) are la baza circuite integrate; are loc un puternic proces de miniaturizare. Mii de tranzistori sunt gravati pe o pastila de siliciu; fiabilitate = saptamani de functionare; memorie interna = sute de mii de caractere ; viteza de executie = milioane de operatii / secunda; apar sistemele de operare; apar mini-calculatoarele)

Generatia a IVa (79-prezent) are la baza tehnologiile de integrare pe scara larga LSI (Large Scale Integration) si foarte larga VLSI (Very Large Scale Integration). Sute de mii de tranzistori gravati pe o pastila de siliciu; fiabilitatea circuitelor se masoara in luni de zile de functionare; capacitatea memoriei interne = milioane de caractere; apar microprocesoarele; viteza de executie = sute de milioane de operatii / secunda.

Tipuri de calculatoare:

1. Main frame

2. Minicalculatoare

3. Microcalculatoare

Main frame-urile sunt calculatoare cu volum mare, au unul sau mai multe procesoare foarte rapide, memorie interna foarte mare. Exista doua tipuri mari de probleme ce se rezolva cu ajutorul lor:

-primul tip se refera la probleme caracterizate prin milioane de tranzactii zilnice; problema a caror rezolvare necesita efectuarea unor calcule stiintifice de complexitate ridicata (probleme specifice bancilor, agentiilor etc)

-al doilea tip se refera la probleme de modelare a zacamintelor; probleme de prelucrare a informatiei grafice, de proiectare a unor mega-structuri etc

Minicalculatoarele se refera la calculatoarele cu performante bune, insa la preturi de cumparare si intretinere mai mici. Se folosesc ca statii de lucru CAD (Computer Aided Design)

Microcalculatoarele sunt calculatoarele personale (Personal Computers). Arhitectura unui microcalculator este construita in jurul unui microprocesor ce constituie unitatea centrala de prelucrare si care poate fi folosita doar de o singura persoana la un moment dat.

7. Baze de numeratie: Conversia numerelor intregi.

Orice numar Q ≥ 2,

Q= 10 { 0,1,2... 9} 935.7942

Q=2 {0,1} 10110.1011

Q=8 {0,1..7} 53.274

Q=16 {0,1..9,A,B,C,D,E,F} BC2.A3

Conversia numerelor dintr-o baza in alta

1. Conversia numerelor intregi

· Conversia numerelor din baza q in baza 10

Nq = an an-1 ... a1 a0

N10 =an qn + an-1 qn-1 +... + a1 q + a0

Conversia unui numar reprezentat intr-o baza oarecare q in baza 10 se face dezvoltand polinomial numarul Nq si efectuand calculele.

Ex:

N2 = 11010

N10= 1* 2 4+ 1*23 + 0* 22 + 1*21 + 1 * 20

40960+512+192+3 = 41667

· Conversia numerelor din baza 10 in baza q

N10 / q = an qn-1 + an-1 qn-2 +... + a1 + a0/q => a0 = rest impartirii lui N10 la q

N10’ / q = an qn-2 + an-1 qn-3 +... + a1 /q

Ex:

26:2 = 13 rest 0

13:2 = 6 rest 1

6:2 = 3 rest 0 => 2610 = 11010 2

3:2 = 1 rest 1

1:1 = 1 rest 1

26:16 = 1 rest 10 => 1A = 1 * 161 + 10

8. Conversia partii fractionare

· Conversia din baza q in baza 10

Fq = . a-1 a-2 a-3 .... a-m ....

F10= a-1 q-1 + a-2 q-2 +... + a-m q-m + ...

Conversia partii fractionare a unui numar reprezentat intr-o baza oarecare q in baza 10 se face dezvoltand polinomial acel numar.

0.1101 = 1 * 2-1 + 1 * 2-2 + 0 * 2-3 + 1 * 2-4

0.2C = 2* 16-1 + 12 * 16 -2 = 0.17183

· Conversia din baza 10 in baza q

Q * F₁₀ = a_-1 + a_-2 q^-1 +... + a_-m q^-m+1 + ... => a_-1 = [qF₁₀]

F₁₀ ‘ = a_-2 q^-1+ a_-2 q^-2 +... + a_-m q^-m+1 + ... | q

Q* F₁₀ = a_-2 + a_-3 q^-1 +... + a_-m q^-m+2 + ... => a_-2 = [qF₁₀’]

Ex:

0.171875 (10) = ? (16)

9. Conversia rapida a numerelor din baza 2 in baza 8 si 16 si invers

Procedee de conversie rapida intre bazele 8, 16 si baza 2

Triade
8	2
0	000
1	001
2	010
3	011
4	100
5	101
6	110
7	111

+	0	1
0	0	1
1	1	10

2<-> 8

*	0	1
0	0	0
1	0	1

Conversia unui numar scris in baza 8 in baza 2 se face inlocuind fiecare cifra a numarului scris in baza 8 cu triada sa corespunzatoare.

Conversia unui numar din baza 2 in baza 8 se face in felul urmator:

a. Se pun in evidenta triadele (de la dreapta spre stanga pentru partea intreaba, si de la stanga spre dreapta pentru partea fractionara

b. Fiecare triada se inlocuieste cu cifra octala corespunzatoare

In cazul bazei 16 se procedeaza analog.

10. Reprezentarea numerelor intregi in memoria calculatorului

Reprezentarea numerelor intregi se poate realiza in 3 moduri:

1. Reprezentarea in modul si semn (cod direct)

2. Reprezentarea in complemet fata de 1 (cod invers)

3. Reprezentarea in complement fata de 2 (cod complementar)

In reprezentarea in modul si semn, bitul din extremitatea stanga este folosit pentru codificarea semnului. Daca numarul este pozitiv, bitul de semn trebuie sa aiba valoarea 0. Daca numarul este negativ, bitul de semn trebuie sa aiba valoarea 1.

Ex: + 7 = 0 0 0 0 0 1 1 1

- 7 = 1 0 0 0 0 1 1 1

Dezavantaje: exista doua reprezentari pentru 0:

Ex: + 0 = 0 0 0 0 0 0 0 0

- 0 = 1 0 0 0 0 0 0 0

Acest lucru creaza probleme in realizarea circuitelor electronice pentru adunare; bitii de semn trebuiesc tratati separat. Trebuie definita operatia de scadere a numerelor astfel reprezentate.

Complementul fata de 1 al unui numar binar se obtine prin locuirea fiecarei cifre binare cu complementul sau fata de 1. Complementul fata de 1 al cifrei 1 este 0 iar complementul fata de 1 al cifrei 0 este 1.

Ex: + 7 = 0 0 0 0 0 1 1 1

- 7 = 1 1 1 1 1 0 0 0

Avantaje: operatia de scadere se reduce la o operatie de adunare prin reprezentarea scazatorului in cod invers. Daca rezultatul este negativ va fi reprezentat tot in cod invers. Daca apare transport in stanga rangului de semn, atunci acesta se adauga la bitul cel mai putin semnificativ (cel mai din dreapta).

Si la aceasta codificare, 0 are doua reprezentari:

Ex: + 0 = 0 0 0 0 0 0 0 0

- 0 = 1 1 1 1 1 1 1 1

Complementul fata de 2 al unui numar se obtine astfel:

1. Se obtine complementul fata de 1 al numarului

2. Se aduna 1 la rangul cel mai putin semnificativ al numarului.

Daca apare transport la stanga rangului de semn, acesta se ignora. Daca rezultatul este negativ, acesta va fi reprezentat in cod complementar fata de 2. + 0 = 0 0 0 0 0 0 0 0

Obs: Folosind acest cod, 0 are o singura reprezentare:

11. Reprezentarea numerelor reale in virgula mobila.

Virgula fixa (virgula care desparte partea intreaga de partea subunitare are pozitie fixa)

0000.0000<= N2 <= 1111.1111

0.0 <=N10 <= 1* 23 + 1* 22+ 1*21+1*20+1*2-1+1*2-2+1*2-3+1*2-4

F = fractie (mantisa)

Q = baza

e = exponent

In plus, cu conditia 1/q <= |f| <1 aceasta="" alfa="" ca="" este="" in="" l-am="" mobila="" normalizata.="" normalizata="" pe="" reprezentarea="" reprezentat="" se="" si="" span="" spune="" unica="" viregula="" virgula="">

43.7852 = 4.37852 * 101 = 0.437852 * 102 = 0.0437852 * 103=

1/10 = 0.1 <= |f| < 1

Erori ce pot sa apara:

· Underflow si overflow (cand se depaseste limita)

· Reprezentarea numerelor reale cu un numar foarte mare de zecimale, sau cu o infinitate de zecimale, de ex numarul pi.

Pentru prevenirea propagarii erorilor in rezolvarea numerica a problemelor pe calculator trebuie sa dezvoltam algoritmi care asigura stabilitatea calculelor.

Virgula Mobila

i. In virgula mobila in simpla precizie

Reprezentarea se face pe 32 de biti si are urmatoarea forma:

32	31							24																							1
S	Caracteristica (C)								Fractia(f)

S = 0 nr negativ

= 1 nr pozitiv

0<= C <= 1111 1111 = 1*27+... + 1 * 20= = 28-1 = 255

1<= C <= 255

Pentru a reprezenta si exponentii neg duc o functie simpla in intervalul meu intr-un interbal simetric fata de 0.

ii. In virgula mobila in dubla precizie

64	63							53	52																						1
S	Caracteristica (C)								Fractia(f)

C = e + 1023

0 <= c <= 215 – 1 = 2047

-1023 <= e <= 1024

12. Reprezentarea caracterelor alfanumerice.

Calculatoarele prelucreaza atat informatie numerica, cat si informatie nenumerica. Pentru reprezentarea informatiei numerice se utilizeaza rezultatele matematice si conventiile prezentate.

Reprezentarea informatiei nenumerice (litere mari si mici, cifre zecimale, semne de punctuatie, operatori aritmetici si logici, simboluri pentru controlul comunicatiei si evitare etc.) se face pe baza unor conventii sau coduri. Aceste coduri asociaza fiecarui semn o configuratie binara in mod unic. Pentru o multime de m semne avem nevoie de 2ⁿ unde n este cel mai mic numar natural astfel incat 2n ≥ m.

? 011 000

A 100 001 cuvinte moarte

: 101 010

! 110 011

/ 111 100

101 aceste coduri le-am alocat pt catacterele din stanga

110

111

ASCII este unul dintre cele mai cunoascute standarde de coduficare (American Standard Code for Information Interchange). Codul ASCII conserva ordinea alfabetica si ordinea cifrelor in sensul ca ‘a’ < ‘b’ deoarece cod(a) < cod(b). De asemenea ‘2’ < ‘7’.

Prezentarea acestei ordini este importanta deoarece pot sa coordonez sirurile de caractere.

Car 1 <= car 2 <=> cod (car1) <= cod(car2)

13. Sisteme de operare. Notiuni de baza.

Un sistem de operare este o interfata intre componenta hardware si utilizator, reprezentat prin programele sale numite programe de aplicatii. Mai precis un sistem de operare este un ansamblu de programe de control care ghideaza calculatorul in executarea sarcinilor sale si asista programele de aplicatie si utilizatorul prin intermediul anumitor functiuni.

Un sistem de operare este alcatuit din doua categorii de programe:

v Programe de comanda si control

Coordoneaza si controleaza toate functiile sistemului de operare. Principalele sale componente sunt:

- Supervizorul

o Coordoneaza toate componentele sistemului de operare

o Planifica, lanseaza si urmareste executia programului

o Depisteaza si trateaza evenimentele care apar la executie.

Rutinele supervizorului sunt rezidente in memoria interna. Celelalte rutine sunt tranziente (sunt memorate in mem. externa si incarcate la nevoie in memoria interna)

- Sistemul de gestiune al intrarilor si iesirilor

o Coordoneaza modul de alocare a dispozitivelor periferice catre programe precum si transferul dintre dispozitivele de intrare-iesire si memorie.

v Programe de servicii

o translatoare (compilatoare,interprete)

o editoarele de legaturi(link editoare)

o incarcatoare

o editoare de text

o programe utilitare

o progr bibliotecar

o programe pentru gestiunea operatiilor de intrare/iesire pt fisiere si baze de date

Sisteme de operare:

o secventiale

La un sistem secvential este vb de calculatoare secventiale cu un singur procesor, un singur program ce poate fi executat. La aceste sisteme exista o disproportie semnificativa intre timpul necesar pt executia progr si timpul de utilizare al procesorului.

o multiprogramare;

La multi programare se pot incarca 4 programe, un singur procesor, dar la un moment dat se executa doar un singur program datorita calculatorului serial.

o prelucrare multipla

Pentru calculatoarele paralele

Fazele executiei unui program:

o timp real

In timp real se refera la sistemele de monitorizare si conducere al unor procese tehnologice si industriale.

14. Fazele executiei unui program.

Modul de lucru al compilatorului este urmatorul: se analizeaza din punct de vedere sintactic codul sursa si se furnizeaza o lista de erori. Dupa eliminarea erorilor de catre programator, se obtine forma binar translatabila (BT) a programului. Formatul BT inseamna un numar de module obiect fara legatura intre ele. Aceste module sunt legate de catre un program special numit editor de leghaturi sau linkeditor.

Un program numit program incarcator va prelucra forma IMT si o va incarca la o adresa speciala unde programul va fi executat.

Deoarece prezenta unui compilator impune un necesar de memorie suficient pentru a memora atat programul sursa cat si programul compilat, compilatoarele sunt prezente mai ales unde este posibil indeplinita aceasta conditie. Avantajul compilatorului este ca odata compilat, programul poate fi catalogat intr-o bibilioteca si utilizat ori de cate ori este nevoie. Alternativa la acest mod de translatare este interpretorul.

Se analizeaza sintactic linie cu linie programul. Daca linia de program analizata este corecta din punct de vedere sintactic, se executa aceasta linie de program inaintea analizei urmatoarei linii.

Se observa ca, in acest caz, nu se poate face o demarcatie clara intre faza de translatare a programului si faza de executie. Avantajul consta in faptul ca, intrucat toate liniile de program trec succesiv prin aceeasi zona de memorie, necesarul de memorie este mai mic. In acelasi timp, orice executie a programului implica automat analiza sa sintactica, chiar daca, stim ca programul este corect din punct de vedere sintactic.

Dezavantaje / Avantaje: timp de executie mare / necesar de memorie mai mic.

15. Etapele rezolvarii unei probleme cu calculatorul.

Pentru a asigura eficienta si portablitatea programelor, este necesar sa se urmeze anumiti pasi numiti si etape de rezolvare:

1. Analiza problemei

2. Proiectarea algoritmului de rezolvare

3. Descrierea algoritmului

4. Codificarea algoritmului (obtinearea programuluI)

5. Testarea programului

6. Executia programului, obtinearea rezultatelor si interpretarea lor

7. Intretinerea programului

1. Analiza problemei; se are in vedere stabilirea modelului logico-matematic al problemei. Aici se identifica cu claritate functia problemei, se stabilesc datele de iesire si datele de intrare, aceasta etapa are ca principal scop intelegerea cat mai exacta a problemei pe ca dorim sa o rezolvam.

2. Proiectarea algoritmului de rezolvare are ca scop stabilirea algoritmului de rezolvare a problemei. Este etapa in care se precizeaza operatiile pe care trebuie sa le execute un calculator pentru a rezolva problema. In cazul problemelor complexe, este recomandabila descompunerea problemelor in probleme ce pot fi rezolvate mai usor. Aceasta tehnica numita Top – Down va avea ca efect obtinerea unui sistem de module conectate intre ele dupa logica de rezolvare. Impartirea problemei in subprobleme prezinta avantajul lucrului eficient in echipa, in sensul ca subprolemele pot fi rezovlate simultan de catre membrii echipei. In acelasi timp, aceasta abordare modulara are avantaje evidente si in activitatea de depanare a programelor. Un program modular poate fi descris cu ajutorul unei diagrame de structura.

3. Descrierea algoritmului; o importanta deosebita trebuie acordata stilului de programare. In general se considera ca stilul de programare este bun daca indeplineste conditii cum ar fi: programarea trebuie sa fie insotita de documentatia de analiza si proectare care trebuie sa contina elemente minimale: descrierea programului, diagrama de structura, tabele de descriere a variabilelor de intrare – iesire.

Procedee de validare a datelor: sume de control, cifre de control, domenii de apartenenta, citirea cu ecou, verificarea unor relatii existente intre variabilele de intrare.

4. Codificare algoritmului; programul trebuie sa fie lizibil (scriere in fierastrau –identanta-)

Ex: prin alegerea unor numere sugestive pentru identificator; prin folosirea neabuziva a comentariilor

5. Testarea programului; etapa de testare este etapa in care se elimina erorile programului. Acestea pot fi de natura sintactica sau logica. Erorile de sinteza se elimina ca urmare a consultarii listelor de erori date de compilator. Stabilirea corectitudinii din punct de vedere logic a programului se poate face prin demonstrarea matematica sau prin testarea programului folosind date de test. Deoarece demonstrarea corectitudinii programului prin metode matematice este dificila chiar si pentru programe mici, metoda uzuala este metoda datelor de test. Datele de test trebuiesc alese cu grija, astfel incat sa se poata vailda toate ramurile programului. Daca sunt erori, se incearca validarea acestora, utilizand diferite metode cum ar fi: afisarea unor mesaje din loc in loc, utilizarea facilitatilor de depanare moderne, ca de exemplu: ferestre de observare a valorilor expresiilor in timpul executiilor; executia pas cu pas a liniilor de program.

6. Executia programului;

7. Intretinerea programului; consta in modificare ale programelor ori de cate ori este nevoie in scopul mentinerii aplicatiei la zi.

16. Date elementare si structurate

Prin tip de date intelegem valorile pe care datele respective le pot lua, precum si operatiile care se pot executa cu aceste date.

Date:

- Numerice

o Intreg

- Zecimal 79,-52...

- Octal

- Hexazecimal

o Real

- Notatie cu punct 75.895 0.24

- Notatie stiintifica (exponentiala) 0.7e-03 0.24E+0.5

a	B	A sau B	A si B	Nu A
0	0	0	0	1
0	1	1	0	1
1	0	1	0	0
1	1	1	1	0

· E +/- n -> 10+/- n

- Logice

o True 1

o False 0

- Alfa-numerice

Tipuri de date:

- Constante

- Variabile

o Statice v

o Dinamice v

Structuri de date:

1. Tabloul

Este o colectie de date de regula omogena. Accesul la valorile unui tablou se face cu ajutorul indicilor. Din acest motiv, variabilele care rezulta se mai numesc variabile indexate.

a. Tablouri unidimensionale

b. Tablouri multidimensionale

2. Lista

Inlantuire de elemente intr-o anumita ordine. Din punctul de vedere al implementarii poate fi:

· Statica

Elementele vecine din lista sunt memorate in locatii de memorie vecine. Ca suport de implementare se foloseste de exemplu tabloul unidimensional.

Ion

Nae

Gigi

Vasile

Ion, Nae, Gigi, Vasile

Dinamica (inlantuita)

Intr-o reprezentare dinamica, elementele vecine din lista nu sunt memorate obligatoriu in locatii de memorie vecine

Ion

Nae

Gigi

Vasile

a. Coada

b. Stiva

3. Arborele

4. Graf , digraf

5. Inregistrarea

6. Fisierul

7. Baza de date

3. Arborele

Modeleaza relatii ierarhice (piramidale) intre obiecte.

Noduri terminale(frunze)

Parcurgerea arborelui inseamna vizitarea fiecarui nod din arbore o singura data

4. Graf , digraf

Graful este structura de date care modeleaza toate tipurile de relatii simetrice dintre obiecte. Digraf (directed graf) – graf directionat.

Graf

Digraf

5. Inregistrarea

Inregistrearea modeleaza colectii neomogene de date.

Nume	Prenume	Grupa	An	Specializare	Tip liceu terminat
Ionescu	Ion	4023	I	Info	R

6. Fisierul

Colectii de date memorate pe suporti de memorie externa.

7. Baza de date

Colectie de fisiere care dispune de un sistem de management al informatiei.

17. Algoritmi. Caracteristici, descriere (Teorema de structura)

Definitie:

Un algoritm consta intr-o multime ordonata de pasi executabili , descrisi fara ambuguitate, care definesc un proces finit. Cu ajutorul unui algoritm, un set de date de intrare numit domeniu de definitie al algoritmului este transformat intr-un set de date de iesire numit domeniul de valori al algoritmului.

Caracteristici:

1. Generalitare – furnizeaza rezultate pentru diferite seturi de date de intrare

2. Finititudine – procesul trebuie sa fie finit pentru a furniza un rezultat concret

3. Neambiguitate – fiecare pas se executa dupa reguli bine precizate

Descrierea algoritmului:

a. Limbajul natural

b. Pseudo limbajele

a. Schema logica

b. Pseudocod

Teorema de structura

Este elaborata de doi matematicieni Bohm si Jacopini.

Orice algoritm care are un singur punct de intrare si un singur punct de iesire poate fi reprezentat ca o combinatie de trei structuri algoritmice fundamentale:

a. Secventa de doua sau mai multe operatii

Inseamna o anumerare de elemenate

b. Decizia (alegerea unei operatii din doua posibile)

c. Iteratia cu test initial (repetarea unei secvente cat timp este adevarata o anumita conditie)

Acestea se mai numesc structuri de decizie fundamentale, sau structuri de control.

Schema logica - Pseudocod

ax + b = 0

Exemplu: max a,b

Citeste a,b

Daca a>b atunci

Secventa

Ex: max (a,b)

Citeste a,b

Daca a,b

Atunci max <- a="" span="">

Altfel

Max <- b="" span="">

]

Scrie mesaje

STOP

Decizia generalizata (selectia)

Alege expresie dintre:

C1: secventa 1

C2: secventa 2

Cn: secventa n

Altfel secenta n + 1

Sfarsit

18. Instructiuni de decizie si iteratie in pseudocod.

Iteratia

Cu test initial

Cu contor

Cu test final

Iteratia cu test initial

Cat timp conditie executa secventa

]

Obs: 1. Este posibil ca secventa sa nu se execute (cand conditia este falsa)

2. Conditia trebuie sa permita iesirea din ciclu dupa un numar finit de pasi, in caz contrar obtinem un ciclu infinit (bucla eterna)

Iteratie (repetitie, ciclu, bucla)

Bucla eterna

Ex: x1, x2, … , 0 <- sentinela="" span="">

Citeste x

S= 0

Cat timp x 0 executa

S S + x+citeste x

]

Scrie s

STOP

Iteratia cu contor

Pentru V <= Vi, Vf, r, executa

secventa

]

V = contor

Vi = valoare initiala

Vf = valoare finala

r = ratie

ex: s = x1 + x2 + … + xn

citeste n

s <- 0="" span="">

Pentru I <- executa="" i="" n="" span="">

Citeste x

S <- s="" span="" x="">

]

Scrie S

STOP

Iteratie cu test final

Repeta secventa cat timp conditie

1. Secventa se executa cel putin odata

2. Secventa trebuie sa contina operatii care sa permita iesirea din iteratie dupa un numar finit de pasi

Ex: y =

Repeta

Citeste x

Cat timp x 0

Y <- span="">

Scrie y

STOP

Proceduri si functii

Procedura nume procedura (lista parametri formali {fictivi})

Corpul procedurii

Sfarsit

Nume_procedura (lista de parametrii actuali {efectivi})

La apelul unei proceduri intre parametrii formali si parametrii actuali se va realiza o corespondenta biunivoca care va permite transferul valorilor parametrilor actuali catre parametrii formali (daca sunt parametrii de intrare) si transferul parametrilor formali in actuali (daca sunt de iesire)

Functia

Functie nume functie (lista parametrii formali {fictivi})

Corpul functiei

Sfarsit.

Ex: Functia f(x)

Daca x < 0. Atunci

F x – 1

19. Generatii de limbaje de programare

1. Limbajul cod-masina (1950-1958)

o Instructiunile si adresele sunt transpuse in cod-masina sub forma unor siruri binare sau hexazecimale

o Fiecare tip de calculator are un limbaj-masina specific adica limbajele sunt dependente de masina

o Programarea calculatorului intr-un astfel de limbaj este greoaie (programatorul trebuie sa tina cont de aspectele specifice calculatorului pe care lucreaza si este fortat sa gandeasca in termenii operatiilor elementare ale calculatorului)

2. Asamblare (1958-1964)

o Intr-un limbaj de asamplare in locul codurilor numerice care specifica adrese de memorie se folosesc nume simbolice (identificatori), iar in locul codurilor pentru operatii se folosesc cuvinte cu inteles prestabilit numite mnemonice (mnemonica = tehnica prin care poti retine mai usor anumite lucruri)

- Ex: in loc sa folosesti pt niste numere care inseamna op de adunare se foloseste ADD

- Pentru sau se foloseste JMP

o Folosirea simbolurilor pentru a reprezenta coduri de operatii si locatii de memorie a facut ca limbajele de asamblare sa se mai numeasca si limbaje simbolice. Totusi, pentru a putea fi executat, un program scris in limbaj de asamblare trebuie mai intai tradus in cod-masina cu ajutorul unui program translator numit Asamblor. Numele de asamblor provine din faptul ca acest translator are si sarcina de a asambla instructiunile cod-masina din codurile de operanzi si operatori .

- Avantaje:Programatorul nu mai este constrans sa cunoasca cu exactitate adresele locatiilor de memorie cu care lucreaza si codurile instructiunilor programului

- Programatorul se poate concentra mai mult asupra problemelor de rezolvat

- Se reduce riscul producerii unor erori

o Dezavantaje

- Programatorul este obligat in continuare sa gandeasca la nivelul operatiilor elementare specifice unui calculator

- La fel ca si in limbajele cod-masina, in limnajul de asamblare nu exista structutri de date si structuri de control

- Programele nu sunt portabile (portabilitate=posibilitatea de a transfera un program de pe un tip de calculator pe alt tip de calculator fara a face modificari sau facand modificari minime)

Limbajele cod masina si limbajele de asamblare se numesc de nivel coborat.

3. Limbajele generatiei a treia (de nivel inalt) (1964-1970)

a) Sunt limbaje care ofera programatorului posibilitatea sa gandeasca problema in termenii unor primitive de nivel inalt apropiate modului de gandire uman

b) Sunt prezente structurile de date si structurile de control

c) Programele scrise in astfel de limbaje sunt portabile

d) Pentru a putea fi executate, programele scrise in limbaj de nivel inalt au nevoie sa fie traduse in limbaj de nivel coborat

e) Principalele mijloace de translatare sunt compilatoarele si interpretoarele (interpretele)

f) Exact ca in domeniul limbajelor naturale, si in domeniul limbajelor artificiale din generatia a treia apar diverse dialecte. Din acest motiv au avut si au loc mai multe conventii care au permis adoptarea unor standarde internationale pentru cele mai cunoscute limbaje de catre American National Standard Institute.

g) Un limbaj de nivel inalt nu asigura insa atunci cand este nevoie o folosire foarte eficienta a resurselor calculatorului in care este implementat programul

h) C-ul este un limbaj de nivel mediu

Limbajele generatiei a treia

1. Limbajul Fortran (FORmula TRANslator) 1957

Este printre cele mai reprezentative de nivel inalt. Este un limbaj orientat spre rezolvarea problemelor care necesita calcule matematice complexe. Ramane prin adaptarile sale permanente si la ora actuala cel mai puternic limbaj din acest domeniu.

2. Cobol (COmmon Business Oriented Language)

Apare in aceeasi perioada. Este un limbaj orientat spre rezolvarea problemelor de natura economica. Era folosit pentru gestiunea conturilor bancare, probleme din domeniul economic in special.

La ora actuala cobol cunoaste un declin, in sensul ca nu se mai lanseaza proiecte in COBOL, insa aplicatiile importante dezvoltate in COBOL sunt mentinute in stare de functionare. Cobol a functional foarte bine pe Mainframe-uri.

3. Limbajul ADA (Augusta Ada Byron)

Apare ca o incercare de a construii un limbaj care sa inlocuiasca si sa adune la un loc avantajele limbajelor Fortran si Cobol. Numele lombajului provine de la Augusta Ada Byron care este considerata primul programator din istorie. Programul insa nu a avut popularitatea scontata.

4. Limbajul BASIC (Beginner’s All Purpose Symbolic Instruction Code)

Este orientat pe calcule ca si Fortran, dar nu are nici pe departe putereA Fortranului. Varianta noua a acestui limabaj poarta denumirea de Visual Basic in care se pot dezvolta aplicatii incepand cu Win 95.

5. Limbajul Pascal

Este dezvoltat in jurul anilor 70 la Zurich de profesorul Niklaus Wirth. Este un limbaj important deoarece implementeaza foarte riguros conceptele programarii structurate.

Programele dezvoltate in Pascal sunt foarte limpezi si clare, semanand foarte bine cu fraze din limba engleza.

6. Limbajul ALGOLE (ALGOrithmic Language)

7. PL/1 (Programming Language 1)

8. Limbajul C

Este un limbaj de nivel mediu (preia avantejele si ale unui limbaj de nivel coborat, si ale unui limbaj de nivel inalt). A fost conceput de laboratoarele Bell in anii 70. Este dupa unele statistici cel mai raspandit limbaj de pe glob. A fost raspandit in special in dezvoltarea software-ului de sistem.

20. Structura generala a unui program C

Limabajul a fost inventat in anii ’70 de catre Dennis Ritchie la laboratoarele Bell. Isi are originea in BCPL (Basic Computer Programming Language) care prin perfectionari succesive s-a transformat in limbajul B si in final limbajul C.

Raspandirea limbajului se datoreaza folosirii sale in scrierea sistemului de operare Unix. Versiunea a 5-a a Unix a fost descrisa de Dennis Ritchie + Brian Kenningam in cartea “The C programming language”.

In momentul aparitiei microcalculatoarelor au inceput sa apara diverse variante sau dialecte de C. Intrucat exista pericolul stergerii identitatii limbajului C in anul 1983 o comisie speciala incepe lucrul pentru elaborarea standardului ANSI C (American National Standard Institute), care dureaza 6 ani.

Limbajul C este un limbaj de nivel mediu, adica imbina trasaturile limbajelor de nivel inalt, cu cele ale limbajelor de nivel coborat. Are un compilator mult mai permisiv decat al limbajului Pascal si ofera o mai mare libertate programatorului, un numar de cuvinte-cheie mic, dar o familie bogata de operatori, familie care permite crearea unor programe flexibile.

Structura unui program C

Directive preprocesor

Declaratii globale

Tip main(lista de argumente)

{

Declaratii locale

Instructiuni

}

Tip f1 (lista argumente)

{

Delcaratii locale

Instructiuni

}

....

Tip fn (lista argumente)

{

Declaratii locale

Instructiuni

Cuvintele main, f1,.., fn sunt nume de functii.

Functia main este obligatorie in C. Lansarea unui program in C si terminarea programului se fac cu ajutorul instructiunilor din main. Orice functie din program poate apela oricare alta functie din program, exceptie face functia main care poate apela orice functie din program , dar care poate fi apelata doar din sistemul de operare.

Functia main poate figura oriunde in program, insa, de regula ocupa prima pozitie pentru a mari lizibilitatea programului.

Directivele preprocesor sunt instructiuni destinate compilatorului care face transformari preliminare asupra textului inainte de a incepe compilarea. Directivele se constituie ca un limbaj in interiorul limbajului C si ofera anumite facilitati:

· Compilarea conditionata a unor portiuni de cod

· Inlocuirea in text a unui identificator la fiecare aparitie a sa cu un set de caractere

· Includerea unui fisier sursa in program etc

O functie este alcatuita din antet si un bloc de declaratii delimitat de acolade, numit si corpul functiei.

Antet

{Corpul functiei

Sfarsit

Daca precizam doar antetul functiei, se spune ca am declarat functia. Declararea moderna a unei functii in C se numeste prototip. Daca precizam si corpul functiei se spune ca am definit functia. Apelul unei functii se face nume_functie(lista parametrii actuali).

O functia C nu poate fi declarata sau definita in interiorul altei functii (functiile in C nu pot fi imblicate, incuibarite). Declaratiile globale se refera la entitati de exemplu tipuri de date, variabile, etc, care sunt recunoscute de toate functiile. Declaratiile locale limiteaza valabilitatea acestor entitati doar la nivelul functiei unde se fac. In constructia unui program C apar doua categorii de functii:

a) Functii utilizator – elaborate de utilizator

b) Functii standard (predefinite) – care pot fi preluate, apelate, din biblioteca standard a limbajului

- Functii de intrare-iesire

- Functii pentru prelucrarea caracterelor

- Functii matematice

In mod corespunzator, prototipurile (antetele) acestor functii sunt grupate in fisiere antet – header (.h):

a) Math.h

b) String.h

c) Stdio.h

d) Conio.h

Pentru a utiliza o functie standard in program, trebuie cunoscut prototipul ei. Acest lucru este posibil prin includerea in programe a fisierelor header corespunzatoare. Un program C poate avea functiile editate intr-un singur fisier (programe monofisier), sau in mai multe fisiere (programe multifisier).

Elemente de baza ale limbajului C

1. Alfabetul limbajului

A. Simboluri afisabile

a. Litere mari si mici ale alfabetului englez

b. Cifre zecimale

c. Liniuta de subliniere (underscore)

d. Semne de punctiatie si semne speciale

, . : ; ? ‘ ( ) [ ] < > “ ! | \ / ~ (tilda) #(diez) &(ampersand) ^ * - = + { } %

B. Simboluri neafisabile

Sunt numite si simboluri fara echivalent grafic (Backslash caracter). Aceste simboluri sunt reprezentate de coduri ASCII care nu pot fi citite de la tastatura. Folosirea lor in programe este utila pentru ca mareste portabilitatea programelor.

Coduri backslash

· \a - alarma

· \b - backspace \010 octal, \x08 hexazecimal

· \f - form feed

· \n - new line

· \r - carriage return (enter)

· \t - tab orizontal

· \v - tab vertical

· \’ - apostrof ex: printf(“Semnul \’ este apostrof.”); afiseaza: Semnul ‘ este apostrof.

· \” - ghilimele

· \0 - caracterul nul

· \\ - un backslash

· \ddd - un caracter ASCII in notatie octala

· \xdd - hexazecimal

2. Vocabularul limbajului

Vocabularul limbajului este alcatuit din atomi lexicali. Acestia reprezinta grupuri de simboluri afisabile care primesc in timpul procesului de compilare o anumita semnificatie.

a. Identificatori (nume)

Un identificator reprezinta o secventa de litere, cifre, liniute de subliniere. Primul caracter din secventa fiind obligatoriu o litera sau o liniuta de subliniere. Trebuie evitati identificatorii care incep cu liniute de subliniere deoarece pot coincide cu cuvinte rezervate ale unor versiuni ale limbajului. In C se face deosebirea intre literele mici si literele mari folosite in cadrul identificatorilor (case sensitive).

Cuvintele cheie sunt cuvintele rezervate C care au o destinatie prestabilita ( nu pot fi folosite ca nume de functie sau de variabila de catre utilizator). Standardul C are 32 de cuvinte-cheie din care 27 au fost stabilite de varianta initiala descrisa de Dennis Ritchie si Brian Kernighan, in cartea lor “The C programming language”.

Auto, break, case, char, continue, default, do, double, else, extern, float, for, goto, if, int, long, register, return, short, sizeof, static, struct, switch, typedef, union, unsigned, while. (primele 27)

Const, enum, signed, void, volatile (cele 5 adaugate ulterior)

b. Constante

Pot fi numere, caractere, siruri de caractere, iar valoarea lor nu se schimba in timpul executiei unui program. O constanta intreaga este un numar zecimal, octal sau hexazecimal. Constantele in baza 10 se reprezinta obisnuit, constantele in baza 8 incep, pentru identificare, intotdeauna cu cifra 0 ( ex: 073, 0259), iar cele in baza 16 incep, pentru identificare, cu 0x (ex: 0xA21, 0x497).

Constantele reale au doua modalitati de reprezentare: in formal F (cu punct zecimal)- numita si reprezentare uzuala, si in formal exponential (forma stiintifica). 432.59103, 0.7E_08

O constanta caracter este o litera, cifra, semn de punctuatie, secventa escape, cuprinse intre doua apostrofuri. ‘a’, ‘\n’, ‘\0’, ‘7’.

O constanta sir este o secventa de litere, cifre si simboluri, incluse intre ghilimele. “\nAceste e un sir” Constantele sir se memoreaza in octeti consecutivi (fiecare octet este ocupat de un caracter). Fiecare sir se termina cu un octet nul ‘\0’ care se adauga automat.

c. Operatori

Reprezinta combinatii de semne speciale care arata modalitatea de atribuire sau de prelucrare a valorilor. C-ul are o familie bogata de operatori , fapt ce permite realizarea unor programe flexibile.

· []

· ()

· . (membru structura)

· -> (referinta indirecta la membru structura)

· ++ (incrementare prefix sau postfix)

· -- (decrementare)

· ~ (not pe bit)

· sizeof (dimensiunea unei variabile sau a unui tip de date in octeti)

· ! (not logic)

· & (si pe bit, sau adresa)

· * (inmultire sau indirectare)

· / (impartire)

· + (adunare)

· - (scadere, negatia aritmetica)

· << (deplasare logica pe bit la stanga)

· >> (deplasare logica pe bit la dreapta)

· == (egalitate)

· != (neegalitate)

· < , > , <=, >=

· ^ (sau exclusiv pe bit)

· | (sau pe bit)

· && (si logic)

· || (sau logic)

· ?: (operator conditional)

· = (atribuire simpla)

· Op= (unde op poate fi *, /, %, +, - , >>, <<, |, &, ^ se numeste operator compus)

· % (modul = restul impartirii)

· , (operator de secventiere)

d. Semne de punctuatie

Semnele de punctuatie folosite in C sunt: ... , # , : , {}

e. Simboluri speciale

Orice simbol care nu apartine alfabetului C este considerat un atom lexical. Ex: @, $ . Ele pot fi folosite in constructia caracterelor si a sirurilor. Atomii lexicali sunt separati in cadrul programului prin simboluri ale alfabetului cu rol de separator : spatiu, tab , sfarsit de linie, sfarsit de pagina, comentariu. Un comentariu este reprezentat de orice text cuprins intre /*. Comentariile nu pot fi imbricate.

21. Functii generale de I/O. Descriptori de format.

A. Functii generale de intrare-iesire (scanf(), printf())

1. Printf()

Int printf(sir_format, lista de argumente);

Sir_format poate contine:

a. Mesaje pentru utilizator

b. Secvente escape

c. Descriptori de format pentru valorile care se afiseaza

Lista de argumente reprezinta variabile sau expresii al caror continut se va afisa. Descriptorii de format permit efectuarea conversiilor dintre reprezentarea externa a datelor, si reprezentarea lor interna (la citire), si dintre reprezentarea interna a datelor si reprezentarea lor externa (la scriere).

Atat la citire cat si la scriere descriptorii de format sunt pusi in corespondenta de la stanga la dreapta cu valorile din lista de argumente.

%u	Nr intregi zecimale fara semn
%d sau %i	Nr intregi zecimale cu semn
%c	Caracter
%f	Nr reale in notatie uzuala (cu punct)
%e sau %E	Nr reale in notatie exponentiala sau stiintifica
%o	Octal fara semn
%s	Sir de caractere
%p	Pointer

Exemplu:

Int x=7;

Float y=3.5;

printf(“\nx=%i\ty=%f,s=%f”,x,y,x+y);

Dimensiunea campului de afisare, precizia si modul de aliniere pot fi stabilite prin simboluri plasate intre simbolul procent (%) si specificatorul descriptorului.

In cazul in care dimensiunea precizata in descriptor este mai mica decat dimensiunea variabilei pe care dorim sa o afisam, descriptorul de iesire este ignorat si se afiseaza in intregime informatia. Folosirea descriptorilor de format permite o editare convenabila a valorilor care se afiseaza. Este utila in special in cazul in care afisez valorile unei matrici. Implicit, in cazul in care numarul de pozitii pentru afisare este mai mare decat dimensiunea valorii care se afiseaza, alinierea se face la dreapta.

In cazul descriptorului real %f se precizeaza doua valori: una se refera la lungimea numarului, iar cea de-a doua la numarul de zecimale dorite.

Ex: x=374.892

Printf(“\n x=%9.2f”,x); x=

2. Scanf()

Int scanf(sir _format, lista adrese variabile)

Unde sir_format poate contine:

a. Caractere albe de spatiere (blank,tab)

b. Descriptori de format

Lista adrese variabile poate contine &v1,&v2...&vn, unde &vi = adresa variabilei vi

Exemplu: scanf(“%i %f ”,&x,&y); 524 83.2 => x=524, y=83.2

Caracterele de spatiere din sir_format vor fi folosite obligatoriu si in lista de valori care se introduce de la tastatura.

Observatii:

Ø In cazul functiei printf() functia intoarce numarul de caractere scrise efectiv sau o valoare negativa in caz de insucces.

Ø In cazul functiei scanf(), functia intoarce numarul de argumente carora li s-a atribuit o valoare, sau constanta EOF (care are de regula valoarea -1) in caz de insucces

22. Functii speciale de I/O pentru caractere si siruri de caractere.

I. Functii pentru citirea si scrierea caracterelor

1. getchar(); citirea unui caracter

Int getchar(void);

Returneaza urmatorul caracter care va fi citit. Daca s-a atins sfarsitul sirului sau se produce o eroare, se returneaza EOF.

2. putchar(); afisarea unui caracter

Int putchar(int ch);

In caz de succes, functia intoarce caracterul scris, iar in caz contrar, EOF.

Din motive istorice, in C se folosesc si alte functii de citire.scriere caractere acceptate pe majoritatea compilatoarelor chiar daca aceste functii nu apartin standardului ANSI C.

Input: Int getch(void);

Int getche(void);

Output: int putch(int ch);

In cazul in care se foloseste getchar, dupa tastarea caracterului trebuie apasata tasta enter. Functiile getch si getche preiau caracterul, fara a mai fi nevoie sa apasam tasta enter. In plus, getche citeste cu ecou, adica afiseaza automat caracterul tastat.

La toate aceste functii, caracterul este vazut ca un intreg (din motive istorice) reprezentat pe doi octeti, din care unu este octetul nul.

II. Functii pentru citirea / scrierea sirurilor de caractere

1. Gets(sir_destinatie)

Ex: gets(x); scanf(“Sirul citit este “); puts(x);

2. Puts(sir)

23. Tipuri de date predefinite in C

In C ca si in alte limbaje, datele sunt clasificate in tipuri de date. Exista tipuri de date fundamentale (predefinite, simple, sau de baza) si tipuri de date derivate (ex: tablouri, pointeri, structuri, uniuni, si orice alt tip de date definite de utilizator).

Tipuri de date fundamentale in C:

1. Char

2. Int

3. Float

4. Double

5. Void

Dimensiunea zonei de memorie alocate, si domeniul de valori asociat tipurilor aritmetice, pot sa difere in functie de varianta de implementare a limbajului si de tipul de procesor folosit. Standardul ANSIC nu precizeaza decat domeniul de valori, nu si dimensiunea sa. De regula tipul de date char ocupa 1 octet, int ocupa 2 octeti, float ocupa 4 octeti.

Domeniul de valori poate fi modificat cu ajutorul modificatorilor de tip. Acestia sunt: signed, unsigned, short si long. Toti acesti modificatori se pot aplica tipului de date int, signed si unsigned tipului de date char, iar long, tipului de date double.

Daca consideram o zona de marimea a n biti, daca zona este considerata pozitiva, plaja de reprezentare este de la 0 la 2n-1. Daca zona este interpretata negativ, plaja de interpretare este de la -2n-1 pana la 2n-1-1.

Signed int [-32768,32737]

Unsigned int [0, 65535]

Declaratia si definitia de variabile

Tip lista variabile;

Ex: int x,i=7,y; unde x,y declaratie varibile; i definitie variabila

Daca pe linia de declaratie apar initizari de variabile se spune ca acestea sunt definite. Modificatorul de acces (const) permite crearea unor constante simbolice.

Ex: cont double pi=3.1415926536

........

L= 2*pi*r*v

24. Operatori la nivel de bit

1. Operatori la nivel de bit

Acesti operatori pun in evidenta caracterul de limbaj mediu al C-ului.

& | ^(sau exclusiv pe bit) ~ (nu pe bit) << (shift stanga) >>(shift dreapta)

a	b	a& b	a\|b	a^b	~a
0	0	0	0	0	1
0	1	0	1	1	1
1	0	0	1	1	0
1	1	1	1	0	0

0 si 1 de aici sunt valorile bitului

Exemplu:

· X=5 y=36

X=0000 0101 y=0010 0100

0000 0101 &

0010 0100

X & y 0000 0100

X | Y 0010 0101

X ^ Y 0010 0001

~X 1111 1010

~X+1 = complement fata de 2 sau cod complementar

In operatia de transmitere a datelor, bitul cel mai din stanga al unui octet este considerat de cele mai multe ori bit de paritate.daca numarul de biti = 1 din octet este par, se spune ca paritarea este para, in caz contrar se spune ca paritatea este impara.

Exemplu:

1000 0101 &

0111 1111

0000 0101 |

1000 0000

1000 0101

X&127 anuleaza bit de paritate in 0

X | 128 seteaza 1 bitul de paritate

K= 0010 0100 (cheia)

X=0000 0101 ^ (mesajul)
0010 0100 (cheia)

0010 0001 (mesajul transmis)

0010 0001 ^

0010 0100

0000 0101 (mesajul)

25. Operatori relationali si logici

Operatorii relationali

< <= > >= == !=

Operatorii relationali au ca rezultat valoarea 0 pentru fals si valoarea 1 pentru adevarat.

Operatori logici

Si logic &&, sau logic ||, nu logic !

a	b	a&&b	a\|\|b	!a
0	0	0	0	1
0	1	0	1	1
1	0	0	1	0
1	1	1	1	0

a<=b || c>d <=> (a<=b)||(c>d)

!a>b < ≠> !(a>b)

26. Instructiuni de expresie si de decizie:

Expresie

Este formata dintr-o expresie care contine cel putin un semn de atribuire, sau dintr-un apel de functie.

X++; s+=2; getch();

De decizie

If cu doua ramuri, if cu ramura vida, if imbricat, switch, operatorul conditional

if , switch , ?:

if (conditie)

instructiune 1

else

instructiune 2

Efect: Daca conditia este adevarata se executa instructiune 1, in caz contrar se executa instructiunea 2

Obs) Daca instructiunea 1 si/sau instructiunea 2 sunt compuse, trebuiesc incadrate intre acolade.

Daca nu se doreste executia vreunei instructiuni in cazul in care conditia este falsa, forma generala a lui if devine:

If (conditie)

Instructiunea 1.

Switch:

Switch (var)

{

Case ‘val1’ :instructiune 1; [break;]

Case ‘val2’ :instructiune 2;[break;]

……………………………………

Case ‘val n’ : instructiune n;[break;]

[default: instructiune n+1;]

}

Legenda: [ … ] → optional ce este intre paranteze

Daca var este egala cu val 1 se executa instructiunea 1 , instructiunea 2, … N, pana se termina switch-ul sau pana se intalneste break;

Daca var = val 2, se executa instructiunea 2…pana se termina switch-ul sau pana la break;.

Default se foloseste in cazul in care se doreste afisarea vreunui mesaj sau executia vreunei instructiuni in cazul in care var nu este egal cu nici o valoare.

Break; se foloseste ca o instructiune de salt la sfarsitul switch-ului.

Expresie1?expresie2:expresie3;

Daca expresie 1 = 1 (adevarata) se executa expresie 2, daca este falsa se executa expresie 3.

Seamana cu if , insa se poate pune o singura expresie.

27. Instructiuni iterative in C

Iterative

for, while, do... while

for (initializare;conditie;increment)

instructiune

pornind de la instructiunile din initializare, cat timp conditia este adevarata, se executa instructiunea.

In increment trebuie sa existe instructiuni care sa schimbe valoarea contorului for-ului.

Initializare - de unde porneste “ i=1 “

Conditie – pana unde

Increment – i++ ( i+1) contor, cu cat creste.

Instructiunile compuse se pun intre acolade.

While (conditie)

Instructiune ;

Do {

Instructiune;

}

While (conditie);

While: cat timp conditia este adevarata se executa instructiunea

Do-while: executa instructiunea cat timp conditia este adevarata.

While este instructiune de iteratie cu test initial, iar do este cu test final.

La Do-while se executa cel putin o data instructiunea.

Daca la while instructiunea este compusa se pun acolade.

28. Tablouri in C

Sunt succesiuni de informatii de acelasi tip.

In functie de modul cum sunt aranjate:

- unidimensionale

- bidimensionale

- multidimensionale (rar tridimensionale)

Tablouri unidimensionale (vectori sau siruri)

1) Tip nume[dim]; max 255

int a[100];

Citirea:

printf(“n=”);scanf(“%d”,&n);

for (i=1;i≤n;i++)

{

printf(“a[%d]=,i);

scanf(“%d”,&a[i]);

}

tiparirea:

for (i=1;i≤n;i++)

printf(“%d”,a[i]);

Tablouri Bidimensionale

tip_nume[dim1][dim2]; (maxim 255)

float x[10][15];

int n,m;

citire:

printf(“n=”);scanf(“%d”,&n);

printf(“m=”);scanf(“%d”,&m);

for (i=1;i≤n;i++)

for (j=1;j≤m;j++)

{

printf(“x[%d][%d]”,i,j);

scanf(“%f”,&x[i][j]);

}

tiparire:

for (i=1;i≤n;i++)

for (j=1;j≤m;j++)

printf(“%7.2f (space) “,x[i][j];

printf(“\n);