Pezision

[boxer123]

Guten Tag, ich habe schon sehr viel erreicht, ich komm nun mit einem Programm nicht mehr vorwärts.

Also das Programm soll folgendes machen, nehmen wir mal eine Zahl z.b 333, diese Zahl soll das Programm erstmals zerhacken ,dann hätten wir folgende Ziffer.

3 3 3 diese 3 Ziffern soll er Multiplitzieren mit folgenden Prinzip : 3 * 3 * 3, dass wäre 27 und jetzt soll das Programm die 27 zerhacken und nun hätten wir dann 2*7 ist 14 und das soll er solange machen bis eine ein stellige Zahl rauskommt und er muss naklar die Schritte aufzählen z.b hier warens 3 und das Programm soll eine Zahl finden mit 9 Schritten.

Wenn was Unklar ist schreibt .

[DeddyH]

Was mir unklar ist: was ist Dir unklar?

[Medium]

Deine Frage? (Nicht, dass es in deinen mindestens letzten zwei Threads nicht auch schon um das Zerlegen von Zahlen in Ziffern ging... :roll:)
Was hat der Titel, abgesehen davon, dass es das Wort nicht gibt, eigentlich mit dem Thema zu tun?

[mkinzler]

Und was ist Pezision?

[Daniel]

Zitat:

Zitat von boxer123 (Beitrag 1139756)

Wenn was Unklar ist schreibt .

Mir ist unklar, an welcher Stelle Du jetzt festhängst, bzw. worin genau Dein Problem besteht. Wie weit bist Du denn mit der Problemlösung?

[boxer123]

Das mit dem Zerlegen ist nicht das Problem, das Problem ist, dass er es solange machen soll bis er eine Zahl mit 9 Schritten gefunden hat.

[Luckie]

Der wievielte Thread zu dem Thema ist das jetzt? Der dritte? Und was bedeutet Pezision? Und was hat der mir unbekannte begriff mit dem Problem zu tun? Und wann merkst du eigentlich, dass es im Grunde genommen immer wieder das gleiche Problem ist, was du uns hier präsentierst?

[boxer123]

Pezision sind die Schritte die man raushat

Hier mein Ansatz:

Delphi-Quellcode:

procedure TForm1.Button1Click(Sender: TObject);
var ziffer:array[1..10] of integer;
stellen,i,j,divisor,faktor,summe,p,zahl:longint;
    begin
        zahl := strtoint (edit1.text) ;
        stellen := length (edit1.text) ;
    repeat
        zahl := zahl + 1 ;
        divisor := 1 ; faktor:= 10 ; summe:=0 ;
    for i:= 1 to stellen do
  begin
    ziffer[i]:= (zahl mod divisor) div (divisor div 10) ;
    for j:= 2 to stellen do
    summe:= ziffer[i]*ziffer[j];
  end;
    until zahl=9;
edit2.text:= inttostr(summe);
end;

end.

edit;

[Luckie]

Zitat:

Zitat von boxer123 (Beitrag 1139764)

Pezision sind die Schritte die man raushat

Das Wort kennt weder mein Duden noch Google. Oder meinst du Präzision?

[DeddyH]

Wenn der Divisor 1 ist, was soll denn dann bei

Zitat:

Delphi-Quellcode:

(zahl mod divisor) div (divisor div 10) ;

herauskommen?

[boxer123]

Zitat:

Zitat von DeddyH (Beitrag 1139767)

Wenn der Divisor 1 ist, was soll denn dann bei

Zitat:

Delphi-Quellcode:

(zahl mod divisor) div (divisor div 10) ;

herauskommen?

Bei welcher Zahl? Meinst du vielleicht wenn der Benutzer etwas eingibt, mit diesem Rhytmus teilt er die Zahl.


Ja glaub schon Präzision! Habe gehört, dass es so heißen soll.

[Medium]

Wenn, dann eher Progression, oder, wenn es einen seltsamen mathematischen Zusammenhang geben sollte, auch Präzession. Dein Rythmus heisst mit Vornamen übrigens Algo, und hat ein i statt eines y ;)
(Es ist i.A. wenig sinnvoll, mit Wörtern zu hantieren, deren Bedeutung einem nicht klar ist. Gerade bei einem "Fachpublikum" stiftet man so gewaltig mehr Verwirrung, als wenn man das Gewünschte alternativ umschreibt.)

[Bummi]

ich würde vorschlagen wir kürzen das Ganze diesmal ab

