Maximum product C++ - c++

Question

I am given a few array of both negative and positive numbers.
I should Find the maximum product obtained from multiplying 2 adjacent numbers in the array.
This is the code I wrote :
#include <vector>
#include <iostream>
using namespace std;
int adjacentElementsProduct(vector<int> inputArray)
{
for(int i = 0; i < inputArray.size(); i++) {
if((inputArray[i] * inputArray[i+1])>(inputArray[i+1] * inputArray[i+2])) {
std::cout << inputArray[i] * inputArray[i+1] << "\n";
} else if((inputArray[i+1] * inputArray[i+2])>(inputArray[i+2] * inputArray[i+3])) {
std::cout << inputArray[i+1] * inputArray[i+2] << "\n";
} else if((inputArray[i+2] * inputArray[i+3])>(inputArray[i+3] * inputArray[i+4])) {
std::cout << inputArray[i+2] * inputArray[i+3] << "\n";
} else if((inputArray[i+3] * inputArray[i+4])>(inputArray[i+4] * inputArray[i+5])) {
std::cout << inputArray[i+3] * inputArray[i+4] << "\n";
} else {
std::cout << "Unknow" << "\n";
} return 1;
}
}
int main() {
adjacentElementsProduct({5, 8});
adjacentElementsProduct({1,2,3});
adjacentElementsProduct({1,5,10,9});
adjacentElementsProduct({5,1,2,3,1,4});
adjacentElementsProduct({4,12,3,1,5});
adjacentElementsProduct({3,6,-2,-5,7,3});
adjacentElementsProduct({9, 5, 10, 2, 24, -1, -48});
adjacentElementsProduct({5, 6, -4, 2, 3, 2, -23});
adjacentElementsProduct({-23, 4, -5, 99, -27, 329, -2, 7, -921});
adjacentElementsProduct({1,0,1,0,1000});
adjacentElementsProduct({1,2,3,0});
return 1 ;
}
Output:
40
6
90
5
48
18
50
30
-20
Unknow
6
The code only compares the product of inputArray[i] * inputArray[i+1] and inputArray[i+1] * inputArray[i+2] But I want to find the maximum product among all the numbers in array.

Answer 1

