ShaysXIA/CodeInsightBench huggingface dataset:
Problem: 2050D - Digital string maximization
Language: python

Solution 1 (runtime: 233 ms):
import sys 
from math import*
from collections import*
I=lambda: map(int,input())
for i in range(int(input())):
    a=list(I())
    n=len(a)
    for j in range(n):
        for k in range(j,max(0,j-10,),-1):
            if a[k-1]+1<a[k]:
                a[k],a[k-1]=a[k-1],a[k]-1
                
    print(*a,sep="")

Solution 2 (runtime: 171 ms):
def solve():
    s = input()
    s = list(s)  # Преобразуем строку в список символов для удобства работы
    for i in range(len(s)):
        best = int(s[i])
        pos = i
        for j in range(i, min(i + 10, len(s))):
            current_score = int(s[j]) - (j - i)
            if current_score > best:
                best = current_score
                pos = j
        while pos > i:
            s[pos], s[pos - 1] = s[pos - 1], s[pos]
            pos -= 1
        s[i] = str(best)
    print("".join(s))

if __name__ == "__main__":
    tests = int(input())
    for _ in range(tests):
        solve()
Problem: 2050D - Digital string maximization
Language: python

Solution 1 (runtime: 233 ms):
import sys 
from math import*
from collections import*
I=lambda: map(int,input())
for i in range(int(input())):
    a=list(I())
    n=len(a)
    for j in range(n):
        for k in range(j,max(0,j-10,),-1):
            if a[k-1]+1<a[k]:
                a[k],a[k-1]=a[k-1],a[k]-1
                
    print(*a,sep="")

Solution 2 (runtime: 218 ms):
t = int(input())
for _ in range(t):
    num = list(input())  # Convert string to list for mutable operations
    n = len(num)
    for i in range(n - 1):
        j = i + 1
        while j < n and (int(num[j]) - 1 > int(num[j - 1])):
            temp = str(int(num[j]) - 1)
            num[j] = num[j - 1]
            num[j - 1] = temp
            j -= 1  # Move backward to recheck the order
            if j <= 0:  # Prevent going out of bounds
                break
    print(''.join(num))  # Convert list back to string for output
Problem: 2050D - Digital string maximization
Language: python

Solution 1 (runtime: 233 ms):
import sys 
from math import*
from collections import*
I=lambda: map(int,input())
for i in range(int(input())):
    a=list(I())
    n=len(a)
    for j in range(n):
        for k in range(j,max(0,j-10,),-1):
            if a[k-1]+1<a[k]:
                a[k],a[k-1]=a[k-1],a[k]-1
                
    print(*a,sep="")

Solution 2 (runtime: 187 ms):
t = int(input())
for _ in range(t):
    s = input().strip()
    l = [int(c) for c in s]
    i = 1
    while i < len(l):
        if l[i] > l[i - 1]+1 and l[i] != 0:
            l[i] -= 1
            l[i - 1], l[i] = l[i], l[i - 1]
            if i > 1:
                i -= 1
        else:
            i += 1
    print("".join(map(str, l)))
Problem: 2050D - Digital string maximization
Language: python

Solution 1 (runtime: 233 ms):
import sys 
from math import*
from collections import*
I=lambda: map(int,input())
for i in range(int(input())):
    a=list(I())
    n=len(a)
    for j in range(n):
        for k in range(j,max(0,j-10,),-1):
            if a[k-1]+1<a[k]:
                a[k],a[k-1]=a[k-1],a[k]-1
                
    print(*a,sep="")

Solution 2 (runtime: 358 ms):
n = int(input())
for _ in range(n):
    n1 = list(input())  # Convert input to a list for mutability
    length = len(n1)

    for i in range(length):
        best = int(n1[i])
        pos = i

        # Optimize the inner loop to minimize recalculations
        for j in range(i, min(i + 9, length)):
            value = int(n1[j]) - (j - i)
            if value > best:
                best = value
                pos = j

        # Perform swaps to bring the best element to the correct position
        while pos > i:
            n1[pos], n1[pos - 1] = n1[pos - 1], n1[pos]
            pos -= 1

        n1[i] = str(best)

    print("".join(n1))
Problem: 2050D - Digital string maximization
Language: python

Solution 1 (runtime: 233 ms):
import sys 
from math import*
from collections import*
I=lambda: map(int,input())
for i in range(int(input())):
    a=list(I())
    n=len(a)
    for j in range(n):
        for k in range(j,max(0,j-10,),-1):
            if a[k-1]+1<a[k]:
                a[k],a[k-1]=a[k-1],a[k]-1
                
    print(*a,sep="")

