 GFG App
Open App Browser
Continue

Given a string S that consists of only alphanumeric characters and dashes. The string is separated into N + 1 groups by N dashes. Also given an integer K.

We want to reformat the string S, such that each group contains exactly K characters, except for the first group, which could be shorter than K but still must contain at least one character. Furthermore, a dash must be inserted between two groups, and you should convert all lowercase letters to uppercase.

Return the reformatted string.

Examples:

Input: S = “5F3Z-2e-9-w”, K = 4
Output: “5F3Z-2E9W”
Explanation: The string S has been split into two parts,
each part has 4 characters.
Note that two extra dashes are not needed and can be removed.

Input: S = “2-5g-3-J”, K = 2
Output: “2-5G-3J”
Explanation: The string s has been split into three parts,
each part has 2 characters except the first part
as it could be shorter as mentioned above

Naive Approach: To solve the problem follow the below idea:

• We will have a Greedy approach in which we will create a temporary string with only the alphanumeric characters(but in reverse) and then add the dashes after every K step.
• The reversal is necessary at the beginning because each group contains exactly K characters, except for the first group as mentioned in the problem.

Follow the steps to solve the problem:

• Create an empty string temp and push only the characters (in upper-case) that are different than ‘-‘.
• Now reverse the string obtained. Also, create a string ‘ans’ to store the final string.
• Iterate over the string and whenever ‘K’ characters are pushed in ‘ans’ push a dash “-” into the string.
• Return ‘ans’ as the result.

Below is the implementation to solve the problem:

## C

 `#include ` `#include ` `#include `   `// Function to compute the answer` `char``* ReFormatString(``char``* S, ``int` `K)` `{` `    ``// Create a temporary string to store` `    ``// the alphanumeric characters only` `    ``char` `temp;` `    ``int` `n = ``strlen``(S);` `    ``int` `len = 0;` `    ``for` `(``int` `i = 0; i < n; i++) {` `        ``if` `(S[i] != ``'-'``) {` `            ``temp[len++] = ``toupper``(S[i]);` `        ``}` `    ``}`   `    ``// String ans is created to store` `    ``// the final string.` `    ``char``* ans` `        ``= (``char``*)``malloc``(``sizeof``(``char``) * (len + len / K + 1));` `    ``int` `val = K;` `    ``int` `j = 0;`   `    ``// Iterate over the string from right` `    ``// to left and start pushing` `    ``// characters at an interval of K` `    ``for` `(``int` `i = len - 1; i >= 0; i--) {` `        ``if` `(val == 0) {` `            ``val = K;` `            ``ans[j++] = ``'-'``;` `        ``}` `        ``ans[j++] = temp[i];` `        ``val--;` `    ``}`   `    ``// Reverse the final string and` `    ``// return it.` `    ``ans[j] = ``'\0'``;` `    ``int` `i = 0, k = j - 1;` `    ``while` `(i < k) {` `        ``char` `t = ans[i];` `        ``ans[i++] = ans[k];` `        ``ans[k--] = t;` `    ``}` `    ``return` `ans;` `}`   `// Driver code` `int` `main()` `{` `    ``char` `s[] = ``"5F3Z-2e-9-w"``;` `    ``int` `K = 4;`   `    ``// Function Call` `    ``printf``(``"%s"``, ReFormatString(s, K));` `    ``return` `0;` `}`

## C++

 `// C++ code for the above approach`   `#include ` `using` `namespace` `std;`   `// Function to compute the answer` `string ReFormatString(string S, ``int` `K)` `{` `    ``// Create a temporary string to store` `    ``// the alphanumeric characters only` `    ``string temp;` `    ``int` `n = S.length();` `    ``for` `(``int` `i = 0; i < n; i++) {` `        ``if` `(S[i] != ``'-'``) {`   `            ``temp.push_back(``toupper``(S[i]));` `        ``}` `    ``}` `    ``int` `len = temp.length();`   `    ``// String ans is created to store` `    ``// the final string.` `    ``string ans;` `    ``int` `val = K;`   `    ``// Iterate over the string from right` `    ``// to left and start pushing` `    ``// characters at an interval of K` `    ``for` `(``int` `i = len - 1; i >= 0; i--) {` `        ``if` `(val == 0) {` `            ``val = K;` `            ``ans.push_back(``'-'``);` `        ``}` `        ``ans.push_back(temp[i]);` `        ``val--;` `    ``}`   `    ``// Reverse the final string and` `    ``// return it.` `    ``reverse(ans.begin(), ans.end());` `    ``return` `ans;` `}`   `// Driver code` `int` `main()` `{` `    ``string s = ``"5F3Z-2e-9-w"``;` `    ``int` `K = 4;`   `    ``// Function Call` `    ``cout << ReFormatString(s, K);` `    ``return` `0;` `}`

