भाष में समस्या समाधान · Bhash Problem Showcase

Nine worked solutions to the 2026 Practice Problems. Save any .bhash source file and run it with Bhash 0.25.1 using java -jar bhash-compiler-0.25.1.jar run filename.bhash. Enter the sample input one line at a time.

Bullseye · निशाने के अंक

Compare x² + y² with each squared radius. Testing rings from the center outward awards a boundary hit to the inner ring.

Input · निवेश

0 100
0 200
0 300
0 400
0 500

Output · परिणाम

gold
red
blue
black
white
30
Bhash source · स्रोत कोड
आयात मानक.पाठ्य;
फलन संख्याएँ() -> सूची<पूर्णांक> {
    स्थिर पंक्ति: पाठ = पाठपढ़ो();
    स्थिर परिणाम: सूची<पूर्णांक> = नया सूची<पूर्णांक>();
    मान संख्या: पूर्णांक = 0;
    मान चिह्न: पूर्णांक = 1;
    मान सक्रिय: तार्किक = असत्य;
    मान स्थान: पूर्णांक = 0;
    जबतक (स्थान <= लंबाई(पंक्ति)) {
        मान अक्षर: पाठ = " ";
        यदि (स्थान < लंबाई(पंक्ति)) { अक्षर = अंश(पंक्ति, स्थान, स्थान + 1); }
        स्थिर अंक: पूर्णांक = पाठ्य.खोजो("0123456789", अक्षर);
        यदि (अंक >= 0) { संख्या = संख्या * 10 + अंक; सक्रिय = सत्य; }
        अन्यथा यदि (अक्षर == "-") { चिह्न = -1; }
        अन्यथा यदि (सक्रिय) { परिणाम.जोड़ो(चिह्न * संख्या); संख्या = 0; चिह्न = 1; सक्रिय = असत्य; }
        स्थान = स्थान + 1;
    }
    लौटाओ परिणाम;
}
फलन दशमलवलेखन(मानक: पूर्णांक) -> पाठ {
    यदि (मानक < 0) { लौटाओ "-" + दशमलवलेखन(-मानक); }
    स्थिर अंक: पूर्णांक = मानक % 10;
    स्थिर अक्षर: पाठ = अंश("0123456789", अंक, अंक+1);
    यदि (मानक < 10) { लौटाओ अक्षर; }
    लौटाओ दशमलवलेखन(मानक/10) + अक्षर;
}

फलन मुख्य() -> शून्य {
    स्थिर रंग: पाठ[] = नया पाठ[]{"gold","red","blue","black","white","miss"};
    मान कुल: पूर्णांक = 0;
    मान तीर: पूर्णांक = 0;
    जबतक (तीर < 5) {
        स्थिर बिंदु: सूची<पूर्णांक> = संख्याएँ();
        स्थिर दूरीवर्ग: पूर्णांक = बिंदु[0]*बिंदु[0] + बिंदु[1]*बिंदु[1];
        मान घेरा: पूर्णांक = 0;
        जबतक (घेरा < 5 && दूरीवर्ग > 10000*(घेरा+1)*(घेरा+1)) { घेरा = घेरा+1; }
        लिखो(रंग[घेरा]);
        कुल = कुल + 10 - 2*घेरा;
        तीर = तीर+1;
    }
    लिखो(दशमलवलेखन(कुल));
}


Tipsy Canoe · डोंगी का संतुलन

Check the total weight first. Across all seating arrangements, the greatest front-to-back difference is the heaviest weight minus the lightest. Equality with the tipping threshold counts.

Input · निवेश

500 20 140 150 160

Output · परिणाम

