Минимальное произведение

public class Solution {
    public static int MinPossibleProduct(List<int> nums) {
        int a = nums[0];
        int b = nums[1];

        // min1 — самый минимальный элемент в массиве
        // min2 — второй минимальный элемент
        int min1 = Math.Min(a, b);
        int min2 = Math.Max(a, b);

        // max1 — самый максимальный элемент в массиве
        // max2 — второй максимальный элемент
        int max1 = Math.Max(a, b);
        int max2 = Math.Min(a, b);

        for (int i = 2; i < nums.Count; i++) {
            int num = nums[i];

            // Обновляем минимумы
            if (num < min1) {
                min2 = min1;
                min1 = num;
            } else if (num < min2) {
                min2 = num;
            }

            // Обновляем максимумы
            if (num > max1) {
                max2 = max1;
                max1 = num;
            } else if (num > max2) {
                max2 = num;
            }
        }
        // Выбираем наименьшее произведение из трёх возможных комбинаций
        // Заметка: max1 * max2 даст минимальный результат, когда
        // в массиве только отрицательные числа
        return Math.Min(Math.Min(min1 * min2, min1 * max1), max1 * max2);
    }
}

#include <vector>

using namespace std;

int minPossibleProduct(vector<int>& nums) {
    int a = nums[0];
    int b = nums[1];

    // min1 — самый минимальный элемент в массиве
    // min2 — второй минимальный элемент
    int min1 = min(a, b);
    int min2 = max(a, b);

    // max1 — самый максимальный элемент в массиве
    // max2 — второй максимальный элемент
    int max1 = max(a, b);
    int max2 = min(a, b);

    for (int i = 2; i < nums.size(); i++) {
        int num = nums[i];

        // Обновляем минимумы
        if (num < min1) {
            min2 = min1;
            min1 = num;
        } else if (num < min2) {
            min2 = num;
        }

        // Обновляем максимумы
        if (num > max1) {
            max2 = max1;
            max1 = num;
        } else if (num > max2) {
            max2 = num;
        }
    }
    // Выбираем наименьшее произведение из трёх возможных комбинаций
    // Заметка: max1 * max2 даст минимальный результат, когда
    // в массиве только отрицательные числа
    return min(min(min1 * min2, min1 * max1), max1 * max2);
}

package main

func min(a, b int) int {
    if a < b {
        return a
    }
    return b
}

func max(a, b int) int {
    if a > b {
        return a
    }
    return b
}

func minPossibleProduct(nums []int) int {
    a := nums[0]
    b := nums[1]

    // min1 — самый минимальный элемент в массиве
    // min2 — второй минимальный элемент
    min1 := min(a, b)
    min2 := max(a, b)

    // max1 — самый максимальный элемент в массиве
    // max2 — второй максимальный элемент
    max1 := max(a, b)
    max2 := min(a, b)

    for i := 2; i < len(nums); i++ {
        num := nums[i]

        // Обновляем минимумы
        if num < min1 {
            min2 = min1
            min1 = num
        } else if num < min2 {
            min2 = num
        }

        // Обновляем максимумы
        if num > max1 {
            max2 = max1
            max1 = num
        } else if num > max2 {
            max2 = num
        }
    }
    // Выбираем наименьшее произведение из трёх возможных комбинаций
    // Заметка: max1 * max2 даст минимальный результат, когда
    // в массиве только отрицательные числа
    return min(min(min1 * min2, min1 * max1), max1 * max2)
}

import java.util.*;

public class Solution {
    public int minPossibleProduct(List<Integer> nums) {
        int a = nums.get(0);
        int b = nums.get(1);

        // min1 — самый минимальный элемент в массиве
        // min2 — второй минимальный элемент
        int min1 = Math.min(a, b);
        int min2 = Math.max(a, b);

        // max1 — самый максимальный элемент в массиве
        // max2 — второй максимальный элемент
        int max1 = Math.max(a, b);
        int max2 = Math.min(a, b);

        for (int i = 2; i < nums.size(); i++) {
            int num = nums.get(i);

            // Обновляем минимумы
            if (num < min1) {
                min2 = min1;
                min1 = num;
            } else if (num < min2) {
                min2 = num;
            }

            // Обновляем максимумы
            if (num > max1) {
                max2 = max1;
                max1 = num;
            } else if (num > max2) {
                max2 = num;
            }
        }
        // Выбираем наименьшее произведение из трёх возможных комбинаций
        // Заметка: max1 * max2 даст минимальный результат, когда
        // в массиве только отрицательные числа
        return Math.min(Math.min(min1 * min2, min1 * max1), max1 * max2);
    }
}

from typing import *

def min_possible_product(nums: List[int]) -> int:
    a = nums[0]
    b = nums[1]

    # min1 — самый минимальный элемент в массиве
    # min2 — второй минимальный элемент
    min1 = min(a, b)
    min2 = max(a, b)

    # max1 — самый максимальный элемент в массиве
    # max2 — второй максимальный элемент
    max1 = max(a, b)
    max2 = min(a, b)

    for i in range(2, len(nums)):
        num = nums[i]

        # Обновляем минимумы
        if num < min1:
            min2 = min1
            min1 = num
        elif num < min2:
            min2 = num

        # Обновляем максимумы
        if num > max1:
            max2 = max1
            max1 = num
        elif num > max2:
            max2 = num

    # Выбираем наименьшее произведение из трёх возможных комбинаций
    # Заметка: max1 * max2 даст минимальный результат, когда
    # в массиве только отрицательные числа
    return min(min1 * min2, min1 * max1, max1 * max2)

/**
 * @param {number[]} nums
 * @return {number}
 */
export function minPossibleProduct(nums) {
    let a = nums[0];
    let b = nums[1];

    // min1 — самый минимальный элемент в массиве
    // min2 — второй минимальный элемент
    let min1 = Math.min(a, b);
    let min2 = Math.max(a, b);

    // max1 — самый максимальный элемент в массиве
    // max2 — второй максимальный элемент
    let max1 = Math.max(a, b);
    let max2 = Math.min(a, b);

    for (let i = 2; i < nums.length; i++) {
        let num = nums[i];

        // Обновляем минимумы
        if (num < min1) {
            min2 = min1;
            min1 = num;
        } else if (num < min2) {
            min2 = num;
        }

        // Обновляем максимумы
        if (num > max1) {
            max2 = max1;
            max1 = num;
        } else if (num > max2) {
            max2 = num;
        }
    }
    // Выбираем наименьшее произведение из трёх возможных комбинаций
    // Заметка: max1 * max2 даст минимальный результат, когда
    // в массиве только отрицательные числа
    return Math.min(min1 * min2, min1 * max1, max1 * max2);
}