சம வரிசை கூறுகள் லீட்கோட் தீர்வுக்கான குறைந்தபட்ச நகர்வுகள்


சிரமம் நிலை எளிதாக
அடிக்கடி கேட்கப்படுகிறது அமேசான் ஆப்பிள் Coursera கூடுதலாக உண்மை உண்மையில் ஜேபி மோர்கன் கணித வேலைகள் மைக்ரோசாப்ட் 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), வரிசையில் நிலையான நினைவக இடத்தைப் பயன்படுத்துவதால்.