Treceți la conținutul principal

lean pascal 21 days code pseudoc

lean pascal 21 days code pseudoc
learn pascal in 21 days

 
 
 

1


cautare (elementcautat , inceput, sfarsit) este
{mijloc <- (inceput + sfarsit) /2
daca (sfarsit - inceput) < 2 atunci
rezultat <- egal(elementcautat , x[inceput])
sau egal(elementcautat ,x[sfarsit])
altfel daca maimare(elementcautat, x[mijloc])
atunci rezultat <- cautare (y,mijloc + 1, sfarsit)
altfel daca maimic(elementcautat, x[mijloc])
atunci rezultat <- cautare(y, inceput, mijloc-1)
altfel rezultat <- adevarat
intoarce rezultat }




algoritmul 2.1

{repeta
{afisaremeniu
selectie si validare comanda
alege comanda dintre
{inscriere : executa procedurainscriere
}
}
pana cand comanda = oprire
}

algoritmul 2.2

prezent (l, nume) este
{executa pozitionareinceput(l)
gasit <- false
cat timp ! testsfarsit(l) si !gasit
{extrage cheia din elementul curent
gasit <- nume = cheie extrasa
daca !gasit atunci avans la urmatorul element
}intoarce gasit
}


algoritmul 2.3

procinscriere este{
executa initlista{listacandidati}
repeta
citeste nume
daca nu este terminator atunci
{daca prezent(listacandidati,nume)
atunci
scrie mesaj candidat a fost inscris inainnte
altfel
{
iteste numarul
creaza o celula si leaga la ea informatia citita
adauga celula la sfarsitul listei de candidati
}}
pana cand s-a citit terminator
}

algoritm 2.4

procmodificare este
{
citeste nume
daca prezent(listacandidati, nume) atunci
{
citeste date modificate
ataseaza la celula curenta informatia modificata
}
}




algoritm 2.5

procnote este
{
executa positionareinceput(listacandidati)
cat timp !testsfarsit(listacandidati) executa
{extrafe nume si numar din celula curent
citeste note
calcul medie
ataseaza la celula curenta informatia modificata
executa urmator(listacandidati)
}}


algoritmul 2.6

procordonare(l1, l2) este
{
executa initlista(l2)
executa posinceput(l1)
cat timp !testsfarsit(l1) executa
{ copiaza elementul curent din l1
cauta primul element din l2 avand cheia mai mica decat elementul curent
daca nu s-a gasit atunci
adauga elementul la sfarsitul liseti l2
altfel
inseareaza elementul inainte celui cu cheie mai mica din l2
executa urmator(l1)
}
}


algoritmul 2.7

afisare(l) este
{
executa posinceput(l)
cat timp !testsfarsit(l) executa
{
extrage info din elemcurent 
afisare info extrasa
executa urmator(l)
}
}



algoritm 3.1

