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

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

palindrome स्ट्रिंग् सत्यापयन्तु

यदि सर्वेषां बृहत्वर्णानां लघुवर्णेषु परिवर्तनं कृत्वा सर्वान् अवर्णसंख्याकवर्णान् अपसारयित्वा समानं ऊर्ध्वं पश्चात् च पठति चेत् वाक्यं पलिण्ड्रोम् इति गण्यते

class Solution {
public:
    bool isPalindrome(string s) {
        int left = 0;
        int right = s.size()-1;
        while(left < right){
            while(left < right && !isalnum(s[left])){
                left++;
            }
            while(left < right && !isalnum(s[right])){
                right--;
            }
            if(left < right && tolower(s[left]) != tolower(s[right])){
                return false;
            }
            left++;
            right--;
        }
        return true;
    }
};
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21

उपक्रमं निर्धारयतु

s तथा t इति तारं दत्त्वा s t इत्यस्य उपक्रमः अस्ति वा इति निर्धारयन्तु ।
उपक्रमः शेषवर्णानां सापेक्षस्थानानि परिवर्तनं विना मूलतारात् केचन वर्णाः विलोपयित्वा निर्मितं नूतनं तारं निर्दिशति

द्विगुणं सूचकः
क्रमशः s तथा t इत्येतयोः आरम्भिकस्थानानि दर्शयन् i तथा j इत्येतयोः सूचकद्वयं आरभत ।
प्रत्येकस्य लोभीमेलनस्य कृते यदि मेलनं सफलं भवति तर्हि i तथा j एकस्मिन् समये दक्षिणदिशि स्थानान्तरिताः भविष्यन्ति, s इत्यस्य अग्रिमस्थानस्य मेलनं यदि मेलनं विफलं भवति तर्हि j दक्षिणदिशि स्थानान्तरिता भविष्यति, i च परिवर्तनं न भविष्यति .

अन्ते i s इत्यस्य अन्ते गच्छति, यत् s इत्यस्य t इत्यस्य उपक्रमः इति सूचयति ।

class Solution {
public:
    bool isSubsequence(string s, string t) {
        int n = s.size();
        int m = t.size();
        int sIndex = 0, tIndex = 0;
        while(sIndex < n && tIndex < m){
            if(s[sIndex] == t[tIndex]){
                sIndex++;
                tIndex++;
            }else{
                tIndex++;
            }
        }
        return sIndex == n;
    }
};
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17

द्वयोः सङ्ख्यायोः योगः

class Solution {
public:
    vector<int> twoSum(vector<int>& numbers, int target) {
        int left = 0;
        int right = numbers.size()-1;
        while(left < right){
            int num = numbers[left] + numbers[right];
            if(num == target){
                return {left+1, right+1};
            }else if(num < target){
                left++;
            }else{
                right--;
            }
        }
        return {0,0};
    }
};
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18

मुक्तिपत्रम्

पूर्वं पश्चात् च क्रमसम्बन्धः नास्ति, केवलं द्विगुणसूचकानाम् उपयोगं कुर्वन्तु ।

class Solution {
public:
    bool canConstruct(string ransomNote, string magazine) {
        sort(ransomNote.begin(), ransomNote.end());
        sort(magazine.begin(), magazine.end());
        int i = 0, j = 0, m = ransomNote.size(), n = magazine.size();
        while(i<m && j<n){
            if(ransomNote[i] == magazine[j]){
                i++;
                j++;
            }else{
                j++;
            }
        }
        return i == m;
    }
};
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17

हैश तालिका

class Solution {
public:
    bool canConstruct(string ransomNote, string magazine) {
        unordered_map<int, int> count;
        for(char c : magazine){
            count[c]++;
        }
        for(char c : ransomNote){
            if(count[c] == 0){
                return false;
            }else{
                count[c]--;
            }
        }
        return true;
    }
};
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17

सरणी

class Solution {
public:
    bool canConstruct(string ransomNote, string magazine) {
        int count[26] = {};
        for(char c : magazine){
            count[c-'a']++;
        }
        for(char c : ransomNote){
            if(count[c-'a'] == 0){
                return false;
            }else{
                count[c-'a']--;
            }
        }
        return true;
    }
};
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17

समरूपताराः

s तथा t इति तारद्वयं दत्त्वा ते समरूपाः सन्ति वा इति निर्धारयन्तु ।

class Solution {
public:
    bool isIsomorphic(string s, string t) {
        unordered_map<char, char> s2t;
        unordered_map<char, char> t2s;
        
        for(int i=0; i<s.size(); i++){
            char x = s[i];
            char y = t[i];
            if((s2t.count(x) && s2t[x] != y) || (t2s.count(y) && t2s[y] != x)){
                return false;
            }
            s2t[x] = y;
            t2s[y] = x;
        }
        return true;
    }
};
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18

