You are given a license key represented as a string S which consists only alphanumeric character and dashes. The string is separated into N+1 groups by N dashes.

Given a number K, we would want to reformat the strings 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, there must be a dash inserted between two groups and all lowercase letters should be converted to uppercase.

Given a non-empty string S and a number K, format the string according to the rules described above.

Example 1:

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 the two extra dashes are not needed and can be removed.




Example 2:

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.



Note:

The length of string S will not exceed 12,000, and K is a positive integer.
String S consists only of alphanumerical characters (a-z and/or A-Z and/or 0-9) and dashes(-).
String S is non-empty.

Difficulty: introductory

Starter code:

class Solution:
    def licenseKeyFormatting(self, S: str, K: int) -> str:
        

Solutions:
class Solution:
     def licenseKeyFormatting(self, S, K):
         """
         :type S: str
         :type K: int
         :rtype: str
         """
 #         count_dash = 0
 #         for item in S:
 #             if item == '-':
 #                 count_dash += 1
                 
 #         S_len = len(S) - count_dash
         
 #         ans = ''
 #         second_from = 0
         
 #         frist_group = S_len % K
 #         if frist_group != 0:
 #             count = 0
 #             for i in range(len(S)):
 #                 if S[i] != '-':
 #                     ans = ans + S[i].upper()
 #                     count += 1
 #                 if count == frist_group:
 #                     second_from = i + 1
 #                     ans += '-'
 #                     break
 #         count_k = 0
 #         for j in range(second_from,len(S)):
 #             if S[j] != '-':
 #                 ans = ans + S[j].upper()
 #                 count_k += 1
 #             if count_k == K:
 #                 ans = ans + '-'
 #                 count_k = 0
         
 #         return ans[:-1]
         S = S.replace('-', '')[::-1].upper()
         return '-'.join([S[i:i+K] for i in range(0, len(S), K)])[::-1]


class Solution:
     def licenseKeyFormatting(self, S, K):
         """
         :type S: str
         :type K: int
         :rtype: str
         """
         S = S.upper().replace('-','')
         size = len(S)
         s1 = K if size%K==0 else size%K
         res = S[:s1]
         while s1<size:
             res += '-'+S[s1:s1+K]
             s1 += K
         return res

class Solution:
     def licenseKeyFormatting(self, S, K):
         """
         :type S: str
         :type K: int
         :rtype: str
         """
         S = S.upper().replace("-","")
         s1 = len(S) % K if len(S) % K else K
         res = S[:s1]
         while s1<len(S):
             res +='-'+S[s1:s1+K]
             s1+=K
         return res

class Solution:
     def licenseKeyFormatting(self, S, K):
         """
         :type S: str
         :type K: int
         :rtype: str
         """
         S = S.upper().replace("-","")
         i = 0
         res = []
         start = len(S) % K
         if start:
             res.append(S[:start])
             i = start
         
         while i < len(S):
             res.append(S[i:i+K])
             i += K
         
         return "-".join(res)
             
             
         
         


class Solution:
     def licenseKeyFormatting(self, S, K):
         """
         :type S: str
         :type K: int
         :rtype: str
         """
         s = list(''.join(S.split('-')))
         tmp = [''.join(s[:len(s) % K])] + [''.join(s[i:i+K]) for i in range(len(s) % K, len(s), K)] 
         return '-'.join(filter(None, tmp)).upper()

class Solution:
     def licenseKeyFormatting(self, S, K):
         """
         :type S: str
         :type K: int
         :rtype: str
         """
         char_list = self.getChars(S)
         num_groups = len(char_list) // K
         group_1_cnt = len(char_list) % K
         
         output = ""
         if group_1_cnt > 0:
             output += char_list[0:group_1_cnt]
             if num_groups > 0:
                 output += "-"
             
         for i in range(1, num_groups + 1):
             start = i * K + group_1_cnt - K
             finish = start + K
             output += char_list[start:finish]
             if i != num_groups:
                 output += "-"
                 
         return output
         
     def getChars(self, S):
         char_list = ""
         
         for char in S:
             if char != "-":
                 char_list += char.upper()
         
         return char_list


