Sumowanie liczb parzystych

0

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?

2

Prymitywnie by wyglądał, zgodnie z zadaniem.
Z czym konkretnie masz problem?

2

Na przykład mogłyby tam znajdować się dwie pętle, trzy zmienne i dwie funkcje.

0

Takie jest polecenie zadania.
Mógłby ktoś napisać taki program?

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;
}

http://dpaste.dzfl.pl/e5fa367fed03

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)
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()
0

Lektura na dziś:

  1. 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
  2. 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 ;)
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ć :/

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 :(

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.

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");
}

1 użytkowników online, w tym zalogowanych: 0, gości: 1