प्रौद्योगिकी साझेदारी

한어Русский языкEnglishFrançaisIndonesianSanskrit日本語DeutschPortuguêsΕλληνικάespañolItalianoSuomalainenLatina

चर विभाजन प्रबन्धन समाधान

• सर्वोत्तम अनुकूलनम् : मुक्तक्षेत्रं क्षमतया वर्धते
• दुष्टतमः अनुकूलनः : मुक्तक्षेत्रं क्षमतानुसारं न्यूनं भवति
• प्रथमं अनुकूलतां कुर्वन्तु: मुक्तक्षेत्रं पताद्वारा वर्धितं भवति

C++ संरचनासु कन्स्ट्रक्टर् सन्ति ।

Linux मध्ये नूतनं उपयोक्तारं समूहं वा रचयन्तु

• useradd: आदेशस्य उपयोगः उपयोक्तृलेखस्य निर्माणार्थं भवति
• usermod: उपयोक्तृलेखं परिवर्तयन्तु
• groupadd: नूतनं कार्यसमूहं रचयन्तु
• userdel: उपयोक्तृलेखं विलोपयन्तु

#include प्रोग्रामसञ्चिकायाः ​​मध्ये दृश्यते ।

औपचारिकमापदण्डनामानि कार्यघोषणासु लोपयितुं शक्यन्ते, परन्तु परिभाषासु न ।

रेखीय सारणी

यदि निम्नलिखितशर्तद्वयं पूरयति तर्हि अशून्यदत्तांशसंरचना:

1. एकः एव मूलग्रन्थिः अस्ति
2. प्रत्येकं नोड् अधिकतया एकः पूर्वनोड् अधिकतया एकः अनुवर्ती नोड् च भवति ।

रेखीयसंरचना इति कथ्यते, दत्तांशसंरचनासु रेखीयसारणी इति च कथ्यते ।
द्विगुणितसूचीनोड् इत्यस्य द्वौ सूचकक्षेत्रौ स्तः तथा च रेखीयसंरचना अस्ति ।
वृत्ताकारलिङ्क्ड् सूचीयां सर्वेषां नोड्-सूचकाः अशून्याः सन्ति, रेखीयसंरचना अपि सन्ति ।

हैश टेबल ज्ञातव्यम्

हैश-सारणीं निर्मातुं विधिषु अन्तर्भवति: प्रत्यक्ष-सङ्केत-विधिः, विभागः, शेष-विधिः च ।

द्वन्द्वनिराकरणविधयः अन्तर्भवन्ति- १.

• श्रृङ्खला-सङ्केत-विधिः : लिङ्क्ड्-सूचिकायाः ​​उपयोगेन समान-हैश-मूल्येन सह तत्त्वानि संयोजयन्तु ।
• रेखीयपरिचयः ततः हैशिंगविधिः : संघर्षस्य अनन्तरं स्थापनार्थं रिक्तस्थानानि अन्वेष्टुं अधः चक्रं कुर्वन्तु ।

संख्यात्मकपरिधिषु बिट्विज AND

वाम-दक्षिणयोः पूर्णाङ्कद्वयं दत्त्वा, अन्तरालं [वाम, दक्षिण] प्रतिनिधियन्, अस्मिन् अन्तरालस्य सर्वेषां सङ्ख्यानां बिट्विज AND परिणामं प्रत्यागच्छतु ।

बिट्-श्रृङ्खलायाः कृते यावत् शून्य-मूल्येन सह बिट् भवति तावत् अस्याः श्रृङ्खलायाः बिट्-आकारस्य AND-सञ्चालनस्य परिणामः शून्यः भवति ।

उपर्युक्ते उदाहरणे तत् ज्ञातुं शक्नुमःसर्वेषु सङ्ख्यासु बिट्वाइज् AND ऑपरेशनं करणस्य परिणामः शून्यैः गद्दीकृतैः शेषबिट्-सहितं सर्वेषां तत्सम्बद्धानां द्विचक्रीय-तारानाम् सामान्यः उपसर्गः भवति ।

एकवारमेव दृश्यन्ते ये संख्याः (2) .

