Skocz do zawartości

  •  
  • Mini kompendium
  • MimeTeX
  • Regulamin

- zdjęcie

Mariusz M

Rejestracja: 11 Sep 2010
Offline Ostatnio: wczoraj, 19:39
*****

Moje tematy

Kulki

14.05.2017 - 09:26

Znalazłem u pewnego kolesia grę w kulki 
Brakuje w niej jednak sprawdzania ukośnych linii a także zapisu wyniku do pliku

 

http://www.wklej.org/id/3112539/
http://www.wklej.org/id/3112545/

 

 


O blogu jak opisać serce

13.02.2017 - 07:14

http://matma4u.pl/bl...k-opisac-serce/

 

Ja też się kiedyś tym bawiłem ale moje kody w Pascalu gdzieś zniknęły, prawdopodobnie zostały skasowane wraz z formatem dysku

Tak naprawdę serce nieco inaczej wygląda  ale to co otrzymałeś może się przydać np do zaprojektowania swojej talii kart
Krzywa którą narysowałeś to mogą być kiery , asteroida to może być karo
Gdy nieco zmodyfikujesz  krzywą którą uzyskałeś to otrzymasz piki

Zastanów się jeszcze nad koniczynką wtedy będziesz miał trefle

 

Punktem wyjścia do trefli może być rozeta trójlistna (mamy sytuację podobną jak w przypadku twojej krzywej i pików)


Usuwanie rekurencji

07.12.2016 - 13:30

Na podstawie pseudokodu Cormena (Algorithms unklocked , Introduction to algorithms) napisałem kody sortowania

 

W sortowaniu przez scalanie Cormen używa wartowników oraz dwóch tablic pomocniczych

Udało mi się usunąć wartowników i jedną z tablic pomocniczych

jednak została mi rekurencja

program sort;
uses crt;
const maxT=2500;
type tablica=array[1..maxT]of real;

procedure merge(var A:tablica;p,q,r:integer);
var n1,n2,i,j,k:integer;
      B:tablica;
begin
    n1:=q-p+1;
    n2:=r-q;
    for i:=p to r do
        B[i-p+1]:=A[i];
    i:=1;
    j:=n1+1;
    k:=p;
    while((i<=n1)and(j<=n1+n2)) do
    begin
        if(B[i]<=B[j]) then
        begin
        A[k]:=B[i];
        i:=i+1;
        end
        else
        begin
        A[k]:=B[j];
        j:=j+1;
        end;
        k:=k+1;
    end;
    while(i<=n1) do
    begin
        A[k]:=B[i];
        i:=i+1;
        k:=k+1;
    end;
    while(j<=n1+n2) do
    begin
        A[k]:=B[j];
        j:=j+1;
        k:=k+1;
    end;
end;

procedure mergesort(var A:tablica;p,r:integer);
var q:integer;
begin
    if(p<r) then
    begin
        q:=(p+r) div  2;
        mergesort(A,p,q);
        mergesort(A,q+1,r);
        merge(A,p,q,r);
    end;
end;

var k,n,p,q:integer;
A:tablica;
esc:char;

begin
    clrscr;
    repeat
        writeln('Podaj rozmiar tablicy');
        readln(n);
        randomize;
        for k:=1 to n do
        begin
            p:=(1-2*random(2))*random(10);
            q:=1+random(10);
            A[k]:=(p/q);
        end;
        for k:=1 to n do
            write(A[k]:1:10,' ');
        writeln;
        writeln;
        mergesort(A,1,n);
        for k:=1 to n do
            write(A[k]:1:10,' ');
        writeln;
        writeln;
        esc:=readkey;
    until esc=#27;
end.

 
program sort;
uses crt;
const maxT=2500;
type tablica=array[1..maxT]of real;

procedure heapify(var A:tablica;i,heapsize:integer);
var l,r,largest:integer;
      temp:real;
begin
    l:=2*i;
    r:=2*i+1;
    if((l<=heapsize)and(A[l]>A[i])) then
            largest:=l
    else
            largest:=i;
    if((r<=heapsize)and(A[r]>A[largest])) then
            largest:=r;
    if(largest<>i) then
        begin
            temp:=A[i];
            A[i]:=A[largest];
            A[largest]:=temp;
            heapify(A,largest,heapsize);
        end;
