Universitatea Transilvania din Braov

Facultatea de Inginerie Electric i tiina

Calculatoarelor

Portofoliu de
teme
[PCLP3]

Zarnescu Laurentiu
Gr. 4433, AIA II

BRAOV, 2015

1. Bitmap Editor
1.1. Enuntarea temei :
S se scrie un program care s genereze, pe baza unui fiier bitmap de
intrare, trei fiiere
bitmap, care prezint separat cele trei componente de culoare.
package bmped;
import java.io.BufferedInputStream;
import java.io.BufferedOutputStream;
import java.io.FileInputStream;
import java.io.FileOutputStream;
public class BitmapEditorMain
{
public static void main(String[] args) {
try{

FileInputStream fis = new FileInputStream("iesc.bmp");

BufferedInputStream img = new BufferedInputStream(fis);
FileOutputStream ofis1= new FileOutputStream("iescR.bmp");
FileOutputStream ofis2= new FileOutputStream("iescG.bmp");
FileOutputStream ofis3= new FileOutputStream("iescB.bmp");
BufferedOutputStream imgR = new BufferedOutputStream(ofis1);
BufferedOutputStream imgG = new BufferedOutputStream(ofis2);
BufferedOutputStream imgB = new BufferedOutputStream(ofis3);
byte[] sti= new byte[54];
img.read(sti,0,54);
//Scrierea headerului
imgR.write(sti);
imgG.write(sti);
imgB.write(sti);

1.2.Algoritmul de rezolvare a problemei :

1 | Page
Zarnescu Laurentiu
AIA 4433

while(img.available()>0){
int r,g,b;
//Citirea valorilor RGB
b=img.read();
g=img.read();
r=img.read();
//Scrierea noilor valori in 3 poze diferite
imgB.write(b);
imgB.write(b);
imgB.write(b);

imgG.write(g);
imgG.write(g);
imgG.write(g);

imgR.write(r);
imgR.write(r);
imgR.write(r);
}
img.close();
imgR.close();
imgG.close();
imgB.close();
}
catch(Exception e)
{
System.out.println(e);
}
}
}

1.3.Imagini din timpul functionarii:

2 | Page
Zarnescu Laurentiu
AIA 4433

Acesta este ruzultatul rularii programului, imaginea din stnga reprezint

imaginea originala , urmtoarea fiind cea care conine valorile nuantelor
de Albastru , apoi Verde apoi Rou .

1.4 Algoritmul pentru desaturarea unei

imagini de format jpeg.
1.4.1 Imagini din timpul rularii.

3 | Page
Zarnescu Laurentiu
AIA 4433

1.4.2 Cod sursa.

package sfsgsg;

import java.awt.Color;
import java.awt.FlowLayout;
import java.awt.Frame;
import java.awt.image.BufferedImage;
import java.io.File;
import java.io.IOException;
import javax.imageio.ImageIO;
import javax.swing.ImageIcon;
import javax.swing.JLabel;
public class ImgageReading
{
public static void main(String[] args) {
try
{
BufferedImage img=ImageIO.read(new File("woman.jpg"));
int h=img.getHeight();
int w=img.getWidth();
int R,G,B;
//int x=2;
int aux;
BufferedImage buf =new BufferedImage(w, h, BufferedImage.TYPE_INT_RGB);
Color c=null;
Color col=null;

4 | Page
Zarnescu Laurentiu
AIA 4433

for(int i=0;i<w;i++) {
for(int j=0;j<h;j++) {
//Citirea si scrierea culorii
c=new Color(img.getRGB(i, j));
R=c.getRed();
G=c.getGreen();
B=c.getBlue();
aux=(R+G+B)/3;
col=new Color(aux,aux,aux);
buf.setRGB(i, j,col.getRGB());
}}
//Scrierea imaginii
File f=new File("EditImg.jpg");
ImageIO.write(buf,"jpg",f);
//Afisarea in fereastra
ImageIcon im=new ImageIcon(buf);
ImageIcon im2=new ImageIcon(img);
String description=im.getDescription();
Frame geam=new Frame(description);
geam.setSize(w, 2*h);
geam.setLayout(new FlowLayout());
geam.add(new JLabel(im2));
geam.add(new JLabel(im));
geam.show();
}
catch(IOException e){}
}
public void Desaturate(String url)
}

5 | Page
Zarnescu Laurentiu
AIA 4433

2. Buble sort i Quick sort

2.1. Enuntarea temei :
Modificai programul de mai sus pentru a afia numrul de
interschimbri
e fectuate pentru metoda BubleSort .

2.2. Algoritmul de rezolvare a problemei :

package sortt;
import java.awt.Frame;
import javax.swing.JFrame;
import javax.swing.JTextArea;public class MainSort

