while (getline(input, s)) {

 //These are lower case letters. 
 while (s.find("a") != string::npos)
    s.replace(s.find("a"), 1, "⠁");

while  (s.find("b") != string::npos)
 s.replace(s.find("b"), 1, "⠃");

while  (s.find("c") != string::npos)
    s.replace(s.find("c"), 1, "⠉");

 while (s.find("d") != string::npos)  
 s.replace(s.find("d"), 1, "⠙"); 

  while (s.find("e") != string::npos)
  s.replace(s.find("e"), 1, "⠑");

  while  (s.find("f") != string::npos)
    s.replace(s.find("f"), 1, "⠋");

  while  (s.find("g") != string::npos)
    s.replace(s.find("g"), 1, "⠛"); 

  while  (s.find("h") != string::npos)
    s.replace(s.find("h"), 1, "⠓");       

   while  (s.find("i") != string::npos)
    s.replace(s.find("i"), 1, "⠊"); 

   while  (s.find("j") != string::npos)
    s.replace(s.find("j"), 1, "⠚"); 

  while  (s.find("k") != string::npos)
    s.replace(s.find("k"), 1, "⠅"); 

  while  (s.find("l") != string::npos)
    s.replace(s.find("l"), 1, "⠇"); 

   while  (s.find("m") != string::npos)
    s.replace(s.find("m"), 1, "⠍"); 

   while  (s.find("n") != string::npos)
    s.replace(s.find("n"), 1, "⠝"); 

   while  (s.find("o") != string::npos)
    s.replace(s.find("o"), 1, "⠕"); 

   while  (s.find("p") != string::npos)
    s.replace(s.find("p"), 1, "⠏"); 

  while  (s.find("q") != string::npos)
    s.replace(s.find("q"), 1, "⠟"); 

  while  (s.find("r") != string::npos)
    s.replace(s.find("r"), 1, "⠗"); 

  while  (s.find("s") != string::npos)
    s.replace(s.find("s"), 1, "⠎"); 

 while  (s.find("t") != string::npos)
    s.replace(s.find("t"), 1, "⠞"); 

 while  (s.find("u") != string::npos)
    s.replace(s.find("u"), 1, "⠥"); 

 while  (s.find("v") != string::npos)
    s.replace(s.find("v"), 1, "⠧"); 

 while  (s.find("w") != string::npos)
    s.replace(s.find("w"), 1, "⠺"); 

 while  (s.find("x") != string::npos)
    s.replace(s.find("x"), 1, "⠭"); 

while  (s.find("y") != string::npos)
    s.replace(s.find("y"), 1, "⠽"); 

 while  (s.find("z") != string::npos)
    s.replace(s.find("z"), 1, "⠵");

    //These are UPPER case letters. 
 while (s.find("A") != string::npos)
    s.replace(s.find("A"), 1, "⠨⠁");

while  (s.find("B") != string::npos)
 s.replace(s.find("B"), 1, "⠨⠃");

while  (s.find("C") != string::npos)
    s.replace(s.find("C"), 1, "⠨⠉");

 while (s.find("D") != string::npos)  
 s.replace(s.find("D"), 1, "⠨⠙"); 

 while (s.find("E") != string::npos)
s.replace(s.find("E"), 1, "⠨⠑");

while  (s.find("F") != string::npos)
    s.replace(s.find("F"), 1, "⠨⠋");

while  (s.find("G") != string::npos)
    s.replace(s.find("G"), 1, "⠨⠛"); 

 while  (s.find("H") != string::npos)
    s.replace(s.find("H"), 1, "⠨⠓");       

 while  (s.find("I") != string::npos)
    s.replace(s.find("I"), 1, "⠨⠊"); 

 while  (s.find("J") != string::npos)
    s.replace(s.find("J"), 1, "⠨⠚"); 

 while  (s.find("K") != string::npos)
    s.replace(s.find("K"), 1, "⠨⠅"); 

while  (s.find("L") != string::npos)
    s.replace(s.find("L"), 1, "⠨⠇"); 

while  (s.find("M") != string::npos)
    s.replace(s.find("M"), 1, "⠨⠍"); 

while  (s.find("N") != string::npos)
    s.replace(s.find("N"), 1, "⠨⠝"); 

while  (s.find("O") != string::npos)
    s.replace(s.find("O"), 1, "⠨⠕"); 

while  (s.find("P") != string::npos)
    s.replace(s.find("P"), 1, "⠨⠏"); 

while  (s.find("Q") != string::npos)
    s.replace(s.find("Q"), 1, "⠨⠟"); 

 while  (s.find("R") != string::npos)
    s.replace(s.find("R"), 1, "⠨⠗"); 

 while  (s.find("S") != string::npos)
    s.replace(s.find("S"), 1, "⠨⠎"); 

 while  (s.find("T") != string::npos)
    s.replace(s.find("T"), 1, "⠨⠞"); 

 while  (s.find("U") != string::npos)
    s.replace(s.find("U"), 1, "⠨⠥"); 

 while  (s.find("V") != string::npos)
    s.replace(s.find("V"), 1, "⠨⠧"); 

while  (s.find("W") != string::npos)
    s.replace(s.find("W"), 1, "⠨⠺"); 

while  (s.find("X") != string::npos)
    s.replace(s.find("X"), 1, "⠨⠭"); 

while  (s.find("Y") != string::npos)
    s.replace(s.find("Y"), 1, "⠨⠽"); 

 while  (s.find("Z") != string::npos)
    s.replace(s.find("Z"), 1, "⠨⠵");

//These is some french letters.
    while  (s.find("é") != string::npos)
    s.replace(s.find("é"), 1, "⠿");

    while  (s.find("à") != string::npos)
    s.replace(s.find("à"), 1, "⠷");

    while  (s.find("â") != string::npos)
    s.replace(s.find("â"), 1, "⠡");

    while  (s.find("ç") != string::npos)
    s.replace(s.find("ç"), 1, "⠯");

    while  (s.find("è") != string::npos)
    s.replace(s.find("è"), 1, "⠮");

    while  (s.find("ê") != string::npos)
    s.replace(s.find("ê"), 1, "⠣");

    while  (s.find("ë") != string::npos)
    s.replace(s.find("ë"), 1, "⠫");

    while  (s.find("î") != string::npos)
    s.replace(s.find("î"), 1, "⠩");

    while  (s.find("ï") != string::npos)
    s.replace(s.find("ï"), 1, "⠻");

    while  (s.find("ô") != string::npos)
    s.replace(s.find("ô"), 1, "⠹");

    while  (s.find("œ") != string::npos)
    s.replace(s.find("œ"), 1, "⠪");

    while  (s.find("ù") != string::npos)
    s.replace(s.find("ù"), 1, "⠾");

    while  (s.find("û") != string::npos)
    s.replace(s.find("û"), 1, "⠱");

    while  (s.find("ü") != string::npos)
    s.replace(s.find("ü"), 1, "⠳");

 // These are numbers 0-9.   
     while (s.find("1") != string::npos)  
     s.replace(s.find("1"), 1, "⠼⠁");   

    while  (s.find("2") != string::npos)
    s.replace(s.find("2"), 1, "⠼⠃");  

    while  (s.find("3") != string::npos)
    s.replace(s.find("3"), 1, "⠼⠉");  

    while  (s.find("4") != string::npos)
    s.replace(s.find("4"), 1, "⠼⠙");  

    while  (s.find("5") != string::npos)
    s.replace(s.find("5"), 1, "⠼⠑");  

    while  (s.find("6") != string::npos)
    s.replace(s.find("6"), 1, "⠼⠋");  

    while  (s.find("7") != string::npos)
    s.replace(s.find("7"), 1, "⠼⠛");  

    while  (s.find("8") != string::npos)
    s.replace(s.find("8"), 1, "⠼⠓");  

    while  (s.find("9") != string::npos)
    s.replace(s.find("9"), 1, "⠼⠊");  

    while  (s.find("0") != string::npos)
    s.replace(s.find("0"), 1, "⠼⠚");   


    // These are punctuation marks  
    while  (s.find(",") != string::npos)
    s.replace(s.find(","), 1, "⠂");  

    while  (s.find(";") != string::npos)
    s.replace(s.find(";"), 1, "⠆");  

    while  (s.find(":") != string::npos)
    s.replace(s.find(":"), 1, "⠒");  

    while  (s.find(".") != string::npos)
    s.replace(s.find("."), 1, "⠲");  

    while  (s.find("?") != string::npos)
    s.replace(s.find("?"), 1, "⠦");  

    while  (s.find("!") != string::npos)
    s.replace(s.find("!"), 1, "⠖");  

    while  (s.find("‘") != string::npos)
    s.replace(s.find("‘"), 1, "⠄");  

    while  (s.find("“") != string::npos)
    s.replace(s.find("“"), 1, "⠄⠶");  

    while  (s.find("”") != string::npos)
    s.replace(s.find("”"), 1, "⠘⠴");  

    while  (s.find("‘") != string::npos)
    s.replace(s.find("‘"), 1, "⠄⠦");  

    while  (s.find("’") != string::npos)
    s.replace(s.find("’"), 1, "⠄⠴");  

    while  (s.find("(") != string::npos)
    s.replace(s.find("("), 1, "⠐⠣");  

    while  (s.find(")") != string::npos)       
    s.replace(s.find(")"), 1, "⠐⠜");  

    while  (s.find("/") != string::npos)
    s.replace(s.find("/"), 1, "⠸⠌");  

    while  (s.find("–") != string::npos)
    s.replace(s.find("–"), 1, "⠤");

    while (s.find("'") != string::npos)
    s.replace (s.find("'"), 1, "⠄");

    while (s.find("£") != string::npos)
    s.replace (s.find("£"), 1, "⠘⠇");

    while (s.find(".") != string::npos)
    s.replace (s.find("."), 1, "⠲");   

    while (s.find("*") != string::npos)
    s.replace (s.find("*"), 1, "⠔");  

    while (s.find("§") != string::npos)
    s.replace (s.find("§"), 1, "⠐⠏"); 

    while (s.find("&") != string::npos)
    s.replace (s.find("&"), 1, "⠐⠿"); 

    while (s.find("¥") != string::npos)
    s.replace (s.find("¥"), 1, "⠘⠽"); 

    while (s.find("€") != string::npos)
    s.replace (s.find("€"), 1, "⠘⠑");

    while (s.find("$") != string::npos)
    s.replace (s.find("$"), 1, "⠘⠎");

    while (s.find("©") != string::npos)
    s.replace (s.find("©"), 1, "⠐⠉");

    while (s.find("®") != string::npos)
    s.replace (s.find("®"), 1, "⠐⠗");

    while (s.find("™") != string::npos)
    s.replace (s.find("™"), 1, "⠐⠞");

    while (s.find("%") != string::npos)
    s.replace (s.find("%"), 1, "⠐⠬");

    while (s.find("‰") != string::npos)
    s.replace (s.find("‰"), 1, "⠐⠬⠬");

    while (s.find("‱") != string::npos)
    s.replace (s.find("‱"), 1, "⠐⠬⠬⠬");

    cout << s << endl;
}