Solution 2 (runtime: 1171 ms):

class LinkedList:
    def __init__(self, l):
        self.list = l
        self.len = len(l)
        self.next = [i+1 for i in range(self.len)]
        self.next[-1] = None
        self.prev = [i-1 for i in range(self.len)]
        self.prev[0] = None
        self.head = 0
        self.current = self.head
    
    def to_head(self):
        self.current = self.head
        
    def pop(self, i=None):
        if i == None:
            self.current = self.head
        else:
            self.current = i
        next_ = self.next[self.current]
        prev_ = self.prev[self.current]
        if self.len == 1:
            self.head=None  
        elif self.current == self.head:
            self.head = self.next[self.head]
            self.prev[self.head] = None
        elif next_ == None:
            self.next[prev_] = None 
        else:
            self.next[prev_] = next_
            self.prev[next_] = prev_
        self.len -= 1
        
    def to_next(self):
        self.current = self.next[self.current]
        
    def elem(self):
        return self.list[self.current]
    
    def print_(self):
        i = self.head
        data = []
        data_n = []
        while i != None:
            data.append(self.list[i])
            data_n.append(self.next[i])
            i = self.next[i]
        print(data, data_n)
    
        


t = int(input())
for k in range(t):
    s = LinkedList(list(map(int,list(str(input())))))
    res = ''
    n = s.len
    count_masked = 0
    i = 0
    #s.print_()
    while s.len > 0:
        s.to_head()
        cost=1
        max_v=s.elem()
        max_j=-1
        s.to_next()
        while 9 - (s.list[s.head] + cost) > 0 and s.current != None:
            if s.list[s.current] - cost > max_v:
                max_v = s.list[s.current] - cost
                max_j = s.current
            cost+=1
            s.to_next()
        if max_j != -1:
            res+=str(max_v)
            s.pop(max_j)
        else:
            res+=str(s.list[s.head])
            s.pop()
        #s.print_()
    print(res)
Problem: 2050D - Digital string maximization
Language: python

Solution 1 (runtime: 233 ms):
import sys 
from math import*
from collections import*
I=lambda: map(int,input())
for i in range(int(input())):
    a=list(I())
    n=len(a)
    for j in range(n):
        for k in range(j,max(0,j-10,),-1):
            if a[k-1]+1<a[k]:
                a[k],a[k-1]=a[k-1],a[k]-1
                
    print(*a,sep="")

Solution 2 (runtime: 718 ms):
t=int(input())
for _ in range(t):
    s=input()
    l=list(map(int,s))
    for i in range(1,len(s)):
        while i>0 and l[i]>l[i-1]+1:
            l[i],l[i-1]=l[i-1],l[i]-1
            i-=1
    print(''.join(map(str,l)))
Problem: 2050D - Digital string maximization
Language: python

Solution 1 (runtime: 233 ms):
import sys 
from math import*
from collections import*
I=lambda: map(int,input())
for i in range(int(input())):
    a=list(I())
    n=len(a)
    for j in range(n):
        for k in range(j,max(0,j-10,),-1):
            if a[k-1]+1<a[k]:
                a[k],a[k-1]=a[k-1],a[k]-1
                
    print(*a,sep="")

Solution 2 (runtime: 1202 ms):
t = int(input())



for _ in range(t):

    word = input()

    s = [int(digit) for digit in word]

    l = len(s)



    for i in range(l):

        findMax= s[i]

        maxPos = i

        for j in range(10):

            if s[i+j]>findMax+((j+i)-maxPos):

                findMax = s[i+j]

                maxPos = i+j

            

            if l-(i+j)-1==0:

                break



        for j in range(maxPos-i):

            temp = s[maxPos-1]

            s[maxPos-1] = s[maxPos]-1

            s[maxPos] = temp

            maxPos-=1



    print("".join([str(digit) for digit in s]))
Problem: 2050D - Digital string maximization
Language: python

Solution 1 (runtime: 233 ms):
import sys 
from math import*
from collections import*
I=lambda: map(int,input())
for i in range(int(input())):
    a=list(I())
    n=len(a)
    for j in range(n):
        for k in range(j,max(0,j-10,),-1):
            if a[k-1]+1<a[k]:
                a[k],a[k-1]=a[k-1],a[k]-1
                
    print(*a,sep="")

