Brüche addieren - Programmieraufgaben.ch

Brüche addieren (Algorithmen)

Schreiben Sie ein Programm, das zwei Brüche addieren kann. Dabei werden jeweils Zähler und Nenner eingegeben. Die Ausgabe ist ein neuer Bruch - es werden also wiederum Zähler und Nenner ausgegeben.

Zusatzaufgabe: Kürzen Sie das Resultat. Dies gelingt am einfachsten, wenn Sie Zähler und Nenner des Resultats durch ihren größten gemeinsamen Teiler (ggT) dividieren.

0 Kommentare

Bitte melde dich an um einen Kommentar abzugeben

23 Lösung(en)

java
java
python
python
java
php
cpp
java
java
python
python
python
javascript
python
perl
vb
c
python
abap
python
java
csharp
cpp

package ch.programmieraufgaben.sequenz;

import java.util.Scanner;

/**
 * Bruchrechnen (ohne Kürzen)
 * @author Philipp Gressly (phi@gressly.ch)
 */
public class Bruchrechnen {
  public static void main(String[] args) {
    new Bruchrechnen().top();
  }
  
  void top() {
      int a = einlesen ("Zähler erster Bruch (a)");
      int b = einlesen ("Nenner erster Bruch (b)");
      int c = einlesen ("Zähler zweiter Bruch (c)");
      int d = einlesen ("Nenner zweiter Bruch (d)");
      
      int neuZaehler = a * d + c * b;
      int neuNenner  = b * d;
      
      System.out.println("Addition der Brüche ergibt " + neuZaehler + "/" + neuNenner);
  }

  Scanner sc = new Scanner(System.in);
  int einlesen(String frage) {
    System.out.println(frage + ": ");
    return sc.nextInt();
  }
} // end of class Bruchrechnen

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

package ch.programmieraufgaben.sequenz;

import java.util.Scanner;

/**
 * Bruchrechnen mit Kürzen
 * @author Philipp Gressly (phi@gressly.ch)
 */
public class Kuerzen {
  public static void main(String[] args) {
    new Kuerzen().top();
  }
  
  void top() {
      int a = einlesen ("Zähler erster Bruch (a)");
      int b = einlesen ("Nenner erster Bruch (b)");
      int c = einlesen ("Zähler zweiter Bruch (c)");
      int d = einlesen ("Nenner zweiter Bruch (d)");
      
      int neuZaehler = a * d + c * b;
      int neuNenner  = b * d;
      
      int ggT    = ggT(neuZaehler, neuNenner);
      neuZaehler = neuZaehler / ggT;
      neuNenner  = neuNenner  / ggT;
      
      System.out.print("Addition der Brüche ergibt " + neuZaehler);
      if(1 != neuNenner) {
          System.out.println("/" + neuNenner);
      }
  }

  int ggT(int a, int b) {
      if(0 == a % b) {
          return b;
      }
      return ggT(b, a%b);
  }
  
  Scanner sc = new Scanner(System.in);
  int einlesen(String frage) {
    System.out.println(frage + ": ");
    return sc.nextInt();
  }
} // end of class Kuerzen

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

"""
author: m1s73r
date: 01/17/2012
"""

def eingabe():
    #Eingabe Funktion, Daten werden eingelesen
    zaehler1 = int(input("Zaehler des 1. Bruchs eingeben: "))
    nenner1 = int(input("Nenner des 1. Bruchs eingeben: "))
    print("------------------------------")
    zaehler2 = int(input("Zaehler des 2. Bruchs eingeben: "))
    nenner2 = int(input("Nenner des 2. Bruchs eingeben: "))
    return (zaehler1, nenner1, zaehler2, nenner2)

def kontrolle(p_nenner1, p_nenner2):
    #Kontrolle ob einer der Nenner = O ist (Division durch Null)
    if p_nenner1 and p_nenner2 != 0:
        richtig = True
    else:
        richtig = False
    return richtig

def ggt(x, y):
   #Ermittlung des ggT, um das kgV auszurechnen (Hauptnenner)
   if x < y:        #ggf. werden die Zahlen vertauscht
       (x,y) = (y,x)
   while x % y != 0:
      x,y = y, x % y
   return y

def addieren(p_zaehler1, p_nenner1, p_zaehler2, p_nenner2):
    #Brüche werden addiert
    kgv = p_nenner1 * p_nenner2 // ggt(p_nenner1, p_nenner2)
    hauptnenner = kgv
    if p_nenner1 != hauptnenner:
        erg = hauptnenner // p_nenner1
        p_zaehler1 = p_zaehler1 * erg
    if p_nenner2 != hauptnenner:
        erg = hauptnenner // p_nenner2
        p_zaehler2 = p_zaehler2 * erg
    zaehler = p_zaehler1 + p_zaehler2
    return(hauptnenner, zaehler)

def kuerzen(p_hn, p_zaehler):
    #Wenn möglich wird das Erg. gekürzt
    teiler = ggt(p_hn, p_zaehler)
    p_nenner = p_hn // teiler
    p_zaehler = p_zaehler // teiler
    return(p_nenner, p_zaehler)

def ausgabe(p_nenner, p_zaehler):
    #Ausgabe Funktion im Bruch-Stil
    print("    %i    " % (p_zaehler))
    print("----------")
    print("    %i    " % (p_nenner))
    
