Final Array State After K Multiplication Operations I solution and explanation

def final_array_state(nums, k, multiplier):
    for _ in range(k):
        min_index = min(range(len(nums)), key=nums.__getitem__)
        nums[min_index] *= multiplier
    return nums

nums = [2, 1, 3, 5, 6]
k = 5
multiplier = 2
print(final_array_state(nums, k, multiplier))

import java.util.List;
import java.util.ArrayList;

public class Solution {
    public static void finalArrayState(List<Integer> nums, int k, int multiplier) {
        int numsSize = nums.size();
        for (int i = 0; i < k; i++) {
            int minIndex = 0;
            for (int j = 1; j < numsSize; j++) {
                if (nums.get(j) < nums.get(minIndex)) {
                    minIndex = j;
                }
            }
            nums.set(minIndex, nums.get(minIndex) * multiplier);
        }
    }
    
    public static void main(String[] args) {
        List<Integer> nums = new ArrayList<>();
        nums.add(2);
        nums.add(1);
        nums.add(3);
        nums.add(5);
        nums.add(6);
        
        int k = 5;
        int multiplier = 2;
        
        finalArrayState(nums, k, multiplier);

        System.out.println(nums);
    }
}

#include <iostream>
#include <vector>

void finalArrayState(std::vector<int>& nums, int k, int multiplier) {
    int numsSize = nums.size();
    while (k--) {
        int minIndex = 0;
        for (int i = 1; i < numsSize; ++i) {
            if (nums[i] < nums[minIndex]) {
                minIndex = i;
            }
        }
        nums[minIndex] *= multiplier;
    }
}

int main() {
    std::vector<int> nums = {2, 1, 3, 5, 6};
    int k = 5, multiplier = 2;

    finalArrayState(nums, k, multiplier);

    for (int num : nums) {
        std::cout << num << " ";
    }
    return 0;
}

function finalArrayState(nums, k, multiplier) {
    for (let i = 0; i < k; i++) {
        let minIndex = 0;
        for (let j = 1; j < nums.length; j++) {
            if (nums[j] < nums[minIndex]) minIndex = j;
        }
        nums[minIndex] *= multiplier;
    }
    return nums;
}

let nums = [2, 1, 3, 5, 6];
let k = 5;
let multiplier = 2;
console.log(finalArrayState(nums, k, multiplier));

#include <stdio.h>

void finalArrayState(int* nums, int numsSize, int k, int multiplier) {
    for (int i = 0; i < k; ++i) {
        int minIndex = 0;
        for (int j = 1; j < numsSize; ++j) {
            if (nums[j] < nums[minIndex]) {
                minIndex = j;
            }
        }
        nums[minIndex] *= multiplier;
    }
}

int main() {
    int nums[] = {2, 1, 3, 5, 6};
    int k = 5, multiplier = 2;
    int size = sizeof(nums)/sizeof(nums[0]);

    finalArrayState(nums, size, k, multiplier);

    // Output the results
    for(int i = 0; i < size; i++) {
        printf("%d ", nums[i]);
    }
    return 0;
}

using System;
using System.Linq;

class Program
{
    static void FinalArrayState(int[] nums, int k, int multiplier)
    {
        for (int i = 0; i < k; ++i)
        {
            int minIndex = Array.IndexOf(nums, nums.Min());
            nums[minIndex] *= multiplier;
        }
    }

    static void Main()
    {
        int[] nums = {2, 1, 3, 5, 6};
        int k = 5, multiplier = 2;
        FinalArrayState(nums, k, multiplier);

        Console.WriteLine(string.Join(" ", nums));
    }
}

import heapq

def final_array_state(nums, k, multiplier):
    heap = [(val, i) for i, val in enumerate(nums)]
    heapq.heapify(heap)
    nums_indices = {i: val for i, val in enumerate(nums)}

    while k > 0:
        # Get the current minimum
        min_val, min_idx = heapq.heappop(heap)

        # Release the new minimum after update
        if nums_indices[min_idx] == min_val:  # Ensure it's the latest value
            nums[min_idx] *= multiplier
            new_val = nums[min_idx]

            # Push the new value with the same index back to the heap
            heapq.heappush(heap, (new_val, min_idx))
            nums_indices[min_idx] = new_val
            k -= 1

    return nums

nums = [2, 1, 3, 5, 6]
k = 5
multiplier = 2
print(final_array_state(nums, k, multiplier))

import java.util.PriorityQueue;
import java.util.Comparator;
import java.util.HashMap;
import java.util.Map;
import java.util.List;
import java.util.ArrayList;

class ArrayElement {
    int value;
    int index;

    ArrayElement(int value, int index) {
        this.value = value;
        this.index = index;
    }
}

public class Solution {
    public static List<Integer> finalArrayState(List<Integer> nums, int k, int multiplier) {
        PriorityQueue<ArrayElement> heap = new PriorityQueue<>(Comparator.comparingInt(a -> a.value));
        Map<Integer, Integer> indexValueMap = new HashMap<>();

        for (int i = 0; i < nums.size(); i++) {
            heap.offer(new ArrayElement(nums.get(i), i));
            indexValueMap.put(i, nums.get(i));
        }

        while (k > 0 && !heap.isEmpty()) {
            ArrayElement minElem = heap.poll();
            if (indexValueMap.get(minElem.index) == minElem.value) {
                int newValue = minElem.value * multiplier;
                nums.set(minElem.index, newValue);
                indexValueMap.put(minElem.index, newValue);
                heap.offer(new ArrayElement(newValue, minElem.index));
                k--;
            }
        }

        return nums;
    }

    public static void main(String[] args) {
        List<Integer> nums = new ArrayList<>();
        nums.add(2);
        nums.add(1);
        nums.add(3);
        nums.add(5);
        nums.add(6);

        int k = 5;
        int multiplier = 2;

        List<Integer> finalState = finalArrayState(nums, k, multiplier);

        System.out.println(finalState);
    }
}

function getFinalState(nums: number[], k: number, multiplier: number): number[] {
    const pq = new PriorityQueue<number>((i, j) =>
        nums[i] === nums[j] ? i - j : nums[i] - nums[j],
    );

    for (let i = 0; i < nums.length; ++i) {
        pq.enqueue(i);
    }
    while (k--) {
        const i = pq.dequeue()!;
        nums[i] *= multiplier;
        pq.enqueue(i);
    }
    return nums;
}

func getFinalState(nums []int, k int, multiplier int) []int {
	h := &hp{nums: nums}
	for i := range nums {
		heap.Push(h, i)
	}

	for k > 0 {
		i := heap.Pop(h).(int)
		nums[i] *= multiplier
		heap.Push(h, i)
		k--
	}

	return nums
}

type hp struct {
	sort.IntSlice
	nums []int
}

func (h *hp) Less(i, j int) bool {
	if h.nums[h.IntSlice[i]] == h.nums[h.IntSlice[j]] {
		return h.IntSlice[i] < h.IntSlice[j]
	}
	return h.nums[h.IntSlice[i]] < h.nums[h.IntSlice[j]]
}

func (h *hp) Pop() any {
	old := h.IntSlice
	n := len(old)
	x := old[n-1]
	h.IntSlice = old[:n-1]
	return x
}

func (h *hp) Push(x any) {
	h.IntSlice = append(h.IntSlice, x.(int))
}