Buch Cover Buch Cover Buch Cover Buch Cover

Web-Code: - Webcode Help

Defiziente Zahl (Algorithmen)

Schreiben Sie ein Programm, welches überprüft ob eine natürliche Zahl defiziente ist oder nicht.

Eine natürliche Zahl heißt defizient, wenn ihre echte Teilersumme (die Summe aller Teiler ohne die Zahl selbst) kleiner ist als die Zahl selbst. Ist die Teilersumme dagegen gleich der Zahl, spricht man von einer vollkommenen Zahl, ist sie groeßer, so spricht man von einer abundanten Zahl.

z.B : Eingabe: 80

       Ausgabe: 80 ist keine defiziente Zahl [ 1 + 2 + 4 + 5 + 8 + 10 + 16 + 20 + 40 = 106 ]

1 Kommentare

Bitte melde dich an um einen Kommentar abzugeben

Kommentare (1)

python 16. Oktober 2015 05:53   reply report
Die Aufgabe ist identisch mit "Abundante und vollkommene Zahlen"

16 Lösung(en)

def zahl = 80
def teilersumme = getListeDerEchtenTeiler(zahl)

if (teilersumme.sum() < zahl) println "Zahl ${zahl} ist defizient"
else if (teilersumme.sum() == zahl) println "Die Zahl ${zahl} ist vollkommen"
else println "Die Zahl ${zahl} ist abdudant"


def getListeDerEchtenTeiler(def zahl) {
    def teilerliste = []
    zahl.times { index ->
        if (index != 0 && zahl % index == 0) teilerliste.add(index)
    }
    return teilerliste
}
                

Lösung von: Max Jando (Hochschule Mannheim)

i = int(input("Zahl:"))
list = []

for j in range(i-1):
    if(i%(j+1) == 0):
        list.append(j+1)

p=sum(list)

print('Teilersumme der Zahl %d = %d' % (i,p))
if(p < i):
    print("Die Zahl %d ist defizient" %i)
if(p == i):
     print("Die Zahl %d ist vollkommen" %i)
if(p > i):
     print("Die Zahl %d ist abundant" %i)
                

Lösung von: Name nicht veröffentlicht

package consoleprogramme.zahlen.defizientezahlen;

import java.util.ArrayList;
import java.util.List;


public class DefizienteZahlen {
   
    public static void main(String[] args) {

	istDefizienteZahl(86);
	istDefizienteZahl(80);
	istDefizienteZahl(60);
	istDefizienteZahl(100);

    }

   
    private static boolean istDefizienteZahl(int zahl) {

	int summeAllerTeiler = 0;
	List<Integer> teiler = new ArrayList<Integer>();
	for (int i = 1; i <= zahl / 2; i++) {

	    if (zahl % i == 0) {
		summeAllerTeiler += i;
		teiler.add(i);
	    }
	}

	boolean defizient = (summeAllerTeiler < zahl);
	//boolean vollkommen = (summeAllerTeiler == zahl);
	//boolean abundant = (summeAllerTeiler > zahl);
	System.out
		.println(zahl
			+ " ist "
			+ (defizient ? "eine defiziente Zahl"
				: "keine defiziente Zahl") + " "
			+ getSumme(teiler, summeAllerTeiler) +"\n");
//	if(vollkommen)
//	    System.out.println("aber vollkommen");
//	else if(abundant)
//	    System.out.println("aber abundant");
	
	return defizient;
    }

    /**
     * Berechnet die summe aller Teiler
     * 
     * @param teiler
     * @param summeAllerTeiler
     * @return
     */
    private static String getSumme(List<Integer> teiler, int summeAllerTeiler) {

	StringBuilder sb = new StringBuilder("[ ");

	for (int i = 0; i < teiler.size(); i++) {

	    if (i > 0) {
		sb.append(" + ");
	    }

	    sb.append(teiler.get(i));
	}

	sb.append(" = ").append(summeAllerTeiler).append(" ]");
	return sb.toString();
    }
}
                

Lösung von: Houssein Fofana ()