ठीक है तो यह मेरा कोड है जो मेरे पास अब तक है, और यदि आपने देखा है कि यह पूरी तरह से हाथ से बाहर है और बहुत लंबा है। मैं सी ++ में कार्यों को जानने में बिल्कुल सर्वश्रेष्ठ नहीं हूं लेकिन मुझे वास्तव में ऐसा लगता है कि कुछ आसान तरीका है जो इसे 1000000 गुना छोटा या आंखों पर आसान बना देगा। क्या कोई मुझे इसके लिए एक आसान तरीका समझा सकता है या दिखा सकता है? मैं इस पर काफी नया हूं इसलिए कृपया इसे यथासंभव सरल बनाएं धन्यवाद! इस लंबी बात को समझने के लिए मैं चाहता हूं कि मेरा प्रोग्राम फ़ाइल में क्या है और मैं चाहता हूं कि यह उसमें प्रत्येक वर्ण को प्रतिस्थापित करे जो मैं इसे इसके द्वारा प्रतिस्थापित करने के लिए कहता हूं जैसे मैं चाहता हूं कि अक्षर ए को एक बिंदु से बदल दिया जाए आदि... और फिर इसे डॉट्स के रूप में प्रदर्शित करने के लिए।

c++
-2
Zachattack 20 जून 2018, 00:34