Not balanced
Bhash source · स्रोत कोड
आयात मानक.पाठ्य;
फलन संख्याएँ() -> सूची<पूर्णांक> {
    स्थिर पंक्ति: पाठ = पाठपढ़ो();
    स्थिर परिणाम: सूची<पूर्णांक> = नया सूची<पूर्णांक>();
    मान संख्या: पूर्णांक = 0;
    मान चिह्न: पूर्णांक = 1;
    मान सक्रिय: तार्किक = असत्य;
    मान स्थान: पूर्णांक = 0;
    जबतक (स्थान <= लंबाई(पंक्ति)) {
        मान अक्षर: पाठ = " ";
        यदि (स्थान < लंबाई(पंक्ति)) { अक्षर = अंश(पंक्ति, स्थान, स्थान + 1); }
        स्थिर अंक: पूर्णांक = पाठ्य.खोजो("0123456789", अक्षर);
        यदि (अंक >= 0) { संख्या = संख्या * 10 + अंक; सक्रिय = सत्य; }
        अन्यथा यदि (अक्षर == "-") { चिह्न = -1; }
        अन्यथा यदि (सक्रिय) { परिणाम.जोड़ो(चिह्न * संख्या); संख्या = 0; चिह्न = 1; सक्रिय = असत्य; }
        स्थान = स्थान + 1;
    }
    लौटाओ परिणाम;
}
फलन मुख्य() -> शून्य {
    स्थिर भार: सूची<पूर्णांक> = संख्याएँ();
    मान न्यून: पूर्णांक = भार[2];
    मान अधिक: पूर्णांक = भार[2];
    मान कुल: पूर्णांक = 0;
    मान क्रम: पूर्णांक = 2;
    जबतक (क्रम < 5) {
        यदि (भार[क्रम] < न्यून) { न्यून = भार[क्रम]; }
        यदि (भार[क्रम] > अधिक) { अधिक = भार[क्रम]; }
        कुल = कुल + भार[क्रम]; क्रम = क्रम+1;
    }
    यदि (कुल > भार[0]) { लिखो("Too heavy"); }
    अन्यथा यदि (अधिक-न्यून >= भार[1]) { लिखो("Not balanced"); }
    अन्यथा { लिखो("No problem"); }
}

Programming Contest · सबसे सरल प्रश्न

Accumulate each question’s rating sum and vote count. Cross-multiplication compares averages exactly. Scanning in numerical order preserves the first question in a tie.

Input · निवेश

2 2 2 2
2 4 3 4
1 2 1 4

Output · परिणाम

2
Bhash source · स्रोत कोड
आयात मानक.पाठ्य;
फलन संख्याएँ() -> सूची<पूर्णांक> {
    स्थिर पंक्ति: पाठ = पाठपढ़ो();
    स्थिर परिणाम: सूची<पूर्णांक> = नया सूची<पूर्णांक>();
    मान संख्या: पूर्णांक = 0;
    मान चिह्न: पूर्णांक = 1;
    मान सक्रिय: तार्किक = असत्य;
    मान स्थान: पूर्णांक = 0;
    जबतक (स्थान <= लंबाई(पंक्ति)) {
        मान अक्षर: पाठ = " ";
        यदि (स्थान < लंबाई(पंक्ति)) { अक्षर = अंश(पंक्ति, स्थान, स्थान + 1); }
        स्थिर अंक: पूर्णांक = पाठ्य.खोजो("0123456789", अक्षर);
        यदि (अंक >= 0) { संख्या = संख्या * 10 + अंक; सक्रिय = सत्य; }
        अन्यथा यदि (अक्षर == "-") { चिह्न = -1; }
        अन्यथा यदि (सक्रिय) { परिणाम.जोड़ो(चिह्न * संख्या); संख्या = 0; चिह्न = 1; सक्रिय = असत्य; }
        स्थान = स्थान + 1;
    }
    लौटाओ परिणाम;
}
फलन दशमलवलेखन(मानक: पूर्णांक) -> पाठ {
    यदि (मानक < 0) { लौटाओ "-" + दशमलवलेखन(-मानक); }
    स्थिर अंक: पूर्णांक = मानक % 10;
    स्थिर अक्षर: पाठ = अंश("0123456789", अंक, अंक+1);
    यदि (मानक < 10) { लौटाओ अक्षर; }
    लौटाओ दशमलवलेखन(मानक/10) + अक्षर;
}

