Notes

Szyfrujący (cezara):
//Algorytm szyfrujący za pomocą szyfru Cezara
//działa dla małych i wielkich liter alfabetu
//www.algorytm.org

#include<iostream>
using namespace std;

int main()
{
string tekst; //zmienna do przechowywania naszego tekstu
// UWAGA!!! tekst wprowadzać bez spacji
int x; // zmienna przechowujaca wspolczynnik przesuniecia <0;26>

cout<<"podaj tekst do zaszyfrowania"<<endl;
cin >>tekst; //tekst do zaszyfrowania
cout<<"podaj wspolczynnik przesuniecia"<<endl;
cin >> x; //o ile miejsc zamieniamy litery

for(int i=0;i<=tekst.length();i++){
if(tekst[i]>=65 && tekst[i]<=90-x) tekst[i]=int(tekst[i])+x; //wielkie liter
else if(tekst[i]>=91-x && tekst[i]<=90) tekst[i]=int(tekst[i])-26+x; // wielkie litery
else if(tekst[i]>=97 && tekst[i]<=122-x) tekst[i]=int(tekst[i])+x; //małe litery
else if(tekst[i]>=123-x && tekst[i]<=122) tekst[i]=int(tekst[i])-26+x; //małe litery
}
cout << tekst<<endl;

return 0;
}

Dijksty:
#include <stdio.h>
#include <vector.h>
#define N 10000
#define NUM 2000000

using namespace std;
class kopiec{
public:
int tab[N];
int node_nr[N];
int size;
kopiec();
void insert_into(int v,int node);
void delete_into();
};

bool QS[N];//czy wierzcholek jest juz przerobiony czy nie
//false oznacza ze juz jest albo jeszcze nie odwiedzono
//true ze ma jakas wartosc ale czeka w kopcu
vector <vector<int> > waga(N);//tablica vectorow (graf)
vector <vector<int> > graf(N);//-||- (wagi)

int main()
{
int n,m;//ilosc krawedzi !!!
scanf("%d %d",&n,&m);//wczytuje ilosc wierzcholkow i krawedzi
int * wartosc = new int [n+1] ;//tablica na wartosci

for(int i = 0 ; i <= n ;i++)wartosc[i]=NUM;//wypelniam je duzym czyms


for(int i = 1 ; i <= m;i++){
int a,b,w;
scanf("%d %d %d",&a,&b,&w);//wczytuje
graf[a].push_back(b);//wypelniam krawiedzi
waga[a].push_back(w);//i wagi
}

wartosc[1]=0; //wierzcholek nr 1
QS[1]=false; //juz odwiedzony
kopiec K; //nasz kopiec
int ii = 1; //aktualny wierzcholek na ktorym sie poruszamy
for(int x = 1 ; x <= n ; x++){//wszystkie wierzchołki

while(!graf[ii].empty()){//dopoki nie odwiedzimy wsyzstkich krawedzi wychodzacych z wierzchołka

int z = graf[ii].back();//numer wierzchołka do ktorego mamy krawedz
if(wartosc[z] > wartosc[ii]+waga[ii].back()){//sprawdzamy czy da sie poprawic droge , jezeli tak
wartosc[z] = wartosc[ii] + waga[ii].back(); //poprawiamy
QS[z]=true;//wierzchołek do kopca
K.insert_into(wartosc[z],z);//insert do kopca

}//if waga
waga[ii].pop_back();//usuwamy wage
graf[ii].pop_back();//usuwamy wierzcholek
}
ii = K.node_nr[1];//sprawdzamy kolejny wierzcholek z najlżejszą drogą
K.delete_into();//usuwamy go z kopca , ew czyscimy z nadmiaru wierzchołkow dublowanych
}
for(int i = 1 ; i <= n ; i++)printf("%d : %dn",i,wartosc[i]);//wyswietlamy min drogi

return 0;
}


kopiec::kopiec(){
size = 0;
}

void kopiec::insert_into(int v,int node){
tab[size+1] = v;
int s = size+1;
node_nr[s] = node;
while(s!=1)
{
if(tab[s/2] > tab[s]){
tab[s]=tab[s]^tab[s/2];
tab[s/2]=tab[s]^tab[s/2];
tab[s]=tab[s]^tab[s/2];
node_nr[s]=node_nr[s]^node_nr[s/2];
node_nr[s/2]=node_nr[s]^node_nr[s/2];
node_nr[s]=node_nr[s]^node_nr[s/2];
s/=2;}
else break;
}

size++;
}

void kopiec::delete_into(){
tab[1] = tab[size];
size--;
int tmp = 1;
while(tmp*2 <= size){
if(tab[tmp] > tab[tmp*2] || tab[tmp] > tab[tmp*2+1])
{
if(tab[tmp*2] < tab[tmp*2+1] || tmp*2+1 > size){

tab[tmp]=tab[tmp]^tab[tmp*2];
tab[tmp*2]=tab[tmp]^tab[tmp*2];
tab[tmp]=tab[tmp]^tab[tmp*2];
node_nr[tmp]=node_nr[tmp]^node_nr[tmp*2];
node_nr[tmp*2]=node_nr[tmp]^node_nr[tmp*2];
node_nr[tmp]=node_nr[tmp]^node_nr[tmp*2];
tmp=tmp*2;

}
else{

tab[tmp]=tab[tmp]^tab[tmp*2+1];
tab[tmp*2+1]=tab[tmp]^tab[tmp*2+1];
tab[tmp]=tab[tmp]^tab[tmp*2+1];
node_nr[tmp]=node_nr[tmp]^node_nr[tmp*2+1];
node_nr[tmp*2+1]=node_nr[tmp]^node_nr[tmp*2+1];
node_nr[tmp]=node_nr[tmp]^node_nr[tmp*2+1];
tmp=tmp*2+1;}
}
else {QS[tmp]=false;break;}
}
if(QS[node_nr[1]]==false)delete_into();
}


Eukieldesa:

Rozwiązanie iteracyjne:
#include<iostream>
#include<cstdlib>
using namespace std;

int NWD(int a, int b)
{
while(a!=b)
if(a>b)
a-=b; //lub a = a - b;
else
b-=a; //lub b = b-a
return a; // lub b - obie zmienne przechowują wynik NWD(a,b)
}

int main()
{
int a, b;

cout<<"Podaj dwie liczby: ";
cin>>a>>b;

cout<<"NWD("<<a<<","<<b<<") = "<<NWD(a,b)<<endl;

system("pause");
return 0;
}


Rozwiązanie rekurencyjnie:
#include<iostream>
#include<cstdlib>
using namespace std;

int NWD(int a, int b)
{
if(a!=b)
return NWD(a>b?a-b:a,b>a?b-a:b);
return a;
}

int main()
{
int a, b;

cout<<"Podaj dwie liczby: ";
cin>>a>>b;

cout<<"NWD("<<a<<","<<b<<") = "<<NWD(a,b)<<endl;

system("pause");
return 0;
}



dodawanie:

#include


using namespace std;


int main () {


//short int a, b;

//int a, b;

float a, b;

//double a, b;


cout << "Podaj dwie liczby:" << endl;

cin >> a >> b;


//cout << "Suma liczb = " << a+b << endl;

cout << a+b << endl;


return 0;

}

ONP (strumień łańcuchowy)


#include <iostream>
#include <sstream>
#include <string>

using namespace std;

int main()
{
double x;
stringstream ss; // strumień łańcuchowy
string s; // łańcuch;

cin >> s; // czytamy łańcuch znaków
ss << s; // odczytany łańcuch umieszczamy w strumieniu
if(ss >> x) // konwertujemy na liczbę i sprawdzamy, czy konwersja była poprawna
cout << "LICZBAn";
else
cout << "NIE LICZBAn";
return 0;
}

Herona:


#include <cstdlib>
#include <iostream>

using namespace std;

int main(int argc, char *argv[])
{
float a,b,c,pom,p,pole2;
cout<<"Równanie herona "<<endl;
cout<<"Podaj pierwszy z bokow trojkata"<<endl;
cin>>a;
cout<<"Podaj drugi z bokow trojkata"<<endl;
cin>>b;
cout<<"Podaj trzeci z bokow trojkata"<<endl;
cin>>c;
if (a+b>c && a+c>b && b+c>a)
{
cout<<"Mozna utworzyc trojkat i bedzie on "<<endl;
cout << pom==pole (a+b+c)*0,5 <<endl ;
cout << pole2==sqrt(pom) <<endl ;
}
else cout<<"Nie mozna utworzyc trojkata"<<endl;
cout<<" a jego pole to ";
cout<<pole2<<endl;
cout<<endl;

system("pause");
return 0;
}


Cantora:

#include <stdio.h>

void cantor(unsigned e)
{
unsigned i,k,d,x,in,n=1;
for(d=e,k=3;d;d>>=1,k*=k) if(d&1) n*=k;
for(d=0;d<=e;++d,putchar('n')) for(i=0;i<n;++i,putchar("xDB "[in])) for(x=3*i,in=k=0;k<d;x%=n,x*=3,++k) in|=(x/n==1);
}

int main()
{
cantor(3);
return 0;
}