Eingabe = int(input("Bitte geben sie eine beliebige Zahl ein: "))
Teiler = 1
TestaD = 0
for Teiler in range(1, Eingabe):
    if Eingabe % Teiler == 0:
        TestaD = TestaD + Teiler
        Teiler = Teiler + 1
if Eingabe / TestaD >= 1:
    print(Eingabe, "ist eine defiziente Zahl da", Eingabe, "/", TestaD, ">= 1")
else:
    print(Eingabe, "ist keine defiziente Zahl da", Eingabe, "/", TestaD, "<= 1")
                

Lösung von: Jasper -- (Gymnasium)

function isDeficiantNumber(num) {
   var x = num - 1,
       divisors = [];
   for (x; x > 0; x--) {
      if (num % x === 0) divisors.push(x);
   }
   console.log(divisors.reverse().join(" + ") + " = " + eval(divisors.join("+")));
   return eval(divisors.join("+")) < num;
}

console.log(isDeficiantNumber(80));
                

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

/*
* Autor: Hade Mohamed | HTL Bulme
* Contact: proxfreak@gmail.com

Schreiben Sie ein Programm, welches überprüft ob eine natürliche Zahl defiziente ist oder nicht.
Eine natürliche Zahl heißt defizient, wenn ihre echte Teilersumme (die Summe aller Teiler ohne die Zahl selbst) kleiner ist als die Zahl selbst. Ist die Teilersumme dagegen gleich der Zahl, spricht man von einer vollkommenen Zahl, ist sie groeßer, so spricht man von einer abundanten Zahl.
z.B : Eingabe: 80
      Ausgabe: 80 ist keine defiziente Zahl [ 1 + 2 + 4 + 5 + 8 + 10 + 16 + 20 + 40 = 106 ]
*/

#include <stdio.h>
int main()
{
	int input = 0;
	printf("Eingabe = ");
	scanf("%i", &input);

	int teiler_summe = 0;
	for(int i = 1; i < (input/2)+1; i++)
		if(input % i == 0)
			teiler_summe += i;

	if(teiler_summe < input)
		printf("%i ist eine defiziente Zahl [Teilersumme = %i]", input, teiler_summe);
	else if(teiler_summe > input)
		printf("%i ist eine abundante Zahl [Teilersumme = %i]", input, teiler_summe);
	else
		printf("%i ist vollkommen", input);

	while(true);
	return 0;
}

                

Lösung von: Hade Mohamed (HTL Österreich)

#include <stdio.h>

int isDefizient(int num) 
{
	int divisor = 1;
	int all = 0;

	while (divisor < num)
	{
		if (num % divisor != 0)
		{
			divisor++;
			continue;
		}
		all += divisor;
		divisor++;
	}

	if (all < num)
		return 1;
	else
		return 0;
}

int main() 
{
	int buffer;

	do
	{
		scanf_s("%d", &buffer);
		
		if (isDefizient(buffer))
			printf("%d ist eine Defiziente Zahl\n", buffer);
		else
			printf("%d ist keine Defiziente Zahl\n", buffer);
	} while (1);
	return 0;
}
                

Lösung von: Name nicht veröffentlicht

public class DefizienteZahl {

	public static int scheissaufgabe(int n){
		int summe = 0;
		boolean defizient = true;
		for (int i = 1; i <= n/2;i++  ){
			if (n % i == 0){
				summe +=i;
			}
		}
		if(summe > n){
			defizient = false;
		}
		if (defizient == false){
			System.out.println("Abundante Zahl gefunden ! ");
		}else if(defizient == true){
			System.out.println("Defiziente Zahl gefunden !");
		}
			
		return summe;
	
	}
	public static void main(String [] args ){
		
	System.out.println(DefizienteZahl.scheissaufgabe(123917417));
		
	}
}

                

Lösung von: Name nicht veröffentlicht

public class Programmieraufgaben_ch{
    public static void main (String [] Args) {
    	DefizienteZahl(8);
    }