Solution 2 (runtime: 203 ms):
t= int(input())
for k in range(t):    
    a=list(input())
    b= len(a)
    for i in range(b):
        t= min(i+9,b)
        m= int(a[i])
        n=i
        for j in range(i,t):
            if (int(a[j])-j+i)> m:
                m= int(a[j])-j+i
                n= j
        while n>i:
            a[n],a[n-1]= a[n-1],str(int(a[n])-1)
            n-=1
    print("".join(a))
Problem: 2050D - Digital string maximization
Language: python

Solution 1 (runtime: 233 ms):
import sys 
from math import*
from collections import*
I=lambda: map(int,input())
for i in range(int(input())):
    a=list(I())
    n=len(a)
    for j in range(n):
        for k in range(j,max(0,j-10,),-1):
            if a[k-1]+1<a[k]:
                a[k],a[k-1]=a[k-1],a[k]-1
                
    print(*a,sep="")

Solution 2 (runtime: 702 ms):
n = int(input())

res = []

for _ in range(n):

    s = input()

    temp = []

    for ch in s:

        temp.append(int(ch))

    for i in range(1, len(s)):

        j = i - 1

        while j >= 0:

            r = temp[j+1]

            l = temp[j]

            if r > l + 1:

                temp[j] = r - 1

                temp[j+1] = l

            else:

                break

            j -= 1

    r = ''

    for n in temp:

        r += str(n)

    res.append(r)



for val in res:

    print(val)
Problem: 2050D - Digital string maximization
Language: python

Solution 1 (runtime: 233 ms):
import sys 
from math import*
from collections import*
I=lambda: map(int,input())
for i in range(int(input())):
    a=list(I())
    n=len(a)
    for j in range(n):
        for k in range(j,max(0,j-10,),-1):
            if a[k-1]+1<a[k]:
                a[k],a[k-1]=a[k-1],a[k]-1
                
    print(*a,sep="")

Solution 2 (runtime: 218 ms):
for _ in range(int(input())):

    s=list(input())

    #print(s)

    for i in range(len(s)):

        val=str(s[i])

        index=i



        for j in range(i+1,min(i+10,len(s))):

            if (int(s[j])-(j-i))>int(val):

                val=str(int(s[j])-(j-i))

                index=j 

        

        if index!=i:

            prev=s[i]

            for j in range(i+1,index+1):

                x=s[j]

                s[j]=prev

                prev=x

                

            s[i]=val

    print("".join(s))
Problem: 2050D - Digital string maximization
Language: python

Solution 1 (runtime: 233 ms):
import sys 
from math import*
from collections import*
I=lambda: map(int,input())
for i in range(int(input())):
    a=list(I())
    n=len(a)
    for j in range(n):
        for k in range(j,max(0,j-10,),-1):
            if a[k-1]+1<a[k]:
                a[k],a[k-1]=a[k-1],a[k]-1
                
    print(*a,sep="")

Solution 2 (runtime: 624 ms):
def solve():

    s = list(input().strip())  # Convert string to list for mutability

    n = len(s)



    for i in range(1, n):

        j, curr = i - 1, i

        while j >= 0 and s[curr] > '0' and s[curr] > chr(ord(s[j]) + 1):

            s[curr] = chr(ord(s[curr]) - 1)  # Decrease digit

            s[curr], s[j] = s[j], s[curr]  # Swap

            curr -= 1

            j = curr - 1



    print("".join(s))



# Handling multiple test cases

t = int(input())

for _ in range(t):

    solve()
Problem: 2050D - Digital string maximization
Language: python

Solution 1 (runtime: 233 ms):
import sys 
from math import*
from collections import*
I=lambda: map(int,input())
for i in range(int(input())):
    a=list(I())
    n=len(a)
    for j in range(n):
        for k in range(j,max(0,j-10,),-1):
            if a[k-1]+1<a[k]:
                a[k],a[k-1]=a[k-1],a[k]-1
                
    print(*a,sep="")

Solution 2 (runtime: 234 ms):
n = int(input())

for x in range(n):

s= list(map(int, input()))

g = len(s)

for i in range(1,g):

for j in range(0, s[i]):

if(i-j-1 < 0):

break

if(s[i-j]-1 > s[i-j-1]):

temp = s[i-j-1]

s[i-j-1] = s[i-j]-1

s[i-j] = temp

else:

break

result = ''.join(map(str,s))