2 जवाब

सबसे बढ़िया उत्तर

बार-बार खोजने और बदलने के बजाय, इनपुट स्ट्रिंग पर चलना और प्रत्येक वर्ण के लिए प्रतिस्थापन को देखना अधिक कुशल है क्योंकि आप उस तक पहुंचते हैं। हम प्रतिस्थापन फ़ंक्शन को एक बड़े switch या तालिका के रूप में लिख सकते हैं:

#include <map>
#include <string>

std::wstring to_braille(wchar_t c) noexcept
{
    static const std::map<wchar_t, std::wstring> table = {
        // lower case letters
        { L'a', L"⠁" }, { L'b', L"⠃" }, { L'c', L"⠉" }, { L'd', L"⠙" }, { L'e', L"⠑" },
        { L'f', L"⠋" }, { L'g', L"⠛" }, { L'h', L"⠓" }, { L'i', L"⠊" }, { L'j', L"⠚" },
        { L'k', L"⠅" }, { L'l', L"⠇" }, { L'm', L"⠍" }, { L'n', L"⠝" }, { L'o', L"⠕" },
        { L'p', L"⠏" }, { L'q', L"⠟" }, { L'r', L"⠗" }, { L's', L"⠎" }, { L't', L"⠞" },
        { L'u', L"⠥" }, { L'v', L"⠧" }, { L'w', L"⠺" }, { L'x', L"⠭" }, { L'y', L"⠽" },
        { L'z', L"⠵" },
        // UPPER case letters
        { L'A', L"⠨⠁" }, { L'B', L"⠨⠃" }, { L'C', L"⠨⠉" }, { L'D', L"⠨⠙" }, { L'E', L"⠨⠑" },
        { L'F', L"⠨⠋" }, { L'G', L"⠨⠛" }, { L'H', L"⠨⠓" }, { L'I', L"⠨⠊" }, { L'J', L"⠨⠚" },
        { L'K', L"⠨⠅" }, { L'L', L"⠨⠇" }, { L'M', L"⠨⠍" }, { L'N', L"⠨⠝" }, { L'O', L"⠨⠕" },
        { L'P', L"⠨⠏" }, { L'Q', L"⠨⠟" }, { L'R', L"⠨⠗" }, { L'S', L"⠨⠎" }, { L'T', L"⠨⠞" },
        { L'U', L"⠨⠥" }, { L'V', L"⠨⠧" }, { L'W', L"⠨⠺" }, { L'X', L"⠨⠭" }, { L'Y', L"⠨⠽" },
        { L'Z', L"⠨⠵" },
        // accented letters
        { L'é', L"⠿" }, { L'à', L"⠷" }, { L'â', L"⠡" }, { L'ç', L"⠯" }, { L'è', L"⠮" },
        { L'ê', L"⠣" }, { L'ë', L"⠫" }, { L'î', L"⠩" }, { L'ï', L"⠻" }, { L'ô', L"⠹" },
        { L'œ', L"⠪" }, { L'ù', L"⠾" }, { L'û', L"⠱" }, { L'ü', L"⠳" },
        // digits
        { L'1', L"⠼⠁" }, { L'2', L"⠼⠃" }, { L'3', L"⠼⠉" }, { L'4', L"⠼⠙" }, { L'5', L"⠼⠑" },
        { L'6', L"⠼⠋" }, { L'7', L"⠼⠛" }, { L'8', L"⠼⠓" }, { L'9', L"⠼⠊" }, { L'0', L"⠼⠚" },
        // punctuation
        { L',', L"⠂" }, { L';', L"⠆" }, { L':', L"⠒" }, { L'.', L"⠲" }, { L'?', L"⠦" },
        { L'!', L"⠖" }, { L'‘', L"⠄" }, { L'“', L"⠄⠶" }, { L'”', L"⠘⠴" }, { L'‘', L"⠄⠦" },
        { L'’', L"⠄⠴" }, { L'(', L"⠐⠣" }, { L')', L"⠐⠜" }, { L'/', L"⠸⠌" }, { L'–', L"⠤" },
        { L'\'', L"⠄" }, { L'£', L"⠘⠇" }, { L'.', L"⠲" }, { L'*', L"⠔" }, { L'§', L"⠐⠏" },
        { L'&', L"⠐⠿" }, { L'¥', L"⠘⠽" }, { L'€', L"⠘⠑" }, { L'$', L"⠘⠎" }, { L'©', L"⠐⠉" },
        { L'®', L"⠐⠗" }, { L'™', L"⠐⠞" }, { L'%', L"⠐⠬" }, { L'‰', L"⠐⠬⠬" }, { L'‱', L"⠐⠬⠬⠬" },
    };

    auto const it = table.find(c);
    if (it == table.end())
        return std::wstring{} + c; // fallback - use character unchanged
    else
        return it->second;
}