def main():
    #main
    (zaehler1, nenner1, zaehler2, nenner2) = eingabe()
    richtig = kontrolle(nenner1, nenner2)
    print("    %i     " % (zaehler1), "      %i    " % (zaehler1))
    print("----------  +  ----------")
    print("    %i     " % (nenner1), "      %i    " % (nenner2))
    print("")
    print("")
    print("")
    if richtig == True:
        (hauptnenner, zaehler) = addieren(zaehler1, nenner1, zaehler2, nenner2)
        (nenner, zaehler) = kuerzen(hauptnenner, zaehler)
        print("--- Ergebnis ---")
        print("")
        print("")
        print("")
        ausgabe(nenner, zaehler)
    else:
        print("Der/Die Nenner darf/dürfen nicht 0 sein!")

#-------------------------------------------
#main

if __name__ == "__main__":
    main()

Lösung von: Name nicht veröffentlicht

"""Bruchrechner ohne zu kürzen"""
zaehler1 = int(input("Zähler 1: "))
nenner1 = int(input("Nenner 1: "))
zaehler2 = int(input("Zähler 2: "))
nenner2 = int(input("Nenner 2: "))

gemeinsamer_nenner = nenner1*nenner2
zaehler1_ = zaehler1*nenner2
zaehler2_ = zaehler2*nenner1


sum_zaehler = zaehler1+zaehler2

print ("Die Summe aus ", zaehler1, "|" , nenner1,
       "und ", zaehler2, "|", nenner2, "ist ", sum_zaehler, "|",
       gemeinsamer_nenner)

Lösung von: Py Thon ()

package javaapplication7;

import java.util.Scanner;

public class JavaApplication7 {


    public static void main(String[] args) {
        Scanner input = new Scanner(System.in);
        String Bruch1, Bruch2;
        int zaehler1, zaehler2, nenner1, nenner2;
        int ergZ, ergN;
        
        String[] bruchSplit;
        
        //Eingabe der Brüche als String Zähler/Nenner
        System.out.print("Erster Bruch (Z/N): ");
        Bruch1 = input.next();
        
        System.out.print("Zweiter Bruch (Z/N): ");
        Bruch2 = input.next();
        
       //Brüche parsen
       bruchSplit = Bruch1.split("/");
       zaehler1 = Integer.parseInt(bruchSplit[0]);
       nenner1 = Integer.parseInt(bruchSplit[1]);
       
       bruchSplit = Bruch2.split("/");
       zaehler2 = Integer.parseInt(bruchSplit[0]);
       nenner2 = Integer.parseInt(bruchSplit[1]);
       
       //Ergebnis berechnen
       ergZ = (nenner2 * zaehler1) + (nenner1 * zaehler2);
       ergN = nenner1 * nenner2;
       
       //Größter gemeinsamer Teiler finden
       int ggt = 0;
       for(int i = 1; i<= Math.max(ergZ, ergN); i++) {
           if(ergZ % i == 0 && ergN % i == 0)
               ggt++;
       }
       
       ergZ /= ggt;
       ergN /= ggt;
       
       //Ergebnis ausgeben
        System.out.println("Ergebnis: " + ergZ + "/" + ergN);
    }
}

Lösung von: Name nicht veröffentlicht

HTML - Code:
<html>
<center>
<table border ="1">
<center>


<tr>
<th colspan="5">BRUCH ADDITION</th>
<form action="Bruche.php" method="post">
</tr>

<tr>
<td>
Zähler1:
</td>
<td>
<input type="text" name="z1">
</td>
<td><PRE>	</PRE></td>
<td>Zähler2:</td><td><input type="text" name="z2"></td>
</tr>

<tr>
<td><PRE>	</PRE></td>
<td>DURCH</td>
<td>PLUS</td>
<td><PRE>	</PRE></td>
<td>DURCH</td>
</tr>

<tr>
<td>Nenner1: </td>
<td><input type="text" name="n1">	</td>
<td><PRE>	</PRE></td>
<td>Nenner2: </td>
<td> <input type="text" name="n2"></td>
</tr>

<tr>				
<td colspan="5"><center>

<input type="submit" value="Brüche addieren">
</form>
</center>
</td>
</tr>


</center>
</table>
</center>
</html>

PHPCODE:

<?php
#Schreiben Sie ein Programm, das zwei Brüche addieren kann. 
#Dabei werden jeweils Zähler und Nenner eingegeben. Die Ausgabe ist ein neuer Bruch - es werden also wiederum Zähler und Nenner ausgegeben.
#Zusatzaufgabe: Kürzen Sie das Resultat.
#Dies gelingt am einfachsten, wenn Sie Zähler und Nenner des Resultats durch ihren größten gemeinsamen Teiler (ggT) dividieren.

if ( isset($_POST["z1"])) {
			$z1 = (int)$_POST['z1'];
		
			}
if ( isset($_POST["z2"])) {
			$z2 = (int)$_POST['z2'];
			
			}
if ( isset($_POST["n1"])) {
			$n1 = (int)$_POST['n1'];
	
			}
if ( isset($_POST["n2"])) {
			$n2 = (int)$_POST['n2'];
	
			}

			

$neuZaehler = $z1 * $n2 + $n1 * $z2;
$neuNenner = $n1 * $n2;
echo "Addition der Brüche " . $z1 . "/". $n1 . " und " . $z2 . "/" . $n2 .  " ergibt " . $neuZaehler . " / " . $neuNenner;
?>

Lösung von: Lara Korner (HTL Innsbruck)

// Autor:				Andy Großhennig
// Solution for task:	Brüche addieren (Algorithmen)

#include <iostream>
#include <string>

using namespace std;