print(result)
Problem: 2050D - Digital string maximization
Language: python

Solution 1 (runtime: 233 ms):
import sys 
from math import*
from collections import*
I=lambda: map(int,input())
for i in range(int(input())):
    a=list(I())
    n=len(a)
    for j in range(n):
        for k in range(j,max(0,j-10,),-1):
            if a[k-1]+1<a[k]:
                a[k],a[k-1]=a[k-1],a[k]-1
                
    print(*a,sep="")

Solution 2 (runtime: 156 ms):
for _ in range(int(input())):

a = input()

s = [int(digit) for digit in a]

n = len(s)

for i in range(n):

best_value = s[i]

best_idx = -1

for j in range(i + 1, min(i + 9, n)):

score = s[j]-(j - i)

if score>best_value:

best_value=score

best_idx=j



if best_idx != -1:

# print(best_value,s[best_idx],i,best_idx)

s[i], s[best_idx] = best_value, s[i]

for j in range(best_idx, i+1, -1):

s[j], s[j - 1] = s[j - 1], s[j]

# print(s)



print("".join(map(str, s)))
Problem: 2050D - Digital string maximization
Language: python

Solution 1 (runtime: 233 ms):
import sys 
from math import*
from collections import*
I=lambda: map(int,input())
for i in range(int(input())):
    a=list(I())
    n=len(a)
    for j in range(n):
        for k in range(j,max(0,j-10,),-1):
            if a[k-1]+1<a[k]:
                a[k],a[k-1]=a[k-1],a[k]-1
                
    print(*a,sep="")

Solution 2 (runtime: 171 ms):
mod = 1e9 + 7

for _ in range(int(input())):

s = list(map(int,list(input())))

for i in range(len(s)-1):

mxi = -1

mx = 0

for j in range(1,10):

if i + j >= len(s):

break

if int(s[i+j]) - j - int(s[i]) > mx:

mx = int(s[i+j]) - j - int(s[i])

mxi = j

if mxi == -1:

continue



for jj in range(i+mxi,i,-1):

s[jj],s[jj-1] = s[jj-1],s[jj] - 1



print(''.join(list(map(str,s))))
Problem: 2050D - Digital string maximization
Language: python

Solution 1 (runtime: 233 ms):
import sys 
from math import*
from collections import*
I=lambda: map(int,input())
for i in range(int(input())):
    a=list(I())
    n=len(a)
    for j in range(n):
        for k in range(j,max(0,j-10,),-1):
            if a[k-1]+1<a[k]:
                a[k],a[k-1]=a[k-1],a[k]-1
                
    print(*a,sep="")

Solution 2 (runtime: 218 ms):
t =  int(input())

def solve():

s = [int(i) for i in list(input())]

n = len(s)

for i in range(1,n,1):

for j in range(max(i-10, 0), i):

if s[i] - (i-j) > s[j]:

tmp = s[j:i]

s[j] = s[i] - (i-j)

s[j+1:i+1] = tmp

break

print("".join([str(i) for i in s]))

return

for i in range(t):

solve()
Problem: 2050D - Digital string maximization
Language: python

Solution 1 (runtime: 233 ms):
import sys 
from math import*
from collections import*
I=lambda: map(int,input())
for i in range(int(input())):
    a=list(I())
    n=len(a)
    for j in range(n):
        for k in range(j,max(0,j-10,),-1):
            if a[k-1]+1<a[k]:
                a[k],a[k-1]=a[k-1],a[k]-1
                
    print(*a,sep="")

Solution 2 (runtime: 906 ms):
def solve():

s = list(input())

n = len(s)

while True:

changed = False

for i in range(1, n):

if s[i] != '0' and int(s[i]) - 1 > int(s[i-1]):

num = int(s[i])

s[i] = str(int(s[i-1]))

s[i-1] = str(num - 1)

changed = True

if not changed:

break

print("".join(s))



t = int(input())

for _ in range(t):

solve()
Problem: 2050D - Digital string maximization
Language: python

Solution 1 (runtime: 233 ms):
import sys 
from math import*
from collections import*
I=lambda: map(int,input())
for i in range(int(input())):
    a=list(I())
    n=len(a)
    for j in range(n):
        for k in range(j,max(0,j-10,),-1):
            if a[k-1]+1<a[k]:
                a[k],a[k-1]=a[k-1],a[k]-1
                
    print(*a,sep="")

Solution 2 (runtime: 265 ms):
for _ in range(int(input())):

