JAVA I TY.....

18

Wtorek 7 Luty

Napisa� program obliczaj�cy nale�ny podatek dochodowy od os�b fizycznych. Program
ma pobiera� od u�ytkownika doch�d i po obliczeniu wypisywa� na ekranie
nale�ny podatek. Podatek obliczany jest wg. nast�puj�cych regu�:
• do 85.528 podatek wynosi 18% podstawy minus 556,02 PLN,
• od 85.528 podatek wynosi 14.839,02 z� + 32% nadwy�ki ponad 85.528,00

package ania;

import java.util.Scanner;

public class Ania {

public static void main(String[] args) {
Scanner s = new Scanner(System.in);
System.out.println("Podaj sw�j doch�d");
double dochod = s.nextDouble();
if (dochod < 85528) {
System.out.println("Twoj podatek :" + (dochod * 0.18 - 556.02));
} else {
System.out.println("Twoj podatek :" + (14839.02 + (dochod - 85528) * 0.32));
}
}
}

17

Wtorek 7 Luty

Napisa� program, kt�ry oblicza warto�� wsp�czynnika BMI (ang. body mass
index) wg. wzoru: waga/wzrost^2 . Je�eli wynik jest w przedziale (18,5 - 24,9) to wypisuje
”waga prawid�owa”, je�eli poni�ej to ”niedowaga”, je�eli powy�ej ”nadwaga”.

package ania;

import java.util.Scanner;

public class Ania {

public static void main(String[] args) {
Scanner s = new Scanner(System.in);
System.out.println("Podaj wage..");
double waga = s.nextDouble();
System.out.println("Podaj wzrost");
double wzrost = s.nextDouble();
double BMI = waga / Math.pow(wzrost, 2);
if (BMI < 18.5) {
System.out.println("Niedowaga ;(");
} else {
if (BMI < 24.9) {
System.out.println("Waga Prawid�owa :)");
}
else{
System.out.println("Nadwaga ;(");
}
}
}
}

Muzyczka

Niedziela 15 Styczeń

TC equ 262
TD equ 294
TE equ 330
TF equ 349
TG equ 391
TA equ 440
TH equ 494
TCC equ 523
TDD equ 587
TEE equ 659
TFF equ 698

assume cs:code,ss:stac,ds:data

data segment
dzwiek db 'gageegageeDDhhCCggaaChagagegaaChagagegDDFDhCECgegfdccck'
czasy db '021000210001010101010210210101021021010102100021021000'
d dw 0
c dw 0
ends

stac segment
dw 128 dup(0)
ends

code segment
start:
mov ax, data
mov ds, ax
mov es, ax
jmp dal

gr: mov dl,czasy[si]
cmp dl,'0'
je cala
cmp dl,'1'
je polo
cmp dl,'2'
je cwia
grd:
in al,61h
or al,3
out 61h,al
mov bx,d
mov ax,34ddh
mov dx,12h
div bx
out 42h,al
mov al,ah
out 42h,al
mov al,0b6h
out 43h,al
mov dx,4240
mov cx,c
mov ah,86h
int 15h
inc si
in al,61h
and al,0
out 61h,al
jmp dal

cala:
mov c,15
jmp grd

polo:
mov c,8
jmp grd

cwia:
mov c,5
jmp grd

ddf: mov d,TF
jmp gr
da: mov d,TA
jmp gr
ddh: mov d,TH
jmp gr
de: mov d,TE
jmp gr
dg: mov d,TG
jmp gr
ddd: mov d,TD
jmp gr
dc: mov d,TC
jmp gr
dddd:mov d,TDD
jmp gr
dee:mov d,TEE
jmp gr
dff:mov d,TFF
jmp gr
dcc:mov d,TCC
jmp gr
;ppppppppppppppppppppppppppppppppppppppppppppppppppppp
dal:
mov dl,dzwiek[si]
cmp dl,'k'
je kon
cmp dl,'g'
je dg
cmp dl,'a'
je da
cmp dl,'h'
je ddh
cmp dl,'f'
je ddf
cmp dl,'e'
je de
cmp dl,'d'
je ddd
cmp dl,'c'
je dc
cmp dl,'D'
je dddd
cmp dl,'E'
je dee
cmp dl,'F'
je dff
cmp dl,'C'
je dcc
;pppppppppppppppppppppppppppppppppppppppppppppppppppppp
kon:mov ax, 4c00h
int 21h
ends

end start

4.Drzewa binarne - ZAD 2

Sobota 17 Grudzień

Zad 2 Napisz funkcj� wyznaczaj�ce: liczb� wez��w drzewa binarnego, liczb� li�ci, liczb� prawych potomk�w w ca�ym drzewie, wysoko�� drzewa.

struct node
{
int dane;
node * left;
node * right;
};