इसे देखते हुए, प्रत्येक वर्ण को बदले में परिवर्तित करना बहुत आसान है:

std::wstring to_braille(const std::wstring& s)
{
    std::wstring braille;
    braille.reserve(s.size());  // output is at least as big as input

    for (wchar_t c: s)
        braille += to_braille(c);

    return braille;
}

डेमो:

#include <iostream>
#include <locale>
int main()
{
    std::locale::global(std::locale{""});
    std::wcout << to_braille(L"Hello World!");
}
⠨⠓⠑⠇⠇⠕ ⠨⠺⠕⠗⠇⠙⠖
1
Toby Speight 20 जून 2018, 12:36

मैं अपनी टिप्पणी पर आपके पहले के प्रश्न पर विस्तार कर सकता हूं।

सबसे पहले, आइए देखें कि आपका वर्तमान कोड बाहरी लूप के अंदर क्या करता है। तो आप उस स्थिति में हैं जहां आपके पास s नामक एक स्ट्रिंग है और आप प्रत्येक वर्ण को दूसरे रूप में अनुवाद करना चाहते हैं (विशेष रूप से, इसका ब्रेल रूप, लेकिन वह विवरण तर्क को प्रभावित नहीं करता है)। ऐसा करने के लिए, आप (find() के माध्यम से) स्ट्रिंग के प्रत्येक वर्ण के माध्यम से तब तक कदम रखते हैं जब तक कि आपको एक 'a' न मिल जाए। यदि आप एक पाते हैं, तो आप (find() फिर से कॉल करते हुए) स्ट्रिंग के प्रत्येक वर्ण के माध्यम से तब तक कदम रखें जब तक कि आपको एक 'a' न मिल जाए और उस वर्ण को बदल न दें। फिर आप इसे दोहराते हैं: स्ट्रिंग की शुरुआत में फिर से शुरू करते हुए, आप प्रत्येक वर्ण के माध्यम से तब तक कदम रखते हैं जब तक आपको एक 'a' नहीं मिल जाता। और इसी तरह।