s = list(map(int,input()))

for i in range(9):

for j in range(len(s)-1):

if s[j] < s[j+1] - 1:

s[j],s[j+1] = s[j+1]-1,s[j]

print(*s,sep= '')
Problem: 2050D - Digital string maximization
Language: python

Solution 1 (runtime: 296 ms):
def fun(s):
    for i in range(1, len(s)):
        while i!=0 and s[i]-1 > s[i-1]:
            s[i], s[i-1] = s[i-1], s[i]-1
            i-=1
            
    return ''.join(map(str, s))
    
if __name__ == "__main__":
    for _ in range(int(input())):
        n=list(map(int, input()))
        rs=fun(n)
        print(rs)

Solution 2 (runtime: 249 ms):
for _ in range(int(input())):
    a = list(map(int, list(input())))
    for i in range(1, len(a)):
        for j in range(i, 0, -1):
            if a[j] - 1 > a[j - 1]:
                a[j], a[j - 1] = a[j - 1], a[j] - 1
            else:
                break
    print(*a, sep="")
Problem: 2050D - Digital string maximization
Language: python

Solution 1 (runtime: 296 ms):
def fun(s):
    for i in range(1, len(s)):
        while i!=0 and s[i]-1 > s[i-1]:
            s[i], s[i-1] = s[i-1], s[i]-1
            i-=1
            
    return ''.join(map(str, s))
    
if __name__ == "__main__":
    for _ in range(int(input())):
        n=list(map(int, input()))
        rs=fun(n)
        print(rs)

Solution 2 (runtime: 750 ms):
for _ in range(int(input())):
    a=list(input())
    for i in range(len(a)):
        a[i]=int(a[i])
    for i in range(9):
        for j in range(len(a)-1):
            if a[j]<(a[j+1]-1):
                a[j],a[j+1]=a[j+1]-1,a[j]
    print(*a,sep='')
Problem: 2050D - Digital string maximization
Language: python

Solution 1 (runtime: 296 ms):
def fun(s):
    for i in range(1, len(s)):
        while i!=0 and s[i]-1 > s[i-1]:
            s[i], s[i-1] = s[i-1], s[i]-1
            i-=1
            
    return ''.join(map(str, s))
    
if __name__ == "__main__":
    for _ in range(int(input())):
        n=list(map(int, input()))
        rs=fun(n)
        print(rs)

Solution 2 (runtime: 1264 ms):
for _ in range(int(input())):
    s = list(map(int,input()))
    i = 1
    while i<len(s):
        if i > 0 and s[i] > s[i-1] + 1 :
            s[i],s[i-1] = s[i-1],s[i]-1
            i -= 1
        else:
            i += 1
    print(''.join(str(i) for i in s))
Problem: 2050D - Digital string maximization
Language: python

Solution 1 (runtime: 296 ms):
def fun(s):
    for i in range(1, len(s)):
        while i!=0 and s[i]-1 > s[i-1]:
            s[i], s[i-1] = s[i-1], s[i]-1
            i-=1
            
    return ''.join(map(str, s))
    
if __name__ == "__main__":
    for _ in range(int(input())):
        n=list(map(int, input()))
        rs=fun(n)
        print(rs)

Solution 2 (runtime: 202 ms):
t=int(input())
for _ in range(t):
  n=input()
  l=[]
  for i in n:
    l.append(int(i))
  for i in range(1,len(l)):
    j=i
    while j>=1 and l[j]-1>l[j-1]:
      l[j-1],l[j]=l[j]-1,l[j-1]
      j-=1
  print("".join(map(str,l)))
Problem: 2050D - Digital string maximization
Language: python

Solution 1 (runtime: 296 ms):
def fun(s):
    for i in range(1, len(s)):
        while i!=0 and s[i]-1 > s[i-1]:
            s[i], s[i-1] = s[i-1], s[i]-1
            i-=1
            
    return ''.join(map(str, s))
    
if __name__ == "__main__":
    for _ in range(int(input())):
        n=list(map(int, input()))
        rs=fun(n)
        print(rs)

Solution 2 (runtime: 858 ms):
def solution():
    a = list(map(int, list(input())))
    for i in range(len(a)):
        _, j = max((a[j]-(j-i), -j) for j in range(i, min(i+9+1, len(a))))
        j = -j
        for k in reversed(range(i+1, j+1)):
            a[k-1], a[k] = a[k]-1, a[k-1]
    return "".join(map(str, a))

