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.
Compare x² + y² with each squared radius. Testing rings from the center outward awards a boundary hit to the inner ring.
0 100 0 200 0 300 0 400 0 500
gold red blue black white 30
आयात मानक.पाठ्य;
फलन संख्याएँ() -> सूची<पूर्णांक> {
स्थिर पंक्ति: पाठ = पाठपढ़ो();
स्थिर परिणाम: सूची<पूर्णांक> = नया सूची<पूर्णांक>();
मान संख्या: पूर्णांक = 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;
}
लिखो(दशमलवलेखन(कुल));
}
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.
500 20 140 150 160
Not balanced
आयात मानक.पाठ्य;
फलन संख्याएँ() -> सूची<पूर्णांक> {
स्थिर पंक्ति: पाठ = पाठपढ़ो();
स्थिर परिणाम: सूची<पूर्णांक> = नया सूची<पूर्णांक>();
मान संख्या: पूर्णांक = 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"); }
}
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.
2 2 2 2 2 4 3 4 1 2 1 4
2
आयात मानक.पाठ्य;
फलन संख्याएँ() -> सूची<पूर्णांक> {
स्थिर पंक्ति: पाठ = पाठपढ़ो();
स्थिर परिणाम: सूची<पूर्णांक> = नया सूची<पूर्णांक>();
मान संख्या: पूर्णांक = 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;
}
लिखो(दशमलवलेखन(सरल));
}
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.
10 10 XXXXXXXXXX XS.xF....X X........X X........X X........X X........X X........X X........X X........X XXXXXXXXXX
5 steps
आयात मानक.पाठ्य;
फलन संख्याएँ() -> सूची<पूर्णांक> {
स्थिर पंक्ति: पाठ = पाठपढ़ो();
स्थिर परिणाम: सूची<पूर्णांक> = नया सूची<पूर्णांक>();
मान संख्या: पूर्णांक = 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");
}
A rearrangement can increase strictly exactly when all values are distinct. A presence table detects duplicates in one scan.
2 4 4 3 2 1 3 9 4 9
YES NO
आयात मानक.पाठ्य;
फलन संख्याएँ() -> सूची<पूर्णांक> {
स्थिर पंक्ति: पाठ = पाठपढ़ो();
स्थिर परिणाम: सूची<पूर्णांक> = नया सूची<पूर्णांक>();
मान संख्या: पूर्णांक = 0;
मान चिह्न: पूर्णांक = 1;
मान सक्रिय: तार्किक = असत्य;
मान स्थान: पूर्णांक = 0;
जबतक (स्थान <= लंबाई(पंक्ति)) {
मान अक्षर: पाठ = " ";
यदि (स्थान < लंबाई(पंक्ति)) { अक्षर = अंश(पंक्ति, स्थान, स्थान + 1); }
स्थिर अंक: पूर्णांक = पाठ्य.खोजो("0123456789", अक्षर);
यदि (अंक >= 0) { संख्या = संख्या * 10 + अंक; सक्रिय = सत्य; }
अन्यथा यदि (अक्षर == "-") { चिह्न = -1; }
अन्यथा यदि (सक्रिय) { परिणाम.जोड़ो(चिह्न * संख्या); संख्या = 0; चिह्न = 1; सक्रिय = असत्य; }
स्थान = स्थान + 1;
}
लौटाओ परिणाम;
}
फलन मुख्य() -> शून्य {
स्थिर मामले: सूची<पूर्णांक> = संख्याएँ();
मान क्रम: पूर्णांक = 0;
जबतक (क्रम < मामले[0]) {
स्थिर आकार: सूची<पूर्णांक> = संख्याएँ();
स्थिर अंक: सूची<पूर्णांक> = संख्याएँ();
स्थिर आवृत्ति: पूर्णांक[] = नया पूर्णांक[1001];
मान संभव: तार्किक = सत्य;
मान स्थान: पूर्णांक = 0; जबतक (स्थान < आकार[0]) { स्थिर क: पूर्णांक = अंक[स्थान]; स्थान = स्थान+1;
यदि (आवृत्ति[क] > 0) { संभव = असत्य; }
आवृत्ति[क] = 1;
}
यदि (संभव) { लिखो("YES"); } अन्यथा { लिखो("NO"); }
क्रम = क्रम+1;
}
}
Calculate both results and print the larger signed integer. With negative factors, the sum can exceed the product.
3 -1 4
6
आयात मानक.पाठ्य;
फलन संख्याएँ() -> सूची<पूर्णांक> {
स्थिर पंक्ति: पाठ = पाठपढ़ो();
स्थिर परिणाम: सूची<पूर्णांक> = नया सूची<पूर्णांक>();
मान संख्या: पूर्णांक = 0;
मान चिह्न: पूर्णांक = 1;
मान सक्रिय: तार्किक = असत्य;
मान स्थान: पूर्णांक = 0;
जबतक (स्थान <= लंबाई(पंक्ति)) {
मान अक्षर: पाठ = " ";
यदि (स्थान < लंबाई(पंक्ति)) { अक्षर = अंश(पंक्ति, स्थान, स्थान + 1); }
स्थिर अंक: पूर्णांक = पाठ्य.खोजो("0123456789", अक्षर);
यदि (अंक >= 0) { संख्या = संख्या * 10 + अंक; सक्रिय = सत्य; }
अन्यथा यदि (अक्षर == "-") { चिह्न = -1; }
अन्यथा यदि (सक्रिय) { परिणाम.जोड़ो(चिह्न * संख्या); संख्या = 0; चिह्न = 1; सक्रिय = असत्य; }
स्थान = स्थान + 1;
}
लौटाओ परिणाम;
}
फलन दशमलवलेखन(मानक: पूर्णांक) -> पाठ {
यदि (मानक < 0) { लौटाओ "-" + दशमलवलेखन(-मानक); }
स्थिर अंक: पूर्णांक = मानक % 10;
स्थिर अक्षर: पाठ = अंश("0123456789", अंक, अंक+1);
यदि (मानक < 10) { लौटाओ अक्षर; }
लौटाओ दशमलवलेखन(मानक/10) + अक्षर;
}
फलन मुख्य() -> शून्य {
स्थिर अंक: सूची<पूर्णांक> = संख्याएँ();
स्थिर योग: पूर्णांक = अंक[0] + अंक[1] + अंक[2];
स्थिर गुणन: पूर्णांक = अंक[0] * अंक[1] * अंक[2];
यदि (योग > गुणन) { लिखो(दशमलवलेखन(योग)); } अन्यथा { लिखो(दशमलवलेखन(गुणन)); }
}
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.
4 10 10 20 20 10 20 20 10
38 30
आयात मानक.पाठ्य;
फलन संख्याएँ() -> सूची<पूर्णांक> {
स्थिर पंक्ति: पाठ = पाठपढ़ो();
स्थिर परिणाम: सूची<पूर्णांक> = नया सूची<पूर्णांक>();
मान संख्या: पूर्णांक = 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;
}
लिखो(दशमलवलेखन(अधिक)+" "+दशमलवलेखन(न्यून));
}
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.
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
1 1 1
आयात मानक.पाठ्य;
फलन संख्याएँ() -> सूची<पूर्णांक> {
स्थिर पंक्ति: पाठ = पाठपढ़ो();
स्थिर परिणाम: सूची<पूर्णांक> = नया सूची<पूर्णांक>();
मान संख्या: पूर्णांक = 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;
}
लिखो(दशमलवलेखन(अ)+" "+दशमलवलेखन(ब)+" "+दशमलवलेखन(ग));
}
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.
HELLO MOM
AFXMS FPY
आयात मानक.पाठ्य;
फलन मुख्य() -> शून्य {
स्थिर वर्ण: पाठ = "ABCDEFGHIJKLMNOPQRSTUVWXYZ";
स्थिर चाल: पूर्णांक[] = नया पूर्णांक[]{19,1,12,1,4};
स्थिर संदेश: पाठ = पाठपढ़ो();
मान उत्तर: पाठ = "";
मान क्रम: पूर्णांक = 0;
मान स्थान: पूर्णांक = 0;
जबतक (स्थान < लंबाई(संदेश)) {
मान अक्षर: पाठ = अंश(संदेश,स्थान,स्थान+1);
यदि (अक्षर != " ") {
स्थिर नयाांक: पूर्णांक = (पाठ्य.खोजो(वर्ण,अक्षर)+चाल[क्रम%5])%26;
अक्षर = अंश(वर्ण,नयाांक,नयाांक+1);
क्रम = क्रम+1;
}
उत्तर = उत्तर+अक्षर; स्थान = स्थान+1;
}
लिखो(उत्तर);
}