class Solution:
     def licenseKeyFormatting(self, S, K):
         """
         :type S: str
         :type K: int
         :rtype: str
         """
         key = list(S.replace('-', '').upper())
         offset = len(key) % K
         if offset == 0:
             offset = K
         new_key = []
         i = 0
         while i < len(key):
             if i == 0:
                 new_key.extend(key[:offset])
                 i = offset
             else:
                 new_key.append('-')
                 new_key.extend(key[i:i + K])
                 i = i + K
         return ''.join(new_key)


class Solution:
     def licenseKeyFormatting(self, S, K):
         """
         :type S: str
         :type K: int
         :rtype: str
         """
         S = S.upper().replace('-', '')
         first = len(S) % K
         if first == 0:
             first = K
         blocks = [S[:first]]
         pos = first
         for k in range(len(S) // K):
             block = S[pos:pos+K]
             if len(block) > 0:
                 blocks.append(block)
             pos += K
         return '-'.join(blocks)

class Solution:
     def licenseKeyFormatting(self, S, K):
         """
         :type S: str
         :type K: int
         :rtype: str
         """
         S = S.upper().replace('-', '')
         index = K if len(S) % K == 0 and len(S) > 0 else len(S) % K
         result = S[:index]
         while index < len(S):
             result += '-' + S[index : index + K]
             index += K
         return result

class Solution:
     def licenseKeyFormatting(self, S, K):
         """
         :type S: str
         :type K: int
         :rtype: str
         """
         S = S.replace("-", "")
         l = len(S)
         res = l % K
         if res == 0:
             return "-".join([S[i*K: (i+1)*K].upper() for i in range(l//K)])
         else:
             lst = [S[0:res].upper()]
             return "-".join(lst + [S[i*K + res: (i+1)*K + res].upper() for i in range(l//K)])
         


class Solution:
     def licenseKeyFormatting(self, S, K):
         """
         :type S: str
         :type K: int
         :rtype: str
         """
         S = "".join(S.split("-")) # remove dash
         S = S.upper() # change to upper character
         num_group = len(S) // K
         start_idx = len(S) % K
 
         ans = "" if start_idx == 0 else S[:start_idx]
         for i in range(num_group):
             end_idx = start_idx + K
             if start_idx > 0:
                 ans += "-"
             ans += S[start_idx:end_idx]
             start_idx = end_idx
         return ans


class Solution:
     def licenseKeyFormatting(self, S, K):
         """
         :type S: str
         :type K: int
         :rtype: str
         """
         
         s = list(S.upper())
         s = [c for c in s if c != '-']
         
         groups = []
         while s:
             group = s[-K:]
             groups.append(''.join(group))
             s[-K:] = []
             
         groups.reverse()
         return '-'.join(groups)


class Solution:
     def licenseKeyFormatting(self, S, K):
         """
         :type S: str
         :type K: int
         :rtype: str
         """
      
         if(len(S)<=1):
             return S.upper().strip('-')
         S = S.upper()
         n_dash = S.count('-')
         n = len(S)-n_dash
         form_S = ""
         if(n%K == 0):
             begin_at = K-1
         else:
             left = n%K
             begin_at = left-1
         steps = 0 
         abs_ind = 0
         norm_ind = 0
         
         while(abs_ind <=begin_at and norm_ind < len(S)):
             if(S[norm_ind]=='-'):
                 norm_ind +=1
                 continue
             form_S += S[norm_ind]
             abs_ind +=1
             norm_ind +=1
         form_S += '-'
         for char_ind in range(norm_ind, len(S)):
             if(S[char_ind] =="-"):
                 continue
                 
             elif(steps == K-1 and abs_ind > begin_at):
                 form_S += S[char_ind]+'-'
                 steps =0
             else:
                 form_S += S[char_ind]
                 steps += 1
 
             abs_ind += 1
         
     
         return form_S.strip('-')