    public static boolean DefizienteZahl (int Zahl) {
    	int Summe = 0;
    	// i bis auf Zahl erhöhen
    	for (int i = 2; i<=Zahl; i++) {
    		//wenn i Teiler von Zahl addiere Teiler auf Summe
    		if (Zahl%i==0) {
    			Summe += Zahl/i;
    		}
    	}
    	//Wenn Summe kleiner als Zahl Bedingung für
    	//Defiziente Zahl erfüllt -> return true
    	if (Summe<Zahl) {
    		System.out.println("Defiziente Zahl");
    		return true;
    	}
    	return false;
    }
                

Lösung von: Thomas Anderson (Freie Universität Berlin)

package ch.FastByte22.Programmieraufgaben;

/**
* @author Sam und David
*/
import java.util.Scanner;

public class DefizienteZahl {
    public static void main(String[] args) {
	Scanner sc = new Scanner(System.in);
	System.out.print("Geben Sie die zu untersuchende Zahl ein: ");
	int zahl = sc.nextInt();
	int zwischenzahl = 0, zaehler = 1;
	while (zaehler < zahl) {
	    if (zahl % zaehler == 0) {
		zwischenzahl+= zaehler;
	    }
	    zaehler++;
	}
	if(zwischenzahl<zahl) {
	    System.out.println("Diese Zahl ist defizient!");
	}
    }
}

                

Lösung von: David Wu (Gut-genug.com)


public class defiZahl {

	public static void main(String[] args) {
		new defiZahl().teiler();
		
	}
	
	void teiler(){
		int teiler = 1;
		int i = 496;
		int summe = 0;
		while(teiler < i){
			if(moeglich(i,teiler)){
				ausgabe(teiler);
				summe += teiler;
				
			}
		
			teiler++;
		}
		if(summe > i){
			System.out.println("= " + summe + "  Also " + i +" ist keine defiziente Zahl");
		}
		if(summe < i){
			System.out.println("= " + summe + "  Also " + i +" ist eine defiziente Zahl");
		}
		if(summe == i){
			System.out.println("= " + summe + "  Also " + i +" ist eine vollkommene Zahl");
		}
		
	}
	
	boolean moeglich(int i,int a){
		return 0 == i % a;
	}

	void ausgabe(int b){
		System.out.print(b + ", ");
	}
}

                

Lösung von: René Murrell (Hochschule Rhein Main)

Module Module1

    Sub Main()
        Dim zahl As Integer = 0
        Dim summe As Integer = 0

        Console.WriteLine("Geben Sie eine Zahl ein: ")
        zahl = Console.ReadLine()

        For i As Integer = 1 To zahl Step 1
            If zahl Mod i = 0 Then
                If Not i = zahl Then
                    summe += i
                End If
            End If
        Next

        If summe > zahl Then
            Console.WriteLine()
            Console.WriteLine(zahl & " ist keine defiziente Zahl (Summe: " & summe & ")")
        Else
            Console.WriteLine()
            Console.WriteLine(zahl & " ist eine defiziente Zahl (Summe: " & summe & ")")
        End If

