Wie teilen Sie die Anzahl in integer-Stücke, die jeweils ein Vielfaches von n?

Hatte eine harte Zeit kommen mit einer prägnanten Titel für diese. Ich bin sicher, es gibt Begriffe für das, was ich erreichen will und es ist kein Zweifel, einen gemeinsamen Algorithmus zu erreichen, was ich bin, nachdem ich einfach nicht über Sie wissen noch.

Muss ich brechen eine Anzahl in n Stücke, die jeweils ein Vielfaches von 50. Die Zahl selbst ein Vielfaches von 50. Hier ist ein Beispiel:
Teilen 5,000 3 und am Ende mit drei zahlen, die jeweils ein Vielfaches von 50:

1,650
1,700
1,650

Ich würde auch gerne die zahlen so verteilt, dass Sie flip hin und her, hier ist ein Beispiel mit mehr zahlen um dies zu verdeutlichen:
Teilen Sie 5.000 von 7 und am Ende mit 7 zahlen, die jeweils ein Vielfaches von 50:

Beachten Sie, dass im obigen Beispiel habe ich bin nicht besorgt, dass die extra-50 ist nicht zentriert in der Serie, ist, dass ich nicht brauchen, um etwas wie dies:

700
700
750 <--- Hinweis: die '50er Jahre' zentriert sind
700
750 <--- Hinweis: die '50er Jahre' zentriert sind
700
700

Ich hoffe, ich habe gefragt, dies ist deutlich genug, dass Sie verstehen, was ich erreichen will.

Update: Hier ist die Funktion die ich verwenden werde.

var number = 5000;
var n = 7;
var multiple = 50;

var values = getIntDividedIntoMultiple(number, n, multiple)

function getIntDividedIntoMultiple(dividend, divisor, multiple)
{
    var values = [];
    while (dividend> 0 && divisor > 0)
    {
        var a = Math.round(dividend/ divisor / multiple) * multiple;
        dividend -= a;
        divisor--;
        values.push(a);
    }

    return values;
}

Von deiner Beispiele, es scheint, dass Sie wollen, um jede einzelne der kleineren zahlen wie möglich entspricht. Ist das richtig? Eine triviale Lösung, zum Beispiel, wäre es 50 für jeden der ersten n-1 zahlen und den Rest für den rest, aber ich nehme an, dass ist nicht das, was du suchst...

InformationsquelleAutor Steve K | 2012-03-19

6
```
var number = 5000;
var n = 7;

var values = [];
while (number > 0 && n > 0) {
    var a = Math.floor(number / n / 50) * 50;
    number -= a;
    n--;
    values.push(a);
}  //700 700 700 700 700 750 750
```
Bearbeiten

Können Sie Alternative Math.floor und Math.ceil das gewünschte Ergebnis zu erhalten:
```
while (number > 0 && n > 0) {
    if (a%2 == 0)
        a = Math.floor(number / n / 50) * 50;
    else
        a = Math.ceil(number / n / 50) * 50;
    number -= a;
    n--;
    values.push(a);
}  //700 750 700 750 700 700 700
```
- Schöne Beispiele, wie würden Sie es verlängern, schalten Sie die up-Runde und Runde nach unten, so dass Sie haben, 700, 750, 700, 750, usw.. ?
- Ja, das funktioniert gut. Ich war nur ein Schritt durch den code im debugger, und beobachten, wie es funktionierte und ich bekomme es.
- Schön und sauber, vorausgesetzt es ist ein JS-Beispiel, das war nicht nötig, aber geschätzt wird.
- Ich war nicht zu sagen als eine negative, war nur kommentieren, dass der zusätzliche Aufwand für eine JS-Beispiel wurde geschätzt, da Sie zuerst lieferte ein c Beispiel.
InformationsquelleAutor sch
2

Lassen Ihre startnummer, k - Anzahl der Teile, die Sie teilen möchten.

Nehme an, dass b = a/n.

Jetzt wollen Sie teilen b in k schließen integer-Teile.
- Nehmen k zahlen, jeweils in Höhe der b/k (integer-division).
- Fügen Sie 1, um den ersten b%k zahlen.
- Multiplizieren Sie jede Zahl durch n.
Beispiel:
a = 5000, n = 50, k = 7.

b = 100

Ab Serie {14, 14, 14, 14, 14, 14, 14}

Um 1 ersten 2 Ganzzahlen {15, 15, 14, 14, 14, 14, 14}.

Multiplizieren von 50 {750, 750, 700, 700, 700, 700, 700}.
- Zuerst ist es "wooosh!" über meinem Kopf w/ die Terminologie, sondern nach dem spielen mit dem code sehe ich, was Sie jetzt sagen 😉
InformationsquelleAutor kilotaras