int lb_wezlow ( node * korzen){
int i = 0;
if( korzen != NULL){
i = 1 +lb_wezlow (korzen -> left) + lb_ wezlow (korzen -> right );
}
return i;
}

int lb_lisci ( node * korzen ){
int i = 0;
if (korzen != NULL){
if( korzen -> left == NULL && korzen -> right == NULL){
i++;
}
else{
i = i +lb_lisci ( korzen -> left) +lb_lisci (korzen -> right);
}
}
return i;
}

int lb_ppotomkow (node * korzen){
int i= 0;
if(korzen != NULL){
if(korzen -> right) i++;
i = i + lb_ppotomkow( korzen -> left) + lb_ppotomkow( korzen -> right);
}
return i;
}

int wysokosc( node * korzen){
int i= 0;
if(korzen != NULL ){
if(korzen -> left != NULL || korzen -> right != NULL ){
i++;
}
int a = wysokosc ( korzen -> left );
int b = wysokosc ( korzen -> right);
if( a > b){
i = i+ a;
}
else{
i = i+b;
}
}
return i;
}

4.Drzewa binarne - ZAD 1

Sobota 17 Grudzień

Zad 1 Napisz funkcj� sprawdzaj�c�, czy dany element x znajduje si� w drzewie.
struct node
{
int dane;
node * left;
node * right;
};

bool search( node * korzen, int x){
if(korzen!=NULL){
if(korzen -> dane == x) return TRUE;
if( search(korzen -> left, x) == TRUE ) return TRUE;
if( search( korzen -> right, x) == TRUE ) return TRUE;
}
return FALSE;
}

Piramidka

Czwartek 17 Listopad

ORG 800H
   MVI B,10
SK1    MOV C,B
   MOV D,E
SK2    MOV A,D
   CPI 0
   JZ SK3
   MVI A,' '
   RST 1
   DCR D
   JNZ SK2
SK3    MVI A,'#'
   RST 1
   DCR C
   JNZ SK2
   MVI A,10
   RST 1
   MVI A,13
   RST 1
   MOV A,B
   SUI 1
   JZ KON
   INR E
   DCR B
   DCR B
   JNZ SK1
KON    HLT

Ramka

Czwartek 17 Listopad

ORG 800H
   MVI B,15
   MOV C,B
SCG    MVI A,'+'
   RST 1
   DCR C
   JZ SCB
   MVI A,'-'
   RST 1
   DCR C
   JZ SCB
   JNZ SCG
SCB    MOV A,H
   SUI 1
   JZ KON
   MVI H,1
   MVI A,10
   RST 1
   MVI A,13
   RST 1
   MOV A,B
   SUI 2
   MOV C,A
   MVI L,'-'
ZNAK    MOV A,B
   SUI 2
   MOV D,A
   MOV A,L
   RST 1
SK1    MVI A,' '
   RST 1
   DCR D
   JNZ SK1
   MOV A,L
   RST 1
   MVI A,10
   RST 1
   MVI A,13
   RST 1
   MOV A,L
   SUI '-'
   JZ ZK
   MVI L,'-'
   JMP DA
ZK    MVI L,'+'
DA    DCR C
   JNZ ZNAK
   MOV C,B
   JMP SCG
KON    HLT

Listy <-> Zad 5

Czwartek 17 Listopad

Za��zmy, ze pole „dane” jest typu znakowego i moze przechowywac znaki: ’+’, ’-’ (dwuargumentowy),
’*’, ’/’, ’a’ - ’z’. W�wczas lista moze reprezentowac wyrazenie arytmetyczne w zapisie
przedrostkowym (w notacji polskiej).
Napisz funkcje, kt�ra wypisze w notacji tradycyjnej (w zapisie wrostkowym) wyrazenie arytmetyczne
zapisane w liscie w notacji polskiej.
string print(elem *lista)
Napisz funkcje sprawdzajaca, czy lista reprezentuje poprawnie skonstruowane wyrazenie w takiej
beznawiasowej notacji.
bool accepts(elem *lista).

struct elemM {
char dane;
elemM *nast;
elemM *poprz;
};

string printM(elemM* lista) {
if (!lista) return "B�ad...";
string w = "";
char znak;
bool c = true;
int liczruch = 0;
while (lista != NULL) {
znak = lista->dane;
if (znak != '$') {
if (((znak < 132 && znak > 96) || isdigit(znak)) && c) {
w = w + znak;
c = false;
} else {
elemM* tym = lista;
while ((tym->dane < 132 && tym->dane > 96) || isdigit(tym->dane)) {
tym = tym->nast;
}
if (tym->dane != '$') {
w = w + tym->dane;
tym->dane = '$';
}
c = true;
}
}
if (c) lista = lista->nast;
}
return w;
}

Listy <-> zad 4

