Programmieren lernen

# Summe von feld
def summe(feld):
    summe=0.0
    for e in feld:
        summe = summe + e
    return summe

# Produkt aller Elemente von Feld
def produkt(feld):
    prod=1.0
    for e in feld:
        prod = prod * e
    return prod


a = [2, 17, 10, 9, 16, 3, 9, 16, 5, 1, 17, 14]

print a              
print summe(a)
print produkt(a)
                

Lösung von: Martin Guggisberg (Universität Basel / PH FHNW)

/**
 * Summe (bzw. Produkt) von Elementen aus Arrays berechnen.
 * @author Philipp Gressly (phi AT gressly DOT ch)
 */
public class SummeProdukt {
  public static void main(String[] args) {
    new SummeProdukt().top();
  }

  int[] feld = {2, 17, 10, 9, 16, 3, 9, 16, 5, 1, 17, 14};
  
  void top() {
     System.out.println(summe(feld));
     System.out.println(produkt(feld));
  }
  
  int summe(int[] feld) {
    int summe = 0;
    for(int e: feld) {
      summe = summe + e;
    }
    return summe;
  }
  
  long produkt(int[] feld) {
    long prod = 1;
    for(int e: feld) {
      prod = prod * e;       
    }
    return prod;
  }
  
} // end of class SummeProdukt
                

#!/usr/bin/ruby
# -*- coding: utf-8 -*-

# @autor Philipp Gressly Freimann
# 7. April 2011
#
# Aufgabe http://www.programmieraufgaben.ch / http://www.programmieren-lernen.ch
# Feldelement aufsummieren

$feld = [2, 17, 10, 9, 16, 3, 9, 16, 5, 1, 17, 14]

def summe(fld)
  summe = 0
  fld.each do |act|
    summe = summe + act
  end 
  return summe
end

def produkt(fld)
  produkt = 1
  fld.each do |act|
    produkt = produkt * act
  end 
  return produkt
end

## MAIN ##
  puts "Summe  : #{summe($feld)}"
  puts "Produkt: #{produkt($feld)}"
## END  ##
                