फलन मुख्य() -> शून्य {
    स्थिर प्रश्न: पूर्णांक[] = नया पूर्णांक[]{1,3,5,7,2,4,6,8,2,3,5,7};
    स्थिर योग: पूर्णांक[] = नया पूर्णांक[9];
    स्थिर मत: पूर्णांक[] = नया पूर्णांक[9];
    मान व्यक्ति: पूर्णांक = 0;
    जबतक (व्यक्ति < 3) {
        स्थिर अंक: सूची<पूर्णांक> = संख्याएँ();
        मान क्रम: पूर्णांक = 0;
        जबतक (क्रम < 4) {
            स्थिर क: पूर्णांक = प्रश्न[व्यक्ति*4+क्रम];
            योग[क] = योग[क]+अंक[क्रम]; मत[क] = मत[क]+1;
            क्रम = क्रम+1;
        }
        व्यक्ति = व्यक्ति+1;
    }
    मान सरल: पूर्णांक = 1;
    मान क: पूर्णांक = 2;
    जबतक (क <= 8) {
        यदि (योग[क]*मत[सरल] < योग[सरल]*मत[क]) { सरल = क; }
        क = क+1;
    }
    लिखो(दशमलवलेखन(सरल));
}


Food Search · भोजन तक सबसे छोटा रास्ता

A queue explores adjacent cells in order of distance. Mark each open cell when it enters the queue. The first food reached has the minimum walking distance.

Input · निवेश

10 10
XXXXXXXXXX
XS.xF....X
X........X
X........X
X........X
X........X
X........X
X........X
X........X
XXXXXXXXXX

Output · परिणाम

5 steps
Bhash source · स्रोत कोड
आयात मानक.पाठ्य;
फलन संख्याएँ() -> सूची<पूर्णांक> {
    स्थिर पंक्ति: पाठ = पाठपढ़ो();
    स्थिर परिणाम: सूची<पूर्णांक> = नया सूची<पूर्णांक>();
    मान संख्या: पूर्णांक = 0;
    मान चिह्न: पूर्णांक = 1;
    मान सक्रिय: तार्किक = असत्य;
    मान स्थान: पूर्णांक = 0;
    जबतक (स्थान <= लंबाई(पंक्ति)) {
        मान अक्षर: पाठ = " ";
        यदि (स्थान < लंबाई(पंक्ति)) { अक्षर = अंश(पंक्ति, स्थान, स्थान + 1); }
        स्थिर अंक: पूर्णांक = पाठ्य.खोजो("0123456789", अक्षर);
        यदि (अंक >= 0) { संख्या = संख्या * 10 + अंक; सक्रिय = सत्य; }
        अन्यथा यदि (अक्षर == "-") { चिह्न = -1; }
        अन्यथा यदि (सक्रिय) { परिणाम.जोड़ो(चिह्न * संख्या); संख्या = 0; चिह्न = 1; सक्रिय = असत्य; }
        स्थान = स्थान + 1;
    }
    लौटाओ परिणाम;
}
फलन दशमलवलेखन(मानक: पूर्णांक) -> पाठ {
    यदि (मानक < 0) { लौटाओ "-" + दशमलवलेखन(-मानक); }
    स्थिर अंक: पूर्णांक = मानक % 10;
    स्थिर अक्षर: पाठ = अंश("0123456789", अंक, अंक+1);
    यदि (मानक < 10) { लौटाओ अक्षर; }
    लौटाओ दशमलवलेखन(मानक/10) + अक्षर;
}

फलन मुख्य() -> शून्य {
    स्थिर आकार: सूची<पूर्णांक> = संख्याएँ();
    स्थिर ऊँचाई: पूर्णांक = आकार[0];
    स्थिर चौड़ाई: पूर्णांक = आकार[1];
    स्थिर नक्शा: पूर्णांक[] = नया पूर्णांक[ऊँचाई*चौड़ाई];
    स्थिर कतार: पूर्णांक[] = नया पूर्णांक[ऊँचाई*चौड़ाई];
    स्थिर दूरी: पूर्णांक[] = नया पूर्णांक[ऊँचाई*चौड़ाई];
    मान प: पूर्णांक = 0;
    जबतक (प < ऊँचाई) {
        स्थिर पंक्ति: पाठ = पाठपढ़ो();
        मान स: पूर्णांक = 0;
        जबतक (स < चौड़ाई) {
            स्थिर घर: पूर्णांक = प*चौड़ाई+स;
            स्थिर अक्षर: पाठ = अंश(पंक्ति,स,स+1);
            यदि (अक्षर == "S") { कतार[0] = घर; नक्शा[घर] = 1; }
            यदि (अक्षर == "F") { नक्शा[घर] = 2; }
            यदि (अक्षर == "X" || अक्षर == "x") { नक्शा[घर] = 1; }
            स = स+1;
        }
        प = प+1;
    }
    स्थिर चाल: पूर्णांक[] = नया पूर्णांक[]{-1,1,-चौड़ाई,चौड़ाई};
    मान सिर: पूर्णांक = 0;
    मान अंत: पूर्णांक = 1;
    जबतक (सिर < अंत) {
        स्थिर घर: पूर्णांक = कतार[सिर]; सिर = सिर+1;
        मान दिशा: पूर्णांक = 0; जबतक (दिशा < 4) { स्थिर क: पूर्णांक = चाल[दिशा]; दिशा = दिशा+1;
            स्थिर अगला: पूर्णांक = घर+क;
            यदि (नक्शा[अगला] == 2) { लिखो(दशमलवलेखन(दूरी[घर]+1)+" steps"); लौटाओ; }
            यदि (नक्शा[अगला] == 0) {
                नक्शा[अगला] = 1; दूरी[अगला] = दूरी[घर]+1;
                कतार[अंत] = अगला; अंत = अंत+1;
            }
        }
    }
    लिखो("No food");
}


