Разное

Сумма элементов массива javascript: Как найти сумму массива чисел

Содержание

Array.prototype.reduce() — JavaScript | MDN

Метод reduce() применяет функцию reducer к каждому элементу массива (слева-направо), возвращая одно результирующее значение.

The source for this interactive example is stored in a GitHub repository. If you’d like to contribute to the interactive examples project, please clone https://github.com/mdn/interactive-examples and send us a pull request.

Источник этого интерактивного примера хранится в репозитории GitHub. Если вы хотите внести свой вклад в проект интерактивных примеров, скопируйте https://github.com/mdn/interactive-examples и отправьте нам запрос на перенос.

array.reduce(callback[, initialValue])

Параметры

callback
Функция, выполняющаяся для каждого элемента массива, принимает четыре аргумента:

accumulator
Аккумулятор, аккумулирующий значение, которое возвращает функция callback после посещения очередного элемента, либо значение initialValue, если оно предоставлено (смотрите пояснения ниже).
currentValue
Текущий обрабатываемый элемент массива.
indexНеобязательный
Индекс текущего обрабатываемого элемента массива.
arrayНеобязательный
Массив, для которого была вызвана функция reduce.
initialValueНеобязательный
Необязательный параметр. Объект, используемый в качестве первого аргумента при первом вызове функции callback.

Метод reduce() выполняет функцию callback один раз для каждого элемента, присутствующего в массиве, за исключением пустот, принимая четыре аргумента: начальное значение (или значение от предыдущего вызова callback), значение текущего элемента, текущий индекс и массив, по которому происходит итерация.

При первом вызове функции, параметры accumulator и currentValue могут принимать одно из двух значений. Если при вызове reduce() передан аргумент initialValue, то значение accumulator будет равным значению initialValue, а значение currentValue будет равным первому значению в массиве. Если аргумент initialValue не задан, то значение accumulator будет равным первому значению в массиве, а значение currentValue будет равным второму значению в массиве.

Если массив пустой и аргумент initialValue не указан, будет брошено исключение TypeError. Если массив состоит только из одного элемента (независимо от его положения в массиве) и аргумент initialValue не указан, или если аргумент initialValue указан, но массив пустой, то будет возвращено одно это значение, без вызова функции callback.

Предположим, что reduce() используется следующим образом:

[0, 1, 2, 3, 4].reduce(function(previousValue, currentValue, index, array) {
  return previousValue + currentValue;
});

Колбэк-функция будет вызвана четыре раза, аргументы и возвращаемое значение при каждом вызове будут следующими:

previousValue currentValue index array возвращаемое значение
первый вызов 0 1 1 [0, 1, 2, 3, 4] 1
второй вызов 1 2 2 [0, 1, 2, 3, 4] 3
третий вызов 3 3 3 [0, 1, 2, 3, 4] 6
четвёртый вызов 6 4 4 [0, 1, 2, 3, 4] 10

Значение, возвращённое методом reduce() будет равным последнему результату выполнения колбэк-функции — 10.

Если же вы зададите начальное значение initialValue, результат будет выглядеть так:

[0, 1, 2, 3, 4].reduce(function(accumulator, currentValue, index, array) {
  return accumulator + currentValue;
}, 10);
accumulator currentValue index array возвращаемое значение
первый вызов 10 0 0 [0, 1, 2, 3, 4] 10
второй вызов 10 1 1 [0, 1, 2, 3, 4] 11
третий вызов 11 2 2 [0, 1, 2, 3, 4] 13
четвёртый вызов 13 3 3 [0, 1, 2, 3, 4] 16
пятый вызов 16 4 4 [0, 1, 2, 3, 4] 20

Значение, возвращённое методом reduce() на этот раз, конечно же, будет равным 20.

Суммирование всех значений в массиве

var total = [0, 1, 2, 3].reduce(function(a, b) {
  return a + b;
});

Суммирование значений в массиве объектов

Чтобы суммировать значения, содержащиеся в массиве объектов, вы должны указать initialValue, чтобы каждый элемент смог пройти через callback.

var initialValue = 0;
var sum = [{x: 1}, {x:2}, {x:3}].reduce(function (accumulator, currentValue) {
    return accumulator + currentValue.x;
}, initialValue)

Тоже самое, но со стрелочной функцией: 

var initialValue = 0;
var sum = [{x: 1}, {x:2}, {x:3}].reduce(
    (accumulator, currentValue) => accumulator + currentValue.x,
    initialValue
);

Разворачивание массива массивов

var flattened = [[0, 1], [2, 3], [4, 5]].reduce(function(a, b) {
  return a.concat(b);
});

Пример: склеивание массивов, содержащихся в объектах массива, с использованием оператора расширения и initialValue



var friends = [
{ name: "Anna", books: ["Bible", "Harry Potter"], age: 21 },
{ name: "Bob", books: ["War and peace", "Romeo and Juliet"], age: 26 },
{ name: "Alice", books: ["The Lord of the Rings", "The Shining"], age: 18 }
]



var allbooks = friends.reduce(function(prev, curr) {
  return [...prev, ...curr.books];
}, ["Alphabet"]);



Метод Array.prototype.reduce() был добавлен к стандарту ECMA-262 в 5-м издании; поэтому он может отсутствовать в других реализациях стандарта. Вы можете работать с ним, добавив следующий код в начало ваших скриптов, он позволяет использовать reduce() в реализациях, которые не поддерживают этот метод.




if (!Array.prototype.reduce) {
  Array.prototype.reduce = function(callback) {
    'use strict';
    if (this == null) {
      throw new TypeError('Array.prototype.reduce called on null or undefined');
    }
    if (typeof callback !== 'function') {
      throw new TypeError(callback + ' is not a function');
    }
    var t = Object(this), len = t.length >>> 0, k = 0, value;
    if (arguments.length >= 2) {
      value = arguments[1];
    } else {
      while (k < len && ! (k in t)) {
        k++;
      }
      if (k >= len) {
        throw new TypeError('Reduce of empty array with no initial value');
      }
      value = t[k++];
    }
    for (; k < len; k++) {
      if (k in t) {
        value = callback(value, t[k], k, t);
      }
    }
    return value;
  };
}

BCD tables only load in the browser

Javascript вычислить сумму элементов массива, порядковые номера которых совпадают со

1) Составить линейную программу, печатающую значение true,

если указанное высказывание является истинным, и false —

в противном случае.

Задача:

Сумма цифр заданного четырехзначного числа N превосхо­

дит произведение цифр этого же числа на 1.

2) Текстровая задача

На плоскости .ГОГзадана своими координатами точка А. Ука­

зать, где она расположена (на какой оси или в каком координат­

ном угле) .

3) Написать программу нахождения суммы большего и меньше­

го из трех чисел.

4) Задачи по теме «Оператор выбора»

Написать программу, которая по номеру дня недели (целому

числу от 1 до 7) выдает в качестве результата количество уроков в

вашем классе в этот день.

5) Доказать (путем перебора возможных значений) , что для любых

величин А, В, С типа Boolean следующие пары логических выра­

жений имеют одинаковые значения (эквивалентны) :

а) A OR в и в OR А;

б) A AND ВИ В AND A;

В) (A OR В) OR С И A OR С;

Г) (A AND В) AND С И A AND (В AND С) ;