Lösung von: Philipp G. Freimann (BBW (Berufsbildungsschule Winterthur) https://www.bbw.ch)

/**
 * Autor: phi (at) gress (dot) ly
 * Datum: 7. 4. 2011
 * http://www.programmieraufgaben.ch "Feldelemente aufsummieren"
 * 
 * Tipp: PHP-Code ohne <?php ?> kann einfach aus der Linux-Konsole (bash) mit
 *       dem folgenden Befehl gestartet werden:
 *       
 *          php -r "$(cat filename.php)"
 */

$feld = array(2, 17, 10, 9, 16, 3, 9, 16, 5, 1, 17, 14);

function summe($feld) {
  $summe = 0;
  for($i = 0; $i < sizeof($feld); $i++) {
    $summe = $summe + $feld[$i];
  }
  return $summe;
}

echo "summe: " . summe($feld) . "\n";

function produkt($feld) {
  $produkt = 1;
  for($i = 0; $i < sizeof($feld); $i++) {
    $produkt = $produkt * $feld[$i];
  }
  return $produkt;
}

echo "produkt: " . produkt($feld) . "\n";
                

Lösung von: Philipp G. Freimann (BBW (Berufsbildungsschule Winterthur) https://www.bbw.ch)

function hauptprogramm() {
	var counter = 0;
	var zahlen  = new Array(12);
	zahlen[0]     =  2;
	zahlen[1]     = 17;
	zahlen[2]     = 10;
	zahlen[3]     =  9;
	zahlen[4]     = 16;
	zahlen[5]     =  3;
	zahlen[6]     =  9;
	zahlen[7]     = 16;
	zahlen[8]     =  5;
	zahlen[9]     =  1;
	zahlen[10]    = 17;
	zahlen[11]    = 14;
	
	var summe   = document.getElementById("summe")  ;
	var produkt = document.getElementById("produkt");
	
	summe.innerHTML = "Resultat: " + Summe(zahlen, counter);
	produkt.innerHTML = "Resultat : " + Produkt(zahlen, counter);
	
}

function Summe(zahlen, counter) {
	var summe = zahlen[0];
	
	while (counter != 11) {
		counter = counter + 1;
		summe   = summe + zahlen[counter];	
	}
		
	return summe;		
}

function Produkt(zahlen, counter) {
	var produkt = zahlen[0];
	
	while (counter != 11) {
		counter = counter + 1;
		produkt = produkt * zahlen[counter];
	}
	
	return produkt;
}
                

Lösung von: Raphael Hirsiger (Credit Suisse)

<?php
/**
 * Autor: floheuse (at) gmx (dot) at
 * Website: www.makroebene.at
 * Datum: 3. 9. 2011
 * http://www.programmieraufgaben.ch "Feldelemente aufsummieren"
 */

$feld = array(2, 17, 10, 9, 16, 3, 9, 16, 5, 1, 17, 14);

echo "summe: " . array_sum($feld) . "<br />";

function produkt($feld){
  $produkt = 1;
  foreach ($feld as $value){
    $produkt *= $value;
  }
  return $produkt;
}
echo "produkt: " . produkt($feld) . "\n";


                

Lösung von: Florian Heuse (Wordpress Developer Heuse)

# Feldelemente aufsummieren

def summe(ary)
  ary.inject{|a,b| a + b}
end

def produkt(ary)
  ary.inject{|a,b| a * b }
end

feld = [2, 17, 10, 9, 16, 3, 9, 16, 5, 1, 17, 14]

p feld
puts summe(feld)
puts produkt(feld)
                

Lösung von: Name nicht veröffentlicht

 summe: proc(fld) returns(bin fixed(31));
    dcl fld dim(*) bin fixed(31);
    dcl s bin fixed(31) init(0);
    dcl i bin fixed(15);
    do i = 1 to dimension(fld);
      s = s + fld(i);
    end;
    return (s);
  end summe;

 produkt: proc(fld) returns(bin fixed(63));
    dcl fld dim(*) bin fixed(31);
    dcl p bin fixed(63) init(1);
    dcl i bin fixed(15);
    do i = 1 to dimension(fld);
      p *= fld(i);
    end;
    return (p);
  end produkt;



                

Lösung von: Philipp G. Freimann (BBW (Berufsbildungsschule Winterthur) https://www.bbw.ch)

// Haskell

// standard library:
product [2, 17, 10, 9, 16, 3, 9, 16, 5, 1, 17, 14]

sum [2, 17, 10, 9, 16, 3, 9, 16, 5, 1, 17, 14]

// custom:

sum' :: (Integral a) => [a] -> a

sum' [] = 0
sum' (x:xs) = x + sum' xs


product' :: (Integral a) => [a] -> a

product' [] = 1
product' (x:xs) = x * product' xs

                

Lösung von: Reto Hablützel (www.rethab.ch)

class cSumFields {
    
    private $field;
    
    /**
     * 
     * Berechne die Summe, aus dem übergebenen Array
     * @param array $fields
     */
    public function _getSumField ( array $fields ) {
        
        foreach ( $fields as $field ) {

            $this->field += $field;
            
        }
        
        return $this->field . "<br />";
        
    }
    
    /**
     * 
     * Bilde das Produkt, aus dem übergebenen Array
     * @param array $fields
     * @return string $field
     */
    public function _getProduct ( array $fields ) {
        
        // Muss auf eins gesetzt werden, weil sonst mit Null multipliziert wird
        $this->field = 1;
        
        foreach ( $fields as $field ) {
            
            $this->field *= $field;
            
        }
        
        return $this->field . "<br />";
        
    }
    
}

$fields = array(2, 17, 10, 9, 16, 3, 9, 16, 5, 1, 17, 14);

$objField = new cSumFields();

echo $objField->_getSumField( $fields );
echo $objField->_getProduct( $fields );
                

Lösung von: Name nicht veröffentlicht

class Program
    {
        static void Main(string[] args)
        {
            int[] feld = { 2, 17, 10, 9, 16, 3, 9, 16, 5, 1, 17, 14 };
            Console.WriteLine(summe(feld));
            Console.WriteLine(produkt(feld));
            Console.WriteLine(integerProdukt(feld));

            Console.ReadLine();
        }

        public static int summe(int[] feld)
        {
            return feld.Sum();
        }

        public static long produkt(int[] feld) //Da die Zahl den Datentyp int überschreitet long verwendet.
        {
            long pro = 1;
            feld.ToList<int>().ForEach(ele => pro = pro * ele);
            return pro;
        }

        public static int integerProdukt(int[] feld) //Hier mit int, alternativ könnte auch eine Overflow Exception geworfen werden.
        {
            int pro = 1;
            foreach (int f in feld)
            {
                if (pro * f <= int.MaxValue && pro * f > 0)
                    pro *= f;
                else
                    pro = -1; //Alternativ "throw new OverflowException();"
            }
            return pro;
        }
    }
                

Lösung von: Luca Welker (SBS Software GmbH)

// Copyright 2012, Christian J. Kiewiet.
//
///////////////////////////////////////////////////////////////////////////////
// Lösung zur Aufgabenstellung ``Feldelemente aufsummieren (Felder)''
//
// ``[ ... ] Schreiben Sie nun zwei Funktionen, welche die Summe und das 
// Produkt aller Zahlen aus diesem Array ermittelt. Testen Sie Ihr Programm 
// auch mit anderen Zahlen.''
///////////////////////////////////////////////////////////////////////////////
#include <iostream>
#include <vector>

/** Returns the sum of all elements in |numbers|. */
long Sum(std::vector<long>& numbers) {
  long sum(0);
  for (auto number : numbers) sum += number;
  return sum;
}

/** Returns the product of all elements in |numbers|. */
long Product(std::vector<long>& numbers) {
  long product(1);
  for (auto number : numbers) product *= number;
  return product;
}

/** Entry point. */
int main(int argc, char* argv[]) {
  std::vector<long> numbers = { 2, 17, 10, 9, 16, 3, 9, 16, 5, 1, 17, 14 };
  std::cout << "sum: " << Sum(numbers) 
            << "; product: " << Product(numbers) << std::endl;
  exit(EXIT_SUCCESS);
}

                

Lösung von: Christian Kiewiet ()

array = [2,17,10,9,16,3,9,16,5,1,17,14]
summe = 0
produkt = 1
for item in array:
    summe +=item
    produkt*=item

print("Summe ist : ", summe)
print("Produkt ist: ", produkt)

                

Lösung von: Py Thon ()

(defun feldelemente-berechnen ()
	   (let ((feld '(2 17 10 9 16 3 9 16 5 1 17 14)))
	     (print (summe feld))
	     (print (produkt feld))))

(defun produkt (feld)
	   (reduce #'* feld))

(defun summe (feld)
	   (reduce #'+ feld))
                

Lösung von: Stefan Meichtry (Erwachsenenbildung)

// Autor:				Andy Großhennig
// Solution for task:	Feldelemente aufsummieren (Felder)

#include <iostream>

using namespace std;

unsigned long calculateProduct(int numbers[12])
{
	unsigned long iProduct = numbers[0];

	for(short sh = 1;sh < 12;sh++)
		iProduct *= numbers[sh];

	return iProduct;
}

int calculateSum(int numbers[12])
{
	int iSum = 0;

	for(short sh = 0;sh < 12;sh++)
		iSum += numbers[sh];

	return iSum;
}

int main()
{
	int numbers[12] = {2, 17, 10, 9, 16, 3, 9, 16, 5, 1, 17, 14};

	for(short sh = 0;sh < 11;sh++)
		cout << numbers[sh] << " + ";
	
	cout << numbers[11] << " = " << calculateSum(numbers) << "\n\n";
	
	for(short sh = 0;sh < 11;sh++)
		cout << numbers[sh] << " * ";
	
	cout << numbers[11] << " = " << calculateProduct(numbers);;
	
	cout << "\n\n";
	system("Pause");
	return 0;
}
                

Lösung von: Andy Großhennig (Bundeswehr)

// Programmiersrpache: Go

package main

import "fmt"

func sum(f []int, c chan int) {
        sum := 0

        for _, v := range f {
                sum += v
        }
        c <- sum
}

func main() {
        f := []int{2, 17, 10, 9, 16, 3, 9, 16, 5, 1, 17, 14}
        c := make(chan int)

        go sum(f, c)
        s := <-c

        fmt.Println("Die nebenlaeufig berechnete Summe ist: ", s)
}

                

Lösung von: Matthias Sayler (Bosch)

import java.util.Scanner;
import java.util.regex.Pattern;

public class feldelemente {

    // Zahlenarray das die eingelesenen Zahlen fasst
    private int[] zahlen;

    // füllt das Array mit den eingelesenen Zahlen
    private void fuelleArray(String zahlenstring) {

	// Zahlen werden aus dem String in ein array gesplittet
	String[] strarray = zahlenstring.split(Pattern.quote("; "));

	// für das Zahlenarray wird Größe und Inhalt festgelegt
	zahlen = new int[strarray.length];

	for (int i = 0; i < strarray.length; i++) {
	    zahlen[i] = Integer.parseInt(strarray[i]);
	}
    }

    // multipliziert alle Zahlen im Zahlenarray
    private int miltipliziereArray() {

	// Ergebnis das wiedergegeben wird
	int ergebnis = zahlen[0];

	// Zahlen werden multipliziert
	for (int i = 1; i < zahlen.length; i++) {
	    ergebnis = ergebnis * zahlen[i];
	}

	return ergebnis;
    }

    // addiert alle Zahlen im Zahlenarray
    private int addiereArray() {

	// Ergebnis das wiedergegeben wird
	int ergebnis = 0;

	// Zahlen werden addiert
	for (int i = 0; i < zahlen.length; i++) {
	    ergebnis = ergebnis + zahlen[i];
	}

	return ergebnis;
    }

    // Hauptmethode
    public static void main(String[] args) {

	// Klassenobjekt um auf die Methoden zugreifen zu können
	feldelemente tue = new feldelemente();

	// Scanner um die Zahlen und die Rechenart einzulesen
	Scanner scan = new Scanner(System.in);

	// Eingabe der Zahlen
	System.out
		.println("Bitte geben Sie die Zahlen mit ; und Leerzeichen voneinander getrennt ein:");
	String zahlenstring = scan.nextLine();

	// Zahlenarray befüllen
	tue.fuelleArray(zahlenstring);

	// Rechenart wählen
	System.out
		.println("Bitte waehlen Sie ob die Zahlen addiert (A) oder multipliziert (M) werden sollen: ");
	switch (scan.next()) {

	// addieren
	case "A":
	case "a":
	    System.out.println("Addiert ergeben Ihre Zahlen: "
		    + tue.addiereArray());
	    break;

	// multiplizieren
	case "M":
	case "m":
	    System.out.println("Multipliziert ergeben Ihre Zahlen: "
		    + tue.miltipliziereArray());
	    break;

	// ausnahme
	default:
	    System.out.println("Diese Option stand nicht zur Auswahl");
	    break;
	}
    }
}
                

Lösung von: Sebastian Littel ()

#include "stdafx.h"
#include <stdio.h>
#include <stdlib.h>


int aufsummieren(int iFeld[]) {
	int iSumme = 0;

	for(int iZähler = 0; iZähler <= 11; iZähler += 1) {
		iSumme += iFeld[iZähler]; 
	}
	return iSumme;
}

long produkt(int iFeld[]) {
	long iProdukt = 1;

	for(int iZähler = 0; iZähler <= 11; iZähler += 1) {
		iProdukt *= iFeld[iZähler];
	}
	return iProdukt;
}

int main()
{
	int iFeld[] = { 2, 17, 10, 9, 16, 3, 9, 16, 5, 1, 17, 14 };
	int iSumme = 0;
	long iProdukt = 0;

	iSumme = aufsummieren(iFeld);

	iProdukt = produkt(iFeld);

	printf("Summe: %i", iSumme);
	printf("\nProdukt: %o", iProdukt);

	getchar();
	return 0;
}
                

Lösung von: Elias Zech (Optics Balzers)

def sum(feld)
  feld.inject {|sum, i| sum + i}
end
def multi(feld)
  feld.inject {|sum, i| sum * i}
end
puts sum([2,17,10,9,16,3,9,16,5,1,17,14])
puts multi([2,17,10,9,16,3,9,16,5,1,17,14])
                

Lösung von: Name nicht veröffentlicht

//F#

let arr = [1;5;7;9;11;13;15;16;19]

let summe a'=
    List.sum a'

let produkt a' =
    List.fold (fun acc x -> acc * x) 1 a'
     
printfn "Summe: %d" (summe arr)
printfn "Produkt: %d" (produkt arr)
                

Lösung von: Vural Acar ()

from functools import reduce

l = eval(input("Gib die Elemente der Liste mit Kommatas getrennt an: "))
l = list(l)

s = sum(l)
print("Die Summe der Elemente ist:", s)

p = reduce(lambda x, y: x*y, l)
print("Das Produkt der Elemente ist:", p)

                

Lösung von: Karl Welzel ()

use strict;

my @array = (2, 17, 10, 9, 16, 3, 9, 16, 5, 1, 17, 14);


print summe(@array)."\n";
print produkt(@array)."\n";

sub summe {
    my @array = @_;
    my $summe = 0;
    for(@array){$summe += $_;}
    return($summe);
}

sub produkt {
    my @array = @_;
    my $produkt = 1;
    for(@array){$produkt *= $_;}
    return($produkt);
}
                

Lösung von: Paul Scheinast (http://scheinast.eu)

var theArray = [2, 17, 10, 9, 16, 3, 9, 16, 5, 1, 17, 14];

function arraySum(arr) {
   return eval(arr.join("+"));
}

function arrayProduct(arr) {
   return eval(arr.join("*"));
}
   
console.log(arraySum(theArray));
console.log(arrayProduct(theArray));
                

Lösung von: Lisa Salander (Heidi-Klum-Gymnasium Bottrop)

using System;
using System.Collections.Generic;
using System.Linq;
using System.Text;
using System.Threading.Tasks;

namespace Feldsumme_aufsummieren
{
    class Program
    {
        static void Main(string[] args)
        {
            /*Füllen Sie ein Feld (Array) mit den Zahlen:
            2, 17, 10, 9, 16, 3, 9, 16, 5, 1, 17, 14.
            Schreiben Sie nun zwei Funktionen, welche die Summe und das Produkt aller 
            Zahlen aus diesem Array ermitteln. Testen Sie Ihr Programm auch mit anderen Zahlen.
             */
            int[] arr = new int[]{2, 17, 10, 9, 16, 3, 9, 16, 5, 1, 17, 14};

            int summe = Addieren(arr);
            Ausgeben(summe);
            long produkt = Multiplizieren(arr);
            Ausgeben(produkt);

            Console.ReadKey();
        }

        private static long Multiplizieren(int[] arr)
        {
            long produkt = 1;

            foreach (var item in arr)
                produkt *= item;

            return produkt;
        }

        private static void Ausgeben(long erg)
        {
            Console.WriteLine(erg);
        }

        private static int Addieren(int[] arr)
        {
            int summe = 0;

            foreach (var item in arr)
                summe += item;

            return summe;
        }
    }
}

                

Lösung von: mattia mancina (Berufsfachschule für Informatik Bozen)

'4.3.2017 - PowerBASIC 10

#COMPILE EXE
#DIM ALL

FUNCTION PBMAIN () AS LONG

    DIM myArr(12) AS INTEGER

    ARRAY ASSIGN myArr() = 2, 17, 10, 9, 16, 3, 9, 16, 5, 1, 17, 14

    MSGBOX "Summe:" & $TAB & STR$(Summe(myArr())) & $CRLF & _
           "Produkt:" & $TAB & STR$(Produkt(myArr())),,EXE.NAME$


END FUNCTION

'-----------------------------------

FUNCTION Summe(myArr() AS INTEGER) AS INTEGER
    DIM i AS INTEGER
    DIM y AS INTEGER

    FOR i = 0 TO UBOUND(myArr) -1
        y += myArr(i)
    NEXT i

    FUNCTION = y

END FUNCTION

'-----------------------------------

FUNCTION Produkt(myArr() AS INTEGER) AS QUAD

    DIM i AS INTEGER
    DIM y AS QUAD

    y = 1
    FOR i = 0 TO UBOUND(myArr) -1
        y *= myArr(i)
    NEXT i

    FUNCTION = y

END FUNCTION

                

Lösung von: Markus Sägesser (keine)

public class Main {

    public static void main(String[] args) {
        int[] feld = new int[] {2, 17, 10, 9, 16, 3, 9, 16, 5, 1, 17, 14};

        System.out.println(summe(feld));
        System.out.println(integerprodukt(feld));
    }

    private static int summe(int[] feld) {
        int summe = 0;

        for(int i : feld) {
            summe += i;
        }

        return summe;
    }

    private static long integerprodukt(int[] feld) {
        long produkt = 1;

        for(int i : feld) {
            produkt *= i;
        }

        return produkt;
    }
}
                

Lösung von: Name nicht veröffentlicht

#include <stdio.h>
#include <stdlib.h>




int main()
{


    int lang;
    int i;
    int k;
    int s ;
    int erg;
    float  erg1;
    int zahlen;
    zahlen=0;
    erg=0;
    erg1=1;


    printf("Wie viele Felder wollen Sie erstellen");
    scanf("%i",&k);

    int Felder[k];

    s=0;
    lang=sizeof(Felder)/sizeof(int);
    do{
        printf("Wert  Feld");
        scanf("%i",&Felder[s]);

        s++;


    }while(s<lang);






    for(i=0;i<lang;i++)
    {
        erg=erg+Felder[i];
        erg1=erg1*Felder[i];


    }

    printf("%i  %.0f",erg,erg1);





}

                

Lösung von: Name nicht veröffentlicht

public class Summe {
	
	public static void main(String[] args) {
		int Feld[] = {2, 17, 10, 9, 16, 3};
		int sum = 0;
		int mult = 1;
		System.out.println(summe(Feld, sum));
		System.out.println(produkt(Feld, mult));
	}

	private static int summe(int Feld[], int sum) {
					
		for (int i : Feld) {
			sum += i;
		}
		return sum;
	}


	private static long produkt(int Feld[], int mult) {
			
		for (int i : Feld) {
			mult *= i;
		}
		return mult;
	}
}
                

Lösung von: Raphael Bosshart (ETH ZH)

array = [2, 17, 10, 9, 16, 3, 9, 16, 5, 1, 17, 14]

def addition(array):
    n = 0
    for item in array:
        n = n + item
    print("Summe ist:", n)

def mult(array):
    m = 1
    for item in array:
        m = m*item
    print("Produkt ist:", m)

addition(array)
mult(array)
                

Lösung von: Name nicht veröffentlicht

// NET 6.x | C# 10.x | VS-2022

var lst = new List<long> { 2, 17, 10, 9, 16, 3, 9, 16, 5, 1, 17, 14 };

Console.WriteLine($"{(string.Join(" + ", lst))} = {lst.Sum():##,0}");
Console.WriteLine($"{(string.Join(" * ", lst))} = {lst.Aggregate(1, (long a, long b) => a * b):##,0}");
                

Lösung von: Jens Kelm (@JKooP)

// C++ 17

#include <iostream>
#include <vector>
#include <numeric>

int main() {
    std::vector<int> v{ 2, 17, 10, 9, 16, 3, 9, 16, 5, 1, 17, 14 };

    auto sum{ std::accumulate(v.begin(), v.end(), 0LL) };
    auto product{ std::accumulate(v.begin(), v.end(), 1LL, std::multiplies<long long>()) };

    std::cout << "Summe: " << sum << "\nProdukt: " << product << "\n";
}
                

Lösung von: Jens Kelm (@JKooP)

// C++ 20
#include <iostream>

int main() {
    const auto sum{ [] <typename ...T>(const T & ...param) { return (param + ...); } };
    const auto pro{ [] <typename ...T>(const T & ...param) { return (param * ...); } };

    std::cout << "Summe: " << sum(2, 17, 10, 9, 16, 3, 9, 16, 5, 1, 17, 14LL) << "\n";
    std::cout << "Produkt: " << pro(2, 17, 10, 9, 16, 3, 9, 16, 5, 1, 17, 14LL) << "\n";
}
                

Lösung von: Jens Kelm (@JKooP)

' VBA
Sub Main()
    Set wsf = WorksheetFunction
    arr = Array(2, 17, 10, 9, 16, 3, 9, 16, 5, 1, 17, 14)
    Debug.Print "sum: " & wsf.Sum(arr), "pro: " & wsf.Product(arr)
End Sub

                

Lösung von: Jens Kelm (@JKooP)

array=[2, 17, 10, 9, 16, 3, 9, 16, 5, 1, 17, 14]
plus=lambda x: plus([x[0]+x[1]]+x[2:]) if len(x)>2 else x[0]+x[1]
multi=lambda x: multi([x[0]*x[1]]+x[2:]) if len(x)>2 else x[0]*x[1]
print(plus(array),multi(array))
                

Lösung von: rob ert (tub)

#include <stdio.h>

enum operation{
    add, mult
};

long accumulate(int* arr, size_t size, enum operation oper){
    long result = oper == mult;
    for(size_t i = 0; i < size; i++)
        if(oper == mult) result *= arr[i];
        else result += arr[i];
    return result;
}

int main(){
    int arr[] = {2, 17, 10, 9, 16, 3, 9, 16, 5, 1, 17, 14};
    size_t size = sizeof(arr) / sizeof(arr[0]);
    printf("Summe: %lld\n", accumulate(arr, size, add));
    printf("Produkt: %lld\n", accumulate(arr, size, mult));
}
                

Lösung von: Jens Kelm (@JKooP)