Primfaktorzerlegung in C mit Schnittstelle

Nur Deppen benutzen (lokal) static.

Wieso?

Das static soll ich dann quasi in die main-Funktion einbauen?

Bumblebe3 schrieb:

Das static soll ich dann quasi in die main-Funktion einbauen?

Natürlich nicht. primfaktor() muss sich seine inneren Zustände zwischen zwei Aufrufen merken.

Ja du hast recht da war ich wieder zu schnell am Tippen!

Gut ok, das ganze sollte ja dann irgendwie so aussehen:

static int i = 1;

oder?

Das ist schon mal kein schlechter Anfang!

Sind die statischen Variabeln zwingend notwendig? Weil so weit sind wir mit unserem Stoff noch gar nicht

Also ohne statische Variablen wird das imho nix wenn man keine globalen Variablen (die in diesem Falle auch Murks wären) nutzen darf... Ich bin aber auch nur Anfänger, vielleicht irre ich mich?

Bumblebe3 schrieb:

Sind die statischen Variabeln zwingend notwendig? Weil so weit sind wir mit unserem Stoff noch gar nicht

Der Aufgabenstellung nach, leider ja.

Globale Variablen sind ja untersagt.

Wutz

Es ginge auch rekursiv;
aber wie gesagt, einerseits sollst du in der Funktion keine Ausgaben machen, andererseits willst du die Primfaktoren ja auch irgendwie dokumentieren, wo wenn nicht außerhalb?
Dein Lehrer pfuscht.

Lass uns das Ganze trotzdem mal mit statischen Variabeln machen. Ansich steht nicht drin, dass ich sie nicht verwenden darf allerdings haben wir diese auch noch nicht behandelt!

int primfaktor(int n)
{
 static int i;
}

So oder bin ich komplett auf dem Holzweg?

So oder bin ich komplett auf dem Holzweg?

Nö, passt schon daber das fehlt noch so Einiges.
(Es braucht mehr als eine static-Variable. Erst auf Papier den Algorithmus ausdenken und dann erst nach C übersetzen.)

Damit du was zum Probieren hast:

int primfaktor(int n)
{
 static int i= 0;

  i++;

  return i;
}

Und in main:

printf ("%d\n" , primfaktor (1)); 
printf ("%d\n" , primfaktor (1)); 
printf ("%d\n" , primfaktor (1)); 
printf ("%d\n" , primfaktor (1));

rkhb

Schluss mit der Quälerei:

int primfaktor (int zahl)
{
    static int r = -1;
    static int z;

    if (r < 0)                      // Noch kein Zerlegungslauf gestartet
    {
        r = abs(zahl);
        z = zahl;
    }

    if (zahl != z)                  // Neue Zahl übergeben
    {
        r = abs(zahl);
        z = zahl;
    }

    if (abs(zahl) < 2)              // Ungültige Zahlen 0, 1, -1
    {
        return -2;
    }

    for (int i = 2; i <= r; ++i)    // Nächste kleinste Zahl ist gleichzeitig eine Primzahl
    {                               // (die anderen wurden bereits wegdividiert)
        if (r%i == 0)
        {
            r /= i;
            return i;
        }
    }
    r = -1;                         // Zerlegungslauf beendet
    return r;
}

Ich halte das auch nicht für die beste Aufgabe für static.

viele grüße
ralph

EDIT: Man sollte die Aufgabe gründlich lesen

rkhb schrieb:

Schluss mit der Quälerei:

Fertige Lösungen postet ist keine gute Idee, das sollte sich mittlerweile eigentlich herumgesprochen haben...

Und dein Code erfüllt das hier nicht

Sobald sich der Wert der übergebenen Zahl n ändert beginnt die Funktion wieder von vorne mit der Primfaktorzerlegung.

Aufruf nacheinander 42; 42; 15
Ausgabe Soll: 2; 3; 3
Ausgabe Ist: 2; 3; 7

Ach und wenn alle Faktoren ausgegeben wurden soll -1 rauskommen bei jedem weiterem Aufruf, bei dir kommt erst -2 und dann gehts von vorne los. Mit solchem Code hilfst du dem TO noch weniger...

SeppJ

Dann beende ich mal das Trauerspiel:

#include <stdio.h>

#define XD return
#define DX goto
#define D8 if

int primfaktor(int O_O)
{
// eastern    western
   static       int
    o_o,       //:-D
    o_O,        XP,
    O_o;        D8(
  !(o_o//       :^*
   ^O_O))        DX 
 /*(`-')*/       d;
    o_o         =//
    O_O;//     <:-|
    o_O         =-(
   -1-1);       0xD 
   ;O_o         =-+
   -o_o;         D8
   (o_o          <3 
  -(0-1))        XD 
   -o_O;         d:
  /*q-q*/        D8( 
  !(O_o          %-  
   -o_O)         ||(
    o_O)        //=]
   >O_o)         DX 
  /*p-q*/        q;
  ++o_O;         O:
    0x0;         DX
  /*^ ^ */       d;
    0X0;         q:
 /*(-_-;)*/      D8 
   (o_O>       //:)
    O_o)         XD 
    +-1;         D:
    O_o//     *<|:-)  
  /=o_O;         XD
    - -        //:(
    o_O;        0xD;
}

int main()
{
  int pf; 
  while ((pf = primfaktor (12))> 1)
    printf ("%d\n", pf);
  while ((pf = primfaktor(7)) > 1)
    printf ("%d\n", pf);
  printf ("%d\n" , primfaktor (1));
  return 0; 
}

Wenn man das static einfach weg lässt, hat man übrigens eine relativ gute Chance, dass es trotzdem funktioniert. Bei mir werden dann leider einige Faktoren doppelt ausgegeben, sofern ich keine Zwischenausgaben mache, die aber laut Aufgabenstellung nicht erlaubt sind .

edit: Ups, da hatte sich in einer Zeile noch ein Übersetzungsfehler eingeschlichen. Japanisch ist schwer!