एकं पूर्णाङ्कसरणिका nums दत्तं, प्रत्येकं तत्त्वं त्रिवारं दृश्यते केवलं एकवारं दृश्यमानं तत्त्वं विहाय ।

रेखीयसमयजटिलतायाः सह एल्गोरिदम् डिजाइनं कुर्वन्तु तथा च समस्यायाः समाधानार्थं नित्यस्थानस्य उपयोगं कुर्वन्तु ।

प्रत्येकं द्विचक्रीयबिट् क्रमेण निर्धारयन्तु
यतः सरणीयां तत्त्वानि int इत्यस्य परिधिमध्ये सन्ति, अतः उत्तरस्य प्रत्येकं द्विचक्रीयबिट् क्रमेण 0 अथवा 1 इति गणनां कर्तुं शक्नुवन्ति ।

विशेषतः उत्तरस्य i-तमं द्विचक्रीय-अङ्कं विचारयन्तु (i 0 तः आरभ्य सङ्ख्याकृतं भवति), यत् 0 वा 1 वा भवितुम् अर्हति ।

उत्तरस्य i-तमः अङ्कः सरणीयां सर्वेषां तत्त्वानां i-तम-द्वि-अङ्कानां योगस्य 3 इत्यनेन विभक्तस्य शेषः भवति ।

class Solution {
public:
    int singleNumber(vector<int>& nums) {
        int ret = 0;
        for(int i=0; i<32; i++){
            int sum = 0;
            for(int num : nums){
                sum += ((num >> i) & 1);
            }
            ret += ((sum%3) << i);
        }
        return ret;
    }
};
1
2
3
4
5
6
7
8
9
10
11
12
13
14

पाव(x, n) ९.

द्रुत शक्ति + पुनरावृत्ति
द्रुतशक्ति-अल्गोरिदमस्य सारः divide and conquer algorithm इति ।
x तः आरभ्य प्रत्येकं समये पूर्वफलस्य प्रत्यक्षं वर्गीकरणं कुर्वन्तु । x64 शक्तिं प्राप्तुं 5 वारं गणनां कुर्वन्तु।

class Solution {
public:
    double quickMul(double x, long long N){
        if(N == 0){
            return 1.0;
        }
        double y = quickMul(x, N/2);
        return N%2 == 0 ? y * y : y * y * x;
    }
    double myPow(double x, int n) {
        long long N = n;
        return N >= 0 ? quickMul(x, N) : 1.0 / quickMul(x, -N); 
    }
};
1
2
3
4
5
6
7
8
9
10
11
12
13
14

कारकपश्चात् शून्यम्

एकं पूर्णाङ्कं n दत्तं चेत्, परिणामे पश्चात् शून्यानां संख्यां प्रत्यागच्छतु ।

n!

यतो हि अभाज्यगुणकस्य ५ संख्या अभाज्यगुणितस्य २ संख्यायाः अपेक्षया अधिका न भविष्यति, अतः केवलं अभाज्यगुणकस्य ५ संख्या एव विचार्यते ।

n!

class Solution {
public:
    int trailingZeroes(int n) {
        int res = 0;
        for(int i=5; i<=n; i += 5){
            for(int j=i; j%5 == 0; j/=5){
                res++;
            }
        }
        return res;
    }
};
1
2
3
4
5
6
7
8
9
10
11
12

परिपत्रलिङ्कितसूची

गतिसूचकः

/**
 * Definition for singly-linked list.
 * struct ListNode {
 *     int val;
 *     ListNode *next;
 *     ListNode(int x) : val(x), next(NULL) {}
 * };
 */
class Solution {
public:
    bool hasCycle(ListNode *head) {
        if(head == nullptr || head->next == nullptr){
            return false;
        }
        ListNode* slow = head->next;
        ListNode* fast = head->next->next;
        while(fast != nullptr){
            if(slow == fast){
                return true;
            }
            if(fast->next == nullptr){
                return false;
            }
            slow = slow->next;
            fast = fast->next->next;
        }
        return false;
    }
};
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29

क्रमबद्धलिङ्कितसूचौ विलीनं कुर्वन्तु