public static void main(String[] args){

int []a= new int[10];
int contor=0;
for (int i=0; i<10;i++){
a[i]=(int)((Math.random()*100));
}
for (int i=0; i<10;i++){
System.out.print(a[i]+", ");
}
boolean sort=false;
while(!sort){
sort=true;
}
6 | Page
Zarnescu Laurentiu
AIA 4433

for(int i=0;i<9;i++){
if(a[i]>a[i+1]){
int aux=a[i];
a[i]=a[i+1];
a[i+1]=aux;
sort=false;
contor++;
}
}
}
System.out.println();
System.out.println("Sirul ordonat:");
for (int i=0; i<10;i++){
System.out.print(a[i]+", ");
}
System.out.println();
System.out.println("Orodnarea a fost facuta folosind un numar de "+contor+"
intershimbari .");
}
}

2.3.Imagini din timpul functionarii:

7 | Page
Zarnescu Laurentiu
AIA 4433

2.4. Enuntarea temei :

Modificai programul de mai sus pentru a afia numrul de
interschimbri
e fectuate pentru metoda QuickSort .

2.5. Algoritmul de rezolvare a problemei :

package sort;
publicpublic
class static
QuickSort
{ quicksort(int []T, int startpos, int stoppos){
void
publicif(startpos<stoppos){
static int contor=0;
public static int int
getFixedPos(int
[]T,intstartpos,
startpos,stoppos);
int stoppos) {
k = getFixedPos(T,
int i=startpos;
quicksort(T, startpos,k-1);
int j=stoppos;
quicksort(T, k+1, stoppos);
boolean
mod=false;
}
}

while(i<j){

if(T[i]>T[j])
public static
void main(String[] args) {
{ new int[10];
int []a=
inti<10;i++){
aux=T[i];
for (int i=0;
T[i]=T[j];
a[i]=(int)((Math.random()*100));
}

T[j]=aux;

for (int i=0; i<10;i++){

contor++;
System.out.print(a[i]+", ");
mod=!mod;
}

quicksort(a,0,9);
if(mod)
System.out.println();
i++;
System.out.println("Sirul ordonat:");
else
for (int i=0; i<10;i++){
j--;
}

System.out.print(a[i]+", ");

}
return i;
}

System.out.println();
System.out.println("Orodnarea a fost facuta folosind un numar
de "+contor+" intershimbari .");
}

Zarnescu Laurentiu
}

AIA 4433

8 | Page

2.6.Imagini din timpul functionarii:

3.Comparatie
Bubble Sort

Quick

Sort

VS

3.1 Enuntul problemei.

Realizai o comparaie ntre numrul de interschimbri realizate de
fiecare
algoritm prezentat pentru un ir de numere sortat cresctor si
descrescator.

9 | Page
Zarnescu Laurentiu
AIA 4433

3.2 Algoritmul de rezolvare al problemei.

package sortcomp;
public class SortComp {
public static int contor1=0;
public static int contor2=0;
public static int getFixedPos(int []T,int startpos, int stoppos) {
int i=startpos;
int j=stoppos;
boolean mod=false;
while(i<j)
{
if(T[i]>T[j])
{
int aux=T[i];
T[i]=T[j];
T[j]=aux;
contor1++;
mod=!mod;
}
if(mod)
i++;
else
j--;
}
return i; }

10 | P a g e
Zarnescu Laurentiu
AIA 4433

public static void quicksort(int []T, int startpos, int stoppos)

{
if(startpos<stoppos)
{
int k = getFixedPos(T, startpos, stoppos);
quicksort(T, startpos,k-1);
quicksort(T, k+1, stoppos);
}
}
public static void bublesort(int[]a)
{
boolean sort=false;
while(!sort)
{
sort=true;
for(int i=0;i<9;i++)
{
if(a[i]>a[i+1])
{
int aux=a[i];
a[i]=a[i+1];
a[i+1]=aux;
sort=false;
contor2++;
}
}
}
}
public static void main(String[] args) {
//Generarea unui sir aleator
int []a= new int[10];
int []s=new int[10];
for (int i=0; i<10;i++)
{
a[i]=(int)((Math.random()*100));
s[i]=a[i];
}
for (int i=0; i<10;i++)
{
System.out.print(s[i]+", ");
}
//Sortare Buble sort;
bublesort(a);
//Sortare Quick sort;
quicksort(s, 0, 9);
System.out.println();
System.out.println();
System.out.println("Sirul sortat cu metoda BubleSort");

11 | P a g e
Zarnescu Laurentiu
AIA 4433

for (int i=0; i<10;i++)

{
System.out.print(a[i]+", ");
}
System.out.println();
System.out.println("**** Numarul de inerschimbari: "+contor2);
System.out.println();
System.out.println("Sirul sortat cu metoda QuickSort");
for (int i=0; i<10;i++)
{
System.out.print(s[i]+", ");
}
System.out.println();
System.out.println("**** Numarul de inerschimbari: "+contor1);
}
}

3.3 Imagini din timpul functionarii.

12 | P a g e
Zarnescu Laurentiu
AIA 4433

4. Liste inlantuite.
4.1 Enuntul problemei.
S se modifice programul de mai sus prin implementarea opiunii de
eliminare a elementelor negative din list (opiunea 4).

13 | P a g e
Zarnescu Laurentiu
AIA 4433

4.2 Algoritmul de rezolvare al problemei.

#include <iostream.h>
#include <conio.h>
#include <stdio.h>
struct Nod
{
int inf;
Nod* urm;
};
int nrElemente(Nod* lista)
{
int nr=0;
Nod*aux=lista;
while (aux!=NULL)
{
nr++;
aux=aux->urm;
}
return nr;
}
void adauga(Nod *&lista, int val , int N)
{
if(N==1 || lista == NULL)
{
Nod *aux = new Nod;
aux->inf = val;
aux->urm=lista;
lista = aux;
}

14 | P a g e
Zarnescu Laurentiu
AIA 4433

else
{
int nr=nrElemente(lista);
if (N>nr+1)
N=nr+1;
Nod* tmp=new Nod;
tmp->inf = val;
Nod *aux = lista;
for(int i=1; i>N-1; i++)
aux=aux -> urm;
tmp -> urm = aux-> urm;
aux -> urm = tmp;
}
}
void afisare (Nod * lista)
{
Nod *aux = lista ;
cout<<"Lista este:";
while(aux != NULL)
{
cout<<aux->inf<<" ";
aux = aux -> urm;
}
if (lista == NULL)
cout<<"vida."<<endl;
else
cout<<endl;
}
void eliberaremem(Nod *&lista)
{
Nod* aux =lista;
while (aux != NULL)
{
lista = lista->urm;
delete aux;
aux=lista;
}
}

15 | P a g e
Zarnescu Laurentiu
AIA 4433

void elimin(Nod *&lista , int poz)

{
Nod* aux = lista;
if(lista=NULL)
return;
if(poz>nrElemente(lista))
poz=nrElemente(lista);
if(poz==1)
{
lista=lista->urm;
delete aux;
}
else
for(int i=1; i<poz-1;i++)
aux=aux->urm;
Nod *tmp= aux->urm;
aux->urm=tmp->urm;
delete tmp;
}
void eliminnegat(Nod *&lista)
{
if(lista=NULL)
return;
int n=nrElemente(lista);
for(int i=1;i<n-1;i++)
{
if((lista->inf)<0)
{
elimin(lista,i);
}
}
}
void main()
{
Nod *L =NULL;
int opt;
do
{
cout<<"Operatii"<<endl<<"------"<<endl<<"1 - Adaugare element"<<endl;
cout<<"2 - Eliminare element"<<endl<<"3 - Afisare lista"<<endl;
cout<<"4 -Eliminarea elementelor negative !"<<endl;
cout<<"0 - Iesire"<<endl<<"------"<<endl;
cout <<"?> ";
cin>>opt;

16 | P a g e
Zarnescu Laurentiu
AIA 4433

switch (opt)
{
case 1:
{
int v,p;
cout<<endl<<"Introduceti valoarea: ";
cin>>v;
cout<<"Introduceti pozitia (lista are "<<nrElemente(L)<<" el): ";
cin>>p;
adauga(L,v,p);
afisare(L);
break;
}
case 2:
{
int p;
cout<<endl<<"Pozitia (lista are "<<nrElemente(L)<<" el): ";
cin>>p;
elimin(L,p);
afisare(L);
break;
}
case 3:
{
cout<<endl;
afisare(L);
break;
}
case 4:
{
eliminnegat(L);
cout<<"Eliminarea elementelor negative incheiata !"<<endl;
break;
}
}
fflush(stdin);
getch();
}
while(opt!=0);
eliberaremem(L);
}

17 | P a g e
Zarnescu Laurentiu
AIA 4433

4.3 Imagini din timpul functionarii.

18 | P a g e
Zarnescu Laurentiu
AIA 4433

Contents
1. Bitmap Editor..........................................................1
1.1. Enuntarea temei :.................................................1
1.2.Algoritmul de rezolvare a problemei :....................1
1.3.Imagini din timpul functionarii:..............................3
1.4 Algoritmul pentru desaturarea unei imagini de
format jpeg..................................................................3
1.4.1 Imagini din timpul rularii..................................3
1.4.2 Cod sursa.........................................................4
2. Buble sort i Quick sort.........................................6
2.1. Enuntarea temei :.................................................6
2.2. Algoritmul de rezolvare a problemei :...................6
2.3.Imagini din timpul functionarii:..............................7
2.4. Enuntarea temei :.................................................8
2.5. Algoritmul de rezolvare a problemei :...................8
2.6.Imagini din timpul functionarii:............................10
3.Comparatie Quick Sort VS Bubble Sort..............10
3.1 Enuntul problemei...............................................10
3.2 Algoritmul de rezolvare al problemei..................10
3.3 Imagini din timpul functionarii.............................12
4. Liste inlantuite.....................................................13
4.1 Enuntul problemei...............................................13
4.2 Algoritmul de rezolvare al problemei...................13
4.3 Imagini din timpul functionarii.............................17

19 | P a g e
Zarnescu Laurentiu
AIA 4433