return Summe aller zahlen in einem Bereich

function sumAll(arr) {
    var list = [];

    for (var i = arr[0]; i <= arr[1]; i++) {
        list.push(i);
    }

    var total = list.reduce(function(a, b) {
        return a + b;

    });

    return total;
}

sumAll([10, 5]);
//sumAll([1, 4]);  //returns 10
//sumAll([5, 10]); //returns 45
//sumAll([4, 1]);

Ich brauche die Summe jeder Reihe zwischen den angegebenen Argumenten. Für sumAll([1, 4]) und sumAll([5, 10]). Der code wird passieren, weil es schafft alle zahlen zwischen den beiden Argumenten und hinzufügen. Jedoch, für sumAll([10, 5]) und sumAll([4, 1]), weil die größere Anzahl ist das erste argument, ich glaube, es wird nicht ausgeführt, var Liste. Ich habe versucht, mit .sort() Methode in zwischen so, dass die zahlen sortiert werden, aber kann nicht ankommen es zu wirken. Wie kann ich Math.min() und Math.max() für diesen code?

Vergessen Sie nicht, pass 0 für den Akku zu reduce!

InformationsquelleAutor jyoon006 | 2015-05-04

5

Einfachste Weg ist die Verwendung der mathematischen Formel
```
1+2+...+n = n(n+1)/2
```
Hier wollen die Summe,
```
m+(m+1)+...+n
```
wo m=arr[0] und n=arr[1]. Diese ist gleich der Differenz
```
(1+2+...+n) - (1+2+...+(m-1))
```
die Substitution der obigen Formel doppelt gleich
```
n(n+1)/2 - (m-1)m/2
```
Also der richtige code ist
```
function sumAll(arr) {
  var min = arr[0];
  var max = arr[1];
  return (max*(max+1) - (min-1)*min)) / 2;
}
```
Ursprüngliche Antwort (also nicht - Links für die Nachwelt):

Hier, wie ich benutzen würde Math.min und Math.max um dies zu tun:
```
function sumAll(arr) {
    var list = [];

    var lower = Math.min(arr[0], arr[1]);
    var upper = Math.max(arr[0], arr[1]);

    for (var i = lower; i <= upper; i++) {
        list.push(i);
    }

    var total = list.reduce(function(a, b) {
        return a + b;
    });

    return total;
}
```
Jemand anderes gepostet-code mit arr[0] < arr[0] ? arr[0] : arr[1]; IMO die Math.min und Math.max Funktionen machen für besser lesbaren code als das ? :- operator.

Auch, weitere zwei cents: ich glaube, es wäre einfacher nicht zu machen var list; stattdessen sagen var total = 0 und erhöhen es. Wie diese:
```
function sumAll(arr) {
    var lower = Math.min(arr[0], arr[1]);
    var upper = Math.max(arr[0], arr[1]);

    var total = 0;

    for (var i = lower; i <= upper; i++) {
        total += i;
    }

    return total;
}
```
- Die akzeptierte Antwort sollte der Vorschlag von @Nigel. Es verwendet eine Formel für dein problem, statt eine Schleife oder eine Liste!
- Danke @PatrickDorn. Aktualisiert meine Antwort als gut. Ich weiß nicht, warum ich nicht denke, dass die Formel, wenn ich ursprünglich gepostet.
InformationsquelleAutor jcarpenter2
5

Dies ist eine jener Zeiten, in denen mathematische Gleichungen die in handliches kommen. Check out this code:
```
function sumAll(arr) {
max=Math.max(arr[0],arr[1]);
min=Math.min(arr[0],arr[1]);
return (max*(max+1)/2)-((min-1)*min/2);
}
```
Ganz simple Logik, richtig? 🙂
- Nicht einfach, wenn Sie teilen nicht die Formel dahinter, die trully.
- Beste Antwort bisher. Die Mathematik benutzen, nicht brute-force 😉 Erklärung: mathcentral.uregina.ca/qq/database/qq.02.06/jo1.html
InformationsquelleAutor Nigel

JS:

function sumAll(arr) {

    var first = arr[0] > arr[1] ? arr[1] : arr[0],
        last = arr[0] > arr[1] ? arr[0] : arr[1];
        sum = 0;
    for (var i = first; i <= last; i++) {
        sum += i;
    }
    return sum;
}

InformationsquelleAutor Bertrand KHE

function sumAll(arr) {
  var max = Math.max.apply(null, arr);
  var min = Math.min.apply(null, arr);
  var arr2 = [];

  for (var i=min; i<=max; i++)
  {
    arr2.push(i);
  }

  return arr2.reduce(function(sum, item){sum+=item; return sum;},0);
}

sumAll([1, 4]);

InformationsquelleAutor sugongqing

Kann man das array an die Math.min und Math.max Funktionen.

JS:

function sumAll(arr) {
  var list = [];

  for (var i = Math.min.apply(null, arr); i <= Math.max.apply(null, arr); i++) {
    list.push(i);
  }

  var total = list.reduce(function(a, b) {
    return a + b;
  }, 0);

  return total;
}

[[10, 5], [1, 4], [5, 10], [4, 1]].forEach(function(range) {
  console.log(range.join(' -> ') + ' = ' + sumAll(range));
});

Ausgabe:

10 -> 5 = 45
1 -> 4 = 10
5 -> 10 = 45
4 -> 1 = 10