void getFraction(int i_arrFraction[])
{
	int iInput;
	int iCount = 3;

	cout << "Geben sie direkt nacheinander ein: Zaehler und Nenner des ersten Bruches und Zaehler und Nenner des zweiten Bruches (1234)\n";
	cin >> iInput;
	cout << endl;

	while(iInput != 0)
	{
		i_arrFraction[iCount] = iInput % 10;
		iInput /= 10;
		iCount--;
	}
}

void calculate()
{
	int i_arrFraction[4];
	int iResult;

	getFraction(i_arrFraction);
	
	if(i_arrFraction[1] != i_arrFraction[3])
	{
		if(i_arrFraction[1] > i_arrFraction[3])
		{
			int i_arrSek[2];
			i_arrSek[0] = i_arrFraction[2];
			i_arrSek[1] = i_arrFraction[3];
			i_arrFraction[2] = i_arrFraction[0];
			i_arrFraction[3] = i_arrFraction[1];
			i_arrFraction[0] = i_arrSek[0];
			i_arrFraction[1] = i_arrSek[1];
		}

		int iSummandFirst = i_arrFraction[2];
		int iSummandSecond = i_arrFraction[3]; 

		while(i_arrFraction[3] % i_arrFraction[1] != 0)
		{
			i_arrFraction[2] += iSummandFirst;
			i_arrFraction[3] += iSummandSecond;
		}
		
		i_arrFraction[0] *= (i_arrFraction[3] / i_arrFraction[1]);
		i_arrFraction[1] *= (i_arrFraction[3] / i_arrFraction[1]);
	}

	iResult = i_arrFraction[0] + i_arrFraction[2];

	cout << endl << "	    " << iResult << endl << "Ungekuerzt: ---\n" << "	    " << i_arrFraction[1] << endl;

	while(iResult % 2 == 0 && i_arrFraction[1] % 2 == 0)
	{
		iResult /= 2;
		i_arrFraction[1] /= 2;
	}

	cout << endl << "	    " << iResult << endl << "Gekuerzt:   ---\n" << "	    " << i_arrFraction[1];
}

int main()
{
	calculate();

	cout << "\n\n";
	system("Pause");
	return 0;
}

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

/*
 * SWT-Applikation
 */

package addBruechePack;

import org.eclipse.swt.SWT;
import org.eclipse.swt.layout.*;
import org.eclipse.swt.widgets.*;
import org.eclipse.swt.events.*;

public class prog 
{
	static Display display;
	static Shell shell;
	static Composite comp1, comp2, comp3, comp4;
	static Label labelPlus, labelIstgleich, labelIstgleich2, ergZ, ergN, ergGekuerztZ, ergGekuerztN;
	
	static Text eingabeZ1, eingabeN1, eingabeZ2, eingabeN2;
	static Button b;
	
	public static void main(String args[])
	{
		display = new Display();
		shell = new Shell(display);
		
		initForm();
		initListener();
		
		
		shell.open();
		while(!shell.isDisposed())
		{
			if(!display.readAndDispatch())
			{
				
			}
		}
		
		display.dispose();
	}
	
	static void initForm()
	{
		shell.setText("Brüche addieren");
		shell.setSize(400, 400);
		
		GridLayout layout = new GridLayout();
		layout.numColumns = 7;
		
		GridData data = new GridData(GridData.FILL_HORIZONTAL);
		
		shell.setLayout(layout);
		
		comp1 = new Composite(shell, SWT.NONE);
		labelPlus = new Label(shell, SWT.NONE);
		comp2 = new Composite(shell, SWT.NONE);
		labelIstgleich = new Label(shell, SWT.NONE);
		comp3 = new Composite(shell, SWT.NONE);
		labelIstgleich2 = new Label(shell, SWT.NONE);
		comp4 = new Composite(shell, SWT.NONE);
		
		
		labelPlus.setText("+");
		labelIstgleich.setText("=");
		labelIstgleich2.setText("=");
		
		GridLayout compLayout = new GridLayout();
		compLayout.numColumns = 1;
		
		comp1.setLayout(compLayout);
		comp2.setLayout(compLayout);
		comp3.setLayout(compLayout);
		comp4.setLayout(compLayout);
		
		eingabeZ1 = new Text(comp1, SWT.BORDER);
		new Label (comp1, SWT.SEPARATOR | SWT.HORIZONTAL);
		eingabeN1 = new Text(comp1, SWT.BORDER);
		
		eingabeZ2 = new Text(comp2, SWT.BORDER);
		new Label (comp2, SWT.SEPARATOR | SWT.HORIZONTAL);
		eingabeN2 = new Text(comp2, SWT.BORDER);
		
	    ergZ = new Label(comp3, SWT.NONE);
		new Label (comp3, SWT.SEPARATOR | SWT.HORIZONTAL);
		ergN = new Label(comp3, SWT.NONE);
		
		ergGekuerztZ = new Label(comp4, SWT.NONE);
		new Label(comp4, SWT.SEPARATOR | SWT.HORIZONTAL);
		ergGekuerztN = new Label(comp4, SWT.NONE);
		
		new Label(shell, SWT.NONE);
		new Label(shell, SWT.NONE);
		
		b = new Button(shell, SWT.PUSH);
		b.setText("Berechne!");
		
		
		
		eingabeZ1.setLayoutData(data);
		eingabeN1.setLayoutData(data);
		eingabeZ2.setLayoutData(data);
		eingabeN2.setLayoutData(data);
		ergZ.setLayoutData(data);
		ergN.setLayoutData(data);
		ergGekuerztZ.setLayoutData(data);
		ergGekuerztN.setLayoutData(data);
		b.setLayoutData(data);
		
		shell.pack();
	}
	