        Console.ReadLine()
    End Sub

End Module
                

Lösung von: Elias Zech (Optics Balzers)

<?php

$x = 18410;
$y = array();
$i = 1;


while ($i < $x)
{
    if (strpos($x / $i, ".") === false) 
    {
        array_push($y, $i);
    }

    $i++;
}

if (array_sum($y) < $x)
{
    echo $x . " ist eine defiziente Zahl";
}
else
{
    echo $x . " ist keine defiziente Zahl";
}

?>
                

Lösung von: Maik Scheiermann (Powercloud GmbH)

REPORT  zdefiziente_zahl.

PARAMETERS: pa_z TYPE i.

DATA: lv_helper TYPE i,
      lv_alleteiler TYPE string,
      lv_teilerstr TYPE string,
      lv_halb TYPE i,
      lv_mod TYPE i VALUE 1,
      lt_teiler TYPE STANDARD TABLE OF i,
      ls_teiler LIKE LINE OF lt_teiler.

lv_halb = pa_z / 2. " Um Laufzeit zu verkürzen.

IF pa_z > 0. " Test ob Eingabe eine positive Zahl ist.
  WHILE lv_mod <= lv_halb.
    lv_helper = pa_z MOD lv_mod.
    IF lv_helper = 0.
      APPEND lv_mod TO lt_teiler. " Ganze Teiler werden in die Tabelle eingetragen.
    ENDIF.
    ADD 1 TO lv_mod. " Mod Zahl wird um 1 erhöht.
  ENDWHILE.
  CLEAR lv_helper. " Wiederverwendung der Hilfsvariable.
  LOOP AT lt_teiler INTO ls_teiler.
    lv_teilerstr = ls_teiler. " Da mit einem String gearbeitet werden muss.
    IF sy-tabix = 1. " Vor dem ersten Eintrag kein Plus.
      CONCATENATE lv_alleteiler lv_teilerstr into lv_alleteiler.
    else. " Teiler werden mit + angehängt
      CONCATENATE lv_alleteiler lv_teilerstr into lv_alleteiler SEPARATED BY '+ '.
    ENDIF.
    lv_helper = lv_helper + ls_teiler. " Zusammenzählen aller ganzen Teiler.
  ENDLOOP.
  IF pa_z > lv_helper.
    WRITE: / pa_z,
             ' ist eine defiziente Zahl. [',
             lv_alleteiler,
             ']',
             lv_helper.
  ELSE.
    WRITE: / pa_z,
             ' ist keine defiziente Zahl. [',
             lv_alleteiler,
             ']',
             lv_helper.
  ENDIF.
ELSE.
  WRITE: / pa_z,
           'ist keine natürliche Zahl. Falsche Eingabe!'.
ENDIF.
                

Lösung von: Alexander S. (msg systems)

// DEFIZIENTE ZAHLEN 
//hier Zahl modifizieren
const zahl =80;

var Teilersumme = Summe(Teiler(zahl));

if (Teilersumme < zahl)
	console.log("Die Zahl ist eine defiziente Zahl. Die Teilersumme beträgt: " + Teilersumme);
	else if (Teilersumme > zahl)
		console.log("Die Zahl ist eine abudante Zahl. Die Teilersumme beträgt: " + Teilersumme);
		else if (Teilersumme === zahl)
			console.log("Die Zahl ist eine vollkommene Zahl. Die Teilersumme beträgt: " + Teilersumme);
			

//Teiler ermitteln
function Teiler (u_number) {
	
	var Teiler = [],
		counter= 0;
	
	for (var i=0; i< u_number-1; i++)
		if (u_number%i === 0) {
			Teiler[counter] = i;
			counter++;
		}
	return Teiler;
	
}

//Teiler summieren
function Summe (array) {
	var counter = 0;
	for (var i=0; i<array.length; i++) counter +=array[i];
	return counter;
	
}
                

Lösung von: -- -- ()

#include <Windows.h>
#include <iostream>

using namespace std;


int main() {

	for (int x = 1; x <= 10000; x++) {
		int sum = 0;
		for (int i = 1; i < x; i++)
		{
			if (x % i == 0)
			{
				sum = sum + i;
			}
		}

		if (sum == x)
		{
			cout << x << " ist eine vollkommene Zahl  " << "[" << sum << "]" << endl;
			Sleep(1000);
		}
		if (sum > x)
		{
			cout << x << " ist eine abundanten Zahl   " << "[" << sum << "]" << endl;

		}
		if (sum < x)
		{
			cout << x << " ist eine defiziente Zahl   " << "[" << sum << "]" << endl;

		}
	}

	cin.get();	
	return 0;	
}
                

Lösung von: johan van (Dönerschule)

Aktionen

Bewertung

Durchschnittliche Bewertung:

Eigene Bewertung:
Bitte zuerst anmelden

Meta

Zeit: 0.25
Schwierigkeit: Leicht
Webcode: 33hu-hrjs
Autor: ()

Download PDF

Download ZIP

Zu Aufgabenblatt hinzufügen