Strictly Increasing · दोहराव की पहचान

A rearrangement can increase strictly exactly when all values are distinct. A presence table detects duplicates in one scan.

Input · निवेश

2
4
4 3 2 1
3
9 4 9

Output · परिणाम

YES
NO
Bhash source · स्रोत कोड
आयात मानक.पाठ्य;
फलन संख्याएँ() -> सूची<पूर्णांक> {
    स्थिर पंक्ति: पाठ = पाठपढ़ो();
    स्थिर परिणाम: सूची<पूर्णांक> = नया सूची<पूर्णांक>();
    मान संख्या: पूर्णांक = 0;
    मान चिह्न: पूर्णांक = 1;
    मान सक्रिय: तार्किक = असत्य;
    मान स्थान: पूर्णांक = 0;
    जबतक (स्थान <= लंबाई(पंक्ति)) {
        मान अक्षर: पाठ = " ";
        यदि (स्थान < लंबाई(पंक्ति)) { अक्षर = अंश(पंक्ति, स्थान, स्थान + 1); }
        स्थिर अंक: पूर्णांक = पाठ्य.खोजो("0123456789", अक्षर);
        यदि (अंक >= 0) { संख्या = संख्या * 10 + अंक; सक्रिय = सत्य; }
        अन्यथा यदि (अक्षर == "-") { चिह्न = -1; }
        अन्यथा यदि (सक्रिय) { परिणाम.जोड़ो(चिह्न * संख्या); संख्या = 0; चिह्न = 1; सक्रिय = असत्य; }
        स्थान = स्थान + 1;
    }
    लौटाओ परिणाम;
}
फलन मुख्य() -> शून्य {
    स्थिर मामले: सूची<पूर्णांक> = संख्याएँ();
    मान क्रम: पूर्णांक = 0;
    जबतक (क्रम < मामले[0]) {
        स्थिर आकार: सूची<पूर्णांक> = संख्याएँ();
        स्थिर अंक: सूची<पूर्णांक> = संख्याएँ();
        स्थिर आवृत्ति: पूर्णांक[] = नया पूर्णांक[1001];
        मान संभव: तार्किक = सत्य;
        मान स्थान: पूर्णांक = 0; जबतक (स्थान < आकार[0]) { स्थिर क: पूर्णांक = अंक[स्थान]; स्थान = स्थान+1;
            यदि (आवृत्ति[क] > 0) { संभव = असत्य; }
            आवृत्ति[क] = 1;
        }
        यदि (संभव) { लिखो("YES"); } अन्यथा { लिखो("NO"); }
        क्रम = क्रम+1;
    }
}

Sum or Product · योग या गुणनफल

Calculate both results and print the larger signed integer. With negative factors, the sum can exceed the product.

Input · निवेश

3 -1 4

Output · परिणाम