{initi stiva
repeta
citeste caracter
alege caracter
{
...
caz '(': tratareparantezadeschisa
...
actualizare poscurentacursor
pana cand caracter este caracterul care indica sfarsit de editare
daca nu teststivagoala atunci
tratareeroare
}

tratareparantezadeschisa este :
{
daca mai exista loc in stiva atunci
introduceinstiva ( pozcurentacursor)
altfel
tratareroare
}

tratareparantezainchisa este
{
daca teststivagoala atunci
tratareeroare
altfel
{
temp <- pozcurentacursor
pozcurentacursor <- extragedinstiva
*poz cursor
*intarziere
pozcurentacursor <- temp
}


factorial(intn)
{
daca n == 0 atunci
return 1
else
return (factorial(n-1)*n
}

algoritm 3.2

cat timp biblioteca este deschisa
executa
{
daca s-a introdus o comanda atunci
{ citeste cererea
introduceincoada(cerere)
}
daca nu testcoadagoala atunci
{cererecurenta <- extragedincoada
daca exista volumul cerut atunci
* se aduce volumul cerut
altfel
trateazaeroare
}
}



algoritmul 4.1

parcurgereinadancime (curent) este
{
prelucreaza nodul curent
prelucrat <- primul fiu al nodului curent
cat timp prelucrat <> arborevid executa
{parcurgereinadncime(prelucrat)
prelucrat <- urmatorul fiu al nodului curent
}
}

algoritmul 4.2

parcurgereinpreordine (arb, prel) este
{
daca arborele arb nu este vid atunci
{ prel (arb)
parcurgereinpreordine (subarborestang(arb))
parcurgereinpreordine(arb))
}
}

algoritmul 4.3

tiparirecuparantezecomplete(arbore) este
{daca arborenu este vid atunci
{daca * radacina nu ese nod terminal
atunci
{scrie paranteza deschisa
* parcurgere subarborele stang
scrie cheia nodului radacina
* parcurgere subarborele drept
scrie paranteza inchisa
}
altfel
scrie cheie nodului radacina
}
}

algoritmul 4.4
inseraredreapta (arb, l) este
{
modificadreapta (arb, construiestearbore (i, arborevid, subarboredrept(arb)))
}


algoritmul 4.5

parcurgereinadancime (curent) este
{
p0
daca curent = arborevid atunci
p1
altfel
daca frunza (curent) atunci
p2
altfel
{p3
parcurgereinadancime (subarborestang(curent))
p4 
parcurgereinadancime(subarboredrept(curent))
p5
}
p6
}








p84
algoritmul 5.1

exploraregraf (s) este
{ vizitate <- {s}
prelucreaza informatia din s
neexplorate <- vizitate
cat timp neexplorate <> multimea vida
executa
{ alege un nod v din neexplorate
gaseste (v,w) , urmatorul arc neexplorat care pleaca din v
daca (v,w) nu exista atunci
sterge v din neexplorate
altfel
daca w nu apartine lui vizitate
atunci { adauga w la vizitate 
prelucreaza inforamtia din w
adauga w la neexplorate
}}}


algoritmul 5.2

explorareinlargime(s) este
{
explorare <- {s}
prelucreaza informatia din s
introdu s in coada Q
cat timp Q <> coada vida executa
{
v <-primul nod din coada Q
pentru fiecare nod w adiacent lui v
executa
daca w nu apartine lui explorate
atunci
{
adauga w la explorate
prelucreaza informatia din w
introdu w in coada Q
}
}
}





algoritmul 5.3

explorareinadancime(s) este
{
vizitate <- {s}
prelucreaza informatia din s
introdu s in stiva S
cat timp S != stiva goala executa
{
v <- varf stiva S
w <- urmatorul nod adiacent lui v
daca  nu exista w atunci
scoate v din stiva
altfel
daca w nu apartine lui vizitate atunci
{
adauga w la vizitate
prelucreaza informatia din w
introdu w in stiva S
}
}
}

algoritmul 5.4

explorarerecursiva (s) este
{
adauga s la vizitate
prelucreaza informatia din s
pentru fiecare nod w adiacent lui s executa
daca w este nevizitat atunci explorarerecursiva(w)
}


algoritmul 5.5

cel mai varstnic (s) este

{
adauga s la vizitate
daca virsta mai mare atunci
actualizeaza varstnic
pentru fiecare nod w adiacent lui s executa
daca w este nevizitat atunci
celmaivarsnit(w)

}

programpincipal () este
{
citeste graful
citeste informatia din noduri
introdu sursa
varstnic <- sursa
celmaivarstnic(sursa)
afiseaza varstnic
}


algoritmul 5.6

f(s) este
{
daca virsta lui s mai mare atunci
actualizeaza virstnic
}


celmaivirstnic(s,functie) este
{
adauga s la vizitate
funct(s)
pentru fiecare nod w adiacent lu is executa
daca w este nevizitat atunci
celmaivirstnic(w)
}



algoritmul 5.7

calculdatorii (s) este
{ explorare <- {s}
introdu s in coada Q
cit timp Q <> coada vida executa
{ v <- primul nod din coada Q
datorie <- 0
pentru fiecare nod w adiacent lui v
executa
{ daca w nu apartine lu iexplorate
atunci
{ adauga w la explorate
introdu w in coada Q}
adauga cost(s,w) la datorie}
afiseaza datoria lui v}
}

programulprincipal () este
{
citeste graful
citeste costurile (datoriile)
introdu sursa s
calculdatorii (s)
}










backtrack

algoritmul 6.1

extindere (p, investitie, profitpotential) este
{ daca investitie + fp <= C atunci
{ sp <-1
daca  p<n atunci
extindere (p+1,investitie +fp, profitpotential)
altfel
test optim
sp <- 0
}
profitreal <- profitpotential - bp
daca profitreal >= profitoptim atunci
{ daca p < n atunci
extindere (p + 1, investitie, profitreal)
altfel
test optim
}
}


algoritmul 6.2

extindere (param curenti) este
{ daca includerea alternativei este posibila
atunci
{ daca este solutie atunci
test optim
altfel { prelucrari de avans
extindere ( param alternativei incluse)
prelucrari de revenire}
}
daca excluderea alternativei este posibila 
atunci
{ daca este solutie atunci
test optim
altfel
{ prelucrari de avans
extindere( param fara alternativa)
prelucrari de revenire}
}}


algoritmul 6.3

test optim este
{ daca profit potential > profit optim sau 
profit potential = profit optim si
investitie < investitie optima atunci
{ nsol <- 1
sol opt[nsol]<- s
profit optim <- profit potential
investitie optima <- investitie
}
altfel
daca profit potential = profit optim si
investitie = invetitie optima atunci
{ nsol <- nsol+1
sol optim[nsol] <- s
}
}


algoritmul 6.4

extindere (p, investitie , profitpotential) este
[ pentru nap <- 0 la ntap executa
{ profit real <- profit potential - (ntap - ntp) * bp
daca ( investitie + nap * ap <= c) si 
(profit real >= profit optim)
atunci
{ sp <- nap;
dapa p<n
atunci
exteindere (p +1, investitie + nap * ap , profit real)
altfel
test optim(profit real)
}}}


algoritmul 6.5

extindere (param curenti) este
{ pentru fiecare alternativa executata
 daca alternativa acceptabial atunci
daca nu s-a gasit solutie atunci
{ marcheaza alternativa
prelucrari de avans
extindere ( param alternativa)
prelucrari de revenire
}
altfel
prelucrari solutie
}



algoritmul 6.6

{ generare aleatoare si afisarea matricei de culori
initializari
pentru fiecare element executa
daca n ueste marcat atunci
{ marcare element
construire solutie curenta
test optionalitate solutie
}
afisare solutii optime
}



algoritmi 7.1 pag 112 divide et impera

algoritmul 7.1
sortare(lista) este
{ daca lista are lungime > 1 atunci
[ separa lista in lista1 si lista2
sortare (lista1)
sortare(lista2)
combinare(lista1,lista2,lista)
}
}

algoritmul 7.2

divizare (p,q,x) este
{ daca dimensiunea problemei este mare
atunci
{ separare ( p, q, m)
divizare (p, r, x1)
divizare (r+1, q, x2)
combinare (x1,x2,x) }
altfel
solutie (p,q,x)}


algoritmul 7.3

soartare(inf , sup) este
{ daca inf < sup atunci
{ med <- (inf + sup )/2
soratre(inf,med)
sortware(med+1,sup)
combinare (inf,med,sup)}}

algoritmul 7.4

combinare (inf, med,sup) este
{ i <- inf
j <- med+1
k <- inf
cat timp (i <= med) si (j<=sup) executa
{ daca ai <= aj atunci
{ bk <- ai
i <- i +1
}
altfel
{ bk <- aj
j <- j+1
}
k <- k+1
}
pentru l <- i la med executa
{ bk <- al
k <- k+1
}
pentru l <- j la sup executa
{ bk <- al
k <- k+1
}
pentru l <- inf la sup executa
al <- bl
}























algoritmi 8.1 pag115 greedy

algoritmul 8.1

{ init
succes <- false
semaipoateincerca <- false
repeta
daca se mai poate selecta o solutie partiala optima atunci
{ se maipoateincerca <- true
* selecteaza o solutie partiala optima
daca s-a obtinut o solutie finala atunci
succes <- true
}
pana cand succes sau nu semaipoateincerca
daca succes atunci
* afiseaza solutie
altfel
* afiseaza mesaj
}


algoritmul 8.2

conradictie (a,b ) este
{ intoarce (( a.inceput < b.inceput si 
a.sfarsit > b.inceput si
a.sfarsit < b.sfarsit ) sau
(a.sfarsit > b.sfarsit si
a.inceput > b.inceput si
a.inceput < b.sfarsit))
}

canalcunrmaxcontrad este
{
daca exista canale conditionate neamplasate
atunci
k <- primul canal conditionat dar neamplasat
altfel 
k <- primul canal nefixat
pozitiemaxima <- k
nrmaximcontradictii <- 0
cat timp (k <n) executa
{*determina j = numarul maxim de contradictii intre canalul k
si cele nefixate
daca ( j > nrmaximcontradictii) atunci
{ pozitiemaxima <- k
nrmaximcontradictii <- j
}
k <- pozitie urmatorul canal
}
intoarcere pozitiemaxima
}


algoritmul 8.3

amplaseazacanal(curent) este
{ imposibil <- false
pentru fiecare canal executa
{ daca nu este canalul curent
atunci
daca este in conflict cu canalul curent si
are aceeasi amplasare cu canalul curent
atunci
imposibil <- true
altfel
daca este in conplict cu canalul curent
atunci
* conditioneaza amplasarea canalului pe pozitia opusa canalului curent
}
intoarce nu imposibil;
}


algoritmul 8.4
{ succes <- false
semaipoateincerca <- false
* init i pozitia primului canal tratat
repeta
daca amplasarea canal(i) atunci
{ semaipoateincerca <- true
*amplaseaza canalul i
i <- canalcunrmaxcontrad
daca i>= n atunci
succes <- true;
}
pana succes sa nu semaipoateincerca
daca succes
atunci
afiseaza solutie
altfel
afiseaza nu exista solutie
}


















algoritmul 9.1 pag 124 cautare si sortare


algoritmul 9.1

cautarebinara(x,valcheie) este
{
inceput <-1
sfarsit <-n
mijloc <-(inceput+sfarsit)/2
cat timp (inceput <=sfarsit)
si (valcheie <> x[mijloc].cheie) executa
{ daca valcheie < x[mijloc].cheie atunci
sfarsit <- mijloc -1
altfel
inceput <- mijloc +1
mijloc <- (inceput + sfarsit) /2 
}
intoarce x[mijloc].cheie = valcheie
}


algoritmul 9.2

pentru fiecare pereche de valori executa
{
daca nu sunt in rodine corecta atunci
* schimba valorile intre ele
}


algoritmul 9.3

bubblesort (x,n) este
{
np <- n-1
repeta
ultimamodificare <- 0
pentru fiecare pereche i executa
{ daca ordine incorecta atunci
{* interschimba valorile
ultimamodificare <- 1
}
}
np <- ultimamodificare -1
pana cand ultimamodificare <= 1
}


algoritmul 9.4

insertsort (x,n) este
{
pentru 2 <= i <= n executa
{
gata <- false
j <- i-1
temp <- x[i]
repeta 
daca x[j].cheie > temp
atunci
{ x[j+1] <- x[j]
j <- j-1
}
altfel
gata <- true
pana cand gata sau j < 0
x[j+1] <-temp
}
}



algoritmul 9.5

quicksort (x,primul,ultimul) este
{
i <- primul
j<- ultimul
pivot <- x[(primul + ultimul )/2]
repeta
* pozitioneaza i dupa elementele cu chei < pivot.cheie
* pozitioneaza j inaintea elementele cu chei > pivot.cheie
daca i<j atunci
schimba (x[i],x[j])
daca i<= j atunci
{ j <- j-1
i <- i +1
}
pana cand i> j
}


algoritmul 9.6

cautanod (radacina, cheiedecautata) este
{
curent <- radacina
rezultat <- arborevid
cat timp curent <> arborevid executa
{ daca cheia nodului curent =
cheieacautata atunci
{ rezultat <- curent
curent <- arborevid
}
altfel
daca cheia nodulu curent < cheiacautata
atunci
curent <- subarborestang (curent)
altfel
curent <- subarboredrept(curent)
}
intoarce rezultat
}


algoritmul 9.7

insereazanod (radacina, informatie) este
{
rezultat <- adevarat
daca radacina = arborevid atunci
{ construieste nou nod
radacina <- noul nod
}
altfel
daca cheia radacinii = cheia informatiei
atunci
rezultat <- fals
altfel
daca cheia radacinii < cheie informatiei
atunci
rezultat <- insereazanod in subarborele stang
altfel
rezultat <- insereazanod in subarborele drept
intoarce rezultat
}



algoritmul 9.9

cautarear (radacina, prefix) este
{ curent <- radacina
i <- 0
cat timp ( curent <> arborevid) si
(i < lungime prefix) executa
{ i <- i+1
k <- elementul i al prefixului
curent <- fiu[k]
}
}

algoritmul.9.10

cautanod(radacina, prefix) este
{
r <- radacina
cat timp r <> arborevid si prefix nevid
executa
{ r <- subarborestang(r)
k <- elementul curent al prefixului
cat timp r <> arborevid si k > 1 executa
{ r <- subarboredrept (r)
k <-k-1
}
}
intoace r
}



algoritmul 9.11

adauganod ( radacina, nod) este
{
adauga noul nod ca ultim nod
curent <- nod
cat timp curent <> radacina executa
{ daca cheia nodului curent <= cheia
nodului tata atunci
{ transfera inforamtia din noul nod in noul curent
curent <- radacina
}
altfel
{
transfera informatia din nodul tata i nnodul curent
curent <-tata(curent)
}
}


algoritmul 9.12

extragedinarboredeselectie(arbore) este
{
rezultat <- informatia atasata nodului
radacina
transfera informatia atasata nodului ultimului nod in nodul radacina
elimina ultimul nod
curent <- radacina
temp <- inforamtia atasata nodului curent
propagare <- adevarat
cat timp propagare executa
{ daca nodul curent are fiu stanga atunci
{ urmatorul <- fiu stanga al nodului curent
daca nodul curent are fiu dreapta
atunci
daca cheia fiului dreapta <= cheia fiului stanga atunci
urmatorul <- fiul dreapta al nodului curent
daca cheia (temp)  <- cheia ( urmator)
atunci
propagare  <- fals
altfel
{ transfera inforamtia din nodul urmator in nodul curent
curent  <-  urmator
}
}
altfel
propagare  <-  fals
}
transfera temp in modul curent
}



algoritmul 9.13

succesiune (data1, data2) este
{
intoarce (an1 < an2) sau ((an1 =an2) si (luna1 < luna2)) sau ((an1 = an2) si (luna1 = luna2) si (ziua1 <=ziua2))
}


algoritmul 9.14

heapsort (vector, n ,relatie) este
{ pentru k dela [n/2] la 1 executa
propagare (vector, k, n, relatie)
l<-n
cat timp l > 1 executa
{ * inverseaza informatia atasta radacinii cu cea atasata ultimului nod
l<=l-1
propagare *vector, 1, l , relatie)
}}


algoritmul 9.15

sorwtaretopologica (elemente, conditionari ) este
{
sortare <- lista vida
nesortate <- multimea tuturor elementelor 
repeta
blocaj <- adevarat
pentru fiecare element i nesortat executa
daca nu mai are conditionari atunci
{ blocaj <- fals
* extrage din nesortate
* adauga la sfarsitul listei sortate pentru fiecare element k nesortat
executa
* elimina i din conditionari(k)
}
pana cand blocaj sau n
esortate = multime vida
intoarce sortate , nu blocaj
}


algoritmul 9.16

sortaretopologica2 (elemente, succesor) este
{
nesortate <- multimea tuturor elementelor
analizate <- multime vida
sortate <- adevarat
cat timp sortate si nesortate nevida executa
{* extrage element curent din nesortate
analizeaza (curent)
}
intoarce sortate, soartate
}
analizeaza (curent) este
{
*transfera curent din nesortate in analizate
rest <- multime succesori
cat timp sortate si rest nevid executa
{* extrage urmatorul succesor din rest 
daca urmator este in analizate atunci
sortare <- fals
altfel
daca urmator in nesortate atunci
analizeaza(urmator)
}
*extrage curent din analizate
daca rest = multime vida atunci
* include curent in lista sortare
}



algoritmi 10.1 pag 158 prelucrare grafuri


algoritmul 10.1

explorarerecursiva1(s) este
{ adauga s la vizitate
pentru toate nodurile nw adiacente
executa
daca nw nu apartine lui vizitate
atunci
{ contor1 <- contor 1 + 1
apel [nw] <- contor1
explorarerecursiva1(nw)
contor2 <- contor2 + 1
iesire[nw] <- contor2
}
}

programprincipal este
{
citeste graful
initializeaza contor1 , contor2 vizitate la zero
pentru toate nodurile s executa
daca s nu apartine lui vizitate atunci
{ contor1 <- contor1 + 1
apel[s] <-contor1
explorarerecursiva1(s)
contor2<-contor2+1
iesire[s] <- contor2
}
}



explorarerecursiva2 (s) este
{ minim[s] <- apel[s]
adauga s la vizitate
pentru toate nodurile nw adiacente executa
{ daca nw nu apartine lui vizitate atunci
{ introdu nw in clasacurenta
contor1 <- contor1+1
apel[nw] <- contor1
explorarerecursiva2(nw)
minim[s] <- min(minim[nw])}
daca apel[nw] < apel[s] si nw in clasacurenta atunci
minim[s] <- min(minim[s], apel[nw])
}
daca minim[s] = apel[s] atunci
elimina din clasacurenta nodurile i cu apel[i]>=apel[s]
}


programprincipal este
{
citeste graful
initializeaza contor1, contor2
vizitate la zero
pentru toate nodurile s executa
daca s nu apartine lui vizitate atunci
{
introdu s in clasacurenta
contor1 < - contor1 =1
apel[s] <- contor1
explorarerecursiva2(s)
}
}


explorarerecursiva3(s) este
{ minim[s] <- apel[s]
adauga s la vizitate
pentru toate nodurile nw adiacente
executa
{ daca nw nu apartine lui vizitate atuni
{ introdu nw in clasacurenta
contor1 <- contor1 +1
apel[nw] <- contor1
tata[nw] <-s
explorarerecursiva3[nw]
minim[s] <-min(minim[s],minim[nw])
}
daca apel[nw] < apel[s] atunci
minim[s] <-min(minim[s],apel[nw])
}
daca apel[s] >= 2 si
minim[s] = apel[tata[s]] atunci
elimina din clasacurenta nodurile i
cu apel[i] >= apel[s] care impreuna cu 
tata[s] formeaza c.b. cu centrul s
}

programprincipal este
{ citeste graful
init contor1, contor2, vizitate, clasacurenta si tata la zero
pentru toate nodurile s executa
daca s nu apartine lui vizitate atunci
{ introdu s in clasacurenta
contor1 <- contor1+1
apel[s] <-contor1
explorarerecursiva3(s)
}
}

algoritmul 10.4

gasestecaiminime(sursa) este
{ selectate <- {sursa}
pentru toate varfurile i de la 1 la n executa
distante[i] <- cost[sursa.i]
pentru toate varfurile i de la 1 la n-1
executa
{gaseste varful k neselectat cu
distante[k] minim
adauga k la selectate
pentru fiecare varf j neselectat executa
distante[j] <- min(distante[j], distante[k]+cost[k,j])
}
}


algoritmul 10.5

toatedisatnteleminime() este
{ pentru toate liniile i executa
pentru toate coloanele j executa
a[i,j] <- cost[i,j]
pentru toate liniile i executa
a[i,i]<-0
pentru k de la 1 la n executa
pentru toate liniile i executa
pentru toate coloanele j executa
daca a [i, k] +a[ k, j,< a[ i, j] atunci
a[ i, j]<- a[ i, k]+ a[k, j]
}


algoritmul 10.6

cale (i,j) este
{ k <- p[i,j]
daca k <> 0 atunci
{ cale (i,k)
scrie nodul k
cale (k,j) }
}


algoritmul 10.7

inchideretranzitiva () este
{ pentru toate liniile i executa
pentru toate coloanele j executa
daca cost[i,j] finit atunci
a[i,j] <- adevarat
altfel
a[i,j] <- fals
pentru k de la 1 la n executa
pentru toate liniile i executa
pentru toate coloanele j executa
daca not a[i,j] atunci
a[i,j] <- a[i,k] si a[k,j]
}


algoritmul 10.8


arboreminimprim () este
{
w <- {1}
t <- {}
cat timp w <> n executa
{ selecteaza muichia (w,u) de cost
minim cu w apartinand lui w si u
din n-w
adauga u al w
adauga (w,u) la t
}
}



algoritmul 10.9

arboreminimkruskal () este
{
t <- {}
cat timp t nu este arborede acoperire
executa
{ selecteaza muchia (w,u) de cost
minim din r
sterge (w,u) din r
daca (w,u) nu creeaza un ciclu in t
atunci
adauga (w,u) la t
}
}


}

 
















































Comentarii

Postări populare de pe acest blog

WINDOWS 10 COMPUTER FREEZING PROBLEM SOLVED

good news : a BIOS UPDATE can resolve the problem but just for a Windows 7 on 64 bits o.s. and the system is not stable all the time. even after  bios update the system can freeze.
new info : u can try to low the screen brightness and see if this error appear so often after 
news: last info !!! maybe a virus. scann our system now with an antivirus i generate this error using other device ( a tablet pc) connected in the same network and the laptop i have this problem just freeze  http://thehackernews.com/2013/10/backdoor-found-in-chinese-tenda.html

news : if u use a tenda router this make couse all this problems



what i discover so far :
1.the electric company have many failure and affect the main ISP router/switch for building  also the router/switch installed by the ISP may be affected by overheating and will crash after a long utilisation on heat conditions 2.the router/switch of ISP affect any router of the user between this router and pc/laptop of client 3.the router and any other device of t…

program principal cpp

#include "clasa.h" #include <stdio.h> #include <conio.h> #include <stdlib.h> #include <string.h> #define DELAY 9000000 void delay() { for(long i=0;i<DELAY;i++); } //constructor cu initializare de la tastatura BigInt::BigInt() {char x; signed char t[400]; int i; printf("\nNumarul cu semn "); do s=getche(); while((s!='+')&&(s!='-')); n=0; do {x=getche(); t[n]=x-'0'; n++; } while((x>='0')&&(x<='9')); n--; for(i=0;i<n;i++) nr[i]=t[n-i-1]; } //constructor cu initializare prin parametri BigInt::BigInt(char semn,signed char numar[],int dim) {int i; s=semn; n=dim; for(i=0;i<n;i++) nr[i]=numar[n-i-1]; } //transform un int negativ in pozitiv int BigInt::Pozitiv(int x) {int a,vb; a=0; vb=0; while(vb==0) if((x+a)==0) vb=1; else a=a+1; x=a; return x; } //constructor dintr-un nr int obisnuit BigInt::BigInt(int x) {int i; if(x>=0) s='+'…

o aplicatie php localitati romania

//APLICATIA SE REFERA LA BAZA DE DATE SIRUTA

//dragtable.js


/* dragtable v1.0 June 26, 2008 Dan Vanderkam, http://danvk.org/dragtable/ http://code.google.com/p/dragtable/ \Bsortabledraggable\B Instructions: - Download this file - Add <script src="dragtable.js"></script> to your HTML. - Add class="draggable" to any table you might like to reorder. - Drag the headers around to reorder them. This is code was based on: - Stuart Langridge's SortTable (kryogenix.org/code/browser/sorttable) - Mike Hall's draggable class (http://www.brainjar.com/dhtml/drag/) - A discussion of permuting table columns on comp.lang.javascript Licensed under the MIT license. */ // Here's the notice from Mike Hall's draggable script: //***************************************************************************** // Do not remove this notice. // // Copyright 2001 by Mike Hall. // See http…