Olvass be a cin-ről egy sornyi szöveget egy std::stringbe (std::getline())! Vizsgáld meg, hogy szerepel-e a "kutya" a beolvasott szövegben, és ha igen, cseréld "eb"-re minden előfordulását! Írd ki a kapott szöveget! Keresd meg a harmadik "a" karaktert, és írd ki a pozícióját, az előtte ill. a mögötte lévő szöveget (find, substr, npos). Az std::string függvényeinek leíírását megtalálod a http://www.cplusplus.com/-on, a google rögtön a keresett osztályhoz vezet.
Vegyük elő a múlt héten elkészített ágyú feladatot! Az Euler-integrálásig tartsuk meg a main()-t, az utána következőket törölhetjük, ide jön majd a mostani feladat megoldása:
(a) Iterátor segítségével járd be a pozíciót tároló tömböt (vectort), és írd ki tabulátorral elválasztva az x koordinátákat a kilövéstől a becsapódásig! (tipp: std::vector<vec2D>::iterator it = pv.begin())
(b) Iterátor segítségével járd be a pozíciót tároló tömböt (vectort), és írj ki minden 10. pozíciót a 0.-tól kezdve, soronként 1-et! A kiíráshoz a 2D vektor << operátorát használd! (tipp: a minden 10.-hez nem kell semmilyen C++ hókuszpókusz, egyszerűen egy segédváltozóban számlálod, hogy mikor kell kiírni.)
(c) Az std::max_element algoritmus segítségével keresd meg a legnagyobb y értéket a lövedék pályáján! Ehhez egy segédfüggvényre van szükség, amely bool visszatérési típusú, és két paramétere két 2D vektor típusú érték. A függvény true-t adjon vissza, ha az első paraméter értéke (jelen esetben az y komponense) kisebb, mint a második paramétere.
(d) Készíts egy másik vektort, amelybe a pozíció vektor értékeit y szerint normálva teszed bele: x érték változatlan, y érték a (c) feladatban kapott maximummal leosztva. Ehhez először egy megfelelő méretű új vektort kell létrehoznod, majd egy ciklusban beállítod minden elemét. (A feladatot megoldhatod transform algoritmussal és egy funktor osztállyal, az osztály statikus változója a maximum.)
Valós (double) elemű vectorokkal dolgozunk.
(a) Súlyozott átlag számítása: két vectort használunk (a, w), ezek egyforma méretűek. Számítsuk ki a tömb w súlyok szerinti súlyozott átlagát! (inner_product, accumulate, w_a=sum ai*wi / sum wi)
(b) Képezzük az a és w tömbök összegét: transform, std::plus<double>() A transform algoritmus használata:
Paraméterezése:
transform(be_eleje, be_vége, ki_eleje, egyparam fv)
transform(be1_eleje, be1_vége, be2_eleje, ki_eleje, kétparam fv)
minden elemre (elemparra) meghivja a fv-t, kimenetbe letarolja. HELYET KELL FOGLALNI elotte.
(c) Vektor szorzása skalárral (transform), ehhez írjunk egy skálázó függvényt (szorzó bedrótozva), vagy egy static faktorral rendelkező funktor osztályt (static nélkul volt előadáson).
| 1. feladat |
#include <iostream>
#include <string>
int main(){
size_t n; // !
std::string sor;
std::getline(std::cin, sor);
std::cout << std::endl << "Beolvasott: " << sor << std::endl;
while ((n = sor.find("kutya")) != sor.npos)
sor.replace(n, 5, "eb");
std::cout << " Ebitett: " << sor << std::endl;
n = sor.find("a");
if (n != sor.npos)
n = sor.find("a", n + 1);
if (n != sor.npos)
n = sor.find("a", n + 1);
std::string eleje = sor.substr(0, n);
std::string vege = (n == sor.npos) ? "" : sor.substr(n + 1, sor.npos);
std::cout << " Eleje: " << eleje << std::endl;
std::cout << " Vege: " << vege << std::endl;
return 0;
} |
| 2. feladat (dőlttel a korábban készült rész) |
#include <iostream>
#include <vector>
#include <cmath>
#include <algorithm>
class vec2D{
double x, y;
public:
vec2D(double x = 0, double y = 0) :x(x), y(y){}
double getX()const{ return x; }
double getY()const{ return y; }
double getR()const{ return sqrt(x*x + y*y); }
double getPhi()const{ return atan2(y, x); }
void setXY(double x, double y){ this->x = x; this->y = y; }
void setRPhi(double r, double phi){ x = r*cos(phi); y = r*sin(phi); }
vec2D operator+(const vec2D &v)const
{
return vec2D(getX() + v.getX(), getY() + v.getY());
}
const vec2D& operator+=(const vec2D &v)
{
setXY(getX() + v.getX(), getY() + v.getY()); return *this;
}
vec2D operator*(double d)const{ return vec2D(getX()*d, getY()*d); }
};
inline vec2D operator*(double d, const vec2D &v){
return v*d;
}
std::ostream &operator<<(std::ostream &os, const vec2D &v){
os << '(' << v.getX() << ", " << v.getY() << ')';
return os;
}
bool hasonlit(const vec2D &v1, const vec2D &v2){
return v1.getY() < v2.getY();
}
int main(){
std::vector<vec2D> pv, vv;
vec2D a(0, -9.81), v, p;
double r, phi, dt;
const double pi = acos(0) * 2;
// Adatok bekérése
std::cout << "v0= "
std::cin >> r;
std::cout << "szog(fokban)= "
std::cin >> phi;
phi *= pi / 180;
std::cout << "dt= "
std::cin >> dt;
// Euler integrálás
v.setRPhi(r, phi);
while (p.getY() >= 0){
vv.push_back(v);
pv.push_back(p);
p = pv.back() + vv.back()*dt; // vagy p += v*dt;
v = vv.back() + a*dt; // vagy v += a*dt;
}
for (std::vector<vec2D>::iterator it = pv.begin(); it != pv.end(); it++)
std::cout << it->getX() << '\t';
std::cout << std::endl << std::endl;
int db = 1;
for (std::vector<vec2D>::iterator it = pv.begin(); it != pv.end(); it++){
db--;
if (db == 0){
db = 10;
std::cout << *it << std::endl;
}
}
double maxy = std::max_element(pv.begin(), pv.end(), hasonlit)->getY();
std::cout << "Max y = " << maxy << std::endl;
std::vector<vec2D> normalt(pv.size());
std::vector<vec2D>::iterator it_cel = normalt.begin();
std::vector<vec2D>::iterator it_forr = pv.begin();
for (; it_forr != pv.end(); it_cel++, it_forr++)
it_cel->setXY(it_forr->getX(), it_forr->getY() / maxy);
return 0;
} |
| 3. feladat |
#include <iostream>
#include <vector>
#include <algorithm>
#include <numeric>
class skalarral_szorzo{
public:
static double szorzo;
double operator()(double a){
return a*szorzo;
}
};
double skalarral_szorzo::szorzo = 1.0;
int main(){
double adat[6] = { 2, 5, 10, 5, 2, 4 };
double suly[6] = { 1, 2, 3, 4, 5, 6 };
std::vector<double> a(adat,adat+6), w(suly,suly+6);
double w_a = std::inner_product(a.begin(), a.end(), w.begin(),0.0)/std::accumulate(w.begin(),w.end(),0.0);
std::cout << "w_a = " << w_a << std::endl;
std::vector<double> eredmeny(a.size());
std::transform(a.begin(), a.end(), w.begin(), eredmeny.begin(), std::plus<double>());
for (int i = 0; i < eredmeny.size(); i++)
std::cout << a[i] << " + " << w[i] << " = " << eredmeny[i] << std::endl;
skalarral_szorzo::szorzo = 2;
std::transform(a.begin(), a.end(), eredmeny.begin(), skalarral_szorzo());
for (int i = 0; i < eredmeny.size(); i++)
std::cout << a[i] << " * 2 = " << eredmeny[i] << std::endl;
return 0;
} |