## Java

 `class` `GFG {`   `  ``// Function to compute the answer` `  ``public` `static` `String ReFormatString(String S, ``int` `K) ` `  ``{`   `    ``// Create a temporary String to store` `    ``// the alphanumeric characters only` `    ``String temp = ``""``;` `    ``int` `n = S.length();` `    ``for` `(``int` `i = ``0``; i < n; i++) {` `      ``if` `(S.charAt(i) != ``'-'``) {` `        ``temp += (Character.toUpperCase(S.charAt(i)));` `      ``}` `    ``}` `    ``int` `len = temp.length();`   `    ``// String ans is created to store` `    ``// the final String.` `    ``String ans = ``""``;` `    ``int` `val = K;`   `    ``// Iterate over the String from right` `    ``// to left and start pushing` `    ``// characters at an interval of K` `    ``for` `(``int` `i = len - ``1``; i >= ``0``; i--) {` `      ``if` `(val == ``0``) {` `        ``val = K;` `        ``ans += ``'-'``;` `      ``}` `      ``ans += temp.charAt(i);` `      ``val--;` `    ``}`   `    ``// Reverse the final String and` `    ``// return it.` `    ``char``[] charArray = ans.toCharArray();` `    ``reverse(charArray, charArray.length);` `    ``String res = ``new` `String(charArray);` `    ``return` `res;` `  ``}`     `  ``static` `void` `reverse(``char` `a[], ``int` `n)` `  ``{` `    ``char` `t;` `    ``for` `(``int` `i = ``0``; i < n / ``2``; i++) {` `      ``t = a[i];` `      ``a[i] = a[n - i - ``1``];` `      ``a[n - i - ``1``] = t;` `    ``}` `  ``}`   `  ``public` `static` `void` `main(String args[]) {` `    ``String s = ``"5F3Z-2e-9-w"``;` `    ``int` `K = ``4``;`   `    ``// Function Call` `    ``System.out.println(ReFormatString(s, K));`   `  ``}` `}`   `// This code is contributed by Saurabh Jaiswal`

## Python3

 `# Python code for the above approach`   `# Function to compute the answer` `def` `ReFormatStrings(s,k):`   `    ``# Create a temporary string to store the alphanumeric characters only` `    ``temp ``=` `""` `    ``n ``=` `len``(s)` `    ``for` `i ``in` `range``(``0``,n):` `        ``if``(s[i] !``=` `'-'``):` `            ``temp ``+``=` `s[i].upper()` `    ``length ``=` `len``(temp)` `    `  `    ``# String ans is created to store the final string.` `    ``ans ``=` `""` `    ``val ``=` `k`   `    ``# Iterate over the string from right to left and start pushing characters at an interval of K` `    ``for` `i ``in` `range``(length ``-` `1``,``-``1``,``-``1``):` `        ``if``(val ``=``=` `0``):` `            ``val ``=` `k` `            ``ans ``+``=` `'-'` `        ``ans ``+``=` `temp[i]` `        ``val ``-``=` `1`   `    ``# Reverse the final string and return it.` `    ``ans ``=` `ans[::``-``1``]` `    ``return` `ans`   `# Driver code` `if` `__name__ ``=``=` `"__main__"``:` `    ``s ``=` `"5F3Z-2e-9-w"` `    ``k ``=` `4` `    `  `    ``# Function call` `    ``print``(ReFormatStrings(s,k))` `    `  `    ``# This code is contributed by ajaymakvana`