/**
 * Definition for singly-linked list.
 * struct ListNode {
 *     int val;
 *     ListNode *next;
 *     ListNode() : val(0), next(nullptr) {}
 *     ListNode(int x) : val(x), next(nullptr) {}
 *     ListNode(int x, ListNode *next) : val(x), next(next) {}
 * };
 */
class Solution {
public:
    ListNode* mergeTwoLists(ListNode* list1, ListNode* list2) {
        if(list1 == nullptr){
            return list2;
        }
        if(list2 == nullptr){
            return list1;
        }
        ListNode* newHead;
        if(list1->val <= list2->val){
            newHead = list1;
            list1 = list1->next;
        }else{
            newHead = list2;
            list2 = list2->next;
        }
        ListNode* p = newHead;
        while(list1 && list2){
            if(list1->val <= list2->val){
                p->next = list1;
                p = p->next;
                list1 = list1->next;
            }else{
                p->next = list2;
                p = p->next;
                list2 = list2->next;
            }
        }

        while(list1){
            p->next = list1;
            p = p->next;
            list1 = list1->next;
        }
        while(list2){
            p->next = list2;
            p = p->next;
            list2 = list2->next;
        }
        return newHead;
    }
};
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53

सममित द्विचक्रीय वृक्ष

वृक्षः सममितः भवति यदि तस्य वामदक्षिणौ उपवृक्षाः परस्परं दर्पणप्रतिमाः भवन्ति ।

• तेषां मूलग्रन्थिद्वयस्य मूल्यं समानम् अस्ति
• प्रत्येकस्य वृक्षस्य दक्षिणः उपवृक्षः अन्यस्य वृक्षस्य वामस्य उपवृक्षस्य दर्पणप्रतिमा भवति

द्विचक्रीयवृक्षस्य स्तरसरासरी

विस्तार-प्रथमं भ्रमणम्
अन्वेषणं मूलनोड्तः आरभ्यते, प्रत्येकस्मिन् गोले एकस्मिन् स्तरे सर्वाणि नोड्स् भ्रमति, स्तरस्य नोड्-सङ्ख्यां, स्तरस्य नोड्-सङ्ख्यायाः योगं च गणयति, ततः स्तरस्य औसतमूल्यं गणयति

• प्रारम्भे मूलनोड् पङ्क्तिबद्धः भवति ।
• प्रत्येकं भ्रमणस्य क्रमे पङ्क्तौ सर्वे नोड्स् बहिः निष्कासिताः भवन्ति, एतेषां नोड्स् इत्यस्य संख्या योगः च गण्यते, ततः औसतमूल्यं गण्यते, ततः नोडस्य सर्वे रिक्ताः बालनोड्स् पङ्क्तौ योजिताः भवन्ति

/**
 * Definition for a binary tree node.
 * struct TreeNode {
 *     int val;
 *     TreeNode *left;
 *     TreeNode *right;
 *     TreeNode() : val(0), left(nullptr), right(nullptr) {}
 *     TreeNode(int x) : val(x), left(nullptr), right(nullptr) {}
 *     TreeNode(int x, TreeNode *left, TreeNode *right) : val(x), left(left), right(right) {}
 * };
 */
class Solution {
public:
    vector<double> averageOfLevels(TreeNode* root) {
        vector<double> average;
        queue<TreeNode *> que;
        que.push(root);
        while(!que.empty()){
            double sum = 0;
            int size = que.size();
            for(int i=0; i<size; i++){
                TreeNode* node = que.front();
                que.pop();
                sum += node->val;
                TreeNode* left = node->left;
                TreeNode* right = node->right;
                if(left){
                    que.push(left);
                }
                if(right){
                    que.push(right);
                }
            }
            average.push_back(sum / size);
        }
        return average;
    }
};
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38

द्विचक्रीय वृक्षस्तरक्रमपरिभ्रमणम्

/**
 * Definition for a binary tree node.
 * struct TreeNode {
 *     int val;
 *     TreeNode *left;
 *     TreeNode *right;
 *     TreeNode() : val(0), left(nullptr), right(nullptr) {}
 *     TreeNode(int x) : val(x), left(nullptr), right(nullptr) {}
 *     TreeNode(int x, TreeNode *left, TreeNode *right) : val(x), left(left), right(right) {}
 * };
 */