//i - an integer multiple of k
//k - an integer
//n - a valid array length
//returns an array of length n containing integer multiples of k
//such that the elements sum to i and the array is sorted,
//contains the minimum number of unique elements necessary to
//satisfy the first condition, the elements chosen are the
//closest together that satisfy the first condition.
function f(i, k, n) {
  var minNumber = (((i / k) / n) | 0) * k;
  var maxNumber = minNumber + k;
  var numMax = (i - (minNumber * n)) / k;
  var nums = [];
  for (var i = 0; i < n - numMax; ++i) {
    nums[i] = minNumber;
  }
  for (var i = n - numMax; i < n; ++i) {
    nums[i] = maxNumber;
  }
  return nums;
}

Also dein zweites Beispiel wäre

f(5000, 50, 7)

ergibt

[700,700,700,700,700,750,750]

Schön zu sehen, einen anderen Ansatz, aber nicht genau, was ich wollte, wie die 750-Werte wieder geladen werden fortlaufend durchnummeriert.

InformationsquelleAutor Mike Samuel

2

Dein problem ist das gleiche wie beim teilen einer Zahl X in N integer-Stücke, die sind alle im Umkreis von 1 von einander (multiplizieren Sie einfach alles von 50, nachdem Sie gefunden haben, das Ergebnis). Dies zu tun, ist einfach - setzen Sie alle N zahlen zu Floor(X/N) ist, dann fügen Sie 1 bis X mod N von Ihnen.

InformationsquelleAutor BlueRaja - Danny Pflughoeft

Ich sehe dein problem als im Grunde versucht, zu teilen Sie eine Summe von Geld in der Nähe-gleich-bundles von Wechsel von eine bestimmte Konfession.

Zum Beispiel, die Aufteilung von 10.000 Dollar in 7 in der Nähe-gleich-Bündel 50-dollar-scheine.

function getBundles(sum, denomination, count, shuffle)
{
  var p = Math.floor(sum / denomination);
  var q = Math.floor(p / count);
  var r = p - q * count;

  console.log(r + " of " + ((q + 1) * denomination)
      + " and " + (count - r) + " of " + (q * denomination));

  var b = new Array(count);
  for (var i = 0; i < count; i++) {
    b[i] = (r > 0 && (!shuffle || Math.random() < .5 || count - i == r)
        ? (--r, q + 1) : q)
      * denomination;
  }

  return b;
}

//Divide 10,000 dollars into 7 near-equal bundles of 50-dollar bills
var bundles = getBundles(10000, 50, 7, true);

console.log("bundles: " + bundles);

Ausgabe:

4 of 1450 and 3 of 1400
bundles: 1400,1450,1450,1400,1450,1400,1450

Wenn das Letzte argument shuffle ist true es verteilt den zusätzlichen Betrag, der zufällig zwischen die Bündel.

+1 für puttin' eine kreative spin auf Sie - ich mag es!

InformationsquelleAutor Manish

Hier ist mein nehmen:

public static void main(String[] args) {
    System.out.println(toList(divide(50, 5000, 3)));
    System.out.println(toList(divide(50, 5000, 7)));
    System.out.println(toList(divide(33, 6600, 7)));
}

private static ArrayList<Integer> toList(int[] args) {
    ArrayList<Integer> list = new ArrayList<Integer>(args.length);
    for (int i : args)
        list.add(i);
    return list;
}

public static int[] divide(int N, int multiplyOfN, int partsCount) {
    if (N <= 0 || multiplyOfN <= N || multiplyOfN % N != 0)
        throw new IllegalArgumentException("Invalid args");

    int factor = multiplyOfN / N;
    if (partsCount > factor)
        throw new IllegalArgumentException("Invalid args");

    int parts[] = new int[partsCount];
    int remainingAdjustments = factor % partsCount;
    int base = ((multiplyOfN / partsCount) / N) * N;

    for (int i = 0; i < partsCount; i ++) {
        parts[i] = (i % 2 == 1 && remainingAdjustments-- > 0) ? base + N : base;
    }

    return parts;
}

Falsche Sprache. Zumindest zeigt es, wie viel code Sie eingeben müssen, die in Java nicht eine einfache Sache 😉 (nichts für ungut)

InformationsquelleAutor Victor Sorokin

Mein Algorithmus sorgt für die gleichmäßige Verteilung des Rest über Teile:

function splitValue(value, parts, multiplicity)
{
    var result = [];
    var currentSum = 0;
    for (var i = 0; i < parts; i++)
    {
        result[i] = Math.round(value * (i + 1) / parts / multiplicity) * multiple - currentSum;
        currentSum += result[i];
    }
    return result;
}

Bei Wert = 5000, - Teile = 7, die Vielheit = 50 es gibt

[ 700, 750, 700, 700, 700, 750, 700 ]

InformationsquelleAutor Gennadii Saltyshchak

Schreibe einen Kommentar

Du musst angemeldet sein, um einen Kommentar abzugeben.