## C#

 `using` `System;`   `public` `class` `GFG{`   `  ``// Function to compute the answer` `  ``public` `static` `string` `ReFormatString(``string` `S, ``int` `K)` `  ``{` `    ``// Create a temporary string to store` `    ``// the alphanumeric characters only` `    ``string` `temp=``""``;` `    ``int` `n = S.Length;` `    ``for` `(``int` `i = 0; i < n; i++) {` `      ``if` `(S[i] != ``'-'``) {` `        ``temp+=(``char``.ToUpper(S[i]));` `      ``}` `    ``}` `    ``int` `len = temp.Length;`   `    ``// String ans is created to store` `    ``// the final string.` `    ``string` `ans=``""``;` `    ``int` `val = K;`   `    ``// Iterate over the string from right` `    ``// to left and start pushing` `    ``// characters at an interval of K` `    ``for` `(``int` `i = len - 1; i >= 0; i--) {` `      ``if` `(val == 0) {` `        ``val = K;` `        ``ans+=``'-'``;` `      ``}` `      ``ans+=temp[i];` `      ``val--;` `    ``}`   `    ``// Reverse the final string and` `    ``// return it.` `    ``char``[] charArray = ans.ToCharArray();` `    ``Array.Reverse( charArray );` `    ``string` `res = ``new` `string``(charArray);  ` `    ``return` `res;` `  ``}`   `  ``static` `public` `void` `Main (){` `    ``string` `s = ``"5F3Z-2e-9-w"``;` `    ``int` `K = 4;`   `    ``// Function Call` `    ``Console.WriteLine(ReFormatString(s, K));`   `  ``}` `}` `//  This code is contributed by akashish__`

## Javascript

 `// JS code for the above approach` `function` `reverse(s)` `{` `    ``let splitString = s.split(``""``);` `    ``let reverseArray = splitString.reverse();` `    ``let joinArray = reverseArray.join(``""``);` `    ``return` `joinArray;` `}`   `// Function to compute the answer` `function` `ReFormatString(S,K)` `{` `    ``// Create a temporary string let to store` `    ``// the alphanumeric characters only` `    ``let temp = ``""``;` `    ``let n = S.length;` `    ``for` `(let i = 0; i < n; i++) {` `        ``if` `(S[i] != ``'-'``) {` `            ``temp+=S[i].toUpperCase();` `        ``}` `    ``}` `    ``let len = temp.length;`   `    ``// let ans is created to store` `    ``// the final string.` `    ``let ans = ``""``;` `    ``let val = K;`   `    ``// Iterate over the let from right` `    ``// to left and start pushing` `    ``// characters at an interval of K` `    ``for` `(let i = len - 1; i >= 0; i--) {` `        ``if` `(val == 0) {` `            ``val = K;` `            ``ans += ``'-'``;` `        ``}` `        ``ans += temp[i];` `        ``val--;` `    ``}`   `    ``// Reverse the final let and` `    ``// return it.` `    ``ans = reverse(ans);` `    ``return` `ans;` `}`   `// Driver code` `let s = ``"5F3Z-2e-9-w"``;` `let K = 4;`   `// Function Call` `console.log(ReFormatString(s, K));`   `// This code is contributed by akashish__.`

Output

`5F3Z-2E9W`

Time Complexity: O(n).

Space Complexity: O(n) as extra space has been used by creating temp string.

Efficient approach: To solve the problem follow the below idea:

• Without creating any other string we will move all the dashes to the front and remove them then we will make use of the mathematical formula to calculate the number of dashes at the right of all the alphanumeric characters.
• Number of Dashes=(Total alphanumeric elements)/(number of elements in every group)

Formula:

Number of Dashes at any step = (Total alphanumeric elements to the right of the current index) / (number of elements in every group)

Follow the steps to solve the problem:

• Iterate from the back of the string and move all the alphanumeric characters to the back of the string.
• Delete all the dashes from the beginning.
• Calculate the number of dashes(rounded-up) that would be present in the final string and append free it to the original string.
• Iterate from the front and depending on the number of dashes that would be present up to that character, move the character by that amount in the left direction.
• Delete all the extra dashes that would have accumulated in the front of the string
• Return the string after all the modifications as the answer.

Below is the implementation for the above approach:

## C++

 `// C++ code for the above approach`   `#include ` `using` `namespace` `std;`   `// Function to compute the answer` `string ReFormatString(string S, ``int` `K)` `{` `    ``int` `len = S.length();` `    ``int` `cnt = 0;` `    ``int` `x = 0;`   `    ``// Move the characters to the` `    ``// back of the string.` `    ``for` `(``int` `i = len - 1; i >= 0; i--) {` `        ``if` `(S[i] == ``'-'``) {` `            ``x++;` `        ``}` `        ``else` `{` `            ``S[i + x] = ``toupper``(S[i]);` `        ``}` `    ``}`   `    ``// Calculate total number of` `    ``// alphanumeric characters so` `    ``// as to get the number of dashes` `    ``// in the final string.` `    ``int` `slen = len - x;` `    ``int` `step = slen / K;`   `    ``// Remove x characters from the` `    ``// start of the string`   `    ``reverse(S.begin(), S.end());` `    ``int` `val = x;` `    ``while` `(val--) {` `        ``S.pop_back();` `    ``}`   `    ``// Push the empty spaces in` `    ``// the string (slen+step) to get` `    ``// the final string length`   `    ``int` `temp = step;` `    ``while` `(temp--)` `        ``S.push_back(``' '``);` `    ``reverse(S.begin(), S.end());`   `    ``len = S.length();`   `    ``// Using simple mathematics` `    ``// to push the elements` `    ``// in the string at the correct place.`   `    ``int` `i = slen, j = step, f = 0;` `    ``while` `(j < len) {`   `        ``// At every step calculate the` `        ``// number of dashes that would be` `        ``// present before the character` `        ``step = i / K;` `        ``if` `(f == 1)` `            ``step--;` `        ``int` `rem = i % K;`   `        ``// If the remainder is zero it` `        ``// implies that the character is a dash.`   `        ``if` `(rem == 0 and f == 0) {` `            ``S[j - step] = ``'-'``;` `            ``f = 1;` `            ``continue``;` `        ``}` `        ``S[j - step] = S[j];` `        ``i--;` `        ``j++;` `        ``f = 0;` `    ``}` `    ``// Remove all the dashes that would have` `    ``// accumulated in the beginning of the string.`   `    ``len = S.length();` `    ``reverse(S.begin(), S.end());` `    ``for` `(``int` `i = len - 1; i >= 0; i--) {` `        ``if` `(S[i] != ``'-'``) {` `            ``break``;` `        ``}` `        ``if` `(S[i] == ``'-'``)` `            ``S.pop_back();` `    ``}` `    ``reverse(S.begin(), S.end());`   `    ``return` `S;` `}`   `// Driver code` `int` `main()` `{` `    ``string s = ``"5F3Z-2e-9-w"``;` `    ``int` `K = 4;`   `    ``// Function Call` `    ``cout << ReFormatString(s, K);` `    ``return` `0;` `}`