end;

procedure buildheap(var A:tablica;len:integer);
var i:integer;
begin
    for i:=len div 2 downto 1 do
        heapify(A,i,len);
end;


procedure heapsort(var A:tablica;len:integer);
var i,heapsize:integer;
      temp:real;
begin
    buildheap(A,len);
    heapsize:=len;
    for i:=len downto 2 do
    begin
        temp:=A[1];
        A[1]:=A[i];
        A[i]:=temp;
        heapsize:=heapsize-1;
        heapify(A,1,heapsize);
    end;
end;

var k,n,p,q:integer;
A:tablica;
esc:char;

begin
    clrscr;
    repeat
        writeln('Podaj rozmiar tablicy');
        readln(n);
        randomize;
        for k:=1 to n do
        begin
            p:=(1-2*random(2))*random(10);
            q:=1+random(10);
            A[k]:=(p/q);
        end;
        for k:=1 to n do
            write(A[k]:1:10,' ');
        writeln;
        writeln;
        heapsort(A,n);
        for k:=1 to n do
            write(A[k]:1:10,' ');
        writeln;
        writeln;
        esc:=readkey;
    until esc=#27;
end.

 

QuickSort  z przykładów Borland Pascala

uses crt;
const maxT=2500;
type tablica=array[1..maxT]of real;

procedure quickSort(var A:tablica;l,r:integer);
var i,j:integer;
    x,y:real;
begin
  i:=l;
  j:=r;
  x:=A[(l+r)div 2];
  repeat
    while(A[i]<x) do i:=i+1;
    while(x<A[j]) do j:=j-1;
    if(i<=j) then
    begin
      y:=a[i];
      a[i]:=a[j];
      a[j]:=y;
      i:=i+1;
      j:=j-1;
    end;
  until(i>j);
  if(l<j) then quickSort(A,l,j);
  if(i<r) then quickSort(A,i,r);   
end;

var k,n,p,q:integer;
A:tablica;
esc:char;

begin
    clrscr;
    repeat
        writeln('Podaj rozmiar tablicy');
        readln(n);
        randomize;
        for k:=1 to n do
        begin
            p:=(1-2*random(2))*random(10);
            q:=1+random(10);
            A[k]:=(p/q);
        end;
        for k:=1 to n do
            write(A[k]:1:10,' ');
        writeln;
        writeln;
        quickSort(A,1,n);
        for k:=1 to n do
            write(A[k]:1:10,' ');
        writeln;
        writeln;
        esc:=readkey;
    until esc=#27;
end.

Strukturka do czytania pliku

27.09.2016 - 11:52

Załóżmy że chcielibyśmy wczytać do pamięci jakiś stosunkowo mały plik

Myślę że przydałaby się strukturka

struct node{
int nol;                                // numer linii w pliku
int nochil;                           // liczba znaków w linii
char* line;                          // zawartość linii
struct node* next;              // wskaźnik do węzła przechowującego zawartość następnej linii w pliku
struct node* prev;              // wskaźnik do węzła przechowującego zawartość poprzedniej linii w pliku
};

tylko jak napisać funkcje obsługujące tę strukturkę


Oblicz wysokość

12.08.2016 - 15:11

pre_1471010102__szyhwcyjab8i.jpg

 

Z twierdzenia Pitagorasa mamy

 

\begin{cases}x^{2}+\left(y+h\right)^2=d^2\\x^2+y^2=c^2\end{cases}

 

Z trygonometrii mamy

 

\frac{y}{1340}=sin{34.4^{\circ}}

 

 

 

 

\begin{cases}x^{2}+y^{2}+2yh+h^{2}=d^2\\x^2+y^2=c^2\end{cases}\\</p>\\<p>y=1340\sin{34.4^{\circ}}</p>\\<p>

 

\begin{cases}2yh+h^{2}=d^2-c^2\\y=1340\sin{34.4^{\circ}}\end{cases}

 

Gdyby jakoś się udało obliczyć długości przeciwprostokątnych c oraz d

to wysokość otrzymalibyśmy z rozwiązania równania kwadratowego

Jedno rozwiązanie równania kwadratowego będzie ujemne więc je trzeba odrzucić