	static void initListener()
	{
		b.addSelectionListener(new SelectionListener()
		{
			public void widgetDefaultSelected(SelectionEvent arg0) {}
			public void widgetSelected(SelectionEvent arg0) 
			{
				if(eingabeZ1.getText() != "")
					if(eingabeN1.getText() != "")
						if(eingabeZ2.getText() != "")
							if(eingabeN2.getText() != "")
								berechne();
							
			}
		});
		
		eingabeZ1.addKeyListener(new KeyListener()
		{
			public void keyPressed(KeyEvent arg0) 
			{
				if(arg0.character != '1' && arg0.character != '2' && arg0.character != '3' && arg0.character != '4' && arg0.character != '5' && arg0.character != '6' && arg0.character != '7' && arg0.character != '8' && arg0.character != '9' && arg0.character != '0')
				{
					eingabeZ1.setText("");
				}
			}
			public void keyReleased(KeyEvent arg0) 
			{
				if(arg0.character != '1' && arg0.character != '2' && arg0.character != '3' && arg0.character != '4' && arg0.character != '5' && arg0.character != '6' && arg0.character != '7' && arg0.character != '8' && arg0.character != '9' && arg0.character != '0')
				{
					eingabeZ1.setText("");
				}
			}
		});
		
		eingabeZ2.addKeyListener(new KeyListener()
		{
			public void keyPressed(KeyEvent arg0) 
			{
				if(arg0.character != '1' && arg0.character != '2' && arg0.character != '3' && arg0.character != '4' && arg0.character != '5' && arg0.character != '6' && arg0.character != '7' && arg0.character != '8' && arg0.character != '9' && arg0.character != '0')
				{
					eingabeZ2.setText("");
				}
			}
			public void keyReleased(KeyEvent arg0) 
			{
				if(arg0.character != '1' && arg0.character != '2' && arg0.character != '3' && arg0.character != '4' && arg0.character != '5' && arg0.character != '6' && arg0.character != '7' && arg0.character != '8' && arg0.character != '9' && arg0.character != '0')
				{
					eingabeZ2.setText("");
				}
			}
		});
		eingabeN1.addKeyListener(new KeyListener()
		{
			public void keyPressed(KeyEvent arg0) 
			{
				if(arg0.character != '1' && arg0.character != '2' && arg0.character != '3' && arg0.character != '4' && arg0.character != '5' && arg0.character != '6' && arg0.character != '7' && arg0.character != '8' && arg0.character != '9' && arg0.character != '0')
				{
					eingabeN1.setText("");
				}
			}
			public void keyReleased(KeyEvent arg0) 
			{
				if(arg0.character != '1' && arg0.character != '2' && arg0.character != '3' && arg0.character != '4' && arg0.character != '5' && arg0.character != '6' && arg0.character != '7' && arg0.character != '8' && arg0.character != '9' && arg0.character != '0')
				{
					eingabeN1.setText("");
				}
			}
		});
		eingabeN2.addKeyListener(new KeyListener()
		{
			public void keyPressed(KeyEvent arg0) 
			{
				if(arg0.character != '1' && arg0.character != '2' && arg0.character != '3' && arg0.character != '4' && arg0.character != '5' && arg0.character != '6' && arg0.character != '7' && arg0.character != '8' && arg0.character != '9' && arg0.character != '0')
				{
					eingabeN2.setText("");
				}
			}
			public void keyReleased(KeyEvent arg0) 
			{
				if(arg0.character != '1' && arg0.character != '2' && arg0.character != '3' && arg0.character != '4' && arg0.character != '5' && arg0.character != '6' && arg0.character != '7' && arg0.character != '8' && arg0.character != '9' && arg0.character != '0')
				{
					eingabeN2.setText("");
				}
			}
		});
	}
	
	static void berechne()
	{
		int intZ1, intZ2, intN1, intN2, intErgZ, intErgN, intErgGekuerztZ, intErgGekuerztN;
		Integer integerZ1, integerZ2, integerN1, integerN2, integerErgZ, integerErgN ,integerErgGekuerztZ, integerErgGekuerztN;
		
		integerZ1 = new Integer(eingabeZ1.getText());
		integerZ2 = new Integer(eingabeZ2.getText());
		integerN1 = new Integer(eingabeN1.getText());
		integerN2 = new Integer(eingabeN2.getText());
		
		intZ1 = (int)integerZ1;
		intZ2 = (int)integerZ2;
		intN1 = (int)integerN1;
		intN2 = (int)integerN2;
		
		if(intZ1 < 0 || intZ2 < 0 || intN1 <= 0 || intN2 <= 0)
		{
			ergZ.setText("n.l.");
			ergN.setText("n.l.");
			ergGekuerztZ.setText("n.l.");
			ergGekuerztN.setText("n.l.");
		}
		else
		{
			intErgN = kgV(intN1, intN2);
			intErgZ = intZ1*(kgV(intN1, intN2)/intN1)+intZ2*(kgV(intN1, intN2)/intN2);
			intErgGekuerztZ = intErgZ / ggT(intErgZ, intErgN);
			intErgGekuerztN = intErgN / ggT(intErgZ, intErgN);
			
			
			integerErgZ = new Integer(intErgZ);
			integerErgN = new Integer(intErgN);
			integerErgGekuerztZ = new Integer(intErgGekuerztZ);
			integerErgGekuerztN = new Integer(intErgGekuerztN);
			
			
			ergZ.setText(integerErgZ.toString());
			ergN.setText(integerErgN.toString());
			ergGekuerztZ.setText(integerErgGekuerztZ.toString());
			ergGekuerztN.setText(integerErgGekuerztN.toString());
		}
	}
	