Delphi-Quellcode:

Function QMult(const s:String):String;
var
 a:Array of Integer;
 i:Integer;
 IRes:Integer;
begin
  SetLength(a,Length(s));
  for I := 1 to Length(s) do a[i-1] := Ord(s[i]) - 48;
  IRes := a[0];
  for I := Low(a) + 1 to High(a) do IRes := IRes * a[i];
  Result := IntToStr(IRes);
end;

procedure TForm2.Button1Click(Sender: TObject);
var
 start:Integer;
 SSTart:String;
 cnt:Integer;
begin
   If TryStrToInt(Edit1.Text, Start) then
      begin
         cnt := 0;
         Dec(Start);
         while cnt < 9 do
            begin
               inc(Start);
               SSTart := IntToStr(start);
               cnt := 0;
               while length(SSTart) > 1 do
                  begin
                  inc(cnt);
                  SStart := QMult(SStart);
                  end;
            end;
         Showmessage(IntToStr(Start));
      end;
end;

[DeddyH]

Zitat:

Zitat von boxer123 (Beitrag 1139769)

Zitat:

Zitat von DeddyH (Beitrag 1139767)

Wenn der Divisor 1 ist, was soll denn dann bei

Zitat:

Delphi-Quellcode:

(zahl mod divisor) div (divisor div 10) ;

herauskommen?

Bei welcher Zahl? Meinst du vielleicht wenn der Benutzer etwas eingibt, mit diesem Rhytmus teilt er die Zahl.


Ja glaub schon Präzision! Habe gehört, dass es so heißen soll.

Bei welcher Zahl ist vollkommen wurscht. 1 div 10 ergibt 0, zahl mod 1 ergibt zahl. Im Ergebnis bedeutet das, dass Du Zahl durch 0 teilst.

[vagtler]

Warum findet sich eigentlich *immer* jemand, der dann doch einfach den Code hinschreibt und damit weder dem Thread-Ersteller noch der Gemeinschaft einen nachhaltigen Gefallen tut? :?

[boxer123]

Kann man nicht irgendwie mein Ansatz bissen umformen damit er auch das richtige tut?

[DeddyH]

Das wäre dann Deine Aufgabe.

[boxer123]

Aber ohne Hilfe schaffe ich es nicht

[DeddyH]

Wie man eine Zahl in Ziffern zerlegt haben wir ja nun schon mehrfach durchgekaut. Fang doch erstmal damit an.

[Bummi]

@vagtler

wenn Du Dir die Lernerfolge aus den Vorgängerthreads anschaust ...

[Medium]

Zitat:

Zitat von Bummi (Beitrag 1139792)

@vagtler

wenn Du Dir die Lernerfolge aus den Vorgängerthreads anschaust ...

... sollte klar werden, dass wir auf die Weise noch Länger "Freude" an seiner netten Art haben werden, und keinem, auch ihm nicht geholfen ist. Genau.

[boxer123]

Delphi-Quellcode:

var ziffer:array[1..10] of integer;
stellen,zahl:longint;
    begin
        zahl := strtoint (edit1.text) ;
    repeat
        zahl := zahl + 1 ;
        ziffer[1]:= (zahl mod 10) div 1;
        ziffer[2]:= (zahl mod 100) div 10;
        ziffer[3]:= (zahl mod 1000) div 100;
        ziffer[4]:= (zahl mod 10000) div 1000;
        ziffer[5]:= (zahl mod 100000) div 10000;
        ziffer[6]:= (zahl mod 1000000) div 100000;
        ziffer[7]:= (zahl mod 10000000) div 1000000;
        ziffer[8]:= (zahl mod 100000000) div 100000000;
        ziffer[9]:= (zahl mod 1000000000) div 100000000;
        ziffer[10]:= (zahl mod 10000000000) div 10000000000;
end;

so?

[DeddyH]

Einfacher geht das aber direkt über den String. Ich will mal nicht so sein:

Delphi-Quellcode:

var
  Ziffern: array of Byte; //oder auch integer, Byte reicht aber
  i, dummy, Laenge: integer;
begin
  if TryStrToInt(Edit1.Text, dummy) then
    begin
      Laenge := Length(Edit1.Text);
      SetLength(Ziffern, Laenge);
      for i := 1 to Laenge do
        Ziffern[i - 1] := Edit1.Text[i];
    end;

[boxer123]

gehts auch mit copy ? Was ist der nächste schritt Multiplitzieren oder?

[mkinzler]

Zitat:

Zitat von vagtler (Beitrag 1139781)

Warum findet sich eigentlich *immer* jemand, der dann doch einfach den Code hinschreibt und damit weder dem Thread-Ersteller noch der Gemeinschaft einen nachhaltigen Gefallen tut? :?

Leider war das nur zu 99,x 5 die richtige Lösung :stupid:

[DeddyH]

Zitat:

Zitat von boxer123 (Beitrag 1139799)

gehts auch mit copy ?

Klar geht das auch mit Copy, dauert nur länger bei gleichem Ergebnis.

Zitat:

Zitat von boxer123 (Beitrag 1139799)

Was ist der nächste schritt Multiplitzieren oder?

Sieht ganz danach aus.

[boxer123]

Ich versuche gerade diese Befehle zu verstehen, weil wir hatten sie noch nicht in der Schule.
Können wir das lieber nicht mit Copy machen . Ich weiß es ist schwer mit mir ,weil ich will es auch verstehen.

[DeddyH]

Dann halt mit Copy und ohne den Fehler, den ich vorhin gemacht habe.

Delphi-Quellcode:

var
  Ziffern: array of integer;
  i, dummy, Laenge: integer;
begin
  if TryStrToInt(Edit1.Text, dummy) then
    begin
      Laenge := Length(Edit1.Text);
      SetLength(Ziffern, Laenge);
      for i := 1 to Laenge do
        Ziffern[i - 1] := StringToInt(Copy(Edit1.Text, i, 1));
    end;

So sollte es funktionieren.

[boxer123]

JEtzt muss man Multiplitzieren und das tut man so;

Delphi-Quellcode:

for i:= 1 to .. do
for j:= 2 to .. do
ergebnis:=ziffer[i] * ziffer[j]

oder?

[DeddyH]

Eine Schleife genügt doch bei einem eindimensionalen Array.

[boxer123]

Genau das ist das schwerste.
Wie soll ich es, dann schreiben?

[DeddyH]

Nehmen wir nochmal Dein Beispiel aus dem Ausgangspost. Wenn Du die Zahl 333 zerlegt hast, sollte Dein Array nun so aussehen:

Code:

Index | 0 | 1 | 2
=================
Wert   | 3 | 3 | 3

Nun gehst Du von Index zu Index durch und multiplizierst Dein Ergebnis mit der Zahl, die am aktuellen Index als Wert eingetragen ist. Vergiss aber nicht, dem Ergebnis vorher einen Ausgangswert (1 bietet sich an) zuzuweisen.

[boxer123]

Ich habe gerade starke Kopfschmerzen, oder ich habe gerade einen "Blackout". Könntest du mir nicht ein Tipp geben.

[TiGü]

Boah, /kick /ban /ignore!
Klassischer Forentroll!

Solange kann man im IT-Unterricht gewiss nicht an einer Aufgabe hängen!
Wenn du Fragen hast, dann frage deinen IT-Lehrer, verdammt nochmal!!! :evil:

Befehle die man nicht kennt kann man hier oben links eingeben und nachschlagen:
http://docwiki.embarcadero.com/RADStudio/de/Hauptseite

[DeddyH]

Zitat:

Zitat von boxer123 (Beitrag 1139812)

Könntest du mir nicht ein Tipp geben.

Einfache For-Schleife, das sollte ja wohl möglich sein.

[boxer123]

Delphi-Quellcode:

ergebnis:=1;
for i:= 1 to 3 do
ergebnis:=ziffer[i]*ziffer[i+1];

[DeddyH]

Nein! Erstens gehen dynamische Arrays immer von 0 bis Count-1, und zweitens sollst Du das Ergebnis multiplizieren.

[Daniel]

So, ich denke, dass boxer123 die erhaltenen Infos erst mal sacken lassen sollte - dann geht ihm garantiert ein Licht auf. Ich mache das Thema zu späterer Stunde wieder auf.

Und wer nichts Konstruktives zu diesem Thema beizutragen hat, der möge es sein lassen.

[Bummi]

@mkinzler

Zitat:

Leider war das nur zu 99,x 5 die richtige Lösung

meinst Du wegen Integer statt Int64 bei der Vorgabe 9?

http://de.wikipedia.org/wiki/Querprodukt

[boxer123]

Ihr formuliert ein Programm so Präzise wie nur. Ich bin nicht in Delphi in einer intelektuellen Ebene, deshalb fällt mir es auch so schwer eure Alghorithmen zu verstehen.