उदाहरण के लिए, स्ट्रिंग "gala" को देखते हुए, पहले 'a' को 'g' और फिर 'a' को देखकर खोजें। ठीक है, एक प्रतिस्थापन किया जाना है। तो पहले 'a' को 'g' और फिर 'a' को देख कर ढूंढें और उसे बदल दें, जिससे आपको "g⠁la" मिल जाए। अब 'g', '⠁', 'l', फिर 'a' को देखकर अगला 'a' खोजें। ठीक है, एक प्रतिस्थापन किया जाना है। तो 'g', '⠁', 'l', फिर 'a' को देखकर अगला 'a' ढूंढें और आपको "g⠁l⠁" देकर उसे बदल दें। अब 'g', '⠁', 'l', फिर '⠁' को देखकर अगला 'a' खोजें। ओह हम कर चुके हैं। वाह। केवल 4 वर्णों में से 16 को देखना था!

एक बार जब आप 'a' की जगह ले लेते हैं, तो आप इस प्रक्रिया को वर्णमाला के प्रत्येक अक्षर के लिए दोहराते हैं, और फिर कुछ। यदि आपने ये निर्देश किसी इंसान को दिए हैं, तो वे सबसे अच्छी शिकायत करेंगे कि उन्हें व्यस्त काम दिया जा रहा है।