	static int kgV(int x, int y)//kleinste gemeinsame Vielfache
	{
		if(x == y && x >= 0) return x;
		else if(x >= 1 && y >= 1)
		{
			int rv;
			for(rv = 2; true; rv++)
				if(rv%x == 0 && rv%y == 0)break;
			return rv;
		}
		else return 0;
	}
	
	static int ggT(int x, int y)//größte gemeinsame Teiler
	{
		if(x == y && x >= 0)return x;
		else if(x == y && x < 0) return 0;
		
		int teiler;
		if(x > y) teiler = y;
		else teiler = x;
		
		for(; teiler > 0; teiler--)
		{
			if(x%teiler == 0 && y%teiler == 0)break;
		}
		return teiler;
	}
}

Lösung von: Christian :) (Hochschule Merseburg)

package addfractions;

public class AddFractions {

    private static int[] fractionA = new int[]{2, 4};
    private static int[] fractionB = new int[]{6, 8};

    public static void main(String[] args) {
        int[] addedFraction = new int[]{fractionA[0] * fractionB[1] + fractionB[0] * fractionA[1], fractionA[1] * fractionB[1]};

        int ggt = findGGT(addedFraction[0], addedFraction[1]);
        addedFraction[0] /= ggt;
        addedFraction[1] /= ggt;
        System.out.println(fractionA[0] + "/" + fractionA[1] + " + " + fractionB[0] + "/" + fractionB[1] + " = " + addedFraction[0] + "/" + addedFraction[1]);

    }

    private static int findGGT(int zahl1, int zahl2) {
        while (zahl2 != 0) {
            if (zahl1 > zahl2) {
                zahl1 = zahl1 - zahl2;
            } else {
                zahl2 = zahl2 - zahl1;
            }
        }
        return zahl1;
    }
}

Lösung von: Benedikt Starzengruber (HTL Leonding)

def bruch_aufbereiten(bruch):
    zaehler, nenner = bruch.split("/")
    return [int(zaehler), int(nenner)]


def nenner_angleichen(a, b):
    c = a[:]
    a[0], a[-1] = a[0] * b[-1], a[-1] * b[-1]
    b[0], b[-1] = b[0] * c[-1], b[-1] * c[-1]
    return [a, b]


def kuerzen(bruch):
    term = bruch[:]

    while term[-1] != 0:
        term[0], term[-1] = term[-1], term[0] % term[-1]
    ggt = term[0]

    bruch[0] /= ggt
    bruch[-1] /= ggt
    return bruch

if __name__ == '__main__':
    a = "10/20"
    b = "5/2"

    a, b = bruch_aufbereiten(a), bruch_aufbereiten(b)

    if a[-1] != b[-1]:
        a, b = nenner_angleichen(a, b)

    print "Summe", '/'.join(
        str(x) for x in kuerzen([a[0] + b[0], a[-1]])
    )

Lösung von: Name nicht veröffentlicht

from fractions import Fraction

f1 = Fraction(int(input("Zaehler 1: ")), int(input("Nenner 1: ")))
f2 = Fraction(int(input("Zaehler 2: ")), int(input("Nenner 2: ")))
e = f1+f2
print("{}/{}".format(e.numerator, e.denominator))

Lösung von: Karl Welzel ()

"""author= Cromewell"""


z1= int(input("Bruch eins Zähler: "))
n1= int(input("Bruch eins Nenner: "))
z2= int(input("Bruch zwei Zähler: "))
n2= int(input("Bruch zwei Nenner: "))

print(z1, "/", n1, "+", z2, "/", n2, "ist gleich:")
if n1 == n2:
    print("Das Ergebnis ist", z1+z2, "/", n1)
elif n1 != n2:
    cb= n1*n2
    ca= z1*n2+z2*n1
    print("Das Ergebnis ist", ca, "/", cb)

Lösung von: Name nicht veröffentlicht

// eingabe
var frac1 = prompt("Bruch (x/y):").split("/"),
    frac2 = prompt("Zu addierender Bruch (x/y):").split("/");
    
// pflicht
function addFractions(f1, f2) {
   if (f1[1] == f2[1]) // gleicher nenner
      return [parseInt(f1[0]) + parseInt(f2[0]), f1[1]];
   else {
      return [
         f1[0] * f2[1] + f2[0] * f1[1],   // zähler
         f1[1] * f2[1]                    // nenner
      ];
   }
}

// zusatzaufgabe
function reduce(f) {
   function gcd(a, b) {
      if (b == 0) return a;
      else return gcd(b, a % b);
   }
   var g = gcd(f[0], f[1]);
   if (g != 1) return [f[0] / g, f[1] / g];
   return ["not reducible"];
}

// kür 1: ergebnis als gemischter bruch
function mixedFraction(f) {
   if (f[0] == "not reducible") f = result;
   if (f[0] % f[1] == 0) return [f[0] / f[1]];
   if (f[0] > f[1]) return [
      parseInt(f[0] / f[1]),
      f[0] % f[1],
      f[1]
   ];
   return ["not mixable"];
}
   
// kür 2: ausgabe als MathML
var result = addFractions(frac1, frac2),
    reducedRes = reduce(result),
    mixedRes = mixedFraction(reducedRes);
