Mathe Frage! (Für mich eher ein Rätsel)

Rainer Raisch schrieb:

Die Frage ist dabei doch Wie sag ichs meinem WA

Wolframalpha ist schlecht darin, deswegen sage ich auch suchen und nicht suchen lassen. Wenn du das Muster hinter den Zahlen gefunden hast und es auf Deutsch beschreiben kannst kann ich es dir zumindest in Mathematica Syntax übersetzen, aber wenn man das Muster nicht kennt ist eine KI womöglich besser als ein Mathematikprogramm. Wenn das Programm die Funktion anhand der Inputs finden soll ohne dass man selber einen Clue hat wo man ansetzen soll kann man es mit FindSequenceFunction  oder Predict  probieren, wenn du "details and options" aufpoppst siehst du die Options und weiter unten bei "see also" hast du noch ein paar andere Methoden aufgelistet, aber Garantie gibt es da keine. Du hast anscheinend den Befehl FindGeneratingFunction gewählt, der liefert dann solche Serien wie deine aber damit kriegt man keine Integers so wie sie hier gefragt sind.

Yukterez schrieb:

Die andere Funktion wo gecheckt wird ob die Zahl gerade oder ungerade ist mag auf manchen Systemen vielleicht langsamer sein, aber sie ist näher am menschlichen Denken

Ja stimmt. Und dann mit n&1 testen ob von n das kleinste Bit 0 (n gerade) oder 1 (n ungerade) ist, liegt näher am mathematischen oder maschinellen Denken. So muss das, wenn man die Borg verstehen will. ;–)

Yukterez schrieb:

kann man es mit FindSequenceFunction  oder Predict  probieren

Das kannte ich nicht.
Ich habe fit benützt

Wie kommt die Berechnung der zweiten Spalte zustande?

function calculateF(n) {
   return +(n>3)&&n-3-(n&1); // Steini
}

Wie kommen die Zahlenwerte der dritten Spalte zustande?

Es werden alle Kombinationen gesucht, die aus kleineren Werten als n bestehen und die zusammen addiert n ergeben, ohne dass die 1 benutzt werden darf. Wenn die 1 bei den Kombinationen nicht genutzt werden darf, ist n−1 automatisch auch ausgeschlossen. Die erlaubten Zahlen setze ich folgendermaßen um:

function generateNumbersList(n) {
  let numbers = Array;
  for (let i = 2; i < n-1; i++) {
    numbers.push(i);
  }
  return numbers;
}

Damit erhalte ich ein Array mit Werten von 2 bis n−2. Dieses Array und n werden an eine Funktion übergeben, die alle möglichen Kombinationen aus diesen erlaubten Zahlen berechnet, die n ergeben. Diese Berechnung ist sehr rechenintensiv. Ich habe sie bereits dadurch beschleunigt, dass ich die Arrays mit den Kombinationen nicht mehr speichere und stattdessen nur die Anzahl der Einträge zähle. Aber ab etwa 85 bei einem Bereich von 1 bis 100 dauern die Berechnungen schon Sekunden. Ich habe einmal 100 bis 101 ausprobiert, aber da macht mein alter Rechner schon nicht mehr mit.

function findCombinationsCount(target, numbers) {
let count = 0;

function backtrack(remaining, combination, start) {
  if (remaining === 0 && combination.length > 1) {
     count++;
     return;
   }
   for (let i = start; i < numbers.length; i++) {
     if (numbers > remaining) {
        continue;
      }
      combination.push(numbers);
      backtrack(remaining - numbers, combination, i);
      combination.pop();
    }
  }

  backtrack(target,  Array, 0);
  return count;
}

Aufgerufen wird es in einer normalen For-Schleife.

 for (let n = 1; n <= 50; n++) {
   const fn= calculateF(n);

   const numbers = generateNumbersList(n);
   const mVCount = findCombinationsCount(n, numbers);

   console.log(n, fn, mVCount);
}