class Solution {
public:
    vector<vector<int>> levelOrder(TreeNode* root) {
        vector<vector<int>> res;
        queue<TreeNode* > que;
        if(!root){
            return res;
        }
        que.push(root);
        while(!que.empty()){
            vector<int> temp;
            int size = que.size();
            for(int i=0; i<size; i++){
                TreeNode* node = que.front();
                que.pop();
                temp.push_back(node->val);
                TreeNode* left = node->left;
                TreeNode* right = node->right;
                if(left){
                    que.push(left);
                }
                if(right){
                    que.push(right);
                }
            }
            res.push_back(temp);
        }
        return res;
    }
};
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41

क्रमबद्धसरणौ द्वितीयकानि निष्कासयन्तु

क्रमबद्धः सरणी nums, स्थाने पुनरावृत्तितत्त्वानि विलोपयति, येन द्विवारं अधिकं दृश्यमानानि तत्त्वानि केवलं द्विवारं दृश्यन्ते, लोपानन्तरं च सरणीयाः नूतनदीर्घतां प्रत्यागच्छति

इनपुट् सरणीं स्थाने एव परिवर्तितं भवितुमर्हति तथा च O(1) अतिरिक्तस्थानस्य उपयोगेन करणीयम् ।

class Solution {
public:
    int removeDuplicates(vector<int>& nums) {
        int left = 0;
        int right = 0;
        int n = nums.size();
        int count = 0;
        int sum = 0;
        while (right < n) {
            if (nums[left] == nums[right]) {
                count++;
                right++;
            } else {
                if (count > 1) {
                    nums[++left] = nums[left];
                    sum += 2;
                } else {
                    sum += 1;
                }
                nums[++left] = nums[right++];
                count = 1;
            }
        }
        if (count > 1) {
            nums[++left] = nums[left];
            sum += 2;
        } else {
            sum += 1;
        }
        return sum;
    }
};
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32

सरणीं परिभ्रमन्तु

एकं पूर्णाङ्कसरणिका nums दत्तं, सरणी k स्थानेषु स्थितान् तत्त्वान् दक्षिणतः परिभ्रमन्तु ।

class Solution {
public:
    void rotate(vector<int>& nums, int k) {
        int n = nums.size();
        k = k % n;
        reverse(nums.begin(), nums.end());
        reverse(nums.begin(), nums.begin()+k);
        reverse(nums.begin()+k, nums.end());
    }
};
1
2
3
4
5
6
7
8
9
10

स्टॉक् क्रयणविक्रययोः सर्वोत्तमः समयः

class Solution {
public:
    int maxProfit(vector<int>& prices) {
        int result = 0;
        int price = prices[0];
        for(int i=1; i<prices.size(); i++){
            if(prices[i] > price){
                result = max(result, prices[i] - price);
            }else{
                price = prices[i];
            }
        }
        return result;
    }
};
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15

स्टॉक् क्रेतुं सर्वोत्तमः समयः २

class Solution {
public:
    int maxProfit(vector<int>& prices) {
        int n = prices.size();
        vector<vector<int>> dp(n,vector<int>(2)); //dp[i][0]第i天没有股票
        dp[0][0] = 0;
        dp[0][1] = -prices[0];
        for(int i=1; i<n; i++){
            dp[i][0] = max(dp[i-1][0], dp[i-1][1] + prices[i]);
            dp[i][1] = max(dp[i-1][1], dp[i-1][0]-prices[i]);
        }
        return dp[n-1][0];
    }
};
1
2
3
4
5
6
7
8
9
10
11
12
13
14

कूदन क्रीडा

अऋणात्मकं पूर्णाङ्कसरणिका nums दत्तं, प्रारम्भे सरणीयाः प्रथमसूचकाङ्के स्थितं, सरणीयां प्रत्येकं तत्त्वं अधिकतमदीर्घतां प्रतिनिधियति यत् कूर्दितुं शक्यते
अन्तिमसूचकाङ्कं प्रति कूर्दितुं शक्नोति वा इति निर्धारयन्तु ।

लोलुप
सरणीयां कस्यापि y स्थानं यावत् यावत् x स्थानं स्वयमेव प्राप्तुं शक्यते, x + nums[x] ≥ y च भवति, तावत् y अपि प्राप्तुं शक्यते ।