Czwartek 17 Listopad

Napisz funkcje przekszta�cajaca podana liste jednokierunkowa w liste cykliczna.

struct mkp {
int dane;
mkp* nast;
};

elem* toDlist(mkp* l) { //do test//blad...
elem* w;
while (l) {
elem* nowy = new elem;
nowy->dane = l->dane;
nowy->nast = NULL;
if (w) {
nowy->poprz = w;
w = nowy;
} else {
w = nowy;
nowy->poprz = NULL;
}
l = l->nast;
}
}

Listy <-> zad 3

Czwartek 17 Listopad

Napisz funkcje zmieniajaca kierunek wskaznik�w (pole „nast”) w jednokierunkowej liscie
cyklicznej. (Wskaznik czo�o bedzie wskazywa� na ten sam element).
void redirect(elem *w)

void redirect(elem *w) {
if (w) {
elem* pam = w;
elem* wcz = w;
elem* tym;
w = w->nast;
while (w != pam) {
tym = w->nast;
w->nast = wcz;
wcz = w;
w = tym;
}
w->nast = wcz;
}
}

Listy <-> Zad 2

Czwartek 17 Listopad

Lista dwukierunkowa moze zostac „odwr�cona” na dwa sposoby. Mozna pozmieniac wskazniki
we wszystkich elementach tak, aby dostac odwrotny porzadek lub mozna pozostawic strukture
listy bez zmian i parami pozamieniac dane element�w listy. Zaimplementuj te dwa sposoby.
void reverse(elem *&lista).

void reversee(elem *&lista) {
elem* zap;
elem* tym;
while (true) {
zap = lista->nast;
tym = lista->poprz;
lista->poprz = lista->nast;
lista->nast = tym;
if (!zap) break;
lista = zap;
}
}

int size(elem* pam) {
int rozmiar = 0;
while (pam) {
rozmiar++;
pam = pam->nast;
};
return rozmiar;
}

void reverse(elem *&lista) {
elem* pam = lista;
int rozmiar = size(lista);
int skok = rozmiar - 1;
int dana1;
int dana2;
for (int i = 0; i < rozmiar / 2; i++) {
dana2 = lista->dane;
for (int i = 0; i < skok; i++) {
lista = lista->nast;
}
dana1 = lista->dane;
lista->dane = dana2;
for (int i = 0; i < skok; i++) {
lista = lista->poprz;
}
lista->dane = dana1;
lista = lista->nast;
skok -= 2;
}
lista = pam;
}

Listy<-> Zad 1

Czwartek 17 Listopad

Zaimplementuj podstawowe operacje na listach dwukierunkowych:

void insert(int x, elem *&lista) {
elem* obw = new elem;
obw->dane = x;
obw->poprz = NULL;
if (lista) {
lista->poprz = obw;
obw->nast = lista;
lista = obw;
} else {
lista = obw;
lista->nast = NULL; //moz przyspiesz..
}

}

void insert(int x, int i, elem *&lista) {
elem* obw = new elem;
obw->dane = x;
if (i != 0) {
elem* pam = lista;
while (i > 0) {
pam = pam->nast; //wyjatek
i--;
}
pam->poprz->nast = obw;
obw->poprz = pam->poprz;
obw->nast = pam;
pam->poprz = obw;
} else {
if (lista) {
obw->nast = lista;
obw->poprz = NULL;
lista->poprz = obw;
lista = obw;
} else {
lista = obw;
obw->nast = NULL;
obw->poprz = NULL;
}
}

}

int remove(elem *&lista) {
elem* d = lista;
lista = lista->nast;
lista->poprz = NULL;
delete d;
}

int remove(int i, elem *&lista) {
elem* pam = lista;
elem* d = lista;
if (i != 0) {
while (i != 0) {
d = d->nast; //wyjatek
i--;
}
d->nast->poprz = d->poprz;
d->poprz->nast = d->nast;
lista = pam;
} else {
lista = lista->nast;
lista->poprz = NULL;
}
delete d;
}

LISTY JEDNOLIERUNKOWE

Niedziela 6 Listopad

struct elem {
int dane;
elem *nast;
};

struct elemW {
int expo;
int coef;
elemW* nast;
};

//rozwiazanie do testowania

void azim(elem* &lis, int dana) {
elem* pam = lis;
if (lis == NULL) {
lis = new elem;
lis->dane = dana;
lis->nast = NULL;
} else {
while (lis->nast != NULL) {
lis = lis->nast;
}
elem* n = new elem;
n->dane = dana;
n->nast = NULL;
lis->nast = n;
lis = pam;
}
}

//rozwiazanie do testowania