## Java

 `/*package whatever //do not write package name here */`   `import` `java.io.*;` `import` `java.util.*;`   `class` `GFG {`   `  ``public` `static` `String reverseS(String str)` `  ``{` `    ``String nstr = ``""``;` `    ``for` `(``int` `i = ``0``; i < str.length(); i++) {` `      ``char` `ch` `        ``= str.charAt(i); ``// extracts each character` `      ``nstr` `        ``= ch + nstr; ``// adds each character in` `      ``// front of the existing string` `    ``}` `    ``return` `nstr;` `  ``}`   `  ``// Function to compute the answer` `  ``public` `static` `String ReFormatString(String S, ``int` `K)` `  ``{` `    ``int` `len = S.length();` `    ``int` `cnt = ``0``;` `    ``int` `x = ``0``;`   `    ``// Move the characters to the` `    ``// back of the string.` `    ``for` `(``int` `i = len - ``1``; i >= ``0``; i--) {` `      ``if` `(S.charAt(i) == ``'-'``) {` `        ``x++;` `      ``}` `      ``else` `{` `        ``S = S.substring(``0``, i + x)` `          ``+ Character.toUpperCase(S.charAt(i))` `          ``+ S.substring(i + x + ``1``);` `      ``}` `    ``}`   `    ``// Calculate total number of` `    ``// alphanumeric characters so` `    ``// as to get the number of dashes` `    ``// in the final string.` `    ``int` `slen = len - x;` `    ``int` `step = (``int``)(slen / K);`   `    ``// Remove x characters from the` `    ``// start of the string`   `    ``S = reverseS(S);` `    ``int` `val = x;` `    ``while` `(val > ``0``) {` `      ``S = S.substring(``0``, S.length() - ``1``);` `      ``val--;` `    ``}`   `    ``// Push the empty spaces in` `    ``// the string (slen+step) to get` `    ``// the final string length`   `    ``int` `temp = step;` `    ``while` `(temp > ``0``) {` `      ``S += ``" "``;` `      ``temp--;` `    ``}` `    ``S = reverseS(S);`   `    ``len = S.length();`   `    ``// Using simple mathematics` `    ``// to push the elements` `    ``// in the string at the correct place.`   `    ``int` `i = slen, j = step, f = ``0``;` `    ``while` `(j < len) {`   `      ``// At every step calculate the` `      ``// number of dashes that would be` `      ``// present before the character` `      ``step = (``int``)(i / K);` `      ``if` `(f == ``1``)` `        ``step--;` `      ``int` `rem = i % K;`   `      ``// If the remainder is zero it` `      ``// implies that the character is a dash.`   `      ``if` `(rem == ``0` `&& f == ``0``) {` `        ``S = S.substring(``0``, j - step) + ``"-"` `          ``+ S.substring(j - step + ``1``);` `        ``f = ``1``;` `        ``continue``;` `      ``}` `      ``S = S.substring(``0``, j - step) + S.charAt(j)` `        ``+ S.substring(j - step + ``1``);` `      ``i--;` `      ``j++;` `      ``f = ``0``;` `    ``}` `    ``// Remove all the dashes that would have` `    ``// accumulated in the beginning of the string.`   `    ``len = S.length();` `    ``S = reverseS(S);` `    ``for` `(``int` `m = len - ``1``; m >= ``0``; m--) {` `      ``if` `(S.charAt(m) != ``'-'``) {` `        ``break``;` `      ``}` `      ``if` `(S.charAt(m) == ``'-'``)` `        ``S = S.substring(``0``, S.length() - ``1``);` `    ``}` `    ``S = reverseS(S);`   `    ``return` `S;` `  ``}`   `  ``public` `static` `void` `main(String[] args)` `  ``{` `    ``String s = ``"5F3Z-2e-9-w"``;` `    ``int` `K = ``4``;`   `    ``// Function Call` `    ``System.out.println(ReFormatString(s, K));` `  ``}` `}`   `// This code is contributed by akashish__`

## Python3

 `# Python3 code for the above approach` `# Function to reverse a string` `def` `reverse(string):` `    ``string ``=` `string[::``-``1``]` `    ``return` `string`   `# Function to compute the answer` `def` `ReFormatString( S, K):` `    ``length ``=` `len``(S)` `    ``cnt ``=` `0` `    ``x ``=` `0`   `    ``# Move the characters to the` `    ``# back of the string.` `    ``for` `i ``in` `range``(length``-``1``,``-``1``,``-``1``):` `        ``if` `(S[i] ``=``=` `'-'``):` `            ``x``+``=``1` `        ``else``:` `            ``S ``=` `S[:i``+``x] ``+` `S[i].upper() ``+` `S[i``+``x``+``1``:]`   `    ``# Calculate total number of` `    ``# alphanumeric characters so` `    ``# as to get the number of dashes` `    ``# in the final string.` `    ``slen ``=` `length ``-` `x` `    ``step ``=` `slen ``/` `K`   `    ``# Remove x characterclss from the` `    ``# start of the string`   `    ``S ``=` `reverse(S)` `    ``val ``=` `x` `    ``while` `(val>``0``):` `        ``S ``=` `S[:``len``(S)``-``1``]` `        ``val``-``=``1`   `    ``# Push the empty spaces in` `    ``# the string (slen+step) to get` `    ``# the final string length`   `    ``temp ``=` `step` `    ``while` `(temp>``0``):` `        ``S``+``=``' '` `        ``temp``-``=``1` `    ``S ``=` `reverse(S)` `     `  `    ``length ``=` `len``(S)`   `    ``# Using simple mathematics` `    ``# to push the elements` `    ``# in the string at the correct place.`   `    ``i ``=` `slen` `    ``j ``=` `step` `    ``f ``=` `0` `    ``while` `(j < length):`   `        ``# At every step calculate the` `        ``# number of dashes that would be` `        ``# present before the character` `        ``step ``=` `int``(i ``/` `K)` `        ``if` `(f ``=``=` `1``):` `            ``step``-``=``1` `        ``rem ``=` `i ``%` `K`   `        ``# If the remainder is zero it` `        ``# implies that the character is a dash.` `        ``if` `(rem ``=``=` `0` `and` `f ``=``=` `0``):` `            ``step ``=` `int``(step)` `            ``j ``=` `int``(j)` `            ``S ``=` `S[:``int``(j``-``step)] ``+` `'-'` `+` `S[``int``(j``-``step)``+``1``:]` `            ``f ``=` `1` `            ``continue` `        ``S ``=` `S[:``int``(j``-``step)] ``+` `S[``int``(j)] ``+` `S[``int``(j``-``step)``+``1``:]` `        ``i ``-``=` `1` `        ``j ``+``=` `1` `        ``f ``=` `0` `    ``# Remove all the dashes that would have` `    ``# accumulated in the beginning of the string.` `    ``length ``=` `len``(S)` `    ``S ``=` `reverse(S)` `    ``for` `char ``in` `reversed``(S):` `        ``if` `(char !``=` `'-'``):` `            ``break` `        ``if` `(char ``=``=` `'-'``):` `            ``S ``=` `S[:``len``(S)``-``1``]` `    ``S ``=` `reverse(S)`   `    ``return` `S`   `# Driver code` `s ``=` `"5F3Z-2e-9-w"` `K ``=` `4`   `# Function Call` `print``(ReFormatString(s, K))`   `# This code is contributed by akashish__`

