2024-07-12
한어Русский языкEnglishFrançaisIndonesianSanskrit日本語DeutschPortuguêsΕλληνικάespañolItalianoSuomalainenLatina
यदि सर्वेषां बृहत्वर्णानां लघुवर्णेषु परिवर्तनं कृत्वा सर्वान् अवर्णसंख्याकवर्णान् अपसारयित्वा समानं ऊर्ध्वं पश्चात् च पठति चेत् वाक्यं पलिण्ड्रोम् इति गण्यते
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;
}
};
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;
}
};
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};
}
};
पूर्वं पश्चात् च क्रमसम्बन्धः नास्ति, केवलं द्विगुणसूचकानाम् उपयोगं कुर्वन्तु ।
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;
}
};
हैश तालिका
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;
}
};
सरणी
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;
}
};
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;
}
};
vector<string> splitString(string& str){
istringstream iss(str);
vector<string> res;
string word;
while(iss >> word){
res.push_back(word);
}
return res;
}
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;
}
};
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();
}
};
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();
}
};
वयं प्रथमं दत्तं स्ट्रिंग्-मार्गं /-अनुसारं अनेक-स्ट्रिंग्-सूचौ विभजामः, नामरूपेण अभिलेखिताः ।
नामेषु समाविष्टाः ताराः केवलं निम्नलिखितरूपेण भवितुम् अर्हन्ति ।
रिक्ततारानाम्, बिन्दुस्य च कृते कोऽपि प्रक्रिया आवश्यकी नास्ति ।
द्वयोः बिन्दुयोः अथवा निर्देशिकानामयोः कृते मार्गे प्रत्येकं निर्देशिकानाम निर्वाहयितुम् एकं स्टैक् आवश्यकं भवति । यदा द्वयोः बिन्दुयोः सम्मुखीभवति, यावत् यावत् स्तम्भः रिक्तः नास्ति, तावत् पूर्वस्तरं प्रति स्विच् कुर्वन्तु (स्टैकस्य उपरितननिर्देशिकां पोप् कुर्वन्तु), निर्देशिकनामस्य सम्मुखीभवने च, तत् स्तम्भे स्थापयन्तु
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;
}
};
एकं स्टैक् डिजाइनं कुर्वन्तु यत् 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();
*/
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();
}
};
s इति स्ट्रिंग्-अभिव्यक्तिं दत्त्वा, तस्य मूल्यं गणयितुं, प्रत्यागन्तुं च मूलभूतं गणकयंत्रं कार्यान्वितम् ।
कोष्ठक विस्तार + ढेर
संख्यानां कोष्ठकानां च अतिरिक्तं स्ट्रिंग्-मध्ये केवलं द्वौ ऑपरेटर् स्तः : प्लस् चिह्नं माइनस् चिह्नं च ।
अतः यदि भवान् कस्मिन्चित् व्यञ्जने सर्वाणि कोष्ठकानि विस्तारयति तर्हि परिणामितस्य नूतनव्यञ्जने संख्याः एव न परिवर्तयिष्यन्ति, केवलं प्रत्येकस्य सङ्ख्यायाः पुरतः चिह्नं परिवर्तयिष्यति ।
एकं stack ops स्थापनीयम्, यस्मिन् stack इत्यस्य उपरितनतत्त्वं वर्तमानस्थाने प्रत्येकस्य कोष्ठकस्य चिह्नं अभिलेखयति ।
1+2+(3-(4+5)):
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;
}
};