document.write(
   '<math xmlns="http://www.w3.org/1998/Math/MathML">' +
      '<mfrac>' +
         '<mrow><mn>' + frac1[0] + '</mn></mrow>' +
         '<mn>' + frac1[1] + '</mn>' +
      '</mfrac><mo>+</mo>' + 
      '<mfrac>' +
         '<mrow><mn>' + frac2[0] + '</mn></mrow>' +
         '<mn>' + frac2[1] + '</mn>' +
      '</mfrac><mo>=</mo>' +
      '<mfrac>' +
         '<mrow><mn>' + result[0] + '</mn></mrow>' +
         '<mn>' + result[1] + '</mn>' +
      '</mfrac>'
);
if (reducedRes[0] != "not reducible") document.write(
      '<mo>=</mo><mfrac>' +
         '<mrow><mn>' + reducedRes[0] + '</mn></mrow>' +
         '<mn>' + reducedRes[1] + '</mn>' + 
      '</mfrac>' 
   );
if (mixedRes[0] != "not mixable") {
   if (mixedRes.length == 1) document.write(
      '<mo>=</mo><mn>' + mixedRes[0] + '</mn>'
   ); else document.write(
      '<mo>=</mo><mn>' + mixedRes[0] + '</mn>' +
      '<mfrac><mrow><mn>' + mixedRes[1] + '</mn></mrow>' + 
         '<mn>' + mixedRes[2] + '</mn>' +
      '</mfrac>'
   );
}
document.write('</math>');

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

#02.06.15
#Brueche addieren
def eingeben():
    zaheler1 = int(input("Geben Sie den ersten Zaehler ein: "))
    nenner1 = int(input("Geben Sie den ersten Nenner ein: "))
    zaheler2 = int(input("Geben Sie den zweiten Zaehler ein: "))
    nenner2 = int(input("Geben Sie den zweiten Nenner ein: "))

    ggT = nenner1 * nenner2
    ggTZaehler1 = zaheler1 * nenner2
    ggTZaehler2 = zaheler2 * nenner1

    result = ggTZaehler1 + ggTZaehler2

    print "Der Zaehler ist: ", result
    print "Der Nenner ist:  ", ggT

    def kuerzen(zahl1, zahl2):
        
        print ("--------------kuerzen--------------")
    
        zahl1 %2 == 0
        zahl2 %2 ==0
        while True:
            if zahl1 %2 == 0 and zahl2 %2 ==0:
                zahl1 = zahl1 / 2
                zahl2 = zahl2 / 2
            else:   
                print "Der Zaehler ist: ", zahl1
                print "Der Nenner ist:  ", zahl2
                break
    kuerzen(result, ggT)
eingeben()

Lösung von: Michel Künzle ()

use strict;
my @B1 = (2,3);
my @B2 = (8,5);

my @BC = add(@B1,@B2);
   @BC =simplify(@BC);
print "$BC[0]/$BC[1]\n";
   @BC = subs(@BC,@B2);
   @BC =simplify(@BC);
print "$BC[0]/$BC[1]\n";


sub add {
    my $gn = $_[1]*$_[3];
    return(($_[0]*($gn/$_[1]))+($_[2]*($gn/$_[3])),$gn);
}

sub subs {
    my $gn = $_[1]*$_[3];
    return(($_[0]*($gn/$_[1]))-($_[2]*($gn/$_[3])),$gn);
}

sub simplify {
    for($_ = $_[1];$_>=2;--$_){
        return($_[0]/$_,$_[1]/$_) if($_[0]%$_==0 && $_[1]%$_==0);
    }
    return($_[0],$_[1]);
}

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

Module Module1
    Sub Main()
        Console.Write("Zähler Bruch 1: ") : Dim z1 = Console.ReadLine()
        Console.Write("Nenner Bruch 1: ") : Dim n1 = Console.ReadLine()
        Console.Write("Zähler Bruch 2: ") : Dim z2 = Console.ReadLine()
        Console.Write("Nenner Bruch 2: ") : Dim n2 = Console.ReadLine()

        Dim nenner = n1 * n2
        Dim zähler = z1 * n2 + z2 * n1

        Dim ggt As Integer = getGGT(zähler, nenner)

        If Not ggt = 0 Then
            nenner /= ggt
            zähler /= ggt
        End If

        If nenner = 1 And zähler > nenner Then
            Console.WriteLine("Resultat: " & zähler * nenner)
        Else
            Console.WriteLine("Resultat: " & zähler & "/" & nenner)
        End If

        Console.ReadLine()
    End Sub

    Public Function getGGT(zähler As Integer, nenner As Integer) As Integer
        Dim arr1 As New List(Of Integer)
        Dim arr2 As New List(Of Integer)

        For i As Integer = 1 To zähler
            If zähler Mod i = 0 Then
                arr1.Add(i)
            End If
        Next

        For i As Integer = 1 To nenner
            If nenner Mod i = 0 Then
                arr2.Add(i)
            End If
        Next

        Dim match As Integer = 0
        If zähler > nenner Then
            For i As Integer = arr1.Count - 1 To 0 Step -1
                If nenner Mod arr1(i) = 0 Then
                    match = arr1(i)
                    Exit For
                End If
            Next
        Else
            For i As Integer = arr2.Count - 1 To 0 Step -1
                If zähler Mod arr2(i) = 0 Then
                    match = arr2(i)
                    Exit For
                End If
            Next
        End If
        
        Return match
    End Function
End Module

Lösung von: Elias Zech (Optics Balzers)

#include <stdio.h>

int ggt(int a, int b) {
	if (a == b)
		return a;
	else if (a < b)
		return ggt(a, b - a);
	else
		return ggt(a - b, b);
}

int getLong(char *str) {
	int check, ret;

	do {
		printf("%s\n", str);
		check = scanf("%d", &ret);
	} while (getchar() != '\n' || check != 1);

	return ret;
}

