23:I[344796,["/_next/static/chunks/083cs_iw_ie0y.js","/_next/static/chunks/2sk2f47durg8o.js","/_next/static/chunks/00mfjk9z2ewie.js","/_next/static/chunks/2q9x6spyz4qxv.js","/_next/static/chunks/1wo5i8je1ygp5.js","/_next/static/chunks/1h4l04ysuholp.js","/_next/static/chunks/2qcnia-og0qh0.js","/_next/static/chunks/40webkzfr6rcp.js"],"default"] 27:I[27201,["/_next/static/chunks/083cs_iw_ie0y.js","/_next/static/chunks/2sk2f47durg8o.js","/_next/static/chunks/00mfjk9z2ewie.js","/_next/static/chunks/2q9x6spyz4qxv.js","/_next/static/chunks/1wo5i8je1ygp5.js","/_next/static/chunks/1h4l04ysuholp.js","/_next/static/chunks/2qcnia-og0qh0.js"],"IconMark"] 24:T11a2,

Alphabet Wheel Rearrangement

You are given a string str1 whose characters have to be rearranged according to a specific pattern. In the original assessment the pattern itself was withheld and only worked examples were shown, so your first job is to read the pattern off the examples below.

Some examples following the pattern are given here:

INPUT	OUTPUT
`HELLO`	`JGNNQ`
`WORLD`	`YQTNF`
`OPEN`	`QRGP`
`CLOSE`	`ENQUG`
`ZERO`	`BGTQ`
`AA`	`CC`

So that the contract is exact enough to be judged, the pattern those examples encode is spelled out here (inferred — the source deliberately hides the rule and shows only the six pairs above; the pairs determine the rule uniquely, and a hidden test suite cannot be graded against a rule the solver has to guess, so it is pinned explicitly):

Write the 26 uppercase English letters A B C … Z around a wheel, so that Z is immediately followed by A again. Every character of str1 is replaced, independently of its position, by the letter that stands two places further along the wheel. So A becomes C, M becomes O, Y becomes A, and Z becomes B. The length of the string never changes and characters are never moved to a different index.

Read the input from STDIN and print the output to STDOUT. Do not print anything other than the required answer.

Input Format

The only line of input contains the string str1, which needs to be rearranged.

Output Format

The only line of output should display the rearranged string.

Constraints