## C#

 `using` `System;` `using` `System.Collections.Generic;`   `// C# code for the above approach` `public` `class` `GFG {`   `  ``public` `static` `String reverseS(String str)` `  ``{` `    ``String nstr = ``""``;` `    ``for` `(``int` `i = 0; i < str.Length; i++) {` `      ``char` `ch = str[i]; ``// extracts each character` `      ``nstr = ch + nstr; ``// adds each character in` `      ``// front of the existing string` `    ``}` `    ``return` `nstr;` `  ``}`   `  ``// Function to compute the answer` `  ``public` `static` `String ReFormatString(String S, ``int` `K)` `  ``{` `    ``int` `len = S.Length;` `    ``int` `cnt = 0;` `    ``int` `x = 0;` `    ``int` `i;`   `    ``// Move the characters to the` `    ``// back of the string.` `    ``for` `(i = len - 1; i >= 0; i--) {` `      ``if` `(S[i] == ``'-'``) {` `        ``x++;` `      ``}` `      ``else` `{` `        ``S = S.Substring(0, i + x)` `          ``+ Char.ToUpper(S[i])` `          ``+ S.Substring(i + x + 1);` `      ``}` `    ``}`   `    ``// Calculate total number of` `    ``// alphanumeric characters so` `    ``// as to get the number of dashes` `    ``// in the final string.` `    ``int` `slen = len - x;` `    ``int` `step = (``int``)(slen / K);`   `    ``// Remove x characters from the` `    ``// start of the string`   `    ``S = reverseS(S);` `    ``int` `val = x;` `    ``while` `(val > 0) {` `      ``S = S.Substring(0, S.Length - 1);` `      ``val--;` `    ``}`   `    ``// Push the empty spaces in` `    ``// the string (slen+step) to get` `    ``// the final string length`   `    ``int` `temp = step;` `    ``while` `(temp > 0) {` `      ``S += ``" "``;` `      ``temp--;` `    ``}` `    ``S = reverseS(S);`   `    ``len = S.Length;`   `    ``// Using simple mathematics` `    ``// to push the elements` `    ``// in the string at the correct place.`   `    ``i = slen;` `    ``int` `j = step, f = 0;` `    ``while` `(j < len) {`   `      ``// At every step calculate the` `      ``// number of dashes that would be` `      ``// present before the character` `      ``step = (``int``)(i / K);` `      ``if` `(f == 1)` `        ``step--;` `      ``int` `rem = i % K;`   `      ``// If the remainder is zero it` `      ``// implies that the character is a dash.`   `      ``if` `(rem == 0 && f == 0) {` `        ``S = S.Substring(0, j - step) + ``"-"` `          ``+ S.Substring(j - step + 1);` `        ``f = 1;` `        ``continue``;` `      ``}` `      ``S = S.Substring(0, j - step) + S[j]` `        ``+ S.Substring(j - step + 1);` `      ``i--;` `      ``j++;` `      ``f = 0;` `    ``}` `    ``// Remove all the dashes that would have` `    ``// accumulated in the beginning of the string.`   `    ``len = S.Length;` `    ``S = reverseS(S);` `    ``for` `(``int` `m = len - 1; m >= 0; m--) {` `      ``if` `(S[m] != ``'-'``) {` `        ``break``;` `      ``}` `      ``if` `(S[m] == ``'-'``)` `        ``S = S.Substring(0, S.Length - 1);` `    ``}` `    ``S = reverseS(S);`   `    ``return` `S;` `  ``}`   `  ``// Driver code` `  ``static` `public` `void` `Main()` `  ``{`   `    ``string` `s = ``"5F3Z-2e-9-w"``;` `    ``int` `K = 4;`   `    ``// Function Call` `    ``Console.WriteLine(ReFormatString(s, K));` `  ``}` `}`   `// This code is contributed by akashish__`