विभक्तं तारम्

vector<string> splitString(string& str){
	istringstream iss(str);
	vector<string> res;
	string word;
	while(iss >> word){
		res.push_back(word);
	}
	return res;
}
1
2
3
4
5
6
7
8
9

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;
    }
    bool wordPattern(string pattern, string s) {
        unordered_map<char, string> char2s;
        unordered_map<string, char> s2char;
        
        vector<string> words = splitString(s);
        if(pattern.size() != words.size()){
            return false;
        }
        for(int i=0; i<pattern.size(); i++){
            char c = pattern[i];
            string word = words[i];
            if((char2s.count(c) && char2s[c] != word) || (s2char.count(word) && s2char[word] != c)){
                return false;
            }
            char2s[c] = word;
            s2char[word] = c;
        }
        return true;
    }
};
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

वैध कोष्ठकाः

class Solution {
public:
    bool isValid(string s) {
        stack<char> stk;
        for(int i = 0; i<s.size(); i++){
            char ch = s[i];
            if(ch == '(' || ch == '[' || ch == '{'){
                stk.push(ch);
            }else{
                if(stk.empty()){
                    return false;
                }
                char topCh = stk.top();
                if((topCh =='[' && ch == ']') || (topCh =='(' && ch == ')') || (topCh =='{' && ch == '}')){
                    stk.pop();
                }else{
                    return false;
                }
            }
        }
        return stk.empty();
    }
};
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23

class Solution {
public:
    bool isValid(string s) {
        int n = s.size();
        if(n % 2 == 1){
            return false;
        }

        unordered_map<char, char> pairs = {
            {']','['},
            {'}','{'},
            {')','('}
        };

        stack<char> stk;
        for(char ch:s){
            if(pairs.count(ch)){
                if(stk.empty() || stk.top() != pairs[ch]){
                    return false;
                }
                stk.pop();
            }else{
                stk.push(ch);
            }
        }
        return stk.empty();
    }
};
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

मार्गं सरलं कुरुत

वयं प्रथमं दत्तं स्ट्रिंग्-मार्गं /-अनुसारं अनेक-स्ट्रिंग्-सूचौ विभजामः, नामरूपेण अभिलेखिताः ।
नामेषु समाविष्टाः ताराः केवलं निम्नलिखितरूपेण भवितुम् अर्हन्ति ।

• रिक्तं तारम् । यथा, यदा बहुविधाः क्रमशः /s दृश्यन्ते तदा रिक्तं स्ट्रिंग् विभक्तं भविष्यति ।
• एकः बिन्दुः ।
• द्वौ बिन्दुौ...
• निर्देशिका नाम।

रिक्ततारानाम्, बिन्दुस्य च कृते कोऽपि प्रक्रिया आवश्यकी नास्ति ।

द्वयोः बिन्दुयोः अथवा निर्देशिकानामयोः कृते मार्गे प्रत्येकं निर्देशिकानाम निर्वाहयितुम् एकं स्टैक् आवश्यकं भवति । यदा द्वयोः बिन्दुयोः सम्मुखीभवति, यावत् यावत् स्तम्भः रिक्तः नास्ति, तावत् पूर्वस्तरं प्रति स्विच् कुर्वन्तु (स्टैकस्य उपरितननिर्देशिकां पोप् कुर्वन्तु), निर्देशिकनामस्य सम्मुखीभवने च, तत् स्तम्भे स्थापयन्तु

class Solution {
public:
    vector<string> splitString(string &path){
        vector<string> res;
        string temp;
        for(char c : path){
            if(c == '/'){
                res.push_back(temp);
                temp.clear();
            }else{
                temp += c;
            }
        }
        res.push_back(temp);
        return res;
    }