Д) A AND (A OR В) И А;

е) A OR (A AND В) И А;

Ж) A AND (В OR.С) И (A AND В) OR (A AND С) ;

3) A OR (В AND С) И (A OR В) AND (A OR С)

6) Задачи по теме «Целочисленная арифметика»

Дано натуральное число л. Найти сумму первой и последней

цифры этого числа.

7) Дано натуральное число N. Получить новое число М, кото­

рое образуется из числа N путем замены последней цифры на

значение наибольшей цифры в записи числа N. Пример. N= 128 452,

М= 128 458

8) Составить программу перевода натурального числа из деся­

тичной системы счисления в двоичную.

9) Одномерные массивы

Задана последовательность TV целых чисел. Вычислить сумму

элементов массива, порядковые номера которых совпадают со

значением этого элемента

10) Одномерные массивы

Дан массив целых чисел. Найти в этом массиве минималь­

ный элемент от и максимальный элемент М. Получить в порядке

возрастания все целые числа из интервала (от; Л/), которые не

входят в данный массив.

11) Одномерные массивы

Дан целочисленный массив А [п] , среди элементов есть оди­

наковые. Создать массив из различных элементов А [п] .

12) Операции с элементами массивов

Определить наименьший элемент каждой четной строки

матрицы А [М, N].

[ Задача JavaScript ]: массивы, циклы, условные операторы

Во время решения следующей задачи будут задействованы массивы, циклы, условные операторы, генератор случайных чисел и математические функции.

Задача

  1. Сформировать для ученика список состоящий из n элементов, каждый элемент которого — это оценка от 2 до 5.
    Подсчитать среднее арифметическое и в соответствии с этим дать определение ученику: отличник, хорошист, троечник, двоечник.
  2. Подсчитать количество каждой полученной оценки.

Решение

Для решения первой части задачи требуется сгенерировать массив с оценками, при этом для формирования каждой оценки потребуется генератор случайных чисел.

Необходимо определить количество оценок, которое получал ученик, минимальный и максимальный баллы и пустой массив, который будет содержать оценки ученика, а также переменную, которая будет содержать средний балл и переменную, содержащую определение ученику:

1

2

3

4

5

6

7

8

9

10

11

12

13

14

15

16

17

// кол-во полученных учеником оценок

var n = 20;

 

// определение массива, содержащего оценки ученика

var scores = [];

 

// минимальная оценка, которую может получить ученик

var min = 2;

 

// максимальная оценка, которую может получить ученик

var max = 5;

 

// средняя арифметическая оценка ученика

var sum = 0;

 

// определение переменной содержащей определение ученика

var who = »;

Теперь необходимо провести цикл в котором будет случайным образом генерироваться оценка и помещаться в массив, цикл должен повториться n раз, чтобы набралось определенное ранее количество оценок в массиве:

// цикл формирования списка оценок

for ( var i = 0; i < n; i++ ) {

 

// формирование оценки путем выбора случайного числа от min до max и помещение этой оценки в список всех оценок

scores[ i ] = Math. floor( Math.random() * (max — min + 1) ) + min;

 

// подсчет суммы всех оценок

sum += scores[ i ];

}

Также в цикле считается среднее арифметическое между всеми оценками:

К текущей сумме баллов прибавляется текущий балл, который был добавлен строкой выше и который является i-ым элементом массива, поэтому к нему можно обращаться указав его порядковый номер, что мы и делаем.

После окончания цикла необходимо полученную сумму в переменной sum разделить на количество оценок в сформированном массиве. Можно было бы узнать размер массива с помощью .length, но так как мы сами задавали размер в переменной n достаточно будет просто разделить на n, а за тем округлить результат.

sum = Math.round( sum / n );

После всего проделанного осталось дать определение ученику:

switch ( sum ) {

case 5:

who = ‘отличник’;

break;

case 4:

who = ‘хорошист’;

break;

case 3:

who = ‘троечник’;

break;

case 2:

who = ‘двоечник’;

break;

default:

who = ‘не ясно кто’;

}

…и вывести результат:

// вывод информации в консоль

console.log( ‘Оценки: ‘ + scores );

console.log( ‘Средняя оценка — ‘ + sum );

console.log( ‘Ученик — ‘ + who );

Вторая часть задачи

Для выполнения второй части задания до цикла необходимо определить переменную, которая будет содержать в себе количества каждой из оценок. Так как оценок несколько, то переменная, хранящая информацию о количестве каждой оценки, должна быть массивом. Мы условимся, что нулевой элемент будет содержать количество двоек, полученных учеником, первый — количество троек и так далее. В начальный момент мы еще не сформировали список оценок ученика, поэтому количество каждой из оценок равно нулю:

var most = [ 0, 0, 0, 0 ];

Внутри цикла необходимо добавить подсчет количества оценок. Это можно сделать с помощью условного оператора switch:

switch ( scores[ i ] ) {

case 5:

most[ 3 ]++;

break;

case 4:

most[ 2 ]++;

break;

case 3:

most[ 1 ]++;

break;

case 2:

most[ 0 ]++;

break;

}

Но данный подход не рационален, так как если максимальный балл увеличится с пятерки, скажем до 100, придется писать слишком много условий, поэтому мы запишем гораздо проще:

// увеличение кол-ва конкретных оценок, так как порядковый номер для оценок соответствует формуле score — min

most[ scores[ i ] — min ]++;

В данном случае мы вычисляем индекс элемента, который надо увеличить на единицу: scores[ i ] - min

scores[ i ] — это только что сгенерированная оценка, например 5, а min — это минимальная оценка, равная 2. Если вычесть из пяти два, получится три, 3 — это порядковый номер элемента в массиве most, который хранит количество пятерок и именно его значение мы увеличиваем на единицу.

После всего этого необходимо вывести информацию о количестве полученных оценок:

// определение счетчика равного максимально возможной оценке

i = max;

 

// перебор оценкок, которые, по значению, больше min

while ( i >= min ) {

 

// вывод кол-ва каждой оценки

console.log( ‘Кол-во ‘ + i + ‘-к: ‘ + most[ i — 2 ] );

 

// декремент счетчика

i—;

}

Результат выполнения скрипта

Перезапись JavaScript: Суммирование массива | Крис Бургин

Серия статей о том, как переписывать общие фрагменты Javascript с использованием концепций функций. В этом посте мы расскажем, как найти сумму массива.

Сначала мы рассмотрим стандартный метод, который вы легко узнаете. Даже если вы не являетесь разработчиком Javascript, этот пример должен вызвать недоумение.

Стандартный способ

 var numbers = [10, 20, 30, 40] // суммируется до 100 
var sum = 0; for (var i = 0; i sum + = numbers [i]
}

В The Standard Way мы сначала объявляем переменную sum и устанавливаем ее начальное значение равным нулю. Затем мы используем стандартный цикл for для перебора нашего массива чисел и суммирования массива с использованием суммы . Простое, но не совсем лучшее решение.

Одна из самых больших проблем с этим фрагментом кода заключается в том, что мы вносим мутацию в наш код. Короче говоря, мы создали переменную sum , значение которой будет изменено позже.Это плохо для удобочитаемости, а также более подвержено ошибкам, чем код, избегающий мутаций.

The Rewritten Way