1 <= |str1| <= 15000 (inferred — the source states only 0 < |str1| with no upper bound; a bound is required so that the answer, which is always exactly |str1| characters long, fits the judge's output limit)
str1 contains only uppercase English letters A–Z.
No spaces, digits or punctuation ever appear in str1.
Every value fits comfortably in 32-bit arithmetic; no large-integer handling is needed.

Example 1

Input:

DATA

Output:

FCVC

Explanation: D → F, A → C, T → V, A → C. Each letter moves two places further along the wheel, and the repeated A is transformed the same way both times.

Example 2

Input:

STREAM

Output:

UVTGCO

Explanation: S → U, T → V, R → T, E → G, A → C, M → O.

Example 3

Input:

ZERO

Output:

BGTQ

Explanation: this is the wraparound case. Z is two places past Z on the wheel, which means one past A, i.e. B. Then E → G, R → T, O → Q.

Notes

The rule is applied to each character independently; the position of a character in the string has no effect on how it is transformed.
The output string always has exactly the same length as the input string.
A string of length 1 is a valid input: the single letter is transformed and printed on its own.
Repeated letters are transformed identically every time they occur (AA becomes CC).
Only Y and Z wrap around the end of the wheel, to A and B respectively.
Print the result followed by a newline and nothing else.

25:Tc74,# Alphabet Wheel Rearrangement You are given a string `str1` whose characters have to be rearranged according to a specific pattern. In the original assessment the pattern itself was withheld and only worked examples were shown, so your first job is to read the pattern off the examples below. Some examples following the pattern are given here: | INPUT | OUTPUT | |-------|--------| | `HELLO` | `JGNNQ` | | `WORLD` | `YQTNF` | | `OPEN` | `QRGP` | | `CLOSE` | `ENQUG` | | `ZERO` | `BGTQ` | | `AA` | `CC` | So that the contract is exact enough to be judged, the pattern those examples encode is spelled out here *(inferred — the source deliberately hides the rule and shows only the six pairs above; the pairs determine the rule uniquely, and a hidden test suite cannot be graded against a rule the solver has to guess, so it is pinned explicitly)*: Write the 26 uppercase English letters `A B C … Z` around a wheel, so that `Z` is immediately followed by `A` again. Every character of `str1` is replaced, independently of its position, by the letter that stands **two places further along the wheel**. So `A` becomes `C`, `M` becomes `O`, `Y` becomes `A`, and `Z` becomes `B`. The length of the string never changes and characters are never moved to a different index. Read the input from STDIN and print the output to STDOUT. Do not print anything other than the required answer. ## Input Format The only line of input contains the string `str1`, which needs to be rearranged. ## Output Format The only line of output should display the rearranged string. ## Constraints - `1 <= |str1| <= 15000` *(inferred — the source states only `0 < |str1|` with no upper bound; a bound is required so that the answer, which is always exactly `|str1|` characters long, fits the judge's output limit)* - `str1` contains only uppercase English letters `A`–`Z`. - No spaces, digits or punctuation ever appear in `str1`. - Every value fits comfortably in 32-bit arithmetic; no large-integer handling is needed. ## Example 1 Input: ``` DATA ``` Output: ``` FCVC ``` Explanation: `D` → `F`, `A` → `C`, `T` → `V`, `A` → `C`. Each letter moves two places further along the wheel, and the repeated `A` is transformed the same way both times. ## Example 2 Input: ``` STREAM ``` Output: ``` UVTGCO ``` Explanation: `S` → `U`, `T` → `V`, `R` → `T`, `E` → `G`, `A` → `C`, `M` → `O`. ## Example 3 Input: ``` ZERO ``` Output: ``` BGTQ ``` Explanation: this is the wraparound case. `Z` is two places past `Z` on the wheel, which means one past `A`, i.e. `B`. Then `E` → `G`, `R` → `T`, `O` → `Q`. ## Notes - The rule is applied to each character independently; the position of a character in the string has no effect on how it is transformed. - The output string always has exactly the same length as the input string. - A string of length `1` is a valid input: the single letter is transformed and printed on its own. - Repeated letters are transformed identically every time they occur (`AA` becomes `CC`). - Only `Y` and `Z` wrap around the end of the wheel, to `A` and `B` respectively. - Print the result followed by a newline and nothing else. 26:T1005,## Overview You are handed a string `str1` of uppercase English letters and a table of six worked pairs, and you must produce the transformed string for any input. The transformation the table encodes is a fixed rotation of the alphabet: every letter is replaced by the letter standing two places further along a wheel that carries `A` through `Z` and closes back from `Z` to `A`. No character ever moves to a different index, and the answer always has exactly the same length as the input. ## Key Insight The six sample pairs pin the rule down completely once you look at two of them side by side. `AA` becoming `CC` shows that the shift does not depend on where a character sits, because both copies of `A` move the same way, and it shows the step size is `+2`. `ZERO` becoming `BGTQ` shows what happens at the end of the alphabet: `Z` does not fall off, it comes back round to `B`. Together those two facts say the alphabet is circular of size `26` and the step is a constant `+2`, so the whole problem collapses to a per-character lookup with no state carried between characters. ## Approach Convert each character to its `0`-based position in the alphabet by subtracting the code of `A`. Add `2`, reduce the result modulo `26` so that positions `24` and `25`, which are `Y` and `Z`, come back to `0` and `1`, and then add the code of `A` again to get a letter. Append it to the answer and move on to the next character. Nothing about the previous characters matters, so a single left-to-right sweep is enough, and the answer can be built into a preallocated buffer of the input length rather than by repeated concatenation. Read the line with a whole-line read such as `getline` or `readline`, strip the trailing newline, and print the result followed by one newline and nothing else — the statement is explicit that stray prints count as output and will fail the tests. ## Why This Works Modular reduction by `26` is exactly the arithmetic of the wheel. Walking two places forward from position `p` lands on position `p + 2` when `p + 2` is still under `26`, and on `p + 2 - 26` when it is not, which is precisely what `(p + 2) % 26` computes in both cases. Because the rule is defined per character and depends on nothing else, applying it independently to every index reproduces the pattern on the whole string, and each of the six table pairs can be checked one letter at a time to confirm it. The transformation is a bijection on the alphabet, so distinct letters stay distinct and repeated letters stay repeated, which matches `HELLO` becoming `JGNNQ` with its doubled `N`. ## Complexity Time is `O(n)` for a string of length `n`, since every character is touched once and the per-character work is a constant number of integer operations. Extra space is `O(n)` for the answer string, or `O(1)` beyond the output if you write the transformed characters back into the input buffer in place. At the stated bound of `15000` characters this runs far inside any judge limit in Python, C++ and Java alike, and the values involved are tiny, so ordinary 32-bit integer arithmetic is more than sufficient. ## Common Pitfalls The most frequent mistake is dropping the wraparound and writing the plain character arithmetic `ch + 2`, which silently produces the characters after `Z` for the inputs `Y` and `Z`; the sample `ZERO` to `BGTQ` exists precisely to catch this. A second is shifting by one instead of two, or shifting backward instead of forward, both of which happen when the pattern is read from a single sample rather than from the table as a whole. A third is assuming the shift alternates with position — for instance `-1` on odd positions and `+2` on even ones — which fits no pair in the table and is contradicted immediately by `AA` becoming `CC`. Watch the modulus itself as well: reducing by `25` instead of `26` looks harmless but corrupts `X`, `Y` and `Z`. Finally, do not reverse or reorder the string; the word "rearranged" in the source refers to the letter substitution only, and a length-`1` input must still be transformed rather than echoed back unchanged. 1c:[["$","script",null,{"type":"application/ld+json","dangerouslySetInnerHTML":{"__html":"{\"@context\":\"https://schema.org\",\"@type\":\"LearningResource\",\"learningResourceType\":\"Coding Question\",\"name\":\"Alphabet Wheel Rearrangement\",\"description\":\"Alphabet Wheel Rearrangement You are given a string str1 whose characters have to be rearranged according to a specific pattern. In the original assessment the pattern itself was withheld and only worked examples were shown, so your first job is to read the pattern off the examples below. Some examples following the pattern are given here: INPUT OUTPUT HELLO JGNNQ WORLD YQTNF OPEN QRGP CLOSE ENQUG ZERO BGTQ AA CC So that the contract is exact enough to be judged, the pattern those examples encod\",\"educationalLevel\":\"easy\",\"about\":{\"@type\":\"Organization\",\"name\":\"IDFC\"},\"provider\":{\"@type\":\"Organization\",\"name\":\"OAHelper\",\"url\":\"https://oahelper.in\"},\"isPartOf\":{\"@type\":\"WebSite\",\"name\":\"OAHelper\",\"url\":\"https://oahelper.in\"},\"url\":\"https://oahelper.in/problems/OTEwMDAxMTkyfDA/alphabet-wheel-rearrangement\"}"}}],["$","script",null,{"type":"application/ld+json","dangerouslySetInnerHTML":{"__html":"{\"@context\":\"https://schema.org\",\"@type\":\"BreadcrumbList\",\"itemListElement\":[{\"@type\":\"ListItem\",\"position\":1,\"name\":\"Home\",\"item\":\"https://oahelper.in/\"},{\"@type\":\"ListItem\",\"position\":2,\"name\":\"Problems\",\"item\":\"https://oahelper.in/problems\"},{\"@type\":\"ListItem\",\"position\":3,\"name\":\"Alphabet Wheel Rearrangement\",\"item\":\"https://oahelper.in/problems/OTEwMDAxMTkyfDA/alphabet-wheel-rearrangement\"}]}"}}],["$","section",null,{"className":"sr-only","aria-hidden":"true","children":[["$","p",null,{"children":["Company: ","IDFC"]}],["$","p",null,{"children":["Difficulty: ","easy"]}],false,["$","div",null,{"children":[["$","h2",null,{"children":"Problem Statement"}],["$","p",null,{"children":"Alphabet Wheel Rearrangement You are given a string str1 whose characters have to be rearranged according to a specific pattern. In the original assessment the pattern itself was withheld and only worked examples were shown, so your first job is to read the pattern off the examples below. Some examples following the pattern are given here: INPUT OUTPUT HELLO JGNNQ WORLD YQTNF OPEN QRGP CLOSE ENQUG ZERO BGTQ AA CC So that the contract is exact enough to be judged, the pattern those examples encode is spelled out here (inferred — the source deliberately hides the rule and shows only the six pairs above; the pairs determine the rule uniquely, and a hidden test suite cannot be graded against a rule the solver has to guess, so it is pinned explicitly) : Write the 26 uppercase English letters A B C … Z around a wheel, so that Z is immediately followed by A again. Every character of str1 is replaced, independently of its position, by the letter that stands two places further along the wheel ."}]]}],false,["$","nav",null,{"aria-label":"Related company pages","children":[["$","$Lb",null,{"href":"/company-questions/idfc","children":["More ","IDFC"," OA questions"]}],["$","$Lb",null,{"href":"/interview-experiences","children":"Interview experiences"}]]}]]}],["$","$L23",null,{"id":"OTEwMDAxMTkyfDA","initialQuestion":{"id":"OTEwMDAxMTkyfDA","title":"Alphabet Wheel Rearrangement","google_doc_link":null,"problem_statement":"$24","solution_cpp":"#include \nusing namespace std;\n\nstatic string printResult(const string &str1) {\n string res;\n res.resize(str1.size());\n for (size_t i = 0; i < str1.size(); ++i) {\n int v = (int)(str1[i] - 'A');\n res[i] = (char)('A' + ((v + 2) % 26));\n }\n return res;\n}\n\nint main() {\n ios::sync_with_stdio(false);\n cin.tie(nullptr);\n string str1;\n if (!getline(cin, str1)) str1 = \"\";\n while (!str1.empty() && (str1.back() == '\\r' || str1.back() == '\\n' ||\n str1.back() == ' ' || str1.back() == '\\t'))\n str1.pop_back();\n cout << printResult(str1) << \"\\n\";\n return 0;\n}\n","solution_python":"import sys\n\n\ndef print_result(str1):\n out = []\n for ch in str1:\n out.append(chr((ord(ch) - 65 + 2) % 26 + 65))\n return \"\".join(out)\n\n\ndef main():\n data = sys.stdin.readline()\n str1 = data.strip()\n sys.stdout.write(print_result(str1) + \"\\n\")\n\n\nif __name__ == \"__main__\":\n main()\n","solution_java":"import java.io.DataInputStream;\nimport java.io.IOException;\n\npublic class Main {\n static String printResult(String str1) {\n char[] res = new char[str1.length()];\n for (int i = 0; i < str1.length(); i++) {\n int v = str1.charAt(i) - 'A';\n res[i] = (char) ('A' + ((v + 2) % 26));\n }\n return new String(res);\n }\n\n public static void main(String[] args) throws IOException {\n DataInputStream in = new DataInputStream(System.in);\n StringBuilder sb = new StringBuilder();\n int c;\n while ((c = in.read()) != -1) {\n if (c == '\\n' || c == '\\r') break;\n sb.append((char) c);\n }\n String str1 = sb.toString().trim();\n StringBuilder out = new StringBuilder();\n out.append(printResult(str1)).append('\\n');\n System.out.print(out);\n System.out.flush();\n }\n}\n","pregiven_code_cpp":"#include \n#include \nusing namespace std;\n\nstring printResult(string str1) { // str1 is the given input string.\n string res = \"\";\n\n // Write your code here\n\n return res;\n}\n\nint main() {\n string str1;\n getline(cin, str1);\n while (!str1.empty() && (str1.back() == '\\r' || str1.back() == ' '))\n str1.pop_back();\n string res = printResult(str1);\n cout << res << endl;\n return 0;\n}\n","pregiven_code_python":"import sys\n\n\ndef printResult(str1):\n # str1 is the given input string.\n res = \"\"\n\n # Write your code here\n\n return res\n\n\ndef main():\n str1 = sys.stdin.readline().strip()\n print(printResult(str1))\n\n\nif __name__ == \"__main__\":\n main()\n","pregiven_code_java":"import java.io.BufferedReader;\nimport java.io.IOException;\nimport java.io.InputStreamReader;\n\npublic class Main {\n static String printResult(String str1) {\n // str1 is the given input string.\n String res = \"\";\n\n // Write your code here\n\n return res;\n }\n\n public static void main(String[] args) throws IOException {\n BufferedReader br = new BufferedReader(new InputStreamReader(System.in));\n String line = br.readLine();\n String str1 = (line == null) ? \"\" : line.trim();\n System.out.println(printResult(str1));\n }\n}\n","difficulty":"easy","question_type":"coding","premium_required":0,"created_at":"2026-08-19T10:46:16.451241+00:00","updated_at":"2026-08-20T13:26:50.315938+00:00","solution_code":null,"solution":null,"pregiven_code":"#include \n#include \nusing namespace std;\n\nstring printResult(string str1) { // str1 is the given input string.\n string res = \"\";\n\n // Write your code here\n\n return res;\n}\n\nint main() {\n string str1;\n getline(cin, str1);\n while (!str1.empty() && (str1.back() == '\\r' || str1.back() == ' '))\n str1.pop_back();\n string res = printResult(str1);\n cout << res << endl;\n return 0;\n}\n","input_test_case":"[\"DATA\\n\", \"STREAM\\n\"]","output_test_case":"[\"FCVC\\n\", \"UVTGCO\\n\"]","lc_tags":"[\"String\", \"Simulation\", \"Implementation\"]","visual_animation":null,"difficulty_score":32,"md_problem_statement":"$25","unique_company_name":"idfc","sql_solution":null,"bash_solution":null,"js_solution":null,"editorial":"$26","hidden_test_cases_blob_count":80,"youtube_tutorial":null,"prompt_solution":null,"campus_type":"on_campus","college_name":"----","role":"DA","hidden_test_cases_ref":null,"is_mock_oa":false,"publication_status":"published","has_image":true,"company_name":"IDFC","is_first_in_company":true,"company_ref":"MTg4OXww","total_test_cases":15,"hidden_test_cases_count":13},"isQotdToday":false,"qotdReward":5}]] 1e:null 22:[["$","title","0",{"children":"Alphabet Wheel Rearrangement - IDFC OA Question | OAHelper"}],["$","meta","1",{"name":"description","content":"Alphabet Wheel Rearrangement (IDFC OA) - easy: Alphabet Wheel Rearrangement You are given a string str1 whose characters have to be rearranged according to a specific pattern. In the original assessment the"}],["$","meta","2",{"name":"author","content":"OAHelper Team"}],["$","meta","3",{"name":"keywords","content":"IDFC OA question, IDFC online assessment, Alphabet Wheel Rearrangement, easy, online assessment, coding question, OA practice, interview preparation"}],["$","meta","4",{"name":"robots","content":"index, follow"}],["$","meta","5",{"name":"googlebot","content":"index, follow, max-video-preview:-1, max-image-preview:large, max-snippet:-1"}],["$","link","6",{"rel":"canonical","href":"https://oahelper.in/problems/OTEwMDAxMTkyfDA/alphabet-wheel-rearrangement"}],["$","meta","7",{"name":"google-site-verification","content":"MCxApq58khiH0y4KRigRUpoTS3ckefkhoCSHRIRLiXo"}],["$","meta","8",{"property":"og:title","content":"Alphabet Wheel Rearrangement - IDFC OA Question | OAHelper"}],["$","meta","9",{"property":"og:description","content":"Alphabet Wheel Rearrangement (IDFC OA) - easy: Alphabet Wheel Rearrangement You are given a string str1 whose characters have to be rearranged according to a specific pattern. In the original assessment the"}],["$","meta","10",{"property":"og:url","content":"https://oahelper.in/problems/OTEwMDAxMTkyfDA/alphabet-wheel-rearrangement"}],["$","meta","11",{"property":"og:site_name","content":"OAHelper"}],["$","meta","12",{"property":"og:image","content":"https://oahelper.in/campus-ceo-favicon.png?v=11"}],["$","meta","13",{"property":"og:image:width","content":"256"}],["$","meta","14",{"property":"og:image:height","content":"256"}],["$","meta","15",{"property":"og:image:alt","content":"Alphabet Wheel Rearrangement - IDFC OA Question"}],["$","meta","16",{"property":"og:type","content":"website"}],["$","meta","17",{"name":"twitter:card","content":"summary_large_image"}],["$","meta","18",{"name":"twitter:title","content":"Alphabet Wheel Rearrangement - IDFC OA Question | OAHelper"}],["$","meta","19",{"name":"twitter:description","content":"Alphabet Wheel Rearrangement (IDFC OA) - easy: Alphabet Wheel Rearrangement You are given a string str1 whose characters have to be rearranged according to a specific pattern. In the original assessment the"}],["$","meta","20",{"name":"twitter:image","content":"https://oahelper.in/campus-ceo-favicon.png?v=11"}],["$","link","21",{"rel":"shortcut icon","href":"/campus-ceo-favicon.png?v=11"}],["$","link","22",{"rel":"icon","href":"/campus-ceo-favicon-128.png?v=11","sizes":"128x128","type":"image/png"}],["$","link","23",{"rel":"icon","href":"/campus-ceo-favicon.png?v=11","sizes":"256x256","type":"image/png"}],["$","link","24",{"rel":"icon","href":"/campus-ceo-favicon-512.png?v=11","sizes":"512x512","type":"image/png"}],["$","link","25",{"rel":"apple-touch-icon","href":"/campus-ceo-favicon-512.png?v=11","sizes":"180x180","type":"image/png"}],["$","$L27","26",{}]]