C++ ನಲ್ಲಿ ನಾಜೂಕಾಗಿ ಸ್ಟ್ರಿಂಗ್ ಪದಗಳ ಮೇಲೆ ಪುನರಾವರ್ತನೆ
C++ ನಲ್ಲಿ ಸ್ಟ್ರಿಂಗ್ಗಳೊಂದಿಗೆ ಕೆಲಸ ಮಾಡುವಾಗ, ವೈಟ್ಸ್ಪೇಸ್ನಿಂದ ಬೇರ್ಪಡಿಸಿದ ಪದಗಳ ಮೇಲೆ ಪುನರಾವರ್ತನೆ ಮಾಡುವುದು ಸಾಮಾನ್ಯ ಕಾರ್ಯವಾಗಿದೆ. ಈ ಲೇಖನವು ಕಚ್ಚಾ ದಕ್ಷತೆಯ ಮೇಲೆ ಸೊಬಗನ್ನು ಒತ್ತಿಹೇಳುವ ಪರಿಹಾರವನ್ನು ಪರಿಶೋಧಿಸುತ್ತದೆ, ಸಿ ಸ್ಟ್ರಿಂಗ್ ಕಾರ್ಯಗಳನ್ನು ಅಥವಾ ನೇರ ಅಕ್ಷರ ಕುಶಲತೆಯನ್ನು ತಪ್ಪಿಸುತ್ತದೆ.
ಇದನ್ನು ಶುದ್ಧ ಮತ್ತು ಓದಬಲ್ಲ ರೀತಿಯಲ್ಲಿ ಸಾಧಿಸಲು, ನಿರ್ದಿಷ್ಟವಾಗಿ `ಇಸ್ಟ್ರಿಂಗ್ಸ್ಟ್ರೀಮ್`, ಪ್ರಮಾಣಿತ C++ ಲೈಬ್ರರಿಗಳನ್ನು ಬಳಸಿಕೊಂಡು ನಾವು ನೀಡಿದ ವಿಧಾನವನ್ನು ಪರಿಶೀಲಿಸುತ್ತೇವೆ. ಈ ವಿಧಾನವು ಸ್ಟ್ರಿಂಗ್ನಲ್ಲಿ ಪದಗಳನ್ನು ಪ್ರಕ್ರಿಯೆಗೊಳಿಸಲು ದೃಢವಾದ ಮಾರ್ಗವನ್ನು ಒದಗಿಸುತ್ತದೆ, ಕೋಡ್ ಸೊಬಗುಗೆ ಆದ್ಯತೆ ನೀಡುವ ಡೆವಲಪರ್ಗಳಿಗೆ ಸೂಕ್ತವಾಗಿದೆ.
ಆಜ್ಞೆ | ವಿವರಣೆ |
---|---|
istringstream | ಸ್ಟ್ರಿಂಗ್ಗಳ ಮೇಲೆ ಕಾರ್ಯನಿರ್ವಹಿಸಲು ಸ್ಟ್ರೀಮ್ ವರ್ಗ, ಸ್ಟ್ರಿಂಗ್ ಆಧಾರಿತ ಸ್ಟ್ರೀಮ್ಗಳನ್ನು ರಚಿಸಲು ಮತ್ತು ಪ್ರಮಾಣಿತ ಇನ್ಪುಟ್ ಸ್ಟ್ರೀಮ್ಗಳಂತೆಯೇ ಬಳಸಲು ಅನುಮತಿಸುತ್ತದೆ. |
getline | ಇನ್ಪುಟ್ ಸ್ಟ್ರೀಮ್ನಿಂದ ಅಕ್ಷರಗಳನ್ನು ಹೊರತೆಗೆಯುತ್ತದೆ ಮತ್ತು ಡಿಲಿಮಿಟರ್ ಅಕ್ಷರ ಕಂಡುಬರುವವರೆಗೆ ಅವುಗಳನ್ನು ಸ್ಟ್ರಿಂಗ್ನಲ್ಲಿ ಸಂಗ್ರಹಿಸುತ್ತದೆ. |
while (getline(iss, word, ' ')) | ಇನ್ಪುಟ್ ಸ್ಟ್ರಿಂಗ್ ಸ್ಟ್ರೀಮ್ನಿಂದ ಪದಗಳನ್ನು ಓದುವುದನ್ನು ಮುಂದುವರಿಸುವ ಲೂಪ್, ಸ್ಪೇಸ್ಗಳಿಂದ ವಿಭಜಿಸಲಾಗಿದೆ. |
iss >> subs | ಇನ್ಪುಟ್ ಸ್ಟ್ರಿಂಗ್ ಸ್ಟ್ರೀಮ್ನಿಂದ ಪದವನ್ನು ಹೊರತೆಗೆಯುತ್ತದೆ, ಅದನ್ನು ಸಬ್ಸ್ ವೇರಿಯೇಬಲ್ನಲ್ಲಿ ಸಂಗ್ರಹಿಸುತ್ತದೆ. |
do { } while (iss) | ಇನ್ಪುಟ್ ಸ್ಟ್ರಿಂಗ್ ಸ್ಟ್ರೀಮ್ ಮಾನ್ಯವಾಗಿ ಉಳಿಯುವವರೆಗೆ ಅದರ ದೇಹವನ್ನು ಒಮ್ಮೆಯಾದರೂ ಕಾರ್ಯಗತಗೊಳಿಸುವ ಲೂಪ್ ರಚನೆ. |
using namespace std; | ಎಲ್ಲಾ ಪ್ರಮಾಣಿತ ಲೈಬ್ರರಿ ಹೆಸರುಗಳನ್ನು ಎಸ್ಟಿಡಿಯೊಂದಿಗೆ ಅರ್ಹತೆ ಪಡೆಯದೆಯೇ ನೇರವಾಗಿ ಬಳಸಲು ಅನುಮತಿಸುತ್ತದೆ::. |
ಸೊಗಸಾದ C++ ಸ್ಟ್ರಿಂಗ್ ಪುನರಾವರ್ತನೆಯನ್ನು ಅರ್ಥಮಾಡಿಕೊಳ್ಳುವುದು
ಮೊದಲ ಸ್ಕ್ರಿಪ್ಟ್ ಹೇಗೆ ಬಳಸಬೇಕೆಂದು ತೋರಿಸುತ್ತದೆ istringstream ಸ್ಟ್ರಿಂಗ್ನಲ್ಲಿ ಪದಗಳ ಮೇಲೆ ಸೊಗಸಾಗಿ ಪುನರಾವರ್ತಿಸಲು. ರಚಿಸುವ ಮೂಲಕ istringstream ಇನ್ಪುಟ್ ಸ್ಟ್ರಿಂಗ್ನೊಂದಿಗೆ ಆಬ್ಜೆಕ್ಟ್, ನಾವು ಅದನ್ನು ಪ್ರಮಾಣಿತ ಇನ್ಪುಟ್ ಸ್ಟ್ರೀಮ್ನಂತೆ ಬಳಸಿಕೊಳ್ಳಬಹುದು. ಒಳಗೆ ಎ do-while ಲೂಪ್, ಸ್ಕ್ರಿಪ್ಟ್ ಸ್ಟ್ರೀಮ್ನಿಂದ ಪ್ರತಿ ಪದವನ್ನು ಸ್ಟ್ರಿಂಗ್ ವೇರಿಯೇಬಲ್ಗೆ ಓದುತ್ತದೆ subs, ತದನಂತರ ಅದನ್ನು ಮುದ್ರಿಸುತ್ತದೆ. ಸ್ಟ್ರೀಮ್ ಖಾಲಿಯಾಗುವವರೆಗೆ ಲೂಪ್ ಮುಂದುವರಿಯುತ್ತದೆ, ವೈಟ್ಸ್ಪೇಸ್ನಿಂದ ಬೇರ್ಪಡಿಸಿದ ಪದಗಳನ್ನು ಪಾರ್ಸಿಂಗ್ ಮಾಡಲು ಸರಳವಾದ ಆದರೆ ಸೊಗಸಾದ ವಿಧಾನವನ್ನು ಪ್ರದರ್ಶಿಸುತ್ತದೆ. ಈ ವಿಧಾನವು C++ ನ ಸ್ಟ್ಯಾಂಡರ್ಡ್ ಲೈಬ್ರರಿಯ ಶಕ್ತಿಯನ್ನು ಸ್ಪಷ್ಟವಾದ ಮತ್ತು ನಿರ್ವಹಿಸಬಹುದಾದ ಕೋಡ್ ಅನ್ನು ಒದಗಿಸುತ್ತದೆ.
ಎರಡನೇ ಸ್ಕ್ರಿಪ್ಟ್ ಬಳಸಿಕೊಂಡು ಪರ್ಯಾಯ ವಿಧಾನವನ್ನು ನೀಡುತ್ತದೆ getline ಜೊತೆಗೆ istringstream. ಇಲ್ಲಿ, ದಿ getline ಕಾರ್ಯವನ್ನು ಸ್ಟ್ರೀಮ್ನಿಂದ ಪದಗಳನ್ನು ಓದಲು ಬಾಹ್ಯಾಕಾಶ ಅಕ್ಷರವನ್ನು ಎದುರಿಸುವವರೆಗೆ ಬಳಸಲಾಗುತ್ತದೆ. ಈ ವಿಧಾನವು ಒಳಗೊಂಡಿರುತ್ತದೆ a while ಓದಲು ಹೆಚ್ಚು ಪದಗಳು ಇರುವವರೆಗೂ ಮುಂದುವರೆಯುವ ಲೂಪ್. ದಿ getline ಡಿಲಿಮಿಟರ್ ಯಾವಾಗಲೂ ಹೊಸ ಸಾಲಿನ ಅಕ್ಷರವಲ್ಲದ ಇನ್ಪುಟ್ ಸ್ಟ್ರೀಮ್ಗಳನ್ನು ನಿರ್ವಹಿಸಲು ಕಾರ್ಯವು ವಿಶೇಷವಾಗಿ ಉಪಯುಕ್ತವಾಗಿದೆ. ಎರಡೂ ಸ್ಕ್ರಿಪ್ಟ್ಗಳು C++ ನ ಸ್ಟ್ರಿಂಗ್ ಮತ್ತು ಸ್ಟ್ರೀಮ್ ಹ್ಯಾಂಡ್ಲಿಂಗ್ ಸಾಮರ್ಥ್ಯಗಳ ಬಹುಮುಖತೆಯನ್ನು ಎತ್ತಿ ತೋರಿಸುತ್ತವೆ, ಡೆವಲಪರ್ಗಳು ತಮ್ಮ ಕೋಡ್ನಲ್ಲಿ ಓದುವಿಕೆ ಮತ್ತು ಸೊಬಗನ್ನು ಉಳಿಸಿಕೊಂಡು ತಮ್ಮ ಅಗತ್ಯಗಳಿಗೆ ಸೂಕ್ತವಾದ ವಿಧಾನವನ್ನು ಆಯ್ಕೆ ಮಾಡಲು ಅನುವು ಮಾಡಿಕೊಡುತ್ತದೆ.
ಸೊಗಸಾದ ಸ್ಟ್ರಿಂಗ್ ವರ್ಡ್ ಪುನರಾವರ್ತನೆಗಾಗಿ stringstream ಅನ್ನು ಬಳಸುವುದು
C++ ಸ್ಟ್ಯಾಂಡರ್ಡ್ ಲೈಬ್ರರಿ ಉದಾಹರಣೆ
#include <iostream>
#include <sstream>
#include <string>
using namespace std;
int main() {
string s = "Somewhere down the road";
istringstream iss(s);
do {
string subs;
iss >> subs;
cout << "Substring: " << subs << endl;
} while (iss);
return 0;
}
std ::getline ಮತ್ತು istringstream ಬಳಸಿ ಪದಗಳ ಮೇಲೆ ಪುನರಾವರ್ತನೆ
C++ ಪರ್ಯಾಯ ವಿಧಾನದ ಉದಾಹರಣೆ
#include <iostream>
#include <sstream>
#include <string>
using namespace std;
int main() {
string s = "Walking through the park";
istringstream iss(s);
string word;
while (getline(iss, word, ' ')) {
cout << "Word: " << word << endl;
}
return 0;
}
C++ ಸ್ಟ್ರಿಂಗ್ಗಳಲ್ಲಿ ಪದಗಳ ಮೇಲೆ ಪುನರಾವರ್ತಿಸಲು ಸುಧಾರಿತ ತಂತ್ರಗಳು
C++ ಸ್ಟ್ರಿಂಗ್ನಲ್ಲಿ ಪದಗಳ ಮೇಲೆ ಪುನರಾವರ್ತನೆ ಮಾಡುವ ಮತ್ತೊಂದು ಸೊಗಸಾದ ವಿಧಾನವು ಬಳಸುವುದನ್ನು ಒಳಗೊಂಡಿರುತ್ತದೆ std::regex ಗ್ರಂಥಾಲಯ. ದಿ std::regex ಲೈಬ್ರರಿಯು ಸ್ಟ್ರಿಂಗ್ಗಳಲ್ಲಿ ನಮೂನೆಗಳನ್ನು ಹುಡುಕಲು ಪ್ರಬಲವಾದ ಮಾರ್ಗವನ್ನು ಒದಗಿಸುತ್ತದೆ, ಪದ ಪುನರಾವರ್ತನೆಯಂತಹ ಕಾರ್ಯಗಳಿಗೆ ಇದು ಸೂಕ್ತವಾಗಿರುತ್ತದೆ. ವೈಟ್ಸ್ಪೇಸ್ ಅಲ್ಲದ ಅಕ್ಷರಗಳ ಅನುಕ್ರಮಗಳಿಗೆ ಹೊಂದಿಕೆಯಾಗುವ ರೆಜೆಕ್ಸ್ ಮಾದರಿಯನ್ನು ವ್ಯಾಖ್ಯಾನಿಸುವ ಮೂಲಕ, ನಾವು ಬಳಸಬಹುದು std::sregex_token_iterator ಸ್ಟ್ರಿಂಗ್ನಲ್ಲಿರುವ ಪದಗಳ ಮೇಲೆ ಪುನರಾವರ್ತಿಸಲು. ಈ ವಿಧಾನವು ಸಂಕ್ಷಿಪ್ತವಾಗಿ ಮಾತ್ರವಲ್ಲದೆ ಹೆಚ್ಚು ಓದಬಲ್ಲದು, ವಿಶೇಷವಾಗಿ ನಿಯಮಿತ ಅಭಿವ್ಯಕ್ತಿಗಳೊಂದಿಗೆ ಪರಿಚಿತವಾಗಿರುವ ಡೆವಲಪರ್ಗಳಿಗೆ.
ಈ ವಿಧಾನವನ್ನು ಕಾರ್ಯಗತಗೊಳಿಸಲು, ಸೇರಿವೆ regex ಹೆಡರ್ ಮತ್ತು ವ್ಯಾಖ್ಯಾನಿಸಿ a std::regex ಅಪೇಕ್ಷಿತ ಮಾದರಿಯೊಂದಿಗೆ ವಸ್ತು. ನಂತರ, ಎ ರಚಿಸಿ std::sregex_token_iterator ಇನ್ಪುಟ್ ಸ್ಟ್ರಿಂಗ್ ಮತ್ತು ರಿಜೆಕ್ಸ್ ಆಬ್ಜೆಕ್ಟ್ನೊಂದಿಗೆ ಆರಂಭಿಸಲಾಗಿದೆ. ನಂತರ ಸ್ಟ್ರಿಂಗ್ನಲ್ಲಿರುವ ಪದಗಳನ್ನು ದಾಟಲು ಪುನರಾವರ್ತಕವನ್ನು ಬಳಸಬಹುದು. ಈ ತಂತ್ರವು ಸಂಕೀರ್ಣವಾದ ಪಾರ್ಸಿಂಗ್ ಸನ್ನಿವೇಶಗಳಿಗೆ ವಿಶೇಷವಾಗಿ ಉಪಯುಕ್ತವಾಗಿದೆ, ಅಲ್ಲಿ ಪದದ ಗಡಿಗಳನ್ನು ಕೇವಲ ವೈಟ್ಸ್ಪೇಸ್ಗಿಂತ ಹೆಚ್ಚು ವ್ಯಾಖ್ಯಾನಿಸಲಾಗಿದೆ. ನಿಯಮಿತ ಅಭಿವ್ಯಕ್ತಿಗಳನ್ನು ಬಳಸುವುದರಿಂದ ನಿಮ್ಮ ಕೋಡ್ನ ನಮ್ಯತೆ ಮತ್ತು ಸ್ಪಷ್ಟತೆಯನ್ನು ಹೆಚ್ಚಿಸಬಹುದು.
C++ ಸ್ಟ್ರಿಂಗ್ಗಳಲ್ಲಿ ಪದಗಳ ಮೇಲೆ ಪುನರಾವರ್ತನೆ ಮಾಡುವ ಕುರಿತು ಪದೇ ಪದೇ ಕೇಳಲಾಗುವ ಪ್ರಶ್ನೆಗಳು
- ನಾನು ಹೇಗೆ ಬಳಸಲಿ std::regex ಪದಗಳ ಮೇಲೆ ಪುನರಾವರ್ತಿಸಲು?
- ಸೇರಿಸಿ regex ಹೆಡರ್, ಎ ಅನ್ನು ವ್ಯಾಖ್ಯಾನಿಸಿ std::regex ಮಾದರಿ ಮತ್ತು ಬಳಕೆ std::sregex_token_iterator ಪದಗಳ ಮೇಲೆ ಪುನರಾವರ್ತಿಸಲು.
- ನಾನು ವೈಟ್ಸ್ಪೇಸ್ ಜೊತೆಗೆ ಇತರ ಡಿಲಿಮಿಟರ್ಗಳನ್ನು ಬಳಸಬಹುದೇ?
- ಹೌದು, ರೆಜೆಕ್ಸ್ ಮಾದರಿಯನ್ನು ಮಾರ್ಪಡಿಸುವ ಮೂಲಕ, ನೀವು ವಿರಾಮಚಿಹ್ನೆ ಅಥವಾ ಕಸ್ಟಮ್ ಅಕ್ಷರಗಳಂತಹ ವಿಭಿನ್ನ ಡಿಲಿಮಿಟರ್ಗಳನ್ನು ನಿರ್ದಿಷ್ಟಪಡಿಸಬಹುದು.
- ಬಳಸುವುದರಿಂದ ಏನು ಪ್ರಯೋಜನ std::sregex_token_iterator?
- ನಿಯಮಿತ ಅಭಿವ್ಯಕ್ತಿಗಳಿಂದ ವ್ಯಾಖ್ಯಾನಿಸಲಾದ ಸಂಕೀರ್ಣ ಮಾದರಿಗಳ ಆಧಾರದ ಮೇಲೆ ಪದಗಳ ಮೇಲೆ ಪುನರಾವರ್ತಿಸಲು ಇದು ಸಂಕ್ಷಿಪ್ತ ಮತ್ತು ಹೊಂದಿಕೊಳ್ಳುವ ಮಾರ್ಗವನ್ನು ಒದಗಿಸುತ್ತದೆ.
- ಬಳಸುವಾಗ ಕಾರ್ಯಕ್ಷಮತೆಯ ಪರಿಗಣನೆಗಳಿವೆಯೇ std::regex?
- ರಿಜೆಕ್ಸ್ ಸರಳವಾದ ಸ್ಟ್ರಿಂಗ್ ಕಾರ್ಯಾಚರಣೆಗಳಿಗಿಂತ ನಿಧಾನವಾಗಿದ್ದರೂ, ಅದರ ನಮ್ಯತೆ ಮತ್ತು ಓದುವಿಕೆ ಅನೇಕ ಅನ್ವಯಗಳ ಕಾರ್ಯಕ್ಷಮತೆಯ ವೆಚ್ಚವನ್ನು ಮೀರಿಸುತ್ತದೆ.
- ಹೇಗೆ ಮಾಡುತ್ತದೆ std::sregex_token_iterator ಗೆ ಹೋಲಿಸಿ istringstream?
- std::sregex_token_iterator ಸಂಕೀರ್ಣವಾದ ಪಾರ್ಸಿಂಗ್ ಸನ್ನಿವೇಶಗಳಿಗೆ ಹೆಚ್ಚು ನಮ್ಯತೆಯನ್ನು ನೀಡುತ್ತದೆ istringstream ಮೂಲ ವೈಟ್ಸ್ಪೇಸ್-ಬೇರ್ಪಡಿಸಿದ ಪದಗಳಿಗೆ ಸರಳವಾಗಿದೆ.
- ನಾನು ಸಂಯೋಜಿಸಬಹುದೇ? std::regex ಇತರ C++ ಲೈಬ್ರರಿಗಳೊಂದಿಗೆ?
- ಹೌದು, std::regex ಪಾರ್ಸಿಂಗ್ ಸಾಮರ್ಥ್ಯಗಳನ್ನು ಹೆಚ್ಚಿಸಲು ಇತರ ಪ್ರಮಾಣಿತ ಮತ್ತು ಮೂರನೇ ವ್ಯಕ್ತಿಯ ಗ್ರಂಥಾಲಯಗಳ ಜೊತೆಗೆ ಬಳಸಬಹುದು.
- ಇದೆ std::regex ಎಲ್ಲಾ C++ ಕಂಪೈಲರ್ಗಳಲ್ಲಿ ಬೆಂಬಲಿತವಾಗಿದೆಯೇ?
- ಹೆಚ್ಚಿನ ಆಧುನಿಕ C++ ಕಂಪೈಲರ್ಗಳು ಬೆಂಬಲಿಸುತ್ತವೆ std::regex, ಆದರೆ ನಿಮ್ಮ ನಿರ್ದಿಷ್ಟ ಅಭಿವೃದ್ಧಿ ಪರಿಸರದೊಂದಿಗೆ ಹೊಂದಾಣಿಕೆಯನ್ನು ಪರಿಶೀಲಿಸುವುದು ಮುಖ್ಯವಾಗಿದೆ.
- ಬಳಸುವಾಗ ಕೆಲವು ಸಾಮಾನ್ಯ ಮೋಸಗಳು ಯಾವುವು std::regex?
- ನಿಮ್ಮ ರೆಜೆಕ್ಸ್ ಮಾದರಿಗಳನ್ನು ಸರಿಯಾಗಿ ವ್ಯಾಖ್ಯಾನಿಸಲಾಗಿದೆ ಮತ್ತು ಪರೀಕ್ಷಿಸಲಾಗಿದೆ ಎಂದು ಖಚಿತಪಡಿಸಿಕೊಳ್ಳಿ, ಏಕೆಂದರೆ ದೋಷಗಳು ಸಂಭವಿಸಿದಲ್ಲಿ ಸಂಕೀರ್ಣ ಮಾದರಿಗಳನ್ನು ಡೀಬಗ್ ಮಾಡಲು ಕಷ್ಟವಾಗುತ್ತದೆ.
ಸ್ಟ್ರಿಂಗ್ನಲ್ಲಿ ಪದಗಳ ಮೇಲೆ ಪುನರಾವರ್ತಿಸುವ ಅಂತಿಮ ಆಲೋಚನೆಗಳು
ಕೊನೆಯಲ್ಲಿ, C ++ ಸ್ಟ್ಯಾಂಡರ್ಡ್ ಲೈಬ್ರರಿಗಳನ್ನು ಬಳಸುವುದು istringstream ಮತ್ತು regex ಸ್ಟ್ರಿಂಗ್ನಲ್ಲಿ ಪದಗಳ ಮೇಲೆ ಪುನರಾವರ್ತಿಸಲು ಶುದ್ಧ ಮತ್ತು ಸೊಗಸಾದ ಮಾರ್ಗವನ್ನು ಒದಗಿಸುತ್ತದೆ. ಈ ವಿಧಾನಗಳು ತೊಡಕಿನ C ಸ್ಟ್ರಿಂಗ್ ಕಾರ್ಯಗಳನ್ನು ತಪ್ಪಿಸುತ್ತವೆ, ಹೆಚ್ಚು ಓದಬಲ್ಲ ಮತ್ತು ನಿರ್ವಹಿಸಬಹುದಾದ ವಿಧಾನವನ್ನು ನೀಡುತ್ತವೆ. C++ ನ ಅಂತರ್ನಿರ್ಮಿತ ಸಾಮರ್ಥ್ಯಗಳ ಶಕ್ತಿಯನ್ನು ಹೆಚ್ಚಿಸುವ ಮೂಲಕ, ಡೆವಲಪರ್ಗಳು ಸ್ಟ್ರಿಂಗ್ ವರ್ಡ್ ಪುನರಾವರ್ತನೆಯನ್ನು ನಿರ್ವಹಿಸಲು ಸಂಕ್ಷಿಪ್ತ ಮತ್ತು ಪರಿಣಾಮಕಾರಿ ಕೋಡ್ ಅನ್ನು ಬರೆಯಬಹುದು, ಕ್ರಿಯಾತ್ಮಕತೆಯೊಂದಿಗೆ ಸೊಬಗನ್ನು ಸಮತೋಲನಗೊಳಿಸಬಹುದು.