К счастью, Javascript предоставляет нам способы написания неизменяемого кода, которые я продемонстрирую ниже. Изменения выделены жирным шрифтом .

  const  numbers = [10, 20, 30, 40] // сумма до 100 // функция для сложения двух чисел. Легкий! 
const add = (a, b) =>
a + b

Первое, что следует отметить, это то, что мы изменили числа с var на const .Мы хотим убедиться, что числа постоянны; это не изменится. Чтобы узнать больше о const и let, прочтите эту фантастическую статью Mozilla.

Далее вы заметите, что мы добавили функцию под названием add . Эта функция просто берет два числа и складывает их. Если вы раньше не видели этот синтаксис, я рекомендую проверить эту страницу MDN, посвященную функциям стрелок.

Далее мы напишем сегмент, который добавляет наш массив.

 const numbers = [10, 20, 30, 40] // сумма до 100 // функция для сложения двух чисел.Легкий! 
const add = (a, b) =>
a + b // используйте сокращение для суммирования нашего массива
const sum = numbers. reduce (add)

Одна строка, и все готово. Работая слева направо, обратите внимание, что мы устанавливаем переменную sum как константу. Как только эта переменная установлена, мы не хотим, чтобы она изменялась, поскольку это привело бы к мутации.

Далее вы заметите, что мы выполняем метод reduce для чисел и устанавливаем его в переменную sum , устраняя необходимость в мутации.Метод reduce принимает функцию, которая принимает 4 аргумента. В нашем случае нам нужны только первые два. Первые два аргумента заключаются в следующем.

  1. аккумулятор — значение, возвращенное последним обратным вызовом.
  2. currentValue — Текущий обрабатываемый элемент в массиве.

Поскольку мы даем функции уменьшения добавить , значения аккумулятора и currentValue отображаются в a и b в нашей функции сложения соответственно.

Для большей ясности в том, что происходит, давайте разберем его шаг за шагом для каждого значения в нашем массиве по мере его обработки оператором сокращения.

Первая итерация: В первой итерации массива значения следующие: аккумулятор = 10 и currentValue = 20 , сложив вместе, мы вернем 30 .

Вторая итерация: Во второй итерации массива значения следующие: аккумулятор = 30 и currentValue = 30 , сложив вместе, мы вернем 60 .

Третья итерация: В третьей итерации массива значения следующие: аккумулятор = 60 и currentValue = 40 сложив вместе, мы вернем 100 .

Как вы можете видеть на каждой из этих итераций, накопитель — это значение, возвращаемое при каждом выполнении. Как только вы его разберете, метод сокращения станет довольно простым для понимания.Ознакомьтесь со статьей MDN о редукторах для получения дополнительной информации. Я настоятельно рекомендую вам внимательно прочитать его, чтобы понять, что еще может предложить сокращение.

The Wrap

Заменив стандартный цикл на reduce, мы удалили мутацию из нашего кода, что позволило сделать код более чистым и легким для чтения, что принесет нам пользу по мере роста нашего приложения.

В ближайшем будущем я расскажу о других темах о переписывании основных концепций Javascript с использованием новых стандартов. А пока я предлагаю вам взглянуть на полезные материалы, приведенные ниже, для получения дополнительной информации по вышеуказанным темам.

Полезное чтение

Array.prototype.reduce () — JavaScript | MDN

Метод reduce () выполняет редуктор
функция (которую вы предоставляете) для каждого элемента массива, что приводит к одному выходу
ценить.

Исходный код этого интерактивного примера хранится в репозитории GitHub. Если вы хотите внести свой вклад в проект интерактивных примеров, клонируйте https://github.com/mdn/interactive-examples и отправьте нам запрос на перенос.

Функция редуктора принимает четыре аргумента:

  1. Аккумулятор
  2. Текущее значение
  3. Текущий индекс
  4. Исходный массив

Ваш редуктор Возвращаемое значение функции присваивается аккумулятору,
значение которого запоминается на каждой итерации по всему массиву, и в конечном итоге
становится окончательным, единственным результирующим значением.

  arr.reduce (callback (аккумулятор, currentValue, [, index [, array]]) [, initialValue])  

Параметры

callback

Функция, выполняемая для каждого элемента в массиве (кроме первого, если нет
Поставляется initialValue ).

Требуется четыре аргумента:

аккумулятор
Накопитель накапливает значения, возвращаемые обратным вызовом . Это
накопленное значение, ранее возвращенное при последнем вызове обратного вызова, или
initialValue , если оно было предоставлено (см. Ниже).
текущее значение
Текущий обрабатываемый элемент в массиве.
индекс Дополнительно
Индекс текущего обрабатываемого элемента в массиве. Начинается с индекса
0 , если указано значение initialValue . В противном случае запускается
из индекса 1 .
массив Дополнительно
Был вызван массив reduce () .
начальное значение Необязательно
Значение для использования в качестве первого аргумента при первом вызове
обратный звонок .Если нет начальное значение
предоставлен, первый элемент в массиве будет использоваться в качестве начального
аккумулятор значение и пропущено как
текущее значение . Вызов reduce () для пустого массива
без initialValue вызовет TypeError .

Возвращаемое значение

Единственное значение, полученное в результате уменьшения.

Метод reduce () выполняет обратный вызов один раз для
каждое присвоенное значение, присутствующее в массиве, принимает четыре аргумента:

  1. аккумулятор
  2. текущее значение
  3. текущий Индекс
  4. массив

При первом вызове обратного вызова аккумулятор и
currentValue может быть одним из двух значений. Если
initialValue предоставляется в вызове reduce () ,
тогда аккумулятор будет равен
initialValue , а currentValue будет
равно первому значению в массиве. Если нет начальное значение
при условии, что аккумулятор будет равен первому значению в
массив, а currentValue будет равно второму.

Примечание: Если initialValue не указано,
reduce () выполнит функцию обратного вызова, начиная с индекса
1 , пропуская первый индекс. Если начальное значение равно
при условии, что он начнется с индекса 0 .

Если массив пуст и не указано initialValue ,
TypeError будет выброшено.

Если в массиве только один элемент (независимо от позиции) и нет
initialValue предоставляется, или если
initialValue предоставляется, но массив пуст, значение соло
будет возвращено без звонка обратного звонка .

Почти всегда безопаснее указать начальное значение , потому что
может быть до четыре возможных типа вывода без
initialValue , как показано в следующем примере:

  let maxCallback = (acc, cur) => Math.max (acc.x, cur.x);
пусть maxCallback2 = (max, cur) => Math.max (max, cur);


[{x: 2}, {x: 22}, {x: 42}] .reduce (maxCallback);
[{x: 2}, {x: 22}].уменьшить (maxCallback);
[{x: 2}] .reduce (maxCallback);
[] .reduce (maxCallback);


[{x: 22}, {x: 42}] .map (el => el.x)
                        .reduce (maxCallback2, -Бесконечность);
  

Как работает reduce ()

Предположим, что произошло следующее использование reduce () :

  [0, 1, 2, 3, 4] . reduce (function (аккумулятор, currentValue, currentIndex, array) {
  вернуть аккумулятор + currentValue
})
  

Обратный вызов будет вызываться четыре раза с аргументами и возвращаемыми значениями в каждом
звоните по следующему номеру:

обратный вызов итерация аккумулятор текущее значение текущий Индекс массив возвращаемое значение
первый звонок 0 1 1 [0, 1, 2, 3, 4] 1
второй звонок 1 2 2 [0, 1, 2, 3, 4] 3
третий звонок 3 3 3 [0, 1, 2, 3, 4] 6
четвертый звонок 6 4 4 [0, 1, 2, 3, 4] 10

Значение, возвращаемое функцией reduce () , будет значением последнего обратного вызова.
вызов ( 10 ).

Вы также можете указать функцию стрелки
вместо полноценной функции. Приведенный ниже код даст тот же результат, что и код в
блок выше:

  [0, 1, 2, 3, 4] . reduce ((аккумулятор, currentValue, currentIndex, array) => аккумулятор + currentValue)
  

Если бы вы указали initialValue в качестве второго аргумента
до reduce () , результат будет выглядеть так:

  [0, 1, 2, 3, 4].reduce ((аккумулятор, currentValue, currentIndex, array) => {
    вернуть аккумулятор + currentValue
}, 10)
  
обратный вызов итерация аккумулятор текущее значение текущий Индекс массив возвращаемое значение
первый звонок 10 0 0 [0, 1, 2, 3, 4] 10
второй звонок 10 1 1 [0, 1, 2, 3, 4] 11
третий звонок 11 2 2 [0, 1, 2, 3, 4] 13
четвертый звонок 13 3 3 [0, 1, 2, 3, 4] 16
пятый звонок 16 4 4 [0, 1, 2, 3, 4] 20

Значение, возвращаемое функцией reduce () , в этом случае будет 20 .

 


