Witam,
jak wyglądałby program, w którym należy wprowadzić 8 dowolnych liczb. Następnie w pętli sumowane mają być tylko liczby parzyste z tych 8 wcześniej wprowadzonych?
C++ 
- Rejestracja:ponad 10 lat
- Ostatnio:ponad 10 lat
- Postów:2
0
Takie jest polecenie zadania.
Mógłby ktoś napisać taki program?
- Rejestracja:ponad 11 lat
- Ostatnio:około 3 godziny
- Lokalizacja:Szczecin
3
Pewnie, ile płacisz?
Tutaj masz taki programik w D. W C++ ciut więcej roboty, ale bez przesady:
import std.algorithm;
import std.array;
import std.format;
import std.stdio;
import std.string;
void main()
{
int[8] numbers;
foreach(i; 0..8){
readf(" %d", &numbers[i]);
}
"Liczby: %s".format(numbers).writeln;
"Suma parzystych to %s".format(numbers[].filter!(n => n%2 == 0).reduce!((a,b) => a+b)).writeln;
}
edytowany 1x, ostatnio: kq
- Rejestracja:prawie 12 lat
- Ostatnio:około 10 godzin
2
#pseudocode
sum = 0
for _ in range(8):
number = stdin.get()
if number%2 == 0:
sum += number
stdout.put(sum)
lub jeśli to do Ciebie lepiej przemówi
liczby = wczytaj8Liczb()
suma = 0
dla każdej liczby:
jeśli liczba jest parzysta:
suma += liczba
wypisz(suma)
edytowany 1x, ostatnio: spartanPAGE
- Rejestracja:ponad 12 lat
- Ostatnio:ponad 4 lata
- Postów:2412
10
Mysle, ze nie bedziesz mial problemu z przepisaniem na C++.
trait Monad[M[_]] {
def pure[A](a: A): M[A]
def >>=[A,B](f: A => M[B])(ma: M[A]): M[B]
}
case class IO[A](run: () => A)
object IO {
import Monad._
def readLn: IO[String] = IO(() => readLine())
def read[A](implicit R: Read[A]): IO[A] = readLn.fmap(R.read)
def readN[A](n: Int)(implicit R: Read[A]): IO[List[A]] =
Monad.sequence((for(i <- 1 to n) yield read(R)).toList)
def putLn(ln: String): IO[Unit] = IO(() => println(ln))
def put[A](a: A)(implicit S: Show[A]): IO[Unit] = putLn(S.show(a))
def putN[A](xs: List[A])(implicit S: Show[A]): IO[Unit] =
IO(() => xs.foreach(x => put(x)(S)))
}
object Monad {
implicit val IoInstance: Monad[IO] = new Monad[IO] {
def pure[A](a: A): IO[A] = IO(() => a)
def >>=[A,B](f: A => IO[B])(ma: IO[A]): IO[B] =
IO(() => f(ma.run()).run())
}
implicit class MonadOps[M[_], A](m: M[A])(implicit M: Monad[M]) {
def >>=[B](f: A => M[B]): M[B] =
M.>>=(f)(m)
def fmap[B](f: A => B): M[B] =
>>=(a => M.pure(f(a)))
}
def sequence[M[_],F[_],A](xs: F[M[A]])(implicit F: Foldable[F], Mo: Monoid[F[A]], M: Monad[M]): M[F[A]] =
F.foldLeft(xs)(M.pure(F.empty[A]))((acc, x) =>
acc >>= (xs => x >>= (x => M.pure(Mo.|+|(xs, F.single(x))))))
}
trait Foldable[F[_]] {
def empty[A]: F[A]
def single[A](a: A): F[A]
def foldLeft[A,B](src: F[A])(acc: B)(f: (B, A) => B): B
}
object Foldable {
implicit val ListInstance: Foldable[List] = new Foldable[List] {
def empty[A]: List[A] = List.empty[A]
def single[A](a: A): List[A] = List(a)
def foldLeft[A,B](src: List[A])(acc: B)(f: (B, A) => B): B =
src.foldLeft(acc)(f)
}
}
trait Monoid[A] {
def z: A
def |+|(a1: A, a2: A): A
}
object Monoid {
implicit def ListInstance[A]: Monoid[List[A]] = new Monoid[List[A]] {
def z: List[A] = Nil
def |+|(a1: List[A], a2: List[A]): List[A] =
a1 ++ a2
}
implicit val IntInstance: Monoid[Int] = new Monoid[Int] {
def z: Int = 0
def |+|(a1: Int, a2: Int): Int = a1 + a2
}
}
trait Read[A] {
def read(str: String): A
}
object Read {
implicit val IntInstance: Read[Int] = new Read[Int] {
def read(str: String): Int =
try { str.toInt } catch {
case e: Exception => 0
}
}
}
trait Show[A] {
def show(a: A): String
}
object Show {
implicit val IntInstance: Show[Int] = new Show[Int] {
def show(i: Int): String =
i.toString
}
}
import IO._
import Monad._
def sum[F[_], A](f: F[A])(implicit F: Foldable[F], M: Monoid[A]): A =
F.foldLeft(f)(M.z)(M.|+| _)
val program = readN(8) fmap (xs => sum(xs.filter(_ % 2 == 0))) >>= (s => put(s))
program.run()
Zobacz pozostałe 5 komentarzy
da faq it is ? lektura na dzis: http://en.wikipedia.org/wiki/Functional_programming + Nie stawiamy spacji przed znakiem zapytania badz wykrzyknikiem.
@n0name_l nie powiesz mi że nie ma tych mechanizmów wbudowanych w język/biblioteke standardową :P Wyprowadzając je chciałeś tylko pogmatwać sprawę :P
- Rejestracja:ponad 10 lat
- Ostatnio:ponad 10 lat
- Lokalizacja:Olsztyn
0
Lektura na dziś:
- Losowanie liczb: http://cpp0x.pl/kursy/Kurs-C++/Poziom-2/Pseudolosowe-liczby-calkowite/290 Tip ode mnie tworzysz pętle for i przypisujesz do tablicy jednowymiarowej http://cpp0x.pl/kursy/Kurs-C++/Tablice-zmiennych/298
- Sprawdzanie parzystości liczby (polecam ten drugi sposób) http://zadaniacpp.blox.pl/2010/03/Zadanie-6-Sprawdzanie-czy-liczba-jest-parzysta.html
Myślę że sumowanie ogarniesz ;) Jakby co pisaj na forum, ale przyjdź i pokaż że coś zrobiłeś a nie że czekasz na gotowca. Inaczej będziesz miał spam jak wyżej ;)
Dostał rozwiązania w pseudokodzie - wie, co należy wykonać. AD1. losowanie nie ma nic wspólnego z tym zadaniem. AD2. Pętla? A reszta z dzielenia była w podstawówce, tutaj szału nie ma i raczej powinno to siedzieć w głowie.
Zarowno ten temat jak i podejscie autora to kpina (i IMO powinien juz dawno w koszu lezec). Kazda proba pomocy ze zrodlowym problemem jest niczym innym niz godzeniem sie na takie warunki korzystania z forum. Mi sie takie cos nie podoba i nie mam zamiaru pomagac komukolwiek z takim podejsciem. Dziwie sie natomiast, ze znalazl sie ktos, komu to nie przeszkadza.
- Rejestracja:prawie 13 lat
- Ostatnio:około 4 lata
- Lokalizacja:Wrocław
- Postów:474
2
Będę dobry i podam w c++ :)
#include <algorithm>
#include <iostream>
#include <iterator>
#include <numeric>
#include <vector>
int main()
{
std::vector<int> v;
std::copy(std::istream_iterator<int>(std::cin),std::istream_iterator<int>(), back_inserter(v));
std::cout << "Suma parzystych wynosi " << std::accumulate(v.begin(), std::remove_if(v.begin(), v.end(), [](int num){return num % 2;}), 0) << std::endl;
}
Będzie działać, tylko musisz wczytywanie znaków z standardowego wejścia zakończyć ctrl+z, enter po ostatniej liczbie(pod warunkiem że działasz na Windows). Ktoś ma pomysł jak to ominąć? Jeżeli jest to zadanie do szkoły, na uczelnię to musiałbyś też umieć to prowadzącemu wytłumaczyć.
Może jeszcze jakiś pomysł na połączenie pierwszej i drugiej linijki? Bo wiem że z std::ifstream się da, ale std::istream z std::cin za nic nie chce się skompilować :/
edytowany 1x, ostatnio: Zellus
- Rejestracja:ponad 11 lat
- Ostatnio:około 3 godziny
- Lokalizacja:Szczecin
4
Może coś takiego?
cout << accumulate(istream_iterator<int>(cin), istream_iterator<int>(),
int{}, [](int l, int r){
return l + (r&0b1 ? 0 : r);
});
http://melpon.org/wandbox/permlink/yt4iprHIzaAky2IF
Nie mogę się doczekać zakresów w C++17 :(
edytowany 1x, ostatnio: kq
niestety: - "... wprowadzić 8 dowolnych liczb.
Następnie w pętli sumowane mają być ..."
Można by się kłócić, że pętla jest - tylko nie jawna ;) ale ten post miał być raczej odpowiedzią na post wyżej.
Kluczem jest nie tablica zaś
następnie chodzi o to że twój kod nie zbiera 8 liczb tylko zlicza "online" owszem to jest plusem dla kodu, zaś nie spełnia zadania.
- Rejestracja:około 22 lata
- Ostatnio:ponad rok
0
@kq: gratuluję, wymyśliłeś najbardziej nieczytelny sposób sprawdzania, czy liczba jest parzysta.
Spełniający zadanie C++ jest np. taki:
const std::size_t NUMBERS_COUNT = 8;
std::array<int, NUMBERS_COUNT> numbers;
std::copy_n(std::istream_iterator<int>(std::cin), NUMBERS_COUNT, numbers.begin());
const int sum = std::accumulate(numbers.cbegin(), numbers.cend(), 0,
[] (int a, int b) {
return (b % 2 == 0) ? a + b : a; });
http://ideone.com/VuWsN6 (Hint: napisałem to to dużo przed postem wyżej [na ideone jest godzina], tylko nie miałem odwagi postować rozwiązania w C++. Ale skoro już to zrobiliście...)
Ale chyba czytelniej zrobić to za pomocą for po prostu.
edytowany 2x, ostatnio: Endrju
Niespecjalnie najbardziej nieczytelny, mogłem dać np.
a + b - (b&0b1) * b. Pewnie jakbym się postarał to dałoby się to jeszcze poprawić.
Pozwoliłem sobie jeszcze ciut zmodyfikować Twój kod zgodnie z zasadą, aby używać własnych funkcji jak najmniej, jeśli są do tego gotowe algorytmy: http://melpon.org/wandbox/permlink/L3oolPISqitEXpcn W sumie to jest już całkiem czytelne
std::bind byłoby fajne, gdyby nie koszmarne std::placeholders::_1. :<
Zgadzam się. Mając do dyspozycji ADL nie wiem co oni palili, że zamienili wygodne boostowe
_1 na ten koszmar.
- Rejestracja:ponad 10 lat
- Ostatnio:ponad 10 lat
- Postów:1
0
to będzie najczytelniejsze
#include <iostream >
#include <stdlib.h>
using namespace std ;
int main()
{
int i ,suma ,a;
suma=0;
cout<<"Podaj 8 liczb "<<endl;
for (i=1 ; i <=8 ; i++)
{
cout<<"Podaj"<<i<<"liczbe "<<endl;
cin>>a;
if (a%2==0)
suma+=a;
}
cout<<"Suma liczb parzystych to "<<suma<<endl;
system("pause");
}
edytowany 1x, ostatnio: harnas_1216
Myślę, że mamy różne definicje czytelności. Słabe formatowanie, deklaracja wszystkich (w tym nieużywanych) zmiennych na początku funkcji, iteracja od 1 do 8 włącznie. To nie wpływa pozytywnie na czytelność.
Nie spełnia zadania. "... wprowadzić 8 dowolnych liczb.
Następnie w pętli ..."
Rotfl. :-D
Shalom