int main(void) {
	int z1, n1, z2, n2, z3, n3, ggT;

	printf("z1/n1 + z2/n2 = ...\n");

	z1 = getLong("z1 = ");
	n1 = getLong("n1 = ");
	z2 = getLong("z2 = ");
	n2 = getLong("n2 = ");

	printf("z1/n1 + z2/n2 = ");

	z3 = z1 * n2 + n1 * z2;
	n3 = n1 * n2;
	ggT = ggt(z3, n3);

	printf("%d/%d = ", z3, n3);
	printf("%d/%d\n", z3 / ggT, n3 / ggT);

	return 0;
}

Lösung von: André Trobisch ()

def kurzbruch(b):
    z, n = b
    g = 0
    while z >= n:
        z -= n
        g += 1
    if z == 0:
        n = 0
    t = 1
    while t < z:
        t += 1
        if not z % t and not n % t:
            z = int(z / t)
            n = int(n / t)
    return [g, z, n]

def addbruch(b1, b2):
    z1, n1 = b1
    z2, n2 = b2
    zr = (z1 * n2) + (z2 * n1)
    nr = n1 * n2
    return kurzbruch([zr, nr])
    # return [zr, nr]


def subbruch(b1, b2):
    z1, n1 = b1
    z2, n2 = b2
    zr = (z1 * n2) - (z2 * n1)
    nr = n1 * n2
    return kurzbruch([zr, nr])
    # return ["", zr, nr]


def multbruch(b1, b2):
    z1, n1 = b1
    z2, n2 = b2
    zr = z1 * z2
    nr = n1 * n2
    return kurzbruch([zr, nr])
    # return [zr, nr]


def divbruch(b1, b2):
    z1, n1 = b1
    z2, n2 = b2
    zr = z1 * n2
    nr = n1 * z2
    return kurzbruch([zr, nr])
    # return [zr, nr]

r = addbruch([2, 3],[8, 5])
print(r)

Lösung von: Name nicht veröffentlicht

PARAMETERS: p_a TYPE i,
            p_b TYPE i,
            p_c TYPE i,
            p_d TYPE i.
DATA: lv_neuz TYPE i,
      lv_neun TYPE i,
      a TYPE i,
      b TYPE i,
      c TYPE i,
      d TYPE i,
      kurz TYPE i,
      lv_modn TYPE i,
      lv_modz TYPE i,
      zahl TYPE i,
      ggt TYPE i.

IF p_b EQ 0.
  MESSAGE 'durch Null kann es nicht geteilt werden' TYPE 'I'.
ENDIF.
IF p_d EQ 0.
  MESSAGE 'durch Null kann es nicht geteilt werden' TYPE 'I'.
ENDIF.

a = p_a * p_d.
b = p_b * p_d.
c = p_c * p_b.
d = p_d * p_b.
lv_neuz = a + c.
lv_neun = b .

WRITE : 'Resultat=',lv_neuz,'/',lv_neun.


*lv_modn = lv_neun MOD  zahl.
*lv_modz = lv_neuz MOD  zahl.
IF lv_neuz GT lv_neun.
  zahl = lv_neun - 1.

  WHILE  lv_neun GT 0 AND lv_neuz GT 0 .
    lv_modn = lv_neun MOD  zahl.
    lv_modz = lv_neuz MOD  zahl.
    IF lv_modn = 0 AND lv_modz  EQ 0  .
      ggt =  zahl .
      lv_neuz = lv_neuz / zahl  .
      lv_neun = lv_neun / zahl .
      EXIT.
*    elseif sy-subrc <> 0.
*       ggt = 1.
    ENDIF.
    IF zahl GT 1.
      zahl = zahl - 1 .
    ENDIF.

  ENDWHILE.
  WRITE : '====>',lv_neuz,'/',lv_neun.

ENDIF.
IF lv_neuz LT lv_neun .
  zahl = lv_neuz - 1.
  WHILE  lv_neuz GT 0 AND lv_neun GT 0.
    lv_modz = lv_neuz MOD  zahl.
    lv_modn = lv_neun MOD  zahl.
    IF   lv_modn  EQ 0 AND lv_modz  EQ 0.
      ggt =  zahl .
      lv_neuz = lv_neuz / zahl  .
      lv_neun = lv_neun / zahl .
      EXIT.

    ENDIF.


    IF zahl GT 1.
      zahl = zahl - 1 .
    ENDIF.
  ENDWHILE.
  WRITE : '====>',lv_neuz,'/',lv_neun.


ENDIF.
IF lv_neuz EQ lv_neun.
  kurz = lv_neuz / lv_neun.
ENDIF.

*WRITE:'Kurz', ggt.

Lösung von: Name nicht veröffentlicht

# Brüche addieren
# Author: Apop85

def check_input(f1,f2):
  if (len(f1), len(f2)) == (2,2):
    for i in range(2):
      if not (f1[i].isdecimal() and f2[i].isdecimal()):
        return False
      return True
  else:
    return False

def add_fractions(f1,f2):
  if f1[1] == f2[1]:
    result=[str(int(f1[0])+int(f2[0])),f2[1]]
  else:
    new_f1=[int(f1[0])*int(f2[1]), int(f1[1])*int(f2[1])]
    new_f2=[int(f2[0])*int(f1[1]), int(f2[1])*int(f1[1])]
    result=[str(int(new_f1[0])+int(new_f2[0])),str(new_f1[1])]
  print('/'.join(result), end=' ')
  reduced_result=reduce_fraction(result)
  if reduced_result != result and reduced_result != 0:
    print('or '+'/'.join(reduced_result))
  else:
    print()