6
Bhash source · स्रोत कोड
आयात मानक.पाठ्य;
फलन संख्याएँ() -> सूची<पूर्णांक> {
    स्थिर पंक्ति: पाठ = पाठपढ़ो();
    स्थिर परिणाम: सूची<पूर्णांक> = नया सूची<पूर्णांक>();
    मान संख्या: पूर्णांक = 0;
    मान चिह्न: पूर्णांक = 1;
    मान सक्रिय: तार्किक = असत्य;
    मान स्थान: पूर्णांक = 0;
    जबतक (स्थान <= लंबाई(पंक्ति)) {
        मान अक्षर: पाठ = " ";
        यदि (स्थान < लंबाई(पंक्ति)) { अक्षर = अंश(पंक्ति, स्थान, स्थान + 1); }
        स्थिर अंक: पूर्णांक = पाठ्य.खोजो("0123456789", अक्षर);
        यदि (अंक >= 0) { संख्या = संख्या * 10 + अंक; सक्रिय = सत्य; }
        अन्यथा यदि (अक्षर == "-") { चिह्न = -1; }
        अन्यथा यदि (सक्रिय) { परिणाम.जोड़ो(चिह्न * संख्या); संख्या = 0; चिह्न = 1; सक्रिय = असत्य; }
        स्थान = स्थान + 1;
    }
    लौटाओ परिणाम;
}
फलन दशमलवलेखन(मानक: पूर्णांक) -> पाठ {
    यदि (मानक < 0) { लौटाओ "-" + दशमलवलेखन(-मानक); }
    स्थिर अंक: पूर्णांक = मानक % 10;
    स्थिर अक्षर: पाठ = अंश("0123456789", अंक, अंक+1);
    यदि (मानक < 10) { लौटाओ अक्षर; }
    लौटाओ दशमलवलेखन(मानक/10) + अक्षर;
}

फलन मुख्य() -> शून्य {
    स्थिर अंक: सूची<पूर्णांक> = संख्याएँ();
    स्थिर योग: पूर्णांक = अंक[0] + अंक[1] + अंक[2];
    स्थिर गुणन: पूर्णांक = अंक[0] * अंक[1] * अंक[2];
    यदि (योग > गुणन) { लिखो(दशमलवलेखन(योग)); } अन्यथा { लिखो(दशमलवलेखन(गुणन)); }
}



Razorback Ziplines · पेड़ों के बीच मार्ग

Round each individual segment to the nearest integer. For every subset of trees and possible last tree, retain the shortest and longest paths. Extending a smaller subset tries every possible predecessor in O(N² × 2ᴺ) time.

Input · निवेश

4
10 10
20 20
10 20
20 10

Output · परिणाम

38 30
Bhash source · स्रोत कोड
आयात मानक.पाठ्य;
फलन संख्याएँ() -> सूची<पूर्णांक> {
    स्थिर पंक्ति: पाठ = पाठपढ़ो();
    स्थिर परिणाम: सूची<पूर्णांक> = नया सूची<पूर्णांक>();
    मान संख्या: पूर्णांक = 0;
    मान चिह्न: पूर्णांक = 1;
    मान सक्रिय: तार्किक = असत्य;
    मान स्थान: पूर्णांक = 0;
    जबतक (स्थान <= लंबाई(पंक्ति)) {
        मान अक्षर: पाठ = " ";
        यदि (स्थान < लंबाई(पंक्ति)) { अक्षर = अंश(पंक्ति, स्थान, स्थान + 1); }
        स्थिर अंक: पूर्णांक = पाठ्य.खोजो("0123456789", अक्षर);
        यदि (अंक >= 0) { संख्या = संख्या * 10 + अंक; सक्रिय = सत्य; }
        अन्यथा यदि (अक्षर == "-") { चिह्न = -1; }
        अन्यथा यदि (सक्रिय) { परिणाम.जोड़ो(चिह्न * संख्या); संख्या = 0; चिह्न = 1; सक्रिय = असत्य; }
        स्थान = स्थान + 1;
    }
    लौटाओ परिणाम;
}
फलन दशमलवलेखन(मानक: पूर्णांक) -> पाठ {
    यदि (मानक < 0) { लौटाओ "-" + दशमलवलेखन(-मानक); }
    स्थिर अंक: पूर्णांक = मानक % 10;
    स्थिर अक्षर: पाठ = अंश("0123456789", अंक, अंक+1);
    यदि (मानक < 10) { लौटाओ अक्षर; }
    लौटाओ दशमलवलेखन(मानक/10) + अक्षर;
}