for _ in range(int(input())):
    print(solution())
Problem: 2050D - Digital string maximization
Language: python

Solution 1 (runtime: 296 ms):
def fun(s):
    for i in range(1, len(s)):
        while i!=0 and s[i]-1 > s[i-1]:
            s[i], s[i-1] = s[i-1], s[i]-1
            i-=1
            
    return ''.join(map(str, s))
    
if __name__ == "__main__":
    for _ in range(int(input())):
        n=list(map(int, input()))
        rs=fun(n)
        print(rs)

Solution 2 (runtime: 296 ms):
def highest_var(x):
    while True:
        max_n = max(x)  
        check = False   
        while max_n > 1:
            for i in range(1, len(x)):  
                if x[i] == max_n and x[i - 1] < max_n - 1:
                    x[i - 1], x[i] = x[i] - 1, x[i - 1]  
                    check = True  
            max_n -= 1
        if not check:  
            break
    return x


t = int(input())
ab_res = []
for _ in range(t):
    s = input().strip()
    x = list(map(int, s))  
    x = highest_var(x)
    ab_res.append(''.join(map(str, x)))

print('\n'.join(ab_res))
Problem: 2050D - Digital string maximization
Language: python

Solution 1 (runtime: 296 ms):
def fun(s):
    for i in range(1, len(s)):
        while i!=0 and s[i]-1 > s[i-1]:
            s[i], s[i-1] = s[i-1], s[i]-1
            i-=1
            
    return ''.join(map(str, s))
    
if __name__ == "__main__":
    for _ in range(int(input())):
        n=list(map(int, input()))
        rs=fun(n)
        print(rs)

Solution 2 (runtime: 218 ms):
import sys
input = sys.stdin.readline
 
t = int(input())
for _ in range(t):
    s = list(input().strip())
    n = len(s)
 
    i = n - 1
    while i > 0:
        while True:
            if s[i] > '0' and ord(s[i]) - ord(s[i - 1]) > 1:
                s[i] = chr(ord(s[i]) - 1)
                s[i], s[i - 1] = s[i - 1], s[i]
                if i < n - 1:
                    i += 1
            else:
                break
        i -= 1
    print(''.join(s))
Problem: 2050D - Digital string maximization
Language: python

Solution 1 (runtime: 296 ms):
def fun(s):
    for i in range(1, len(s)):
        while i!=0 and s[i]-1 > s[i-1]:
            s[i], s[i-1] = s[i-1], s[i]-1
            i-=1
            
    return ''.join(map(str, s))
    
if __name__ == "__main__":
    for _ in range(int(input())):
        n=list(map(int, input()))
        rs=fun(n)
        print(rs)

Solution 2 (runtime: 203 ms):

import sys

#input=sys.stdin.readline

def solve():
    s = input()
    n = len(s)
    l = [int(c) for c in s]
    for i in range(n):
        best = l[i]
        id = i
        j = i+1
        while(j<i+10 and j<n):
            if ( l[j] - (j-i) > best):
                id = j 
                best = l[j] - (j-i)
            j+=1
        while(id>i):
            l[id],l[id-1] = l[id-1],l[id]-1
            id-=1
        l[i] = str(l[i])
    
    sol = ''.join(l)
    print(sol)
    

t = int(input())
for _ in range(t):
    solve()
Problem: 2050D - Digital string maximization
Language: python

Solution 1 (runtime: 296 ms):
def fun(s):
    for i in range(1, len(s)):
        while i!=0 and s[i]-1 > s[i-1]:
            s[i], s[i-1] = s[i-1], s[i]-1
            i-=1
            
    return ''.join(map(str, s))
    
if __name__ == "__main__":
    for _ in range(int(input())):
        n=list(map(int, input()))
        rs=fun(n)
        print(rs)

Solution 2 (runtime: 140 ms):
import sys

input = sys.stdin.readline
write = sys.stdout.write


def solve():
    # make left as big as possible
    # if curr > left + 1
    # always swap, repeatedly too
    s = [int(x) for x in input().strip()]
    for i in range(1, len(s)):
        for j in range(i, 0, -1):  # at most ~9 iterations
            if not (s[j - 1] < s[j] - 1):
                break
            s[j - 1], s[j] = s[j] - 1, s[j - 1]

    write("".join(map(str, s)) + "\n")


if __name__ == "__main__":
    t = int(input())
    for i in range(t):
        solve()