अगर आपको इसे हाथ से करना पड़े तो आप इस काम को कैसे करेंगे? क्या आप एक की तलाश करेंगे और उन्हें बदल देंगे, या आप चरित्र-दर-चरित्र पर जाएंगे और प्रत्येक का सामना करते ही उसे बदल देंगे? ज्यादातर लोग बाद में करेंगे। तो चलिए कंप्यूटर को इस दृष्टिकोण का उपयोग करने के लिए कहने का प्रयास करते हैं।

"चरित्र द्वारा चरित्र" को लागू करके प्रारंभ करें। ऐसा करने के अलग-अलग तरीके हैं। शिक्षाप्रद उद्देश्यों के लिए, मैं for ( auto it = s.begin(); it != s.end(); ++it ) के साथ जाऊंगा। यह चर it को शुरू से अंत तक स्ट्रिंग के माध्यम से कदम उठाने का कारण बनता है, लूप के प्रत्येक पुनरावृत्ति के साथ प्रत्येक वर्ण को इंगित करता है। अगला कार्य प्रत्येक वर्ण को प्रतिस्थापित करना है। यह कैसे करना है? यह मामूली नहीं है, तो चलिए इसे दूसरे फ़ंक्शन पर धकेलते हैं, इसे to_braille कहते हैं। और चूंकि कुछ प्रतिस्थापन एक से अधिक वर्ण हैं, इसलिए संभवतः एक नई स्ट्रिंग बनाना अधिक सुविधाजनक है। इन फैसलों के साथ, आपके लूप्स की गड़बड़ी निम्नलिखित हो जाती है।

while (getline(input, s)) {
    std::wstring braille;

    for ( auto it = s.begin(); it != s.end(); ++it )
        braille.append(to_braille(*it));

    wcout << braille << endl;
}

ज्यादा उत्तेजित न हों। लिखने के लिए अभी भी एक राक्षस कार्य है; यह सब अनावश्यक लूपिंग से छुटकारा पाने के लिए किया गया है। फिर भी, राक्षस कार्य काफी सीधा है। टिप्पणियों में यह कैसे करना है इसके लिए कुछ सुझाव हैं, लेकिन शुरुआती बिंदु के रूप में, आप केवल एक राक्षस switch कर सकते हैं। (यह देखते हुए कि यह फ़ंक्शन कितने समय के लिए होगा, मैं इसे इसकी अपनी स्रोत फ़ाइल देना चाहूंगा ताकि आपको इसे बार-बार देखने की आवश्यकता न पड़े।)

std::wstring to_braille(char c)
{
    switch ( c )
    {
        case 'a': return L"⠁";
        case 'b': return L"⠃";
        case 'c': return L"⠉";
        // And so on. You can write the rest.
    }
    // Unknown characters are not changed.
    return std::wstring(1, c);
}

इन सबका मुख्य बिंदु यह है कि इस बारे में सोचें कि आप क्या करना चाहते हैं; केवल इसलिए टूल का चयन न करें क्योंकि उनका उपयोग किया जा सकता है। इसके अलावा, विभाजित करें और जीतें।

नोट: टिप्पणियों के आधार पर, मैंने बनाई जा रही स्ट्रिंग को string से wstring में बदल दिया है। हालाँकि, मैंने फ़ाइल से पढ़ी जा रही स्ट्रिंग को नहीं बदला। आपको यह देखने के लिए अपने कार्यक्रम पर जाने की आवश्यकता हो सकती है कि विस्तृत वर्णों की आवश्यकता कहाँ है।

2
JaMiT 20 जून 2018, 13:13