You want to loop over the input vector and compute the products of adjacent elements.
Then, you want to find the maximum of those products. You don't need all that hardcoded [i+1], [i+2], [i+3], ... shenanigans, you already have something that can get all those numbers for you -- a for loop.
int adjacentElementsProduct(vector<int> inputArray)
{
// Set initial max product to a very small number so that
// it is always replaced by our first product
int maxProduct = std::numeric_limits<int>::min();
for(int i = 0;
i < inputArray.size() - 1; /* because we will be doing i + 1 inside the loop */
i++) {
// Calculate product of this and next element
int product = inputArray[i] * inputArray[i + 1];
if (product > maxProduct)
maxProduct = product; // This product is the greatest so far,
// so keep it and get rid of the old max.
}
return maxProduct;
}
To explain how this works, let's look at the execution of the function for an example input. Let's say we do adjacentElementsProduct({5,1,2,3,1,4});
maxProduct is set to some very large negative number (let's say -99999999)
inputArray.size() is 6. inputArray.size() - 1 is 5.
i = 0. Is 0 < 5? Yes. Go inside loop
product = inputArray[0] * inputArray[1] = 5
is 5 > maxProduct (-99999999)? Yes. Set maxProduct = 5
Increment i to 1.
i = 1. Is 1 < 5? Yes. Go inside loop
product = inputArray[1] * inputArray[2] = 2
is 2 > maxProduct (5)? No.
Increment i to 2.
i = 2. Is 2 < 5? Yes. Go inside loop
product = inputArray[2] * inputArray[3] = 6
is 6 > maxProduct (5)? Yes. Set maxProduct = 6
Increment i to 3.
i = 3. Is 3 < 5? Yes. Go inside loop
product = inputArray[3] * inputArray[4] = 3
is 3 > maxProduct (6)? No.
Increment i to 4.
i = 4. Is 4 < 5? Yes. Go inside loop
product = inputArray[4] * inputArray[5] = 4
is 4 > maxProduct (6)? No.
Increment i to 5.
i = 5. Is 5 < 5? No.
Return maxProduct, which is 6.

Answer 2

I think your function is overkill. You can do this with a running maxima:
const unsigned int length = inputArray.length();
int maximum = inputArray[0] * inputArray[1];
for (unsigned int i = 1U; i < (length - 1U); ++i)
{
const int product = inputArray[i] * inputArray[i + 1];
if (product > maximum) maximum = product;
}
This can be further optimized but that is an exercise for the OP.
Edit 1: Via Pointers
This may be more optimal, but only assembly language will tell (or profiling):
const unsigned int length = inputArray.length();
int const * p_first = &inputArray[0];
int const * p_second = &inputArray[1];
int maximum = (*p_first++) * (*p_second++);
for (unsigned int i = 1u; i < (length - 1); ++i)
{
int product = (*p_first++) * (*p_second++);
if (product > maximum) maximum = product;
}
In the above code fragment, the two array locations are maintained in pointers. The pointers can be maintained in registers. No need to calculate the offset within the loop each time. Incrementing pointers is simple and quick operation. Some processors have instructions that can dereference a pointer and increment in a single instruction. Some compilers may perform this optimization depending on the optimization setting.
Edit 2: Tracking Previous Value
Another optimization is to reduce the memory accesses by about half, by remembering the previous value in the array:
const unsigned int length = inputArray.length();
int previous = inputArray[0];
int next = inputArray[1];
int maximum = previous * next;
previous = next;
for (unsigned int i = 1u; i < length; ++i)
{
next = inputArray[i];
const int product = previous * next;
if (product > maximum) maximum = product;
previous = next;
}
In the above code fragment, the previous array value is remembered in a variable. This eliminates the need to access the array for the previous value; only one array access is required.
The compiler may perform this optimization at higher optimization levels. The proof is to compare the assembly language of the variables fragments.

Answer 3

There's an algorithm in <numeric> that does this for you:
int adjacentElementsProduct(std::vector<int> const & inputArray)
{
// [[assert: inputArray.size > 1 ]]
return std::inner_product(inputArray.begin(), inputArray.end() - 1,
inputArray.begin() + 1,
0,
[](int i, int j) { return std::max(i, j); },
std::multiplies{});
}
which is about as efficient, and readable as it gets.

Answer 4

For starters the function should not output any message. It is the caller of the function will decide whether to output a message or not.
The function should return an iterator or a pair of iterators that point to the two adjacent elements with the maximum product.
As for your function implementation then it has undefined behavior because it can access non-existent elements of the vector.
I can suggest the following function definition as it is shown in the demonstrative program below.
#include <iostream>
#include <utility>
#include <vector>
#include <iterator>
std::pair<std::vector<int>::const_iterator, std::vector<int>::const_iterator>
adjacentElementsProduct( const std::vector<int> &v )
{
std::pair<std::vector<int>::const_iterator, std::vector<int>::const_iterator>
p = { std::begin( v ), std::end( v ) };
if (not ( v.size() < 2 ))
{
p.second = std::next( std::begin( v ) );
long long int max_product = static_cast<long long int>( *p.first ) * *p.second;
for (auto prev = p.second, current = std::next( p.second );
current != std::end( v );
std::advance( prev, 1 ), std::advance( current, 1 ))
{
if (max_product < static_cast<long long int>( *prev ) * *current)
{
p = { prev, current };
}
}
}
return p;
}
int main()
{
std::vector<int> v = { 5, 8 };
auto p = adjacentElementsProduct( v );
std::cout << static_cast< long long int >( *p.first ) * *p.second << '\n';
v = { 1,2,3 };
p = adjacentElementsProduct( v );
std::cout << static_cast< long long int >( *p.first ) * *p.second << '\n';
v = { 1,5,10,9 };
p = adjacentElementsProduct( v );
std::cout << static_cast< long long int >( *p.first ) * *p.second << '\n';
v = { 5,1,2,3,1,4 };
p = adjacentElementsProduct( v );
std::cout << static_cast< long long int >( *p.first ) * *p.second << '\n';
v = { 4,12,3,1,5 };
p = adjacentElementsProduct( v );
std::cout << static_cast< long long int >( *p.first ) * *p.second << '\n';
v = { 3,6,-2,-5,7,3 };
p = adjacentElementsProduct( v );
std::cout << static_cast< long long int >( *p.first ) * *p.second << '\n';
v = { 9, 5, 10, 2, 24, -1, -48 };
p = adjacentElementsProduct( v );
std::cout << static_cast< long long int >( *p.first ) * *p.second << '\n';
v = { 5, 6, -4, 2, 3, 2, -23 };
p = adjacentElementsProduct( v );
std::cout << static_cast< long long int >( *p.first ) * *p.second << '\n';
v = { -23, 4, -5, 99, -27, 329, -2, 7, -921 };
p = adjacentElementsProduct( v );
std::cout << static_cast< long long int >( *p.first ) * *p.second << '\n';
v = { 1, 0, 1, 0, 1000 };
p = adjacentElementsProduct( v );
std::cout << static_cast< long long int >( *p.first ) * *p.second << '\n';
v = { 1,2,3,0 };
p = adjacentElementsProduct( v );
std::cout << static_cast< long long int >( *p.first ) * *p.second << '\n';
}
The program output is
40
6
90
6
48
21
48
30
-14
0
6
If you do not know yet iterators than the function can be defined the following way
#include <iostream>
#include <utility>
#include <vector>
std::pair<std::vector<int>::size_type, std::vector<int>::size_type>
adjacentElementsProduct( const std::vector<int> &v )
{
std::pair<std::vector<int>::size_type, std::vector<int>::size_type>
p = { 0, v.size() };
if (not ( v.size() < 2 ))
{
p.second = 1;
long long int max_product = static_cast<long long int>( p.first ) * p.second;
for (std::vector<int>::size_type i = 3; i < v.size(); i++ )
{
if (max_product < static_cast<long long int>( v[i - 1] ) * v[i] )
{
p = { i - 1, i };
}
}
}
return p;
}
int main()
{
std::vector<int> v = { 5, 8 };
auto p = adjacentElementsProduct( v );
std::cout << static_cast< long long int >( p.first ) * p.second << '\n';
v = { 1,2,3 };
p = adjacentElementsProduct( v );
std::cout << static_cast< long long int >( p.first ) * p.second << '\n';
v = { 1,5,10,9 };
p = adjacentElementsProduct( v );
std::cout << static_cast< long long int >( p.first ) * p.second << '\n';
v = { 5,1,2,3,1,4 };
p = adjacentElementsProduct( v );
std::cout << static_cast< long long int >( p.first ) * p.second << '\n';
v = { 4,12,3,1,5 };
p = adjacentElementsProduct( v );
std::cout << static_cast< long long int >( p.first ) * p.second << '\n';
v = { 3,6,-2,-5,7,3 };
p = adjacentElementsProduct( v );
std::cout << static_cast< long long int >( p.first ) * p.second << '\n';
v = { 9, 5, 10, 2, 24, -1, -48 };
p = adjacentElementsProduct( v );
std::cout << static_cast< long long int >( p.first ) * p.second << '\n';
v = { 5, 6, -4, 2, 3, 2, -23 };
p = adjacentElementsProduct( v );
std::cout << static_cast< long long int >( p.first ) * p.second << '\n';
v = { -23, 4, -5, 99, -27, 329, -2, 7, -921 };
p = adjacentElementsProduct( v );
std::cout << static_cast< long long int >( p.first ) * p.second << '\n';
v = { 1, 0, 1, 0, 1000 };
p = adjacentElementsProduct( v );
std::cout << static_cast< long long int >( p.first ) * p.second << '\n';
v = { 1,2,3,0 };
p = adjacentElementsProduct( v );
std::cout << static_cast< long long int >( p.first ) * p.second << '\n';
}