## Javascript

 `// JS code for the above approach`   `// Function to compute the answer` `function` `ReFormatString(S, K) {` `    ``let len = S.length;` `    ``let cnt = 0;` `    ``let x = 0;`   `    ``// Move the characters to the` `    ``// back of the string.` `    ``for` `(let i = len - 1; i >= 0; i--) {` `        ``if` `(S[i] == ``'-'``) {` `            ``x++;` `        ``}` `        ``else` `{` `            ``let c = (S[i].toUpperCase());` `            ``let arr1 = S.split(``''``);` `            ``arr1[i + x] = c;` `            ``S = arr1.join(``""``);` `        ``}` `    ``}`   `    ``// Calculate total number of` `    ``// alphanumeric characters so` `    ``// as to get the number of dashes` `    ``// in the final string.` `    ``let slen = len - x;` `    ``let step = slen / K;`   `    ``// Remove x characters from the` `    ``// start of the string`   `    ``S = S.split(``''``).reverse().join(``''``);`   `    ``let val = x;` `    ``while` `(val--) {` `        ``S = S.substring(0, S.length - 1);` `    ``}`   `    ``// Push the empty spaces in` `    ``// the string (slen+step) to get` `    ``// the final string length`   `    ``let temp = step;` `    ``while` `(temp--)` `        ``S += ``' '``;` `    ``S = S.split(``''``).reverse().join(``''``);`   `    ``len = S.length;`   `    ``// Using simple mathematics` `    ``// to push the elements` `    ``// in the string at the correct place.`   `    ``let i = slen, j = step, f = 0;` `    ``while` `(j < len) {`   `        ``// At every step calculate the` `        ``// number of dashes that would be` `        ``// present before the character` `        ``step = Math.floor(i / K);` `        ``if` `(f == 1)` `            ``step--;` `        ``let rem = i % K;`   `        ``// If the remainder is zero it` `        ``// implies that the character is a dash.`   `        ``if` `(rem == 0 && f == 0) {` `            ``let arr2 = S.split(``''``);` `            ``arr2[j - step] = ``'-'``;` `            ``S = arr2.join(``""``);` `            ``f = 1;` `            ``continue``;` `        ``}` `        ``let arr3 = S.split(``''``);` `        ``arr3[j - step] = S[j];` `        ``S = arr3.join(``""``);` `        ``i--;` `        ``j++;` `        ``f = 0;` `    ``}` `    ``// Remove all the dashes that would have` `    ``// accumulated in the beginning of the string.`   `    ``len = S.length;` `    ``S = S.split(``''``).reverse().join(``''``);`   `    ``for` `(let i = len - 1; i >= 0; i--) {` `        ``if` `(S[i] != ``'-'``) {` `            ``break``;` `        ``}` `        ``if` `(S[i] == ``'-'``)` `            ``S = S.substring(0, S.length - 1);`   `    ``}` `    ``S = S.split(``''``).reverse().join(``''``);` `    ``return` `S;` `}`   `// Driver code` `let s = ``"5F3Z-2e-9-w"``;` `let K = 4;`   `// Function Call` `console.log(ReFormatString(s, K));`   `// This code is contributed by akashish__`

Output

`5F3Z-2E9W`

Time Complexity: O(N)
Auxiliary Space: O(1)

My Personal Notes arrow_drop_up