    string simplifyPath(string path) {
        vector<string> names = splitString(path);
        vector<string> stk;
        for(int i=0; i<names.size(); i++){
            if(names[i] == ".."){
                if(!stk.empty()){
                    stk.pop_back();
                }
            }else if(!names[i].empty() && names[i] != "."){
                stk.push_back(names[i]);
            }
        }

        string res;
        if(stk.empty()){
            res = "/";
        }else{
            for(int i=0; i<stk.size(); i++){
                res += "/" + stk[i];
            }
        }
        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

न्यूनतम ढेर

एकं स्टैक् डिजाइनं कुर्वन्तु यत् push, pop, top operations इत्येतयोः समर्थनं करोति तथा च नित्यसमये लघुतमं तत्त्वं पुनः प्राप्तुं शक्नोति ।

सहायक ढेर

• स्तम्भस्य उपरि धक्कायन्ते सति प्रथमं तत्त्वं साधारणे स्तम्भे स्थापितं भवति, वर्तमानस्य सहायकस्य स्तम्भस्य उपरिभागस्य तुलना तत्त्वेन सह क्रियते, ततः न्यूनतमं मूल्यं स्तम्भस्य उपरि निवेशितं भवति
• यदा स्तम्भात् पोप् करणं भवति तदा उभौ एकत्र पोप् अप भवन्ति ।

class MinStack {
    stack<int> stk;
    stack<int> min_stk;
public:
    MinStack() {
        min_stk.push(INT_MAX);    
    }
    
    void push(int val) {
        stk.push(val);
        min_stk.push(min(min_stk.top(), val));
    }
    
    void pop() {
        stk.pop();
        min_stk.pop();
    }
    
    int top() {
        return stk.top();
    }
    
    int getMin() {
        return min_stk.top();
    }
};

/**
 * Your MinStack object will be instantiated and called as such:
 * MinStack* obj = new MinStack();
 * obj->push(val);
 * obj->pop();
 * int param_3 = obj->top();
 * int param_4 = obj->getMin();
 */
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

विपरीत पोलिश अभिव्यक्ति मूल्याङ्कन

class Solution {
public:
    int evalRPN(vector<string>& tokens) {
        stack<int> stk;
        for(int i=0; i<tokens.size(); i++){
            if(tokens[i] == "+" || tokens[i] == "-" || tokens[i] == "*" || tokens[i] == "/"){
                int num2 = stk.top();
                stk.pop();
                int num1 = stk.top();
                stk.pop();
                if(tokens[i] == "+"){
                    stk.push(num1 + num2);
                }else if(tokens[i] == "-"){
                    stk.push(num1 - num2);
                }else if(tokens[i] == "*"){
                    stk.push(num1 * num2);
                }else{
                    stk.push(num1 / num2);
                }
            }else{
                stk.push(stoi(tokens[i]));
            }
        }
        return stk.top();
    }
};
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

मूलभूत गणकयंत्र

s इति स्ट्रिंग्-अभिव्यक्तिं दत्त्वा, तस्य मूल्यं गणयितुं, प्रत्यागन्तुं च मूलभूतं गणकयंत्रं कार्यान्वितम् ।

कोष्ठक विस्तार + ढेर
संख्यानां कोष्ठकानां च अतिरिक्तं स्ट्रिंग्-मध्ये केवलं द्वौ ऑपरेटर् स्तः : प्लस् चिह्नं माइनस् चिह्नं च ।
अतः यदि भवान् कस्मिन्चित् व्यञ्जने सर्वाणि कोष्ठकानि विस्तारयति तर्हि परिणामितस्य नूतनव्यञ्जने संख्याः एव न परिवर्तयिष्यन्ति, केवलं प्रत्येकस्य सङ्ख्यायाः पुरतः चिह्नं परिवर्तयिष्यति ।

एकं stack ops स्थापनीयम्, यस्मिन् stack इत्यस्य उपरितनतत्त्वं वर्तमानस्थाने प्रत्येकस्य कोष्ठकस्य चिह्नं अभिलेखयति ।
1+2+(3-(4+5))：

• 1+2 यावत् स्कैनिङ्गं कुर्वन् वर्तमानस्थानं कस्मिन् अपि कोष्ठके न समाविष्टं भवति इति कारणतः, स्टैक् इत्यस्य उपरितनतत्त्वं प्रारम्भिकं मूल्यं + 1 भवति;
• 1+2+(3) यावत् स्कैनिङ्गं कुर्वन् वर्तमानस्थानं कोष्ठकेन समाविष्टं भवति।कोष्ठकस्य पुरतः चिह्नं + भवति, अतः स्टैक् इत्यस्य उपरितनतत्त्वं +1 भवति

class Solution {
public:
    int calculate(string s) {
        stack<int> ops;
        ops.push(1);
        int sign = 1;

        int ret = 0;
        int i = 0;
        int n = s.size();
        while(i < n){
            if(s[i] == ' '){
                i++;
            }else if(s[i] == '+'){
                sign = ops.top();
                i++;
            }else if(s[i] == '-'){
                sign = -ops.top();
                i++;
            }else if(s[i] == '('){
                ops.push(sign);
                i++;
            }else if(s[i] == ')'){
                ops.pop();
                i++;
            }else{
                long num = 0;
                while(i < n && s[i] >= '0' && s[i] <= '9'){
                    num = num * 10 + s[i]-'0';
                    i++;
                }
                ret += sign * num;
            }
        }
        return ret;
    }
};
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