फलन मुख्य() -> शून्य {
    स्थिर आकार: सूची<पूर्णांक> = संख्याएँ();
    स्थिर न: पूर्णांक = आकार[0];
    स्थिर कुल: पूर्णांक = 1 << न;
    स्थिर दूरियाँ: पूर्णांक[][] = नया पूर्णांक[न][न];
    स्थिर क्ष: पूर्णांक[] = नया पूर्णांक[न];
    स्थिर य: पूर्णांक[] = नया पूर्णांक[न];
    मान क: पूर्णांक = 0;
    जबतक (क < न) {
        स्थिर बिंदु: सूची<पूर्णांक> = संख्याएँ();
        क्ष[क] = बिंदु[0]; य[क] = बिंदु[1];
        मान ज: पूर्णांक = 0;
        जबतक (ज < क) {
            स्थिर अ: पूर्णांक = क्ष[क]-क्ष[ज];
            स्थिर ब: पूर्णांक = य[क]-य[ज];
            मान द: पूर्णांक = 0;
            जबतक ((2*द+1)*(2*द+1) < 4*(अ*अ+ब*ब)) { द = द+1; }
            दूरियाँ[क][ज] = द; दूरियाँ[ज][क] = द; ज = ज+1;
        }
        क = क+1;
    }
    स्थिर छोटी: पूर्णांक[][] = नया पूर्णांक[कुल][न];
    स्थिर बड़ी: पूर्णांक[][] = नया पूर्णांक[कुल][न];
    मान न्यून: पूर्णांक = 99999;
    मान अधिक: पूर्णांक = 0;
    मान समूह: पूर्णांक = 1;
    जबतक (समूह < कुल) {
        क = 0;
        जबतक (क < न) {
            स्थिर बिट: पूर्णांक = 1 << क;
            यदि ((समूह & बिट) != 0) {
                स्थिर शेषसमूह: पूर्णांक = समूह-बिट;
                यदि (शेषसमूह != 0) { छोटी[समूह][क] = 99999; }
                मान ज: पूर्णांक = 0;
                जबतक (ज < न) {
                    यदि ((शेषसमूह & (1 << ज)) != 0) {
                        स्थिर अ: पूर्णांक = छोटी[शेषसमूह][ज]+दूरियाँ[ज][क];
                        स्थिर ब: पूर्णांक = बड़ी[शेषसमूह][ज]+दूरियाँ[ज][क];
                        यदि (अ < छोटी[समूह][क]) { छोटी[समूह][क] = अ; }
                        यदि (ब > बड़ी[समूह][क]) { बड़ी[समूह][क] = ब; }
                    }
                    ज = ज+1;
                }
                यदि (समूह == कुल-1) {
                    यदि (छोटी[समूह][क] < न्यून) { न्यून = छोटी[समूह][क]; }
                    यदि (बड़ी[समूह][क] > अधिक) { अधिक = बड़ी[समूह][क]; }
                }
            }
            क = क+1;
        }
        समूह = समूह+1;
    }
    लिखो(दशमलवलेखन(अधिक)+" "+दशमलवलेखन(न्यून));
}


Sudoku Checker · सुडोकू की जाँच

Each digit sets one bit in its row, column and box. With nine entries per unit, a mask containing all nine digits proves that each occurs exactly once. Count incomplete masks separately.

Input · निवेश

5 3 4 6 7 8 9 1 2
6 7 2 1 9 5 3 4 8
1 9 8 3 4 2 5 6 7
8 5 9 7 6 1 4 2 3
4 2 6 8 5 3 7 9 1
7 1 3 9 2 4 8 5 6
9 6 1 5 3 7 2 8 4
2 8 7 4 1 9 6 3 5
3 4 5 2 8 6 1 7 6

Output · परिणाम