InformationsquelleAutor Mr. Polywhirl

0

.sort() Sortieren Sie das array als string verwenden compareFunction zu Sortieren: Nummer Wert:
```
arr.sort(function(a, b) {
  return a - b;
});
```
wenn Sie möchten, verwenden Sie min oder max, übergeben Sie das array als Argumente:

1) Math.max.apply(this, arr); || Math.min.apply(this, arr);

2) Math.max(arr[0], arr[1]) || Math.min(arr[0], arr[1])

InformationsquelleAutor Shalev Shalit

Javascript-code:

function myFunction(arr) {
  console.log(arr);
  var list = [];

  var startVal = arr[0];
  console.log(startVal);
  var stopVal = arr[1];
  console.log(stopVal);

  while(startVal < stopVal+1){
    list.push(startVal++);
  }
      console.log(list);

      var total = list.reduce(function(a, b) {
          return a + b;

      });

     //return total;
      document.getElementById("demo").innerHTML = total;
  }

HTML-CODE:

<!DOCTYPE html>
<html>
<head>
  <link rel="stylesheet" href="http://maxcdn.bootstrapcdn.com/bootstrap/3.3.4/css/bootstrap.min.css">
    <script src="https://ajax.googleapis.com/ajax/libs/jquery/1.11.1/jquery.min.js"></script>
    <script src="http://maxcdn.bootstrapcdn.com/bootstrap/3.3.4/js/bootstrap.min.js"></script>
  <script src="app2.js"></script>
</head>
<body>
  <button onclick="myFunction([5,10])">Try it</button>
  <div id="demo"></div>
</body>
</html>

InformationsquelleAutor Ritesh Karwa

Dies ist ein Weg, es zu tun:

function sumAll(arr) {
  var sortedArray = arr.sort(function(a,b) { 
    return a-b;
  });

  return sortedArray.reduce(function(a, b, start, arr) {
    var temp = a, subTotal = a;
    while (temp < b - 1) {
      subTotal += ++temp;
    }

    return subTotal + b;
  });
}

InformationsquelleAutor Oleg P Runov

Ist, wie ich Rolle

function sumAll(arr) {
return (arr[0]+arr[1])*(Math.max(...arr)-Math.min(...arr)+1)/2;;
}

InformationsquelleAutor Vladimir Seferov

0
```
function sumAll(arr) {
  const rangeStart = Math.min(arr[0], arr[1]);
  const rangeEnd = Math.max(arr[0], arr[1]);
  const numberOfDigits = rangeEnd - rangeStart + 1;

  return (rangeEnd + rangeStart) * numberOfDigits / 2;
}
```
Es ist eine Art:
https://betterexplained.com/articles/techniques-for-adding-the-numbers-1-to-100/

Aber nicht starten immer bei 1, sondern bei "rangeStart" und die numberOfDigits ist nicht immer rangeEnd, aber die Idee ist die gleiche.

InformationsquelleAutor Juan Carrey
0

Zwischen α und β ist, gibt es β−α+1 zahlen. Wir brauchen
```
S=α+(α+1)+⋯+β=β+(β−1)+⋯+α
```
Hinzufügen vertikal, wir haben
```
2S=(β−α+1)(α+β)
```
Daher
```
S=(β−α+1)(α+β)2
```
Diese "Umgekehrt und add" - Technik ist durch Gauss und kann verwendet werden, um die Summe aller arithmetischen progression als gut.
```
function sumAll(arr) {
  let alpha = Math.min(...arr);
  let beta= Math.max(...arr); 
  return ((beta - alpha + 1)*(alpha + beta))/2;      
}
```
InformationsquelleAutor Ashutosh Jha

Was über diese? nach der Gauss-Formel:

JS:

function sumAll(arr) {
    return arr.reduce((a,b) => (a+b)*(Math.abs(a-b) + 1) / 2)
}

console.log(sumAll([1,4])); //10
console.log(sumAll([5,10])); //45
console.log(sumAll([10,5])); //45

InformationsquelleAutor Luigi Derson

-1

Ich würde gehen Sie einfach:
```
function sumAll(arr) {

  var sum = 0;

  arr.sort(function(a, b) {
    return a - b;
  });

  for (var i = arr[0]; i <= arr[arr.length - 1]; i++) {
   sum += i;
  }

  return sum;

}

sumAll([4, 1]);
```
- Was hat das hinzufügen, um die Lösungen schon gegeben?
- Während dieses code-snippet lösen können, die Frage, einschließlich einer Erklärung die wirklich hilft, zu verbessern, die Qualität Ihrer post. Denken Sie daran, dass Sie die Beantwortung der Frage für den Leser in der Zukunft, und die Menschen vielleicht nicht wissen, die Gründe für deinen code-Vorschlag. Bitte auch nicht versuchen Sie zu drängen, Ihren code mit Kommentaren wie dies verringert die Lesbarkeit sowohl der code und die Erklärungen!
InformationsquelleAutor baxsus

-1

Ich würde es vorziehen, Einfachheit....

function sumAll(arr) {
 var max = Math.max.apply(null, arr);
 var min = Math.min.apply(null, arr);
 var sum = 0;
 for(var i = min; i <= max; i++)
 sum = sum + i;
 return sum;
}
sumAll([1, 4]);

InformationsquelleAutor Alexie

Schreibe einen Kommentar

Du musst angemeldet sein, um einen Kommentar abzugeben.