FabsOtX schrieb:

aber da macht mein alter Rechner schon nicht mehr mit

 

Das könnte ein Speicherproblem sein.
Du sollltest die Rechenvariablen in der Schleife nicht lokal  definieren, sondern global, damit sie nicht jedesmal gelöscht und neu angelegt werden müssen. (garbage)

Übrigens:
The keyword const is a little misleading. It does not define a constant value. It defines a constant reference to a value.

Es ist zu empfehlen, const immer dann zu verwenden, wenn die Bindung von Bezeichner und Wert einer Variablen über deren Lebensdauer hinweg konstant bleiben soll, es also nicht beabsichtigt ist, der Variable zu einem späteren Zeitpunkt einen anderen Wert zuzuweisen.Solche Variablen sind nicht sinnlos. Zum einen können Sie Berechnungsergebnisse speichern, die im darauffolgenden Programmteil mehrfach benötigt werden

Klingt für mich so, als ob diese "Konstanten" nach der Schleife gar nicht gelöscht werden, sondern nur immer wieder eine neue angelegt wird.

Probiers mal so:
var fn, numbers, mVCount, nmax=50;
for (var n = 1; n <= nmax; n++) {
   fn= calculateF(n);

   numbers = generateNumbersList(n);
   mVCount = findCombinationsCount(n, numbers);

   console.log(n, fn, mVCount);

Das eigentliche Ergebnis sie ht ja so aus:

 1 0 0 -
2 0 0 -
3 0 0 -
4 1 1 [2, 2]
5 1 1 [2, 3]
6 3 3 [2, 2, 2], [2, 4], [3, 3]
7 3 3 [2, 2, 3], [2, 5], [3, 4]
8 5 6 [2, 2, 2, 2], [2, 2, 4], [2, 3, 3], [2, 6], [3, 5], [4, 4]
9 5 7 [2, 2, 2, 3], [2, 2, 5], [2, 3, 4], [2, 7], [3, 3, 3], [3, 6], [4, 5]
10 7 11 [2, 2, 2, 2, 2], [2, 2, 2, 4], [2, 2, 3, 3], [2, 2, 6], [2, 3, 5], [2, 4, 4], [2, 8], [3, 3, 4], [3, 7], [4, 6], [5, 5]

.....

20 17 136 [2, 2, 2, 2, 2, 2, 2, 2, 2, 2], [2, 2, 2, 2, 2, 2, 2, 2, 4], [2, 2, 2, 2, 2, 2, 2, 3, 3], [2, 2, 2, 2, 2, 2, 2, 6], [2, 2, 2, 2, 2, 2, 3, 5], [2, 2, 2, 2, 2, 2, 4, 4], [2, 2, 2, 2, 2, 2, 8], [2, 2, 2, 2, 2, 3, 3, 4], [2, 2, 2, 2, 2, 3, 7], [2, 2, 2, 2, 2, 4, 6], [2, 2, 2, 2, 2, 5, 5], [2, 2, 2, 2, 2, 10], [2, 2, 2, 2, 3, 3, 3, 3], [2, 2, 2, 2, 3, 3, 6], [2, 2, 2, 2, 3, 4, 5], [2, 2, 2, 2, 3, 9], [2, 2, 2, 2, 4, 4, 4], [2, 2, 2, 2, 4, 8], [2, 2, 2, 2, 5, 7], [2, 2, 2, 2, 6, 6], [2, 2, 2, 2, 12], [2, 2, 2, 3, 3, 3, 5], [2, 2, 2, 3, 3, 4, 4], [2, 2, 2, 3, 3, 8], [2, 2, 2, 3, 4, 7], [2, 2, 2, 3, 5, 6], [2, 2, 2, 3, 11], [2, 2, 2, 4, 4, 6], [2, 2, 2, 4, 5, 5], [2, 2, 2, 4, 10], [2, 2, 2, 5, 9], [2, 2, 2, 6, 8], [2, 2, 2, 7, 7], [2, 2, 2, 14], [2, 2, 3, 3, 3, 3, 4], [2, 2, 3, 3, 3, 7], [2, 2, 3, 3, 4, 6], [2, 2, 3, 3, 5, 5], [2, 2, 3, 3, 10], [2, 2, 3, 4, 4, 5], [2, 2, 3, 4, 9], [2, 2, 3, 5, 8], [2, 2, 3, 6, 7], [2, 2, 3, 13], [2, 2, 4, 4, 4, 4], [2, 2, 4, 4, 8], [2, 2, 4, 5, 7], [2, 2, 4, 6, 6], [2, 2, 4, 12], [2, 2, 5, 5, 6], [2, 2, 5, 11], [2, 2, 6, 10], [2, 2, 7, 9], [2, 2, 8, 8], [2, 2, 16], [2, 3, 3, 3, 3, 3, 3], [2, 3, 3, 3, 3, 6], [2, 3, 3, 3, 4, 5], [2, 3, 3, 3, 9], [2, 3, 3, 4, 4, 4], [2, 3, 3, 4, 8], [2, 3, 3, 5, 7], [2, 3, 3, 6, 6], [2, 3, 3, 12], [2, 3, 4, 4, 7], [2, 3, 4, 5, 6], [2, 3, 4, 11], [2, 3, 5, 5, 5], [2, 3, 5, 10], [2, 3, 6, 9], [2, 3, 7, 8], [2, 3, 15], [2, 4, 4, 4, 6], [2, 4, 4, 5, 5], [2, 4, 4, 10], [2, 4, 5, 9], [2, 4, 6, 8], [2, 4, 7, 7], [2, 4, 14], [2, 5, 5, 8], [2, 5, 6, 7], [2, 5, 13], [2, 6, 6, 6], [2, 6, 12], [2, 7, 11], [2, 8, 10], [2, 9, 9], [2, 18], [3, 3, 3, 3, 3, 5], [3, 3, 3, 3, 4, 4], [3, 3, 3, 3, 8], [3, 3, 3, 4, 7], [3, 3, 3, 5, 6], [3, 3, 3, 11], [3, 3, 4, 4, 6], [3, 3, 4, 5, 5], [3, 3, 4, 10], [3, 3, 5, 9], [3, 3, 6, 8], [3, 3, 7, 7], [3, 3, 14], [3, 4, 4, 4, 5], [3, 4, 4, 9], [3, 4, 5, 8], [3, 4, 6, 7], [3, 4, 13], [3, 5, 5, 7], [3, 5, 6, 6], [3, 5, 12], [3, 6, 11], [3, 7, 10], [3, 8, 9], [3, 17], [4, 4, 4, 4, 4], [4, 4, 4, 8], [4, 4, 5, 7], [4, 4, 6, 6], [4, 4, 12], [4, 5, 5, 6], [4, 5, 11], [4, 6, 10], [4, 7, 9], [4, 8, 8], [4, 16], [5, 5, 5, 5], [5, 5, 10], [5, 6, 9], [5, 7, 8], [5, 15], [6, 6, 8], [6, 7, 7], [6, 14], [7, 13], [8, 12], [9, 11], [10, 10]

20 17 136

Ich brauche für weitere Rechnungen die 136 aus der Zeile für n = 20 diese erhalte ich in dem ich diese ganzen arrays zähle. ich brauche eine möglichkeit diese zu zählen/ zu bestimmen ohne sie erstellen zu müssen.

Die letzte möglichkeit die ich sehe ist für die rechnungen, wenn ich die Kombinationen Arrays nichts brauche, eine JSON Werte Tabelle zu erstellen.

Eine Tabelle 1-30 mit allen Arrays ist bereits 16 DIN A4 Seiten lang.

@Fabs

generateNumbersList(n) ist schon mal unnötig. Du kennst ja die Zahlen, nämlich alle von 2 bis n-1. Wozu diese extra in Arrays schreiben? Jedes dieser Arrays enthält nur das vom Vorgänger mit einer Zahl mehr. Es ist, wie wenn man jede Zahl n als Liste von n Einsen speichert. Sorry, aber das ist verrückt. Kein Wunder, dass dir da der Speicher ausgeht.

FabsOtX schrieb:

alle möglichen Kombinationen aus diesen erlaubten Zahlen

Diese rekursive Funktion durchschaue ich nicht ganz. Rekursionen sind generell speicherintensiv. Das würde ich in kleinere Funktionen aufteilen und evtl. über Primfaktorzerlegung lösen oder besser mit Methoden der Kombinatorik (Permutationen).

Mit backtrack(target, Array, 0); verwendest du anscheined "Array" wie eine Variable. Array ist aber ein vordefiniertes Objekt, ein sog. Singelton, dessen Eigenschaften von allen Arrays geerbt werden.
Ein neues Array erzeugt man mit

FabsOtX schrieb:

ich brauche eine möglichkeit diese zu zählen/ zu bestimmen ohne sie erstellen zu müssen.

Dann erzeuge sie halt nicht und zähle bloß eine Variable hoch.
 

Steinzeit-Astronom post=4795 userid=21019Mit backtrack(target, Array, 0); verwendest du anscheined "Array" wie eine Variable. Array ist aber ein vordefiniertes Objekt, ein sog. Singelton, dessen Eigenschaften von allen Arrays geerbt werden.

Ob das verboten ist?

In der Funktion
function generateNumbersList(n) {
  let numbers = Array;
ist Array allerdings nicht definiert, bzw ist es eine Funktion, die somit der Variablen numbers zugewiesen wird.

>alert(Array)
<function Array() {
<    [native code]
<}
>n=Array;alert(n)
<function Array() {
<    [native code]
<}
Was dann wohl numbers.push(i); bewirkt?

Rainer Raisch schrieb:

In der Funktion
function generateNumbersList(n) {
  let numbers = Array;
ist Array allerdings nicht definiert.

Doch, es ist wie gesagt ein vordefiniertes Objekt; die Mutter aller Arrays. Allerdings wundert's mich, dass der Code so überhaupt läuft. So eine falsche Verwendung von "Array" habe ich noch nie gesehen^^.
In JS sind Namen mit Großbuchstaben vorne per Konvention immer Objekte, von denen man dann mit dem Schlüsselwort new Abkömmlinge erzeugen kann, die die Eigenschaften vom Eltern-Objekt erben. JS ist eine ja eine objektorientierte Sprache.

Nachtrag: Ja stimmt, Array ist eigtl. eine Funktion, wie alle Objekte. Sie werden mit funtion(){.... return this;}; definiert. Allerdings muss man Array ja nicht als Argument an eine Funktion übergeben. Das ist Ding ist global bekannt.
 

Steinzeit-Astronom schrieb:

per Konvention immer Objekte

Das ist aber nur für Schlüsselwörter, (wie Array) bindend, ansonsten eben nur Konvention.

Steinzeit-Astronom schrieb:

Allerdings wundert's mich, dass der Code so überhaupt läuft.

Das geht tatsächlich:

>Array.n=7;n=Array;alert(n.n)
<7
>alert(Array)
<function Array() {
<    [native code]
<}
>alert(n)
<function Array() {
<    [native code]
<}
 

Steinzeit-Astronom schrieb:

Allerdings muss man Array ja nicht übergeben. Das ist DIng ist global bekannt

Fabs "wollte" vermutlich den Typus des Parameters vordefinieren.
function fn(Array A,String s){}

Rainer Raisch schrieb:

Steinzeit-Astronom schrieb:

per Konvention immer Objekte

Das ist aber nur für Schlüsselwörter, (wie Array) bindend, ansonsten eben nur Konvention.

Ja sicher. Eigene Objekte kann darf man nennen wie man will, aber man sollte sich besser an die Konvention halten, damit man nicht aus Versehen z.B. das Array-Objekt überscheibt mit etwas ganz anderem.

Rainer Raisch schrieb:

Steinzeit-Astronom schrieb:

Allerdings wundert's mich, dass der Code so überhaupt läuft.

Das geht tatsächlich:

>Array.n=7;n=Array;alert(n.n)
<7
>allert(Array)
<function Array() {
<    [native code]
<}
>allert(n)
<function Array() {
<    [native code]
<}
<undefined

Es heißt alert mit einem l, nicht mit zwei.

Man kann dem Array-Objekt auch zusätzliche Eigenschaften geben, die dann automatisch auch jedes andere Array hat. Z.B. die Eigenschaft maxN mit Array.prototype.maxN = 100;.

Steinzeit-Astronom schrieb:

Es heißt alert mit einem l, nicht mit zwei.
 

die Verdopplung habe ich jetzt vom array übernommen

und die Ausgabe undefined hatte gar nichts damit zu tun... das war alert(alert(n))

Rainer Raisch schrieb:

Steinzeit-Astronom schrieb:

Allerdings muss man Array ja nicht übergeben. Das ist DIng ist global bekannt

Fabs "wollte" vermutlich den Typus des Parameters vordefinieren.

function fn(Array A,String s){}

Mag sein. Das ist jedenfalls ziemlich verwirrend. Wie gesagt noch nie gesehen^^.
 

Steinzeit-Astronom schrieb:

Man kann dem Array-Objekt auch zusätzliche Eigenschaften geben, die dann automatisch auch jedes andere Array hat. Z.B. die Eigenschaft maxN mit Array.prototype.maxN = 100;.

>Array.n=7;alert([ ].n)
<undefined
>Array.prototype.n=7;alert([ ].n)
<7

und dann wieder löschen:
Array.prototype.n=undefined

Rainer Raisch schrieb:

Steinzeit-Astronom schrieb:

Man kann dem Array-Objekt auch zusätzliche Eigenschaften geben, die dann automatisch auch jedes andere Array hat. Z.B. die Eigenschaft maxN mit Array.prototype.maxN = 100;.

>Array.n=7;alert([ ].n)
<undefined
>Array.prototype.n=7;alert([ ].n)
<7

und dann wieder löschen:
Array.prototype.n=undefined

Ja genau. Zum Löschen gibt's das Schlüsselwort delete:
delete Array.prototype.n;
Es macht aber auch nicht anderes als auf undefined zu setzen.

Ich meine z.B. so:

Diesen Code habe habe ich zwar nicht getestet, aber sollte stimmen.

Jedes Array bekommt sozusagen instantan die neue Eigenschaft maxLength, auch wenn es bereits existiert. Das ist cool, um nicht zu sagen genial. Sowas gibt's in anderen objektorientierten Sprachen nicht.

@Fabs:

Es hat mich jetzt doch noch interessiert, wie man es besser machen kann. Dein const und die vielen Arrays kommen wahrscheinlich von ChatGPT, stimmt's? Naja, wenn man richtig fragt, bekommt man sogar eine brauchbare Antwort:



Ich fragte nach der Anzahl versch. Summen mit ganzzahligen Summanden >1 und <10 für die Zahl n=10.
Am Ende behauptet dann ChatGPT: "Die 8 Möglichkeiten sind ...." und listet sie auf. Da fehlen aber welche.

Der Witz ist: Es sind 11 Möglichkeiten, und der Code liefert tatsächlich auch das Resultat 11, also korrekt. :–)
Für n=20 liefert er dann 136, also auch korrekt (wenn deine Tabelle stimmt).
Und das ganz ohne diesen Wald von Arrays. :–P

Meine Frage an ChatGPT war:
"Wie viele Möglichkeiten gibt es, die Zahl n=10 aus ganzzahligen Summanden größer als 1 und kleiner als n zu bilden? Gibt es dafür eine Formel oder einen Algorithmus in ECMAScript?"
ChatGPT sprach u.a.: "Eine direkte mathematische Formel gibt es nicht, aber wir können das Problem rekursiv lösen."

Außer dem Code wird dann noch folgende Erklärung geliefert:

"Erklärung des Algorithmus:
countPartitions(n, minSummand, maxSummand): Diese Funktion zählt die Möglichkeiten, n als Summe von Zahlen zu schreiben, wobei jeder Summand zwischen minSummand und maxSummand liegt.

Wenn n genau 0 ist, haben wir eine gültige Summenkombination gefunden (Basisfall).
Wenn n negativ wird oder keine gültigen Summanden übrig sind (maxSummand < minSummand), ist dies keine gültige Summenkombination.
Der rekursive Schritt besteht darin, entweder den aktuellen maxSummand zu verwenden und den Rest der Summe zu bilden, oder maxSummand zu reduzieren und zu prüfen, welche Kombinationen ohne ihn möglich sind.
countPartitionsForN(n): Diese Funktion startet den Rekursionsprozess mit der Zahl n und verwendet 2 als den kleinsten möglichen Summanden und n-1 als den größten."

Das Ding ist schlauer als ich *grummel*. Das hätte ich nicht in 3 Sekunden hinbekommen, nicht mal die Überlegung dazu, von der Umsetzung und Beschreibung gar nicht zu reden.
.

Steinzeit-Astronom schrieb:

Rainer Raisch schrieb:

Steinzeit-Astronom schrieb:

Allerdings muss man Array ja nicht übergeben. Das ist DIng ist global bekannt

Fabs "wollte" vermutlich den Typus des Parameters vordefinieren.

function fn(Array A,String s){}

Mag sein. Das ist jedenfalls ziemlich verwirrend. Wie gesagt noch nie gesehen^^.

eigentlich hat mir die forumssoftwear immer wieder die [ ] gekillt und deshalb habe ich da "array" rein geschrieben. Hätte ich in eine legende angeben müssen.

Steinzeit-Astronom schrieb:

@Fabs:
Dein const und die vielen Arrays kommen wahrscheinlich von ChatGPT, stimmt's? ....

nein ist auf meinem mist gewachsen.

Die Zahlenfolgen in den Arrays sind ja das eigentliche Ergebnis was ich für die 3D animation brauche.

Die berechnug brauche ich um die größen Zahlen die nicht Animiert werden können zu berechnen und zu positionieren ohne sie darzustellen.

FabsOtX schrieb:

eigentlich hat mir die forumssoftwear immer wieder die [ ] gekillt

Dafür gibt es den Code Befehl, der steht zwar nicht im Menü aber man kann ihn trotzdem so verwenden wie in jedem anderen Forum wo er im Menü steht:


Beim Editieren kann eine leere Klammer aber auch wieder verschwinden, da muss man also aufpassen.[/code]

FabsOtX schrieb:

Hätte ich in eine legende angeben müssen.

Schlampig wie immer^^.

FabsOtX schrieb:

Die Zahlenfolgen in den Arrays sind ja das eigentliche Ergebnis was ich für die 3D animation brauche.

Also doch... dann würde ich trotzdem den einfachen Code ohne Arrays als Ausgangpunkt nehmen und bei jedem Rekursionsschritt den relevanten Summanden rausschreiben in ein globaleres Array. Für die größeren n dann eben nicht mehr, wenn dafür kein Array mehr gebraucht wird. Dann geht die Berechnung natürlich schneller.

Übrigens: Alle Summanden, die für eine Zahl n schon ermittelt sind, kommen unverändert auch in den Arrays für größere n vor. Also sind die meisten Summanden einfach nur redundant. Das kann man ausnützen, indem man für n+1 nicht alle neu rausschreibt, sondern nur die, die wirklich neu dazu kommen...