1 1 1
Bhash source · स्रोत कोड
आयात मानक.पाठ्य;
फलन संख्याएँ() -> सूची<पूर्णांक> {
    स्थिर पंक्ति: पाठ = पाठपढ़ो();
    स्थिर परिणाम: सूची<पूर्णांक> = नया सूची<पूर्णांक>();
    मान संख्या: पूर्णांक = 0;
    मान चिह्न: पूर्णांक = 1;
    मान सक्रिय: तार्किक = असत्य;
    मान स्थान: पूर्णांक = 0;
    जबतक (स्थान <= लंबाई(पंक्ति)) {
        मान अक्षर: पाठ = " ";
        यदि (स्थान < लंबाई(पंक्ति)) { अक्षर = अंश(पंक्ति, स्थान, स्थान + 1); }
        स्थिर अंक: पूर्णांक = पाठ्य.खोजो("0123456789", अक्षर);
        यदि (अंक >= 0) { संख्या = संख्या * 10 + अंक; सक्रिय = सत्य; }
        अन्यथा यदि (अक्षर == "-") { चिह्न = -1; }
        अन्यथा यदि (सक्रिय) { परिणाम.जोड़ो(चिह्न * संख्या); संख्या = 0; चिह्न = 1; सक्रिय = असत्य; }
        स्थान = स्थान + 1;
    }
    लौटाओ परिणाम;
}
फलन दशमलवलेखन(मानक: पूर्णांक) -> पाठ {
    यदि (मानक < 0) { लौटाओ "-" + दशमलवलेखन(-मानक); }
    स्थिर अंक: पूर्णांक = मानक % 10;
    स्थिर अक्षर: पाठ = अंश("0123456789", अंक, अंक+1);
    यदि (मानक < 10) { लौटाओ अक्षर; }
    लौटाओ दशमलवलेखन(मानक/10) + अक्षर;
}

फलन मुख्य() -> शून्य {
    स्थिर पंक्तियाँ: पूर्णांक[] = नया पूर्णांक[9];
    स्थिर स्तंभ: पूर्णांक[] = नया पूर्णांक[9];
    स्थिर खंड: पूर्णांक[] = नया पूर्णांक[9];
    मान प: पूर्णांक = 0;
    जबतक (प < 9) {
        स्थिर अंक: सूची<पूर्णांक> = संख्याएँ();
        मान स: पूर्णांक = 0;
        जबतक (स < 9) {
            स्थिर बिट: पूर्णांक = 1 << अंक[स];
            स्थिर ख: पूर्णांक = (प/3)*3 + स/3;
            पंक्तियाँ[प] = पंक्तियाँ[प] | बिट;
            स्तंभ[स] = स्तंभ[स] | बिट;
            खंड[ख] = खंड[ख] | बिट;
            स = स+1;
        }
        प = प+1;
    }
    मान अ: पूर्णांक = 0;
    मान ब: पूर्णांक = 0;
    मान ग: पूर्णांक = 0;
    प = 0;
    जबतक (प < 9) {
        यदि (पंक्तियाँ[प] != 1022) { अ = अ+1; }
        यदि (स्तंभ[प] != 1022) { ब = ब+1; }
        यदि (खंड[प] != 1022) { ग = ग+1; }
        प = प+1;
    }
    लिखो(दशमलवलेखन(अ)+" "+दशमलवलेखन(ब)+" "+दशमलवलेखन(ग));
}


Caesar Salad Cipher · अक्षरों का चक्रीय बदलाव

Cycle through the five right shifts 19, 1, 12, 1 and 4. Copy spaces without advancing the shift index. Modulo 26 wraps letters past Z.

Input · निवेश

HELLO MOM

Output · परिणाम

AFXMS FPY
Bhash source · स्रोत कोड
आयात मानक.पाठ्य;
फलन मुख्य() -> शून्य {
    स्थिर वर्ण: पाठ = "ABCDEFGHIJKLMNOPQRSTUVWXYZ";
    स्थिर चाल: पूर्णांक[] = नया पूर्णांक[]{19,1,12,1,4};
    स्थिर संदेश: पाठ = पाठपढ़ो();
    मान उत्तर: पाठ = "";
    मान क्रम: पूर्णांक = 0;
    मान स्थान: पूर्णांक = 0;
    जबतक (स्थान < लंबाई(संदेश)) {
        मान अक्षर: पाठ = अंश(संदेश,स्थान,स्थान+1);
        यदि (अक्षर != " ") {
            स्थिर नयाांक: पूर्णांक = (पाठ्य.खोजो(वर्ण,अक्षर)+चाल[क्रम%5])%26;
            अक्षर = अंश(वर्ण,नयाांक,नयाांक+1);
            क्रम = क्रम+1;
        }
        उत्तर = उत्तर+अक्षर; स्थान = स्थान+1;
    }
    लिखो(उत्तर);
}