def reduce_fraction(result):
  for i in range(int(result[0]),0,-1):
    if (int(result[1])%i,int(result[0])%i) == (0,0):
      new_result=[str(int(result[0])//i),str(int(result[1])//i)]
      return new_result
  return 0

while True:
  fraction_1=input('Enter first fraction (Example: 1/2): ')
  fraction_1=fraction_1.split('/')
  fraction_2=input('Enter second fraction (Example: 1/3): ')
  fraction_2=fraction_2.split('/')
  check=check_input(fraction_1,fraction_2)
  if check:
    add_fractions(fraction_1,fraction_2)
  else:
    print('Input is invalid')

Lösung von: Name nicht veröffentlicht

// Lösung mit Klassen(Addition und Multiplikation)
//Klasse
 package brüche.bruch;

public class Brüche {
    int zaehler;
    int nenner;
    public Brüche(int zaehler, int nenner) {
        this.zaehler =  zaehler ;
        this.nenner = nenner;
       
    }
   public Brüche() {
	}
public void print(int zaehler, int nenner){
       System.out.printf("%d/%d%n", zaehler, nenner);
   }
   public void add(int a, int b, int c, int d){
       if(b == d){
    System.out.printf("%d/%d%n", a + c, d);
       }else{
           System.out.printf("%d/%d%n", (a * d) + (b * c), b * d);
       }
   }
   public void muli(int a, int b, int c, int d){
    System.out.printf("%d/%d%n", a * c, b * d );
   }
}

//Main Funktion

package brüche;
import brüche.bruch.*;

class Main {
    public static void main(String[] args) {
      Brüche a = new Brüche();
      a.print(4, 2);
      a.print(5, 2);
      System.out.println();
      a.add(2, 3, 8, 5);
      System.out.println();
      a.muli(4, 5, 2, 3);
    }
}

Lösung von: Name nicht veröffentlicht

// NET 7.x | C# 11.x | VS-2022
// Ausgabe der Lösung als Bruch und gemischter Bruch

const string MATH_PROBLEM = "2/3 + 8/5";
var lst = new List<int>();

var arr = MATH_PROBLEM.Replace("+", "/").Split("/");
if (arr.Length != 4 || !arr.All(x => int.TryParse(x, out _))) return;

for (var i = 0; i < arr.Length; i++)
    lst.Add(int.Parse(arr[i]));

var z = lst[0] * lst[3] + lst[2] * lst[1];
var n = lst[1] * lst[3];
var r = ggt(z, n);
if (r != 1) {
    z /= r;
    n /= r;
}
Console.WriteLine($"{MATH_PROBLEM} = {z}/{n}");

if (z > n && n != 1) {
    var g = z / n;
    z %= n;
    Console.WriteLine($"oder: {g} {z}/{n}");
}

int ggt(int a, int b) => b == 0 ? a : ggt(b, a % b);

/*
 * 2/3 + 8/5 = 34/15
 * oder: 2 4/15
 */

Lösung von: Jens Kelm (@JKooP)

// C++ 17 | VS-2022
#include <iostream>
#include <vector>
#include <algorithm>
#include <functional>
#include <string>

std::function <int(int, int)> get_gcd = [&](int a, int b) -> int { return (b == 0) ? a : get_gcd(b, a % b); };

auto get_split_string(const std::string& s, const char& del = '/') {
    std::vector<std::string> v{};
    std::string w{};
    for (const auto& c : s) {
        if (c == del) { v.push_back(w); w = ""; }
        else { w += c; }
    }
    v.push_back(w);
    return v;
}

auto fractional_calc(const std::string& fct, bool mix = false) -> void {
    auto rpl{ fct };
    std::replace(rpl.begin(), rpl.end(), '+', '/');
    const auto spl{ get_split_string(rpl) };
    if (spl.size() != 4 || !std::all_of(spl.begin(), spl.end(), [](auto x) { return x != ""; })) {
        std::cerr << "no fractions" << "\n";
        return;
    }
    std::vector<int>nums(spl.size());
    std::transform(spl.begin(), spl.end(), nums.begin(), [](auto x) { return std::stoi(x); });

    auto num{ nums[0] * nums[3] + nums[2] * nums[1] };  // numerator
    auto den{ nums[1] * nums[3] };                      // denominator
    const auto gcd{ get_gcd(num, den) };                // greatest common divisor
    if (gcd != 1) {
        num /= gcd;
        den /= gcd;
    }
    if (num > den && den != 1 && mix) {                 // test for mixed numbers
        const auto dec{ num / den };                    // decimal number
        num %= den;
        std::cout << fct << " = " << dec << " " << num << "/" << den << "\n";
        return;
    }
    std::cout << fct << " = " << num << "/" << den << "\n";;
}

auto main() -> int {
    const std::string math_problem{ "2/3 + 8/5" };
    fractional_calc(math_problem);
    fractional_calc(math_problem, true);
}

Lösung von: Jens Kelm (@JKooP)

Verifikation/Checksumme:

2/3 + 8/5 = 34/15

Zeit:
Schwierigkeit:	k.A.
Webcode:	gza2-hx9f
Autor:	Philipp G. Freimann (BBW (Berufsbildungsschule Winterthur) https://www.bbw.ch)

Programmieren lernen

Web-Code:

Brüche addieren (Algorithmen)

0 Kommentare

23 Lösung(en)

Verifikation/Checksumme:

Aktionen

Bewertung

Meta