if (! Array.prototype.reduce) {
  Object.defineProperty (Array.prototype, 'уменьшить', {
    value: function (callback) {
      if (this === null) {
        throw new TypeError ('Array.prototype.reduce' +
          'вызвано по null или undefined');
      }
      if (typeof callback! == 'функция') {
        выбросить новый TypeError (обратный вызов +
          'не функция');
      }

      
      var o = Object (это);

      
      var len = o.length >>> 0;

      
      var k = 0;
      значение var;

      если (аргументы.length> = 2) {
        значение = аргументы [1];
      } еще {
        while (k  = len) {
          throw new TypeError ('Уменьшение пустого массива' +
            'без начального значения');
        }
        значение = o [k ++];
      }

      
      в то время как (k  

Внимание: Если вам нужна поддержка действительно устаревших движков JavaScript
которые не поддерживают объект .defineProperty () , лучше не использовать полифил
Array.prototype методы вообще, так как вы не можете их сделать
неперечислимый .

Суммировать все значения массива

  let sum = [0, 1, 2, 3] .reduce (function (аккумулятор, currentValue) {
  вернуть аккумулятор + currentValue
}, 0)


  

Альтернативно записывается стрелкой:

  let total = [0, 1, 2, 3] .reduce (
  (аккумулятор, текущее значение) => аккумулятор + текущее значение,
  0
)  

Сумма значений в массиве объектов

Чтобы суммировать значения, содержащиеся в массиве объектов, вы должны предоставить
initialValue , чтобы каждый элемент проходил через вашу функцию.

  пусть initialValue = 0
let sum = [{x: 1}, {x: 2}, {x: 3}]. reduce (function (аккумулятор, currentValue) {
    возвратный аккумулятор + currentValue.x
}, Начальное значение)

console.log (сумма)
  

Альтернативно записывается стрелкой:

  пусть initialValue = 0
let sum = [{x: 1}, {x: 2}, {x: 3}]. reduce (
    (аккумулятор, currentValue) => аккумулятор + currentValue.x
    , Начальное значение
)

console.log (сумма)  

Сглаживание массива массивов

  let flattened = [[0, 1], [2, 3], [4, 5]].уменьшать(
  function (аккумулятор, currentValue) {
    вернуть аккумулятор .concat (currentValue)
  },
  []
)

  

Альтернативно записывается стрелкой:

  let flattened = [[0, 1], [2, 3], [4, 5]]. Reduce (
  (аккумулятор, текущее значение) => аккумулятор.concat (текущее значение),
  []
)
  

Подсчет экземпляров значений в
объект

  let names = ['Алиса', 'Боб', 'Тифф', 'Брюс', 'Алиса']

let counttedNames = names.reduce (function (allNames, name) {
  if (имя в allNames) {
    allNames [имя] ++
  }
  еще {
    allNames [имя] = 1
  }
  вернуть allNames
}, {})


  

Группировка объектов по собственности

  let people = [
  {имя: 'Алиса', возраст: 21},
  {имя: 'Макс', возраст: 20},
  {имя: 'Джейн', возраст: 20}
];

function groupBy (objectArray, property) {
  вернуть objectArray.reduce (function (acc, obj) {
    let key = obj [свойство]
    if (! acc [ключ]) {
      acc [ключ] = []
    }
    acc [ключ] .push (объект)
    возврат в соотв.
  }, {})
}

let groupedPeople = groupBy (люди, 'возраст')








  

Связывание массивов, содержащихся в массиве объектов, с помощью оператора распространения и
initialValue

 

пусть друзья = [{
  имя: 'Анна',
  книги: ['Библия', 'Гарри Поттер'],
  возраст: 21
}, {
  имя: 'Боб',
  книги: [«Война и мир», «Ромео и Джульетта»],
  возраст: 26
}, {
  имя: 'Алиса',
  книги: [«Властелин колец», «Сияние»],
  возраст: 18
}]



пусть allbooks = друзья. уменьшить (функция (аккумулятор, текущее значение) {
  return [... аккумулятор, ... currentValue.books]
}, ['Alphabet'])





  

Удалить повторяющиеся элементы в массиве

Примечание: Если вы используете среду, совместимую с
Установите и Array.from () , вы можете использовать
let ordersArray = Array.from (new Set (myArray)) , чтобы получить массив, в котором
повторяющиеся элементы были удалены.

  let myArray = ['a', 'b', 'a', 'b', 'c', 'e', ​​'e', ​​'c', 'd', 'd', 'd', 'd']
пусть myOrderedArray = myArray.уменьшить (функция (аккумулятор, текущее значение) {
  if (аккумулятор.indexOf (currentValue) === -1) {
    аккумулятор.push (currentValue)
  }
  возвратный аккумулятор
}, [])

console.log (myOrderedArray)  

Замените .filter (). map () на .reduce ()

Используя Array.filter () , затем Array.map () просматривает массив
дважды, но вы можете добиться того же эффекта, проходя только один раз с помощью
Array.reduce () , что делает его более эффективным. (Если вам нравятся петли for, вы
может фильтровать и отображать при однократном прохождении с помощью массива .forEach () ).

  постоянные числа = [-5, 6, 2, 0,];

const doubledPositiveNumbers = numbers.reduce ((аккумулятор, currentValue) => {
  if (currentValue> 0) {
    const doubled = currentValue * 2;
    аккумулятор.пуш (сдвоенный);
  }
  возвратный аккумулятор;
}, []);

console.log (doubledPositiveNumbers);  

Выполнение обещаний в последовательности

 
function runPromiseInSequence (arr, input) {
  вернуть arr.reduce (
    (обещание цепочки, текущая функция) => цепочка обещаний.затем (currentFunction),
    Promise.resolve (ввод)
  )
}


функция p1 (a) {
  вернуть новое обещание ((разрешить, отклонить) => {
    решить (a * 5)
  })
}


функция p2 (a) {
  вернуть новое обещание ((разрешить, отклонить) => {
    решить (a * 2)
  })
}


функция f3 (a) {
 вернуть * 3
}


функция p4 (a) {
  вернуть новое обещание ((разрешить, отклонить) => {
    решить (a * 4)
  })
}

const PromiseArr = [p1, p2, f3, p4]
runPromiseInSequence (PromiseArr, 10)
  . then (console.log)
  

Функциональная композиция, обеспечивающая трубопровод

 
const double = х => х + х
константная тройка = х => 3 * х
константная четверка = х => 4 * х


const pipe = (...functions) => input => functions.reduce (
    (acc, fn) => fn (acc),
    Вход
)


const multiply6 = труба (двойная, тройная)
const multiply9 = труба (тройка, тройка)
const multiply16 = труба (четверная, четверная)
const multiply24 = труба (двойная, тройная, четверная)


умножить6 (6)
умножить9 (9)
умножить16 (16)
умножить24 (10)

  

Записать карту, используя сокращение

  if (! Array.prototype.mapUsingReduce) {
  Array.prototype.mapUsingReduce = function (callback, thisArg) {
    верни это.уменьшить (функция (mappedArray, currentValue, index, array) {
      mappedArray [индекс] = callback.call (thisArg, currentValue, индекс, массив)
      вернуть mappedArray
    }, [])
  }
}

[1, 2,, 3] .mapUsingReduce (
  (currentValue, index, array) => currentValue + index + array.length (текущее значение, индекс, массив) => currentValue + index + array.length
)

  

Таблицы BCD загружаются только в браузере

Использование Array.reduce для суммирования свойства в массиве объектов · GitHub

Использование Array.reduce для суммирования свойства в массиве объектов · GitHub

Мгновенно делитесь кодом, заметками и фрагментами.

Использование Array.reduce для суммирования свойства в массиве объектов

var accounts = [
{имя: 'Джеймс Браун', msgCount: 123},
{имя: 'Стиви Уандер', msgCount: 22},
{имя: 'Хитрый камень', msgCount: 16},
{name: 'Otis Redding', msgCount: 300} // У Отиса больше всего сообщений
];
// получаем сумму msgCount prop по всем объектам в массиве
var msgTotal = accounts. уменьшить (функция (предыдущая, текущая) {
return prev + cur.msgCount;
}, 0);
console.log ('Всего сообщений:', msgTotal); // Всего сообщений: 461

Вы не можете выполнить это действие в настоящее время.

Вы вошли в систему с другой вкладкой или окном.Перезагрузите, чтобы обновить сеанс.
Вы вышли из системы на другой вкладке или в другом окне. Перезагрузите, чтобы обновить сеанс.

сумма чисел в массиве с использованием цикла for в javascript

Пример 2: В этом примере используется метод array reduce () для поиска произведения значений массива с помощью JavaScript. На самом деле есть несколько способов сделать это. Как рассчитать XOR элементов массива с помощью JavaScript? Даже если вы не являетесь разработчиком Javascript, этот пример должен вызвать недоумение.Чтобы найти массив суммы двух чисел в Javascript, используйте метод array.reduce (). Чтобы исправить это, мы используем приведение типов и приводим тип N к float, используя приведенный выше синтаксис. Затем вы заметите, что мы выполняем метод reduce для чисел и устанавливаем его на переменную сумму, устраняя необходимость в мутации. Цикл while используется для нахождения суммы натуральных чисел. Вопрос / задание Напишите функцию с именем addNeighbors, которая принимает массив чисел и добавляет каждое число в массиве к числу рядом с ним.Поэтому мы используем цикл for для перебора всех элементов массива. В этом руководстве мы найдем сумму n натуральных чисел, создав пользовательскую функцию в JavaScript. Посмотрите, как ваша статья появляется на главной странице GeeksforGeeks, и помогите другим гикам. let numbers = [2, 8, 1, 16, 4, 3, 9] var sum = 0 var counter = 0 // Введите свой код ниже, пока counter [адрес электронной почты защищен], чтобы сообщить о любых проблемах с вышеуказанным содержанием. Пример 1. В этом примере используется простой метод поиска суммы элементов массива с помощью JavaScript.Ознакомьтесь со статьей MDN о редукторах для получения дополнительной информации. Серия статей о том, как переписывать общие фрагменты Javascript с использованием концепций функций. // функция для сложения двух чисел. Внутри каждой итерации мы добавляем текущее число к нашей общей сумме. Как добавить объект в массив в JavaScript? Используя… 5 марта 2017 г.… мы используем стандартный цикл for для перебора номеров нашего массива и суммирования массива с помощью суммы. Просмотрите массив и суммируйте только числа JavaScript; Получение чисел с четным числом цифр JavaScript; Как написать цикл for на странице JSP? Сумма массива - это небольшая проблема, когда мы должны добавить каждый элемент в массив, пройдя через весь массив.Как открыть URL-адрес в новой вкладке с помощью JavaScript? Функция reduce () выполняет предоставленную функцию для каждого значения массива (слева направо). Этот код, как найти сумму массива в Java, показан ниже. Пишем код в комментарии? Я настоятельно рекомендую вам внимательно прочитать его, чтобы понять, что еще может предложить сокращение. Пример 1. В этом примере используется метод array reduce () для нахождения суммы значений массива с помощью JavaScript. Как распаковать элементы массива в отдельные переменные с помощью JavaScript? Третья итерация: в третьей итерации массива значения следующие: аккумулятор = 60 и currentValue = 40, сложенные вместе, мы возвращаем 100.Вычислили сумму, перебирая массив с помощью цикла for. В приведенной выше программе пользователю предлагается ввести число. Как установить дату типа ввода в формате дд-мм-гггг с помощью HTML? путем нахождения суммы каждой части параллельно. Для некоторого ввода это приведет к неверному результату. В нашем случае нам нужны только первые два. Как получить значение выбранного переключателя с помощью JavaScript? Как проверить, включает ли массив объект в JavaScript? Опыт. например, если на входе 6, то сумма будет 1 + 2 + 3 + 4 + 5 + 6 = 21; Цикл «For» используется для повторения определенного блока кода известное количество раз. На практике нам это нужно очень часто. Первая итерация: в первой итерации массива значения следующие: аккумулятор = 10 и currentValue = 20, сложенные вместе, мы возвращаем 30. Где я ошибаюсь? В… Программа на JavaScript для поиска суммы чисел - Руководство по коду 10 лучших проектов для начинающих, чтобы практиковать навыки HTML и CSS. Это плохо для удобочитаемости, а также более подвержено ошибкам, чем код, избегающий мутаций. JQuery | Установите значение текстового поля ввода, Написать интервью
count {сумма + = числа [счетчик] счетчик + = 1} Затем вы будете извлекать каждый элемент из массива чисел во время выполнения цикла и в конечном итоге решите задачу.Получил длину массива с помощью свойства .length. const numbers = [10, 20, 30, 40] // суммируется до 100, Как добавить функциональное программирование в любой проект JavaScript, Что лучше: innerText, innerHTML и textContent, Шаблоны для создания программ с отслеживанием состояния без каких-либо мутаций, Пять способов Чтобы перевернуть строку в Javascript, 3 вещи, которые необходимо учитывать при поиске хорошего курса Udemy, Самый мощный в мире учебник по Tic-Tac-Toe по JavaScript, Цикл по массивам и объектам в JavaScript, Классы JavaScript ES6, объясненные с примерами.Изменения выделены жирным шрифтом. яркость_4 Как я могу написать цикл for, который складывает все числа в массиве в переменную в JavaScript? Но это можно решить, разделив массив на части и найдя сумму каждой части одновременно, т.е. close, link Далее мы используем стандартный цикл for для перебора номеров нашего массива и суммирования массива с помощью суммы. Здравствуйте, друзья! Я снова застрял в настройке цикла for и внутреннего цикла for в этом массиве.код. Как рассчитать количество дней между двумя датами в javascript? Когда количество раз заранее неизвестно, мы используем цикл «Пока». Как дождаться завершения обещания, прежде чем возвращать переменную функции? Возвращает сумму всех значений в массиве: Версия PHP: 4.0.4+ Журнал изменений PHP: Версии PHP до 4. 2.1 изменили сам переданный массив и преобразовали строки в числа (которые часто конвертировали их в ноль, в зависимости от их значения. ) Как динамически создать элемент изображения с помощью JavaScript? Если вы раньше не видели этот синтаксис, я рекомендую проверить эту страницу MDN, посвященную функциям стрелок.Во время каждой итерации i добавляется к переменной суммы, а значение i увеличивается на 1. Тема: JavaScript / jQuery Пред. | След. Простой метод: он использует простой метод для доступа к элементам массива по номеру индекса и использует цикл для поиска суммы и произведения значений массива с помощью JavaScript. Этот пример находит сумму всех чисел до заданного входного числа, используя для цикла в Java. Введите положительное целое число: 100 Сумма натуральных чисел: 5050. Как выбрать случайный элемент из массива в JavaScript? ; pop берет элемент с конца.Короче говоря, мы создали переменную сумму, значение которой будет изменено позже. Как добавить HTML-код в div с помощью JavaScript? Как преобразовать массив объекта в массив с помощью JavaScript? Самый простой способ суммировать число в массиве в JavaScript будет выглядеть так: var числа = [1,2,3,4] var sum = 0; for (var i = 0; i [email protected] Как выбрать случайный цвет из массива с помощью CSS и JavaScript? Из приведенного выше примера вы можете прочитать: Оператор 1 устанавливает переменную перед запуском цикла (var i = 0) .В стандартном способе мы сначала объявляем переменную sum и устанавливаем ее начальное значение, равное нулю. Как только вы его разберете, метод сокращения станет довольно простым для понимания. В этой статье мы узнаем, как вычислить сумму нечетных и четных чисел на языке программирования Java. Первое, что следует отметить, это то, что мы изменили числа с var на const. У меня все это проходит, за исключением того, что мне нужно, чтобы он возвращал 0 вместо NaN, если мой массив пуст. Как передать переменные JavaScript в PHP? Как преобразовать строку JSON в массив объектов JSON с помощью JavaScript? Как проверить совпадение двух элементов с помощью jQuery / JavaScript? Простой метод: он использует простой метод для доступа к элементам массива по номеру индекса и использует цикл для поиска суммы и произведения значений массива с помощью JavaScript. Сумма массива: сравнение рекурсии с циклом for и методами ES6 в JavaScript. Объектно-ориентированное программирование веб-разработки на JavaScript. Допустим, у нас есть массив с огромным количеством числовых записей, и нам необходимо сравнить время, которое занимает рекурсия, и время, которое занимает простой цикл, и время, затрачиваемое функцией ES6 на суммирование всех записей массива, т.е. есть еще один вариант использования массивов - структура данных с именем stack .. var numbers = [10, 20, 30, 40] // суммируется до 100, for (var i = 0; я

Дешевый гравий рядом со мной,
Оптом Чай в пакетиках Великобритания,
Немецкий сливовый торт,
Ищу друга для анализа конца света,
Flak 38 105мм,
Цена подноса для торта в Шри-Ланке,
Калорийность кофейного ликера на порцию,

Как решить две суммы в JavaScript | Джордан Мур

Так как суть этой проблемы состоит в том, чтобы найти пару элементов, которые в сумме дают определенное число, логику этой задачи легко проследить:

  1. Для currentElement в массиве , сверить сумму currentElement и nextElement с целью.Если sum === target , вернуть индексы currentElement и nextElement .
  2. Перебрать массив , проверяя каждый элемент плюс каждый элемент с более высоким индексом, пока не будет найдена правильная пара.

Это решение грубой силы . Это неэффективное решение, так как оно потенциально требует многократной итерации по массиву , прежде чем найти нужную пару.

В большинстве случаев будет тестовый пример, который имеет массив с тысячами элементов.Теперь представьте, что элементы, сумма которых === target , находятся в индексах [array.length - 2, array.length - 1] .

Чтобы достичь этих двух элементов, элементы n-1 из массива должны проходить итерацию на каждой итерации цикла для currentElement .

Помните, что currentElement необходимо суммировать с каждым элементом после в массиве , поскольку элементы до currentElement уже были проверены.

Этот вложенный цикл приведет к тысячам ненужных итераций.

Вот диаграмма, на которой подробно показано количество итераций, необходимых для проверки всего массива . Имейте в виду, что это очень маленький ввод; представьте себе этот тип алгоритма на входе огромных .

Окно , красное окно , представляет currentElement . Зеленое окно представляет все элементы, которые должны быть добавлены с currentElement для проверки суммы === target .Для каждого элемента в зеленом окне есть одна итерация.

Выражаясь математически, существует n ** 2 возможных пар в массиве . Таким образом, самый длинный (худший случай), который может занять этот алгоритм, составляет O (n ** 2) раз, что невероятно неэффективно.

Как можно видеть, метод перебора не идеален для больших входов массива .

Должен быть способ минимизировать количество итераций, необходимых для поиска правильной пары.Есть ли структура данных, которая позволяет постоянное время поиска O (1) ?

Хеш-таблица

Хеш-таблица - это набор пар ключей и значений. Хэш-функция используется для сопоставления значений с индексами, также известными как ключи. Эти пары ключ и значение обеспечивают постоянное время поиска.

В JavaScript мы можем использовать объект для создания хеш-таблицы. Вот один пример простой хеш-таблицы:

Как показано в строках 6–9, можно получить доступ к индексу каждого элемента из значений , обратившись к значению в хэш-таблице .

Основным преимуществом использования хеш-таблицы является время поиска O (1) . Вместо того, чтобы перебирать список значений, чтобы найти правильное, после того, как значения сопоставлены с каким-то уникальным ключом, на значение можно сразу же ссылаться с использованием его ключа.

Итак, было бы разумно использовать хеш-таблицу для двух сумм; однако, как правильно использовать его для этой проблемы?

Решение методом перебора состоит из двух циклов, один вложен в другой. Цикл, который занимает больше времени, - это вложенный цикл, поскольку он проходит через массив несколько раз.Вложенный цикл был окрашен в зеленый цвет на картинке выше.

Если бы был только первый цикл, представленный окном , красным окном на рисунке выше, временная сложность была бы O (n) , так как в худшем случае массив должен был бы пройти через полностью найти правильную пару.

Рекомендуется исключить вложенный цикл. Можно ли заменить вложенный цикл хеш-таблицей?

Да, хеш-таблица действительно отлично работает вместе с одиночным циклом.

Итак, цикл будет перебирать массив по одному элементу за раз. Это означает, что currentElement необходимо сравнить с каждым другим элементом в массиве . Как это можно реализовать с помощью хеш-таблицы?

Число, которое будет сопряжено с currentElement , - это разница между currentElement и target . Итак, сохраните цель - currentElement в currentDifference .Используя функцию поиска в хеш-таблице, проверьте, является ли currentDifference ключом в хеш-таблице.

Если он существует в хеш-таблице, это означает, что он является элементом массива .

Вот рисунок, на котором подробно описан этот шаг алгоритма. Для этого чертежа входными данными являются: array = [3, 2, 4], target = 6 . Кроме того, в цикле currentElement = 2 .

Иногда необходимы ручка и бумага.

Ответ для этих входных данных: [1, 2] , поскольку 2 и 4 с индексами 1 и 2 соответственно составляют пару чисел, которые в сумме составляют target = 6 .

Алгоритм, описанный выше, успешно нашел правильный элемент путем поиска currentDifference в hashTable , чтобы определить, существует ли этот элемент. Затем он вернул индекс hashTable [currentDifference] , который использовался в возвращаемом значении [1, 2] . 1 представляет собой индекс currentElement в массиве .

Единственное предостережение для этого алгоритма состоит в том, что элемент не должен объединяться сам с собой, чтобы соответствовать цели .Однако простая проверка currentElementIndex! == hashTable [currentDifference] устранит этот пограничный случай.

Итак, окончательный алгоритм:

  1. Создайте объект, содержащий пары ключ-значение элемента и его индекс соответственно.
  2. Обойти массив . Для currentElement вычислите currentDifference .
  3. Если currentDifference существует в hashTable и currentElementIndex! == hashTable [currentDifference] , вернуть индексы каждого элемента.
  4. Если currentDifference не существует или индексы обоих элементов равны, перейти к следующему элементу в массиве .

Практика алгоритмов: сумма продукта. Еще один алгоритм, который часто встречается… | Синди Кей

С 2021 годом! Это новый год и новое начало, и мы снова погружаемся в освоение алгоритмов.

Я был занят подготовкой к предстоящим собеседованиям и удвоил усилия, чтобы попрактиковаться в алгоритмах, поэтому на этой неделе давайте перейдем к третьей итерации серии «Практика алгоритмов».

Фото timJ на Unsplash

Product Sum

На этой неделе мы рассмотрим задачу алгоритма Product Sum. Это еще один алгоритм, который часто возникает во время технических собеседований. Учитывая массив, наша задача - написать функцию, которая возвращает сумму его произведения.

Некоторые вещи, которые нужно прояснить, прежде чем мы приступим к размышлениям о том, как решить текущую задачу. Данный массив (то, что мы будем называть «специальным» массивом) всегда является непустым массивом, содержащим целые числа или другие вложенные «специальные» массивы.

А что мы понимаем под суммой продукта? Сумма продукта «особого» массива представляет собой сумму его элементов, но с одной загвоздкой - там, где есть вложенные «специальные» массивы, элементы вложенного массива суммируются и умножаются на их уровень глубины (как вложенные «специальный» массив).

Давайте рассмотрим несколько примеров, чтобы проиллюстрировать концепцию:

 Данный массив: [a, b] 
Сумма продукта = a + bGiven Массив: [a, [b, c]]
Сумма продукта = a + 2 (b + c) Заданный массив: [a, [b, [c]]]
Сумма продукта = a + 2 (b + 3c)

Эта проблема кажется простой и простой, но вложенные массивы могут быть очень сложными и запутанными. быстро.Как мы можем отслеживать, насколько вложен элемент, чтобы мы могли получить точную сумму продукта для этого элемента?

Концептуальный обзор

Основной проблемой при решении этой проблемы является определение уровня глубины элемента. Поскольку данный массив может состоять из дополнительных вложенных массивов, это может стать довольно запутанным. Однако давайте подумаем об этом - пока мы просматриваем наш массив, если текущий элемент является другим массивом, мы знаем, что это вложенный элемент. Если пройти через данный массив и никогда не попасть в другой элемент массива, то мы знаем, что имеем дело с массивом только одного уровня глубины. Это важный момент, о котором следует помнить, когда мы пытаемся найти решение.

Итак, прежде чем мы перейдем к мельчайшим подробностям, давайте повторим то, что мы знаем до сих пор. Мы знаем, что нам нужно перебрать массив и для каждого элемента проверять, является ли элемент вложенным. Мы можем сделать это, проверив, является ли элемент другим массивом. Если это не другой массив - то есть это невложенный элемент - мы просто добавим элемент к нашей сумме. Если элемент действительно является другим массивом, мы знаем, что сначала нам нужно выяснить, насколько вложен элемент, чтобы мы могли использовать это для умножения на сумму внутреннего массива.Скорее всего, это потребует какой-то рекурсии.

Пошаговое руководство по коду

Теперь мы можем перейти к собственно кодированию.

Я буду использовать цикл for для итерации по массиву. Чтобы проверить, является ли элемент массивом, я буду использовать метод Array.isArray () , который определяет, является ли переданное значение массивом.

Мы можем инициализировать переменную sum и установить для нее начальное значение 0, чтобы мы могли отслеживать общую сумму.Нам также нужно следить за вложенностью. Здесь я буду использовать свойство вложенности , для которого установлено значение по умолчанию 1, чтобы отслеживать уровень глубины элемента.

Во время итерации по массиву мы хотим проверить, является ли каждый элемент массивом. Если это так, мы делаем рекурсивный вызов нашей функции, чтобы обновить нашу сумму. Мы также хотим учесть вложенность элементов, добавив 1 к нашей переменной вложенности . Если мы не имеем дело с массивом, мы можем просто добавить элемент к нашей сумме.В конце мы захотим вернуть сумму, умноженную на нашу вложенную переменную , чтобы получить сумму нашего продукта.

Вот как это выглядит в JavaScript:

Проверить пару в массиве с заданной суммой

Проверить пару в массиве с заданной суммой - Задача интервью

Уровень сложности : Средний

Спрошено в : Google, Facebook, Amazon

Понимание проблемы

Описание проблемы: Учитывая массив из n целых чисел и заданное число K, определяет есть ли в массиве пара элементов, сумма которых равна точно K.

Например:

Ввод: A [] = [-5, 1, -40, 20, 6, 8, 7], K = 15

Выход: true (7, 8 и -5, 20 - пары с суммой 15)

Вход: A [] = [-5, 4, -2, 16, 8, 9], K = 15

Выход: false (Нет пары элементов, сумма которых равна на 15)

Возможные дополнительные вопросы, которые следует задать интервьюеру:

  • Знаем ли мы что-нибудь о диапазоне чисел в массиве? Ответ: Нет, они могут быть произвольными целыми числами.
  • Обязательно ли элементы массива положительны? Ответ: Нет, они могут быть положительными, отрицательными или нулевыми.
  • Знаем ли мы что-нибудь о значении K относительно чисел в массиве? Ответ: Нет, это может быть произвольно.
  • Можно ли рассматривать пары элемента и самого себя? Ответ: Нет, пара должна состоять из двух разных элементов массива.
  • Может ли массив содержать дубликаты? Ответ: Конечно, это возможно.

Разработка эффективных решений

Мы обсуждаем четыре способа решения этой проблемы:

  1. Подход грубой силы: использование двух циклов
  2. Сортировка и бинарный поиск
  3. Сортировка и подход с двумя указателями
  4. Использование хэш-таблицы

1.Подход грубой силы: использование двух петель

Используйте две петли и проверьте A [i] + A [j] == K для каждой пары (i, j) в A []. Если существует пара с суммой, равной K, верните true. К концу обоих циклов, если вы не нашли такую ​​пару, верните false.

Псевдокод

  int find_sumPair (A [], n, K)
{
  для (от i = 0 до n-1)
  {
     для (от j = i + 1 до n-1)
     {
         если (A [i] + A [j] == K)
         возврат 1
     }
  }
возврат -1
}  

Анализ сложности

Общее количествосравнения в худшем случае = Всего нет. возможных пар = nC2 = n (n-1) / 2 = O (n²)

Сложность времени = O (n²) и сложность пространства = O (1). Можем ли мы улучшить временную сложность? Попробуем над этим подумать.

2. Сортировка и двоичный поиск

Идея двоичного поиска отлично работает в случае сортированного массива. Мы можем отсортировать A [] и для каждого значения A [i] искать, есть ли другое значение K-A [i] в ​​массиве или нет. Двоичный поиск выполняет поиск за O (logn), что может помочь нам уменьшить временную сложность.

Шаги решения

  • Отсортируйте массив A [] в порядке возрастания
  • Для каждого элемента A [i] используйте двоичный поиск, чтобы найти K-A [i].
  • Если в массиве A существует значение K-A [i], вернуть true.
  • Если вы не нашли такой пары во всем массиве, то верните false.

Псевдокод

  int find_sumPair (A [], n, K)
 {
   Сортировать (A, n)
   для (от i = 0 до n-1)
   {
      x = binarySearch (A, 0, n-1, K-A [i])
      если (х)
      возврат 1
   }
 возврат -1
 }  

Анализ сложности

Предположим, мы используем сортировку по кучу / сортировку слиянием и итеративный двоичный поиск для реализации.

Сложность времени = Сложность сортировки + n. Временная сложность двоичного поиска = O (nlogn) + n. O (logn) = O (nlogn)

Пространственная сложность = Пространственная сложность сортировки + Пространственная сложность двоичного поиска (итерационная реализация)

При сортировке слиянием сложность пространства = O (n) + O (1) = O ( n)

Если сортировка в куче, сложность пространства = O (1) + O (1) = O (1)

Критические идеи для размышления!

  • Каковы были бы временные и пространственные сложности, если бы мы использовали быструю сортировку? Сравните различные алгоритмы сортировки
  • Какова будет пространственная сложность рекурсивного двоичного поиска?
  • Почему мы ищем K - A [i] для каждого элемента в массиве A []?
  • Подготовьте список проблем, в которых можно применить идею сортировки и бинарного поиска.

3. Сортировка и подход с двумя указателями

Отсортируйте массив A [], затем пройдитесь двумя указателями внутрь от концов массива, в каждой точке глядя на их сумму. Если это ровно k, то все готово. Если он превышает k, то любая сумма, использующая больший элемент, слишком велика, поэтому мы перемещаем этот указатель внутрь. Если он меньше k, то любая сумма, использующая нижний элемент, слишком мала, поэтому мы перемещаем этот указатель внутрь.

Шаги решения

  1. Отсортируйте массив A [] в порядке возрастания
  2. Инициализируйте две индексные переменные в отсортированном массиве A [].
  • левый указатель: i = 0
  • правый указатель: j = n-1

3) Запустить цикл, пока i

  • Если (A [i] + A [j] == K), то вернуть истину
  • if (A [i] + A [j]
  • if (A [i] + A [j]> K) затем уменьшаем j на 1

4) Если не нашел такой пары во всем массиве - вернуть false.

Визуализация решения

Псевдокод

  int find_sumPair (A [], n, K)
 {
    Сортировать (A, n)
    я = 0
    j = n -1
    в то время как (я  

Анализ сложности

Предположим, мы используем сортировку кучи или сортировку слиянием.

Сложность времени = Сложность сортировки + Сложность времени подхода с двумя указателями (цикл while) = O (n log n) + O (n) = O (n log n)

При сортировке слиянием сложность пространства = O ( n)

Если сортировка в куче, сложность пространства = O (1)

Критические идеи для размышления!

  • этот алгоритм работает нормально, если элементы повторяются?
  • Временная сложность цикла while в худшем случае равна O (n) - почему?
  • Почему идея подхода с двумя указателями идеально подходит для отсортированного массива?
  • Подготовьте список проблем, в котором вы можете применить идею подхода с двумя указателями для решения.

4. Использование хеш-таблицы

Идея состоит в том, чтобы использовать хеш-таблицу для улучшения временной сложности, поскольку она выполняет поиск и вставку эффективно в среднем O (1).

Шаги решения

  1. Возьмите хеш-таблицу H размера O (n)
  2. Запустите цикл и просканируйте массив A [] для каждого A [i]. Проверьте, присутствует ли K-A [i] в ​​хеш-таблице или нет.
  • Если да, мы нашли пару и возвращаем истину.
  • Если нет, вставьте A [i] в ​​хеш-таблицу

3.Если вы не нашли такую ​​пару к концу цикла, верните false.

Псевдокод

  bool checkPair (int A [], int n, int K)
{
  Возьмите хеш-таблицу H размера O (n)
  для (от i = 0 до n-1)
  {
      int x = K - A [i]
      если (H.search (x) верно)
          возврат 1
      H.insert (A [i])
  }
 возврат -1
}  

Анализ сложности

В худшем случае мы просматриваем весь массив и не нашли ни одной такой пары. Сложность времени = Сложность времени вставки n элементов в хеш-таблицу + Сложность времени поиска (K-A [i]) n раз в хеш-таблице = n.О (1) + п. O (1) = O (n)

Сложность пространства = Дополнительное пространство в хеш-таблице = O (n)

Критические идеи для размышления!

  • этот алгоритм работает нормально, если элементы повторяются?
  • Каковы были бы временные и пространственные сложности, если бы мы использовали двоичное дерево поиска вместо хеш-таблицы? Сравните хэш-таблицу и двоичное дерево поиска
  • Это также хороший пример решения проблем с помощью структуры данных. Подготовьте список проблем, в которых мы используем структуры данных (хэш-таблица, BST, приоритетная очередь, стек, очередь и т. Д.) Для эффективного решения.
  • Есть ли другой способ решить эту проблему? Think

Сравнение различных решений

Подобные задачи для решения

  1. Дан массив целых чисел и число K, выведите все пары в массиве, сумма которых равна K.

Добавить комментарий

Ваш адрес email не будет опубликован. Обязательные поля помечены *

2021 © Все права защищены. Карта сайта