प्रत्येकं प्राप्यस्थानं x कृते, एतत् क्रमिकस्थानानि x+1, x+2, ..., x+nums[x] प्राप्यताम् करोति ।

class Solution {
public:
    bool canJump(vector<int>& nums) {
        int n = nums.size();
        int rightmost = 0;
        for(int i=0; i<n; i++){
            if(i <= rightmost){
                rightmost = max(rightmost, i+nums[i]);
                if(rightmost >= n-1){
                    return true;
                }
            }
        }
        return false;
    }
};
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16

ज़िगज़ैग परिवर्तन

एकं स्ट्रिंग् s दत्तं, तत् z-आकारेन उपरितः अधः यावत्, वामतः दक्षिणतः च दत्तपङ्क्तयः numRows इत्यस्य अनुसारं व्यवस्थापयन्तु ।

2D मैट्रिक्सस्य उपयोगेन अनुकरणं कुर्वन्तु
n इति स्ट्रिंग् s इत्यस्य दीर्घता भवतु, r = numRows r=1 (केवलं एकः पङ्क्तिः), अथवा r >= n (केवलं एकः स्तम्भः) कृते उत्तरं s इत्यस्य समानं भवति, प्रत्यक्षतया च प्रत्यागन्तुं शक्यते ।

अन्येषु सन्दर्भेषु द्वि-आयामी-मात्रिकायाः ​​निर्माणं कृत्वा, ततः मैट्रिक्स-उपरि ज़िग्ज़ैग्-प्रतिरूपेण s इति स्ट्रिंग् पूरयित्वा, अन्ते उत्तरं निर्मातुं पङ्क्ति-पङ्क्तौ मैट्रिक्स-मध्ये अ-रिक्त-वर्णान् स्कैन् कृत्वा विचारयन्तु

प्रश्नस्य अर्थानुसारं यदा वयं मैट्रिक्सस्य उपरि वर्णाः पूरयामः तदा वयं r वर्णाः अधः पूरयिष्यामः, ततः r-2 वर्णाः उपरि दक्षिणतः पूरयिष्यामः, अन्ते च प्रथमपङ्क्तौ आगमिष्यामः, अतः Z-आकारस्य परिवर्तनकालः त = र + र - २ = २र - २ । प्रत्येकं चक्रं मैट्रिक्सस्य उपरि 1+r-2 = r-1 स्तम्भान् गृह्णीयात् ।

तत्र n/t अवधिः स्तम्भसङ्ख्यायाः गुणा भवति, यत् आकृतिकस्य स्तम्भसङ्ख्यायाः तुल्यम् अस्ति ।

r पङ्क्तिभिः c स्तम्भैः च सह एकं मैट्रिक्सं रचयन्तु, ततः स्ट्रिंग्-मध्ये पुनरावृत्तिं कृत्वा तान् ज़िग्ज़ैग्-प्रतिरूपेण पूरयन्तु ।

class Solution {
public:
    string convert(string s, int numRows) {
        int n = s.length(), r = numRows;
        if(r == 1 || r >= n){
            return s;
        }

        //变换周期
        int t = 2*r - 2;
        int c = (n + t -1) / t * (r - 1);
        //创建二维字符串
        vector<string> mat(r, string(c, 0));
        for(int i = 0, x = 0, y =0; i<n; i++){
            mat[x][y] = s[i];
            if(i % t < r - 1){
                ++x; //向下移动
            }else{
                --x;
                ++y; //向右上移动
            }
        }

        string ans;
        for(auto &row : mat){
            for(char ch : row){
                if(ch){
                    ans += ch;
                }
            }
        }
        return ans;
    }
};
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34

तारे शब्दान् विपर्यययन्तु

class Solution {
public:
    vector<string> splitString(string s){
        istringstream iss(s);
        vector<string> res;
        string word;
        while(iss >> word){
            res.push_back(word);
        }
        return res;
    }
    string reverseWords(string s) {
        vector<string> words = splitString(s);
        string res;
        for(int i=words.size()-1; i>=0; i--){
            res += words[i] + " ";
        }
        res.pop_back();
        return res;
    }
};
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21