void azimW(elemW* &lis, int wyk, int a) {
elemW* pam = lis;
if (lis == NULL) {
lis = new elemW;
lis->expo = wyk;
lis->coef = a;
lis->nast = NULL;
} else {
while (lis->nast != NULL) {
lis = lis->nast;
}
elemW* n = new elemW;
n->expo = wyk;
n->coef = a;
n->nast = NULL;
lis->nast = n;
lis = pam;
}
}

void insert(int x, int i, elem *&lista) {
elem* e = new elem;
e->dane = x;
elem* wsk = lista;
if (wsk != NULL) {
for (int j = 0; j < i - 1; j++) {
wsk = wsk->nast;
}
e->nast = wsk->nast;
wsk->nast = e;
} else {
cout << "b" << endl;
}
}

int remove(int i, elem *&lista) {
elem* d;
elem* wsk = lista;
if (wsk != NULL) {
for (int j = 0; j < i - 2; j++) {
wsk = wsk->nast;
}
d = wsk->nast;
wsk->nast = wsk->nast->nast;
} else {
cout << "b" << endl;
}

delete d;
}

int read(int i, elem* lista) {
elem* wsk = lista;
if (wsk != NULL) {
for (int j = 0; j < i; j++) {
wsk = wsk->nast;
}
return wsk->dane;
}
}

int size(elem* lista) {
int liosc = 0;
while (lista != NULL) {
lista = lista->nast;
liosc++;
}

return liosc;
}

void print(elem *lista) {
while (lista != NULL) {
cout << lista->dane << endl;
lista = lista->nast;
}
}

void printW(elemW* lista) {
while (lista != NULL) {
cout << "Wyk: " << lista->expo << endl;
cout << lista->coef << endl;
lista = lista->nast;
}
}

elem* UNION(elem* L1, elem* L2) {
elem* tym = L1;
while (tym->nast != NULL) {
tym = tym->nast;
}
tym->nast = L2;
return L1;
}

elem* search(int x, elem *lista) {
while (lista != NULL) {
if (lista->dane == x) {
return lista;
}
lista = lista->nast;
}
return NULL;
}

void destroy(elem *&lista) {
elem*tym;
while (lista != NULL) {
tym = lista;
lista = lista->nast;
delete tym;
}
}

elem* MIN(elem *lista) {
elem* min = NULL;
int wmin = 32100; //zminic na zakres int
while (lista != NULL) {
if (wmin > lista->dane) {
wmin = lista->dane;
min = lista;
}
lista = lista->nast;
}
return min;
}

void rev(elem* &lista) {
if (lista != NULL) {
elem* zap = lista;
elem* tym;
lista = lista->nast;
zap->nast = NULL;
while (lista->nast != NULL) {
tym = lista;
lista = lista->nast;
tym->nast = zap;
zap = tym;
}
lista->nast = zap;
}
}

elemW* polyadd(elemW* w1, elemW* w2) {
elemW* w = NULL;
while (w1 != NULL && w2 != NULL) {
if (w1->expo == w2->expo) {
azimW(w, w1->expo, w1->coef + w2->coef);
w1 = w1->nast;
w2 = w2->nast;
} else {
if (w1->expo > w2->expo) {
azimW(w, w1->expo, w1->coef);
w1 = w1->nast;
} else {
azimW(w, w2->expo, w2->coef);
w2 = w2->nast;
}
}
}
while (w1 != NULL) {
azimW(w, w1->expo, w1->coef);
w1 = w1->nast;
}
while (w2 != NULL) {
azimW(w, w2->expo, w2->coef);
w2 = w2->nast;
}
return w;
}

void Fareya(int n) {
ulamek* pocz = new ulamek;
pocz->licz = 0;
pocz->mian = 1;
pocz->nast = NULL;
if (n > 0) {
ulamek* tym = new ulamek;
pocz->nast = tym;
tym->licz = 1;
tym->mian = 1;
tym->nast = NULL;
bool powt = true;
ulamek* t = NULL;
while (powt) {
powt = false;
tym = pocz;
while (tym->nast != NULL) {
if (tym->mian + tym->nast->mian <= n) {
powt = true;
t = new ulamek;
t->licz = tym->licz + tym->nast->licz;
t->mian = tym->mian + tym->nast->mian;
t->nast = tym->nast;
tym->nast = t;
}
tym = tym->nast;
}
}
}
while (pocz) {
cout << pocz->licz << "/" << pocz->mian << endl;
pocz = pocz->nast;
}
}

java

Poniedziałek 24 Padziernik

http://www.youtube.com/user/java?blend=22&ob=5

Zad 10

roda 19 Padziernik

Przenies elementy ze stosu S1 na stos S2 tak, aby zosta� zachowany porzadek element�w
• korzystajac z jednego dodatkowego stosu,
• nie korzystajac z dodatkowego stosu, lecz wy�acznie z pewnej liczby zmiennych lokalnych
(rekurencyjnie).