Professional Documents
Culture Documents
w języku C++
w środowisku systemu Linux
z dnia 27 grudnia 2005
Operacje wejścia/wyjścia
1
potęga wartość
----------------
1 3.1
2 9.87
3 31.006
4 97.4091
5 306.01968
• 1, 3
• 2, 0
• 3, 1.5
• 7, a
Treść listu składa się zawsze z 3 wierszy. Każdy wiersz zawiera nazwę towaru,
dwukropek, cenę w złotych. Nazwa towaru może się składać z dowolnej liczby
słów oddzielonych odstępami, a słowa wyłącznie z liter.
Napisz program suma obliczający całkowitą należność do zapłaty. Podaj
dwa rozwiązania: pierwsze charakterystyczne dla języka C, drugie dla języka
C++.
2
Zad. 13. Plik 2pi.txt zawiera dwa wiersze. W każdym wierszu zapisana
jest wyłącznie wartość liczby π z losowo wybraną liczbą cyfr po przecinku
∈ h100, ∞). Napisz program zamiana, który zamieni kolejność tych liczb
w pliku. Podaj dwa rozwiązania: pierwsze charakterystyczne dla języka C,
drugie dla języka C++.
• double
Wytłumacz różnice. Który z wyników jest najbliższy prawdzie?
Wskazówka: ∞ 1 π2
P
i=1 i2 = 6
Zad. 16. Napisz program anagram, który odczytuję nazwę pliku podaną
przez użytkownika, a następnie odwraca kolejność bajtów w tym pliku.
% ./anagram
Podaj nazwę pliku
a.txt
%
3
3.1
3.14
3.141
3.1415
3.14159
• -------------------------
| 1 | 2 | 3 | 4 |
-------------------------
| 2 | 4 | 6 | 8 |
-------------------------
| 3 | 6 | 9 | 12 |
-------------------------
| 4 | 8 | 12 | 16 |
-------------------------
4
Zad. 21. Napisz program licz będące odpowiednikiem systemowego po-
lecenia wc, zliczającego liczbę znaków, słów i wierszy w standardowym stru-
mieniu wejściowym. Działanie programu sprawdź na jego pliku źródłowym
licz.cc i porównaj z programem wc.
Zad. 22. Napisz program rzeczywista, który liczbę a podaną jako argu-
ment wypisuje w postaci
p · 2w
p · 2w
gdzie (an ) jest ciągiem zadanym rekurencyjnie an+1 = 12 (an + axn ). Wykonaj
10 iteracji przez kopiowanie fragmentu programu. Zwróć uwagę, na
a) szybkość zbiegania w zależności od początkowej wartości a0 ,
b) zachowanie dla ujemnych x.
Dla ustalenia wartości a0 skorzystaj z poprzedniego zadania.
Zad. 25. Korzystając ze wzoru Gaussa napisz program dzien, który ob-
licza dzień tygodnia na podstawie daty.
Numer dnia określony jest następującym wzorem
5
gdzie d ∈ {1, . . . } jest dniem miesiąca, m ∈ {1, . . . , 12} – miesiącem, r –
rokiem. Dzielenie jest typu całkowitego. Ponadto za początek roku należy
przyjąć dzień 1 marca.
Zad. 26. Napisz program podatki obliczający wysokość podatku docho-
dowego w 2003 roku. Przyjmij następujące dane: skala 19 % dla dochodów
poniżej 37024 zł, 30 % dla dochodów poniżej 74048 zł, 40 % dla dochodów
poniżej 600000 zł, 50 % dla pozostałych. Kwota wolna od podatku to 530.08
zł.
Dane dotyczące wysokości kwot i podatku odpowiadające poszczególnym
progom zapisz w tablicy.
Zad. 27. Napisz program dziennik, który oblicza ile dni upłynęło od po-
danej daty do dnia uruchomienia programu. Skorzystaj z doświadczeń pro-
gramu dzien i funkcji time przekazującej liczbę sekund jakie upłynęły od
godziny 000 dnia 1 stycznia 1970 roku.
W zależności od wprowadzonych danych wynikiem działania programu
powinno być wypisanie jednego sposród poniższych komunikatów:
Zad. 28. Korzystając z liczb całkowitych typu int napisz program silnia
obliczający silnię zadanej liczby oraz liczbę wystąpień cyfry 7 w jej zapisie
dziesiętnym. Silnie jakiej największej liczby możemy policzyć tym progra-
mem?
Zad. 29. Napisz program podzielne znajdujący wszystkie liczby z za-
kresu od 1 do 1000, które są podzielne przez sumę swoich cyfr.
Zad. 30. Napisz program podzielne2 znajdujący wszystkie liczby z za-
kresu od 1 do 1000, które są jednocześnie podzielne przez sumy swoich pa-
rzystych i nieparzystych cyfr.
Zad. 31. Napisz program cezar, który czyta bajty ze standardowego stru-
mienia wejściowego (funkcja cin.get) i przepisuje do standardowego stru-
mienia wyjściowego (cout.put) zastępując litery alfabetu łacińskiego lite-
rami znajdującymi się w alfabecie o n pozycji dalej. Wartość n odczytaj z
parametru uruchomienia programu.
6
Zad. 32. Napisz program wielomian obliczający wartość wielomianu
zapisz w postaci osobnych funkcji w1, w2, w3. Porównaj wyniki obliczeń zre-
alizowanych różnymi sposobami.
Następnie zapisując na kartce wyniki i traktując program jako programo-
walny kalkulator, dzięki któremu mamy łatwość liczenia wartości wielomianu
w poszczególnych punktach, znajdź metodą bisekcji miejsca zerowe.
Zad. 33. Napisz program bisekcja – rozwinięcie programu wielomian –
umożliwiający obliczanie miejsc zerowych wielomianu
metodą bisekcji.
Uzyskane wyniki porównaj z dokładnymi wartościami miejsc zerowych
wielomianu.
Zad. 34. Napisz program styczne będący modyfikacją programu bisek-
cja, znajdujący metodą stycznych, w której „kandydata” xn na miejsce ze-
rowe funkcji f (x) zastępujemy „kandydatem lepszym”
f (xn )
xn+1 = xn −
f 0 (xn )
a) silni,
b) liczb Fibonacciego.
7
Liczby Fibonacciego zadane są rekurencyjnie fn+2 = fn+1 + fn oraz f0 =
f1 = 1.
Następnie oblicz 10!, 20!, 50!, f10 , f20 , f50 . Skomentuj uzyskane wyniki.
Zad. 36. Napisz program euklides znajdujący największy wspólny dziel-
nik korzystając z algorytmu Euklidesa: znalezienie N W D(a, b), gdzie a > b
sprowadza się do (poza przypadkiem kiedy a jest wielokrotnością b) do zna-
lezienia N W D(b, reszta z dzielenia a przez b). Rozwiązanie zapisz na dwa
sposoby: iteracyjnie i rekurencyjnie.
Zad. 37. Napisz program newton znajdujący dla zadanego punktu x0
miejsce zerowe wielomianu w(x) = (x − 1)(x − 2)(x − 3)(x − 4) przy po-
mocy metody Newtona (stycznych; polegającej na „zastąpieniu” kandydata
xi na miejsce zerowe na ogół „lepszym” kandydatem xi+1 = xi − ww(x i)
0 (x ) ). Obli-
i
czenia wykonaj w dziedzinie zespolonej. Następnie oblicz miejsca zerowe dla
następujących wartości początkowych x0 :
a) 1.05, 2.1, 2.9, 4.1,
b) 2.5,
c) 2.4, 2.6.
Poniżej przedstawiono działanie przykładowego rozwiązania.
% ./newton (0.95,0.1)
w((9.4999999999999996e-01,1.0000000000000001e-01)) =
(2.0920625000000023e-01,-7.0835000000000004e-01)
w((1.0080677933838893e+00,1.8067861263060966e-02)) =
(-5.1237462461980618e-02,-1.0518620817044756e-01)
w((1.0005141051464106e+00,-5.2136674958264129e-04)) =
(-3.0847118896539993e-03,3.1223053063340199e-03)
w((1.0000000151267927e+00,9.8408636207405684e-07)) =
(-9.0771406412290008e-08,-5.9045178449450769e-06)
w((1.0000000000017750e+00,-5.4577759886899162e-14)) =
(-1.0650147430589576e-11,3.2746655931926366e-13)
%
8
% ./litery2 pt.txt h.txt
"pt.txt.dat"
"h.txt.dat"
0.2
0.15
0.1
0.05
0
_ a b c d e f g h i j k l m n o p q r s t u v w x y z
9
// Paweł Klimczewski, 27 listopada 2005
#include <iostream>
#include <cmath>
int main()
{
for ( int y = -50; y <= 50; ++y )
{
for ( int x = -50; x <= 50; ++x )
{
double r = sqrt( x * x + y * y );
cout << x << ’ ’ << y << ’ ’ << r << endl;
}
cout << endl;
}
return 0;
}
G N U P L O T
Version 4.0 patchlevel 0
last modified Thu Apr 15 14:44:22 CEST 2004
System: Linux 2.4.26
> set pm3d map
> splot "test.dat"
otrzymujemy rysunek
10
"test.dat"
60
80
40 70
60
50
20
40
30
0 20
10
0
-20
-40
-60
-60 -40 -20 0 20 40 60
11
długość boku a = 3, n = 100, = 2.
Biblioteka STL
12
1
23
456
13
na wierzchołku stosu. Po każdej operacji wypisuje na ekranie wartość ele-
mentu z wierzchołka stosu. Skorzystaj z klasy stack.
Zad. 53. Napisz program odleglosci odczytujący ze standardowego stru-
mienia wejściowego liczby zespolone zi i przepisujący je do plików:
14
Rozwiązania zadań
Zad. 1.
% g++ -o hello hello.cc
% ./hello
Programowanie w C++ jest proste i przyjemne!
%
Zad. 2.
% g++ -c -o hello.o hello.cc
% g++ -o hello hello.o
% ./hello
Programowanie w C++ jest proste i przyjemne!
%
Zad. 3.
% g++ -c -o main.o main.cc
% gcc -c -o fun.o fun.c
% g++ -o main main.o fun.o
% ./main
Hello world
%
Zad. 4.
all: hello main
hello: hello.cc
g++ -o hello hello.cc
.PHONY: clean
clean:
rm -f *.o hello main
15
Zad. 5.
%.o: %.c
gcc -c -o $@ $<
%.o: %.cc
g++ -c -o $@ $<
%: %.o
g++ -o $@ $^
hello: hello.o
Zad. 6.
CCFLAGS += -g
CXXFLAGS += -g
hello: hello.o
$(CXX) -o $@ $<
Zad. 7.
% g++ -O0 -o pierwsze pierwsze.cc
% time pierwsze > /dev/null
7.900u 0.000s 0:07.90 100.0% 0+0k 0+0io 265pf+0w
% g++ -O2 -o pierwsze pierwsze.cc
% time pierwsze > /dev/null
7.490u 0.000s 0:07.49 100.0% 0+0k 0+0io 268pf+0w
Zad. 10.
// Program wypisuje kolejne potęgi liczby pi z zadaną dokładnością
// korzystając z biblioteki języka C.
//
// Paweł Klimczewski, 10 października 2005
#include <cstdio>
#include <cmath>
16
int main()
{
printf("potęga wartość\n"
"----------------\n");
printf("1 %5.1f\n",M_PI);
printf("2 %6.2f\n",M_PI*M_PI);
printf("3 %7.3f\n",M_PI*M_PI*M_PI);
printf("4 %8.4f\n",M_PI*M_PI*M_PI*M_PI);
printf("5 %9.5f\n",M_PI*M_PI*M_PI*M_PI*M_PI);
return 0;
}
#include <iostream>
#include <iomanip>
#include <cmath>
int main()
{
cout<<"potęga wartość"<<endl;
cout<<"-----------------"<<endl<<fixed;
cout<<"1 "<<setw(5)<<setprecision(1)<<M_PI<<endl;
cout<<"2 "<<setw(6)<<setprecision(2)<<M_PI*M_PI<<endl;
cout<<"3 "<<setw(7)<<setprecision(3)<<M_PI*M_PI*M_PI<<endl;
cout<<"4 "<<setw(8)<<setprecision(4)<<M_PI*M_PI*M_PI*M_PI<<endl;
cout<<"5 " <<setprecision(5)<<M_PI*M_PI*M_PI*M_PI*M_PI<<endl;
return 0;
}
Zad. 11.
// Program odczytuje dwie liczby i wypisuje ich iloraz i sumę.
// Wersja w stylu C++.
//
// Paweł Klimczewski, 10 października 2005
#include <iostream>
int main()
{
cout<<"Podaj pierwszą liczbę"<<endl;
17
int i;
cin>>i;
cout<<"Podaj drugą liczbę"<<endl;
int j;
cin>>j;
cout<<"Pierwsza odczytana liczba "<<i<<endl;
cout<<"Druga odczytana liczba "<<j<<endl;
cout<<"Iloraz "<<i/j<<endl;
cout<<"Suma "<<i+j<<endl;
return 0;
}
#include <cstdio>
int main()
{
printf("Podaj pierwszą liczbę\n");
int i;
scanf("%d",&i);
printf("Podaj drugą liczbę\n");
int j;
scanf("%d",&j);
printf("Pierwsza odczytana liczba %d\n",i);
printf("Druga odczytana liczba %d\n",j);
printf("Iloraz %d\n",i/j);
printf("Suma %d\n",i+j);
return 0;
}
Zad. 12.
// Program oblicza zadłużenie wobec barku wydziałowego na podstawie rachunku
// nadesłanego w pliku;)
//
// Paweł Klimczewski, 10 października 2005
#include <cstdio>
int main()
{
double cena1;
scanf("%*[A-Za-z ]:%lf\n",&cena1);
double cena2;
scanf("%*[A-Za-z ]:%lf\n",&cena2);
18
double cena3;
scanf("%*[A-Za-z ]:%lf\n",&cena3);
printf("%.2f+%.2f+%.2f=%.2f\n",cena1,cena2,cena3,cena1+cena2+cena3);
return 0;
}
Zad. 13.
// Program zamienia miejscami liczby zapisane w pliku 2pi.txt.
//
// Paweł Klimczewski, 10 października 2005
#include <fstream>
#include <string>
int main()
{
fstream f("2pi.txt");
string s1, s2;
f>>s1>>s2;
f.seekp(0,ios::beg);
f<<s2<<endl<<s1<<endl;
return 0;
}
Zad. 14.
// Program sprawdza liczbę cyfr znaczących dla zmiennych typu float, double
// i long double.
//
// Paweł Klimczewski, 19 października 2005
#include <iostream>
#include <iomanip>
#include <cmath>
int main()
{
// dla łatwiejszego porównania wyników
cout << setprecision( 40 );
// float
cout << "----- float" << endl;
float fsuma = 0, poprzednia_fsuma;
int i = 0;
19
do
{
poprzednia_fsuma = fsuma;
fsuma = fsuma + pow( 10.f, -i );
i = i + 1;
cout << setw( 2 ) << i << ": " << fsuma << endl;
}
while ( poprzednia_fsuma != fsuma );
// double
cout << "----- double" << endl;
double dsuma = 0, poprzednia_dsuma;
i = 0;
do
{
poprzednia_dsuma = dsuma;
dsuma = dsuma + pow( 10., -i );
i = i + 1;
cout << setw( 2 ) << i << ": " << dsuma << endl;
}
while ( poprzednia_dsuma != dsuma );
// long double
cout << "----- long double" << endl;
long double ldsuma = 0, poprzednia_ldsuma;
i = 0;
do
{
poprzednia_ldsuma = ldsuma;
ldsuma = ldsuma + pow( 10.l, -i );
i = i + 1;
cout << setw( 2 ) << i << ": " << ldsuma << endl;
}
while ( poprzednia_ldsuma != ldsuma );
return 0;
}
Zad. 15.
// Program oblicza sumę odwrotności kwadratów z zakresu 1...10^8 posługując
// się zmiennymi typu float, double i long double.
//
// Paweł Klimczewski, 19 października 2005
#include <iostream>
#include <iomanip>
#include <cmath>
20
using namespace std;
int main()
{
cout << setprecision( 40 ); // dla łatwiejszego porównania wyników
// float, od 1 w górę
float fsuma = 0;
for ( int i = 1; i <= 100000000; ++i )
{
float f = i;
fsuma = fsuma + 1.f / f / f;
}
cout << fsuma << endl;
// double, od 1 w górę
double dsuma = 0;
for ( int i = 1; i <= 100000000; ++i )
{
double d = i;
dsuma = dsuma + 1. / d / d;
}
cout << dsuma << endl;
21
cout << ldsuma << endl;
return 0;
}
Zad. 16.
// Program zamienia kolejność znaków w pliku.
//
// Paweł Klimczewski, 4 listopada 2005
#include <iostream>
#include <fstream>
#include <string>
int main()
{
cout << "Podaj nazwę pliku" << endl;
string nazwa;
cin >> nazwa;
fstream f( nazwa.c_str() );
f.seekg( 0, ios::end );
int n = f.tellg();
for ( int i = 0; i < n / 2; ++i )
{
f.seekg( i, ios::beg );
char c1 = f.get();
f.seekg( -( i + 1 ), ios::end );
char c2 = f.get();
f.seekp( i, ios::beg );
f.put( c2 );
f.seekp( -( i + 1 ), ios::end );
f.put( c1 );
}
return 0;
}
22
Zad. 17.
// Program wypisuje w kolejnych wierszach coraz dokładniejszą wartość
// liczby pi.
//
// Paweł Klimczewski, 4 listopada 2005
#include <iostream>
#include <iomanip>
#include <cmath>
int main()
{
cout << "Podaj liczbę wierszy" << endl;
int i;
cin >> i;
if ( !cin || i <= 0 || i > 9 )
{
cout << "Nierozsądna odpowiedź" << endl;
}
else
{
for ( int j = 0; j < i; ++j )
{
cout << setprecision( 1 + j ) << fixed << M_PI << endl;
}
}
return 0;
}
Zad. 18.
// Program wypisuje w kolejnych wierszach coraz dokładniejszą wartość
// kolejnej potęgi liczby pi.
//
// Paweł Klimczewski, 4 listopada 2005
#include <iostream>
#include <iomanip>
#include <cmath>
int main()
{
cout << "Podaj liczbę wierszy" << endl;
int i;
23
cin >> i;
if ( !cin || i <= 0 || i > 9 )
{
cout << "Nierozsądna odpowiedź" << endl;
}
else
{
cout << "potęga wartość" << endl
<< "-------------------------" << endl;
for ( int j = 0; j < i; ++j )
{
double potega = pow( M_PI, j + 1 );
int cyfr = int( log10( potega ) );
cout << setw( 10 - cyfr ) << left << j + 1
<< setprecision( j + 1 ) << fixed << potega
<< endl;
}
}
return 0;
}
Zad. 19.
// Program rysuje kwadrat z przekątną.
//
// Paweł Klimczewski, 4 listopada 2005
#include <iostream>
int main()
{
cout << "Podaj rozmiar kwadratu" << endl;
int n;
cin >> n;
if ( !cin || n <= 0 || n > 20 )
{
cout << "Niepoprawne dane!" << endl;
}
else
{
for ( int y = 0; y < n; ++y )
{
for ( int x = 0; x < n; ++x )
{
char znak = ’ ’;
if ( !x || !y || x == n - 1 || y == n - 1 || x == y )
{
24
znak = ’*’;
}
cout << znak;
}
cout << endl;
}
}
return 0;
}
#include <iostream>
#include <iomanip>
int main()
{
const int n = 4;
for ( int y = 0; y < n; ++y )
{
cout << "---------------------" << endl;
for ( int x = 0; x < n; ++x )
{
cout << "| " << setw(2) << ( x + 1 ) * ( y + 1 ) << " ";
}
cout << "|" << endl;
}
cout << "---------------------" << endl;
return 0;
}
Zad. 20.
// Program oblicza liczbę odczytanych słów i średnią długość słowa
//
// Paweł Klimczewski, 4 listopada 2005
#include <iostream>
#include <string>
int main()
{
int n = 0, znakow = 0;
25
string s;
while ( cin >> s )
{
++n;
znakow += s.size();
}
cout << "Liczba słów: " << n << endl
<< "Średnia długość słowa: " << 1. * znakow / n << endl;
return 0;
}
Zad. 21.
// Program stara się naśladować systemowe polecenie wc.
//
// Paweł Klimczewski, 4 listopada 2005
#include <iostream>
#include <sstream>
#include <string>
int main()
{
int wierszy = 0, slow = 0, znakow = 0;
string s;
while ( getline( cin, s ) )
{
++wierszy;
istringstream is( s );
while ( is >> s )
{
++slow;
znakow += s.size();
}
}
cout
<< "Wierszy " << wierszy
<< ", słów " << slow
<< ", znaków " << znakow << endl;
return 0;
}
Zad. 22.
// Program wypisuje wartość podanej liczby w postaci c*2^m.
//
// Paweł Klimczewski, 11 listopada 2005
26
#include <iostream>
#include <iomanip>
#include <sstream>
#include <cmath>
Zad. 23.
// Program odczytuje podaną wartość x=c*2^m, a następnie konstruuje liczbę
// c*2^(m/2).
27
//
// Paweł Klimczewski, 11 listopada 2005
#include <iostream>
#include <iomanip>
#include <cmath>
#include "czytaj.h"
Zad. 24.
// Program oblicza pierwiastek zadanej liczby metodą Newtona.
//
// Paweł Klimczewski, 11 listopada 2005
#include <iostream>
#include <iomanip>
#include <cmath>
#include "czytaj.h"
28
cout << "Kolejne iteracje" << endl;
cout << left << scientific << setprecision( 16 );
// Iteracyjnie znajduję piewiastek.
for ( int i = 1; ; ++i )
{
double q = 1. / 2 * ( p + x / p );
if ( p == q )
{
// Iteracja nie przyniosła zmian. Przerywam pętlę.
break;
}
cout << setw( 6 ) << i << q << endl;
p = q;
}
return 0;
}
Zad. 25.
// Program oblicza dzień tygodnia.
//
// Paweł Klimczewski, 11 listopada 2005
#include <iostream>
#include <iomanip>
#include <sstream>
#include <cmath>
29
cin.clear();
continue;
}
istringstream is( s );
is >> x;
if ( !is )
{
cerr << "To nie była liczba!" << endl;
continue;
}
is >> ws;
int j = is.tellg();
if ( j != -1 && j != s.size() )
{
cerr << "To nie była tylko liczba!" << endl;
continue;
}
break;
}
}
int main()
{
int r;
czytaj_z_wejscia( r, "Podaj rok" );
int m;
czytaj_z_wejscia( m, "Podaj miesiąc" );
int d;
czytaj_z_wejscia( d, "Podaj dzień" );
if ( m < 3 )
{
m += 10;
r -= 1;
}
else
{
m -= 2;
}
int n = r / 4 - r / 100 + r / 400 + 367 * m / 12 + d + r * 365;
30
Zad. 26.
// Program oblicza wielkość podatku na podstawie podanego dochodu. zgodnie
// ze skalą z 2005 roku.
//
// Paweł Klimczewski, 13 listopada 2005
#include <iostream>
#include "czytaj.h"
Zad. 27.
// Program oblicza liczbę dni jakie upłynęły od zadanej daty.
//
// Paweł Klimczewski, 11 listopada 2005
#include <iostream>
#include <ctime>
#include "czytaj.h"
31
int main()
{
int r;
czytaj_z_wejscia( r, "Podaj rok" );
int m;
czytaj_z_wejscia( m, "Podaj miesiąc" );
int d;
czytaj_z_wejscia( d, "Podaj dzień" );
// Konwersja podanej daty do postaci wymaganej we wzorze Gaussa, czyli
// rok zaczyna się w marcu.
if ( m > 2 )
{
m = m - 2;
}
else
{
m = m + 10;
r = r - 1;
}
if ( n > 0 )
{
cout << "Żyjesz już " << n << " dni." << endl;
if ( n % 1000 == 0 )
{
cout << "Dziś masz mały jubileusz!" << endl;
}
else
{
long p = 1000 - n % 1000;
if ( p == 1 )
{
cout << "Jutro masz mały jubileusz!" << endl;
32
}
else if ( p == 2 )
{
cout << "Pojutrze masz mały jubileusz!" << endl;
}
else
{
cout << "Do najblizszej 1000-nicy zostalo Ci " << p << " dni." << endl;
}
}
}
else
{
cout << "Na pewno już się urodziłeś?" << endl;
}
return 0;
}
Zad. 28.
// Program oblicza silnię zadanej liczby oraz ilość cyfr 7 w jej zapisie.
//
// Paweł Klimczewski, 11 listopada 2005
#include <iostream>
#include <sstream>
#include <cmath>
#include "czytaj.h"
int main()
{
// Dla odczytania wartości podanej przez użytkownika korzystam
// z funkcji czytaj_z_wejscia z programu rzeczywista.
int x;
czytaj_z_wejscia( x );
int s = silnia( x );
ostringstream os;
os << s;
string t = os.str();
int n = 0;
for ( int i = 0; i < t.size(); ++i )
{
33
if ( t[ i ] == ’7’ ) ++n;
}
cout << x << "!=" << s << endl;
cout << "Liczba siódemek w zapisie = " << n << endl;
return 0;
}
Zad. 29.
// Program znajduje wszystkie liczby całkowite z zakresu 1..1000 podzielne
// przez sumę swoich cyfr.
//
// Paweł Klimczewski, 13 listopada 2005
#include <iostream>
#include <sstream>
int main()
{
for ( int i = 1; i <= 1000; ++i )
{
ostringstream os;
os << i;
const string& s = os.str();
int suma = 0;
for ( int j = 0; j < s.size(); ++j )
{
suma += s[ j ] - ’0’;
}
if ( i % suma == 0 ) cout << i << " ";
}
cout << endl;
return 0;
}
Zad. 30.
// Program znajduje wszystkie liczby całkowite z zakresu 1..1000 podzielne
// jednocześnie przez sumy swoich parzystych i nieparzystych cyfr.
//
// Paweł Klimczewski, 13 listopada 2005
#include <iostream>
#include <sstream>
34
int main()
{
for ( int i = 1; i <= 1000; ++i )
{
ostringstream os;
os << i;
const string& s = os.str();
int suma_p = 0, suma_n = 0;
for ( int j = 0; j < s.size(); ++j )
{
int c = s[ j ] - ’0’;
( c % 2 ? suma_n : suma_p ) += c;
}
if ( suma_p && i % suma_p == 0 &&
suma_n && i % suma_n == 0 )
cout << i << " ";
}
cout << endl;
return 0;
}
Zad. 31.
// Program szyfruje dane stosując szyfr cezara.
//
// Paweł Klimczewski, 13 listopada 2005
#include <iostream>
#include "czytaj.h"
35
cout.put( znak );
}
return 0;
}
Zad. 32.
// Program oblicza wartość wielomianu
//
// w( x ) = 100 x^3 - 625 x^2 + 1183.19 x - 660.489
//
// w zadanym punkcie.
//
// Paweł Klimczewski, 13 listopada 2005
#include <iostream>
#include <iomanip>
#include <cmath>
#include "czytaj.h"
36
Zad. 33.
// Program oblicza miejsca zerowe wielomianu
//
// w( x ) = 100 x^3 - 625 x^2 + 1183.19 x - 660.489
//
// metodą bisekcji.
//
// Paweł Klimczewski, 13 listopada 2005
#include <iostream>
#include <iomanip>
#include <cmath>
#include "czytaj.h"
37
return;
}
if ( x1 > x2 )
{
double tmp = x1;
x1 = x2;
x2 = tmp;
}
while ( true )
{
double xs = ( x1 + x2 ) / 2, ys = w( xs );
if ( ys == 0 || xs == x1 || xs == x2 )
{
cout << "x = " << xs << ", w(x) = " << ys << endl;
break;
}
if ( ys * y1 > 0 )
{
x1 = xs;
}
else
{
x2 = xs;
}
}
}
Zad. 34.
// Program oblicza miejsca zerowe wielomianu
//
// w( x ) = 100 x^3 - 625 x^2 + 1183.19 x - 660.489
//
// metodą stycznych.
//
38
// Paweł Klimczewski, 13 listopada 2005
#include <iostream>
#include <iomanip>
#include <cmath>
#include "czytaj.h"
double w( double x )
{
return 100 * x * x * x - 625 * x * x + 1183.19 * x - 660.489;
}
Zad. 35.
// Program oblicza silnię i wyraz ciągu Fibonacciego iteracyjnie
// i rekurencyjnie.
//
// Paweł Klimczewski, 11 listopada 2005
#include <iostream>
#include <sys/time.h>
#include <unistd.h>
#include "czytaj.h"
39
int silnia_r( int n )
{
return n > 1 ? n * silnia_r( n - 1 ) : 1;
}
int main()
{
// Dla odczytania wartości podanej przez użytkownika korzystam
// z funkcji czytaj_z_wejscia z programu rzeczywista.
int x;
czytaj_z_wejscia( x );
40
cout << "Silnia iteracyjnie" << endl;
unsigned int t0 = t();
int i = silnia_i( x );
unsigned int t1 = t();
cout << i << ", " << t1 - t0 << endl;
return 0;
}
Zad. 36.
// Program znajduje największy wspólny dzielnik metodą Euklidesa.
//
// Paweł Klimczewski, 11 listopada 2005
#include <iostream>
#include "czytaj.h"
// iteracyjnie
int nwd1( int a, int b )
{
while ( b )
{
int r = a % b;
a = b;
b = r;
}
return a;
41
}
// rekurencyjnie
int nwd2( int a, int b )
{
if ( b != 0 )
return nwd2( b, a % b );
else
return a;
}
int main()
{
int a;
czytaj_z_wejscia( a, "Podaj pierwszą liczbę" );
int b;
czytaj_z_wejscia( b, "Podaj drugą liczbę" );
cout
<< "NWD( " << a << ", " << b << " ) = "
<< nwd1( a, b ) << " = "
<< nwd2( a, b ) << endl;
return 0;
}
Zad. 37.
// Program oblicza miejsca zerowe wielomianu
//
// w( x ) = (x-1)(x-2)(x-3)(x-4)
//
// metodą stycznych.
//
// Paweł Klimczewski, 13 listopada 2005
#include <iostream>
#include <iomanip>
#include <cmath>
#include <complex>
#include "czytaj.h"
complex<double> w( complex<double> x )
{
return ( x - 1. ) * ( x - 2. ) * ( x - 3. ) * ( x - 4. );
}
42
// [ ( x - 1 ) ( x - 2 ) ( x - 3 ) ( x - 4 ) ]’ =
// = [ x^4 - 10 x^3 + 35 x^2 - 50 x + 24 ]’ =
// = 4 x^3 - 30 x^2 + 70 x - 50 = ( ( 4 x - 30 ) x + 70 ) x - 50
return ( ( 4. * x - 30. ) * x + 70. ) * x - 50.;
}
Zad. 38.
// Program oblicza częstotliwość występowania liter w tekście odczytanym
// ze standardowego strumienia danych
//
// Paweł Klimczewski, 25 listopada 2005
#include <iostream>
int main()
{
int liter = 0; // licznik wszystkich znaków
// Wystąpienia poszczególnych znaków zliczam w komórkach tablicy.
// Pierwsza komórka (indeks 0) odpowiada spacji, druga literze ’a’,...,
// dwudziesta siódma literze ’z’.
int tab[ 27 ];
for ( int i = 0; i < 27; ++i )
{
tab[ i ] = 0;
}
// Odczytuję dane ze strumienia
while ( true )
{
int z = cin.get();
43
if ( z == -1 )
break; // koniec danych w strumieniu
if ( z == ’ ’ || ( z >= ’a’ && z <= ’z’ ) )
{
tab[ z == ’ ’ ? 0 : z - ’a’ + 1 ]++;
liter++;
}
}
// Wyniki zapisuję w na ekranie w formacie "dwukolumnowym"
for ( int i = 0; i < 27; ++i )
{
cout << i << " " << 1. * tab[ i ] / liter << endl;
}
return 0;
}
G N U P L O T
Version 4.0 patchlevel 0
last modified Thu Apr 15 14:44:22 CEST 2004
System: Linux 2.4.26
44
0.18
"pt.dat"
0.16
0.14
0.12
0.1
0.08
0.06
0.04
0.02
0
0 5 10 15 20 25 30
Przy pomocy poleceń set xrange, set xtics itd. możemy ustalić zakres
zmiennych, opisać osie itd.
% gnuplot
G N U P L O T
Version 4.0 patchlevel 0
last modified Thu Apr 15 14:44:22 CEST 2004
System: Linux 2.4.26
45
0.18
"pt.dat"
0.16
0.14
0.12
0.1
0.08
0.06
0.04
0.02
0
_ a b c d e f g h i j k l m n o p q r s t u v w x y z
Zad. 39.
// Program oblicza częstotliwość występowania liter w tekście
// i przygotowuje pliki z danymi oraz poleceniami dla programu gnuplot.
//
// Paweł Klimczewski, 26 listopada 2005
#include <iostream>
#include <fstream>
46
int z = is.get();
if ( z == -1 )
break; // koniec danych
if ( z == ’ ’ || ( z >= ’a’ && z <= ’z’ ) )
{
tab[ z == ’ ’ ? 0 : z - ’a’ + 1 ]++;
liter++;
}
}
// Tworzę plik z danymi dla programu gnuplot.
ofstream os( ( nazwa_pliku + ".dat" ).c_str() );
for ( int i = 0; i < 27; ++i )
{
double x = i + 0.05 + 0.9 / n * ( numer_pliku + 0.5 );
double y = 1. * tab[ i ] / liter;
if ( y > mx )
mx = y;
os << x << " " << y << endl;
}
}
47
skrypt << "plot ";
for ( int i = 1; i < argc; ++i )
{
if ( i > 1 )
skrypt << ", ";
skrypt << "\"" << argv[ i ] << ".dat\" with boxes";
}
skrypt << endl;
return 0;
}
Zad. 40.
// Program kopiuje maksymalnie zadanąliczbę znaków.
//
// Paweł Klimczewski, 26 listopada 2005
#include <iostream>
#include <sstream>
48
Zad. 41.
// Program przygotowuje dane dla programu gnuplot dla rysunku dorzeczy
// pierwiastków równania z^n=1.
//
// Paweł Klimczewski, 26 listopada 2005
#include <iostream>
#include <sstream>
#include <complex>
#include <cmath>
complex<double> u( 1, 0 );
for ( int j = 1; j < n; ++j ) u *= p;
p -= ( p * u - 1. ) / ( 1. * n * u );
}
return 0;
}
int main()
{
cerr << "Podaj n ";
cin >> n;
cerr << "Podaj maxcnt ";
cin >> maxcnt;
cerr << "Podaj obszar x_min y_min x_max y_max ";
double x_min, y_min, x_max, y_max;
cin >> x_min >> y_min >> x_max >> y_max;
49
cerr << "Podaj rozmiar siatki ";
int N;
cin >> N;
G N U P L O T
Version 4.0 patchlevel 0
last modified Thu Apr 15 14:44:22 CEST 2004
System: Linux 2.4.26
> set pm3d map
> splot "newton.dat"
50
"newton.dat"
0.8 5
0.6 4
0.4 3
0.2 2
0 1
-0.2 0
-0.4
-0.6
-0.8
-1
-1 -0.8 -0.6 -0.4 -0.2 0 0.2 0.4 0.6 0.8 1
Zad. 42.
// Program rysuje zbiór Mandelbrota.
//
// Paweł Klimczewski, 27 listopada 2005.
#include <iostream>
#include <sstream>
#include <complex>
#include <cmath>
51
// Ciąg jest rozbieżny. Kolor punktu będzie odpowiadał szybkości
// rozbiegania.
return 1 + i;
}
}
return 0;
}
int main()
{
cerr << "Podaj obszar x_min y_min x_max y_max ";
double x_min, y_min, x_max, y_max;
cin >> x_min >> y_min >> x_max >> y_max;
cerr << "Podaj rozmiar siatki ";
int N;
cin >> N;
52
"mandelbrot.dat"
1.5
100
1
80
0.5 60
40
0 20
0
-0.5
-1
-1.5
-2 -1.5 -1 -0.5 0 0.5 1
Zad. 43.
#include <iostream>
#include <vector>
#include <iterator>
#include <cmath>
#include <numeric>
int main()
{
// Liczby będę pamiętał w wektorze.
vector< double > v;
// Odczytuję liczby.
copy( istream_iterator< double >( cin ),
istream_iterator< double >(),
back_insert_iterator< vector< double > >( v ) );
// Obliczam średnią.
double srednia = accumulate( v.begin(), v.end(), 0. ) / v.size();
// Obliczam średnie odchylenie standardowe.
// Korzystam z iteratorów do odczytania elementów wektora.
vector< double >::const_iterator it;
double sigma = 0;
for ( it = v.begin(); it != v.end(); ++it )
{
sigma += pow( *it - srednia, 2 );
53
}
sigma = sqrt( sigma / ( v.size() - 1 ) );
// Wypisuję wyniki.
// Korzystam z indeksów do odczytania elementów wektora.
for ( int idx = 0; idx < v.size(); ++idx )
{
if ( srednia - sigma < v[ idx ] &&
v[ idx ] < srednia + sigma )
{
cout << v[ idx ] << endl;
}
}
return 0;
}
Zad. 44.
#include <iostream>
#include <list>
#include <cmath>
int main()
{
for ( int i = 2; i < 1000000; ++i )
{
is_prime( i );
}
return 0;
}
54
Zad. 45.
#include <iostream>
#include <set>
#include <iterator>
#include <cstdlib>
int main()
{
// Na podstawie aktualnego wskazania zegara inicjuję parametr związany
// z generowaniem liczb pseudolosowych.
srand( time( 0 ) );
// Wylosowane liczby będę pamiętał w zbiorze.
set< int > s;
// Losuję.
while ( s.size() < 6 )
{
s.insert( 1 + rand() % 49 );
}
// Wypisuję wyniki.
copy( s.begin(), s.end(), ostream_iterator< int >( cout, "\n" ) );
return 0;
}
Zad. 46.
#include <iostream>
#include <map>
55
int main()
{
f[ 0 ] = f[ 1 ] = 1;
cout << "Podaj numer wyrazu ciągu" << endl;
int n;
cin >> n;
cout << "f(" << n << ")=" << fibonacci( n ) << endl;
return 0;
}
Zad. 47.
#include <iostream>
#include <string>
#include <vector>
#include <iterator>
int main()
{
// Wiersze będę pamiętał w wektorze.
vector< string > v;
// Czytam kolejne wiersze ze strumienia wejściowego.
while ( true )
{
string s;
getline( cin, s );
if ( !cin ) break;
v.push_back( s );
}
if ( v.size() > 0 )
{
// Znajduje rozmiar najdłuższego wiersza.
int mx = max_element( v.begin(), v.end(), f )->size();
// Wyrównuję rozmiar wszystkich wierszy dopisując końcowe spacje
// i odwracam kolejność znaków.
vector< string >::iterator it;
for ( it = v.begin(); it != v.end(); ++it )
{
it->resize( mx, ’ ’ );
reverse( it->begin(), it->end() );
56
}
// Wypisuję wynik.
copy( v.rbegin(), v.rend(), ostream_iterator< string >( cout, "\n" ) );
}
return 0;
}
Zad. 48.
#include <iostream>
#include <sstream>
#include <deque>
#include <set>
57
return 0;
}
Zad. 49.
#include <iostream>
#include <map>
#include <set>
int main()
{
// W słowniku będę zliczał wystąpienia poszczególnych słów.
map< string, int > m;
// Odczytuje kolejne słowa i zapisuję w słowniku.
while ( true )
{
string s;
cin >> s;
if ( !cin ) break;
m[ s ]++;
}
// Na podstawie zawartości słownika tworzę zbiór, którego elementy są
// uporządkowane względem liczby występień słów.
set< pair< int, string > > s;
map< string, int >::iterator it;
for ( it = m.begin(); it != m.end(); ++it )
{
s.insert( make_pair( it->second, it->first ) );
}
set< pair< int, string > >::const_reverse_iterator jt;
// Wypisuję wyniki.
int n = 10;
for ( jt = s.rbegin(); jt != s.rend() && n; ++jt, --n )
{
cout << jt->second << ": " << jt->first << endl;
}
return 0;
}
Zad. 50.
#include <iostream>
#include <string>
#include <set>
58
// Literze przyporządkowujemy liczbę.
int c2i( char c )
{
return 1 + ( c - ’a’ + 16 ) % 26;
}
int main()
{
// Słowa zapamiętuję w zbiorze jako pary { wartość bezwzględna różnicy
// liczby przyporządkowanej danemu słowu minus 1000000, dane słowo }.
// ,,Najlepsze’’ słowa będą znajdowały się na początku.
set< pair< int, string > > m;
// Odczytuję słowa.
while ( true )
{
string s;
cin>>s;
if (!cin) break;
m.insert( make_pair( abs( s2i( s ) - 1000000 ), s ) );
}
// Wypisuję 10 najlepszych wartości.
int n = 10;
set< pair< int, string > >::const_iterator it;
for ( it = m.begin(); n && it != m.end(); ++it, --n )
{
cout << s2i( it->second ) << ": " << it->second << endl;
}
return 0;
}
Zad. 51.
#include <iostream>
#include <vector>
#include <algorithm>
#include <iterator>
#include <numeric>
#include <list>
#include <cmath>
59
using namespace std;
// Sprawdzam czy n-ta ksiązka ma taką samą liczbę sąsiadów z każdej strony.
bool sprzyjajace( const vector<int>& v, int n )
{
// Zliczam sąsiadów po lewej stronie.
int l = 0;
if ( n > 0 )
{
l = 1;
for ( int i = n - 2; i >= 0; --i )
{
if ( v[ i ] != v[ n - 1 ] ) break;
++l;
}
}
// Zliczam sąsiadów po prawej stronie.
int p = 0;
if ( n + 1 < v.size() )
{
p = 1;
for ( int i = n + 2; i < v.size(); ++i )
{
if ( v[ i ] != v[ n + 1 ] ) break;
++p;
}
}
return l == p;
}
int main()
{
int z = 4; // liczba książek zielonych
int c = 5; // czerwonych
int n = 8; // niebieskich
int a = 0, omega = 0; // liczba zdarzeń sprzyjających i wszystkich.
// Poszczególne ustawienia zapamiętuję w wektorze.
vector< int > v;
for ( int i = 0; i < z; ++i ) v.push_back( 1 );
for ( int i = 0; i < c; ++i ) v.push_back( 2 );
for ( int i = 0; i < n; ++i ) v.push_back( 3 );
60
{
for ( int i = 0; i < v.size(); ++i )
{
if ( sprzyjajace( v, i ) ) ++a;
++omega;
}
}
while ( next_permutation( v.begin(), v.end() ) );
Zad. 52.
#include <iostream>
#include <sstream>
#include <stack>
int main()
{
// Liczby zapamiętuję na stosie.
stack< double > stos;
// W pętli odczytuje dane wprowadzone przez użytkownika: liczby i symbole
// operacji arytmetycznych.
while ( true )
{
// Wypisuję wartość liczby ze szczytu stosu.
if ( !stos.empty() )
{
cout << "[" << stos.top() << "]" << endl;
}
// Odczytuję dane.
string s;
cin >> s;
if ( s != "+" && s != "-" && s != "*" && s != "/" )
{
// Skoro nie jest to symbol operacji arytmetycznej to powinna być
// to liczba.
istringstream is( s );
double d;
if ( is >> d )
{
stos.push( d );
}
else
{
cout << "Błędne dane!" << endl;
61
}
continue;
}
// Dla każdej operacji potrzebuję dwóch liczb na stosie.
if ( stos.size() < 2 )
{
cout << "Za mało danych na stosie!" << endl;
continue;
}
// Obliczam wynik działania i zapamiętuję na stosie.
if ( s == "+" )
{
double suma = stos.top();
stos.pop();
suma += stos.top();
stos.pop();
stos.push( suma );
}
else if ( s == "-" )
{
double roznica = stos.top();
stos.pop();
roznica -= stos.top();
stos.pop();
stos.push( roznica );
}
else if ( s == "*" )
{
double iloczyn = stos.top();
stos.pop();
iloczyn *= stos.top();
stos.pop();
stos.push( iloczyn );
}
else if ( s == "/" )
{
double iloraz = stos.top();
stos.pop();
iloraz = stos.top() / iloraz;
stos.pop();
stos.push( iloraz );
}
}
return 0;
}
Zad. 53.
#include <iostream>
#include <fstream>
62
#include <complex>
#include <vector>
#include <cmath>
int main()
{
// Liczby zapamiętuję w wektorze.
vector< complex< double > > v;
// Odczytuję je ze strumienia wejściowego.
copy( istream_iterator< complex< double > >( cin ),
istream_iterator< complex< double > >(),
back_insert_iterator< vector< complex< double > > >( v ) );
// Porządkuje względem odległości od początku układu.
sort( v.begin(), v.end(), f );
// Zapisuję do pliku z1.txt.
fstream f1( "z1.txt" );
copy( v.begin(), v.end(),
ostream_iterator< complex< double > >( f1, "\n" ) );
// Porządkuję względem odległości od prostej y=x.
sort( v.begin(), v.end(), g );
// Zapisuję do pliku z2.txt.
fstream f2( "z2.txt" );
copy( v.begin(), v.end(),
ostream_iterator< complex< double > >( f2, "\n" ) );
return 0;
}
Zad. 54.
#include <iostream>
#include <sstream>
63
#include <cmath>
#include <map>
#include <deque>
#include <set>
64
while ( iu != u.end() && iv != v.end() )
{
if ( iu->first < iv->first )
{
s += pow( iu->second / du, 2 );
++iu;
continue;
}
if ( iu->first > iv->first )
{
s += pow( iv->second / dv, 2 );
++iv;
continue;
}
s += pow( iu->second / du - iv->second / dv, 2 );
++iu;
++iv;
}
for ( ; iu != u.end(); ++iu )
{
s += pow( iu->second / du, 2 );
}
for ( ; iv != v.end(); ++iv )
{
s += pow( iv->second / dv, 2 );
}
return sqrt( s );
}
65
}
cerr
<< "Tekst wzorcowy: znaków " << zn
<< ", ciągów " << n << "-elementowych " << st0.size()
<< endl << endl;
}
66