ಸಮಾನ ಅರೇ ಎಲಿಮೆಂಟ್‌ಗಳ ಕನಿಷ್ಠ ಚಲನೆಗಳು ಲೀಟ್‌ಕೋಡ್ ಪರಿಹಾರ


ತೊಂದರೆ ಮಟ್ಟ ಸುಲಭ
ಆಗಾಗ್ಗೆ ಕೇಳಲಾಗುತ್ತದೆ ಅಮೆಜಾನ್ ಆಪಲ್ ಕೋರ್ಸ್ಸೆರಾ ಫ್ಯಾಕ್ಟ್‌ಸೆಟ್ ವಾಸ್ತವವಾಗಿ JP ಮೋರ್ಗಾನ್ ಮ್ಯಾಥ್ವರ್ಕ್ಸ್ ಮೈಕ್ರೋಸಾಫ್ಟ್ Swiggy
ಡ್ರಾಬ್ರಿಡ್ಜ್ ಮಠ

ಸಮಸ್ಯೆ ಹೇಳಿಕೆ

ಈ ಸಮಸ್ಯೆಯಲ್ಲಿ, ನಮಗೆ ಒಂದು ನೀಡಲಾಗಿದೆ ಸರಣಿ ಪೂರ್ಣಾಂಕಗಳ. ಅಲ್ಲದೆ, ಈ ರಚನೆಯಲ್ಲಿ ನಿರ್ದಿಷ್ಟ ಕಾರ್ಯಾಚರಣೆಗಳನ್ನು ನಿರ್ವಹಿಸಲು ನಮಗೆ ಅನುಮತಿಸಲಾಗಿದೆ. ಒಂದು ಕಾರ್ಯಾಚರಣೆಯಲ್ಲಿ, ನಾವು ರಚನೆಯ ”n - 1 ″ (ಯಾವುದನ್ನೂ ಹೊರತುಪಡಿಸಿ ಎಲ್ಲಾ ಅಂಶಗಳು) ಅಂಶಗಳನ್ನು 1 ರಿಂದ ಹೆಚ್ಚಿಸಬಹುದು.

ಎಲ್ಲಾ ರಚನೆಯ ಅಂಶಗಳನ್ನು ಸಮಾನವಾಗಿಸಲು ಅಗತ್ಯವಿರುವ ಕನಿಷ್ಠ ಸಂಖ್ಯೆಯ ಕಾರ್ಯಾಚರಣೆಗಳನ್ನು ನಾವು ಕಂಡುಹಿಡಿಯಬೇಕು.

ಉದಾಹರಣೆ

Array = {1 , 2 , 3}
3
Array = {1 , 1 , 1}
0

 

ಸಮಾನ ಅರೇ ಎಲಿಮೆಂಟ್‌ಗಳ ಕನಿಷ್ಠ ಚಲನೆಗಳು ಲೀಟ್‌ಕೋಡ್ ಪರಿಹಾರಅಪ್ರೋಚ್ (ಮಠ)

ಈ ಸಮಸ್ಯೆಯಲ್ಲಿ, ಎಲ್ಲಾ ರಚನೆಯ ಅಂಶಗಳಿಗೆ ಸಮನಾಗಿ ನೀವು 1 ರಿಂದ ಹೆಚ್ಚಿಸಲು ಬಯಸುವ ಸಂಖ್ಯೆಗಳ ಗುಂಪನ್ನು ಆರಿಸುವುದು ಕಷ್ಟ. ಆದಾಗ್ಯೂ, ಶ್ರೇಣಿಯಲ್ಲಿನ 'N - 1' ಅಂಶಗಳನ್ನು ಹೆಚ್ಚಿಸುವುದರಿಂದ ಒಂದು ರಚನೆಯ ಅಂಶವನ್ನು 1 ರಿಂದ ಕಡಿಮೆಗೊಳಿಸಲಾಗುತ್ತದೆ. ಏಕೆಂದರೆ ಎಲ್ಲಾ ಅಂಶಗಳು ಸಮಾನವಾದ ನಂತರ ಅವುಗಳ ಮೌಲ್ಯ ಏನೆಂದು ಕಂಡುಹಿಡಿಯಲು ನಾವು ಬಯಸುವುದಿಲ್ಲ, ಬದಲಿಗೆ ನಾವು ಚಲಿಸುವಿಕೆಯ ಸಂಖ್ಯೆಯನ್ನು ಕಂಡುಹಿಡಿಯಲು ಆಸಕ್ತಿ ಹೊಂದಿದ್ದೇವೆ. ಈಗ, ಇದು ಅರ್ಥಗರ್ಭಿತವಾಗಿದೆ, ಏಕೆಂದರೆ ನಮ್ಮ ಕಾರ್ಯಾಚರಣೆಯು ರಚನೆಯಲ್ಲಿ ನಿಖರವಾಗಿ ಒಂದು ಅಂಶವನ್ನು 1 ರಿಂದ ಕಡಿಮೆಗೊಳಿಸುವುದರಿಂದ, ನಾವು ಶ್ರೇಣಿಯಲ್ಲಿನ ಎಲ್ಲಾ ಅಂಶಗಳನ್ನು ರಚನೆಯಲ್ಲಿರುವ ಕನಿಷ್ಠ ಅಂಶಕ್ಕೆ ಪರಿವರ್ತಿಸಬೇಕಾಗಿದೆ (ಏಕೆಂದರೆ ಇದನ್ನು ಕಡಿಮೆ ಮಾಡುವ ಅಗತ್ಯವಿಲ್ಲ ಮತ್ತಷ್ಟು).

ಸಮಾನ ಅರೇ ಎಲಿಮೆಂಟ್ಸ್ ಲೀಟ್‌ಕೋಡ್ ಪರಿಹಾರಕ್ಕೆ ಕನಿಷ್ಠ ಚಲನೆಗಳಿಗೆ ಅನುಷ್ಠಾನ

ಸಿ ++ ಪ್ರೋಗ್ರಾಂ

#include <bits/stdc++.h>

using namespace std;

int minMoves(vector <int> nums) {
    int mn = *min_element(nums.begin() , nums.end()) , moves = 0;
    for(int &i : nums)
        moves += i - mn;
    return moves;
}

int main() {
    vector <int> nums = {1 , 2 , 3};
    cout << minMoves(nums) << endl;
    return 0;
}

ಜಾವಾ ಪ್ರೋಗ್ರಾಂ

import java.lang.*;
import java.util.*;

class min_moves {
    public static void main(String args[]) {
        int[] nums = {1 , 2 , 3};
        System.out.println(minMoves(nums));
    }

    public static int minMoves(int[] nums) {
        if(nums.length == 0)
            return 0;
        int mn = nums[0];
        for(int i = 0 ; i < nums.length ; i++) {
            mn = Math.min(mn , nums[i]);
        }

        int moves = 0;
        for(int i = 0 ; i < nums.length ; i++) {
            moves += nums[i] - mn;
        }

        return moves;
    }
}
3

ಸಮಾನ ಅರೇ ಅಂಶಗಳ ಕನಿಷ್ಠ ಚಲನೆಗಳ ಸಂಕೀರ್ಣ ವಿಶ್ಲೇಷಣೆ ಲೀಟ್‌ಕೋಡ್ ಪರಿಹಾರ

ಸಮಯ ಸಂಕೀರ್ಣತೆ

ಒ (ಎನ್), ರಚನೆಯ N = ಗಾತ್ರ. ನಾವು ಒಮ್ಮೆ ಇಡೀ ಶ್ರೇಣಿಯನ್ನು ಹಾದುಹೋಗುತ್ತೇವೆ.

ಬಾಹ್ಯಾಕಾಶ ಸಂಕೀರ್ಣತೆ 

ಒ (1), ನಾವು ರಚನೆಯಲ್ಲಿ ಸ್ಥಿರವಾದ ಮೆಮೊರಿ ಸ್ಥಳವನ್ನು ಬಳಸುತ್ತಿದ್ದಂತೆ.