ShaysXIA/CodeInsightBench huggingface dataset:
Problem: 2063B - Subsequence Update
Language: python

Solution 1 (runtime: 140 ms):
def get_num_cases():
    return int(input())


def get_line():
    return [int(p) for p in input().strip().split()]



from itertools import accumulate
import sys


class ArraySum:

    def __init__(self, arr):
        self.sums = []
        s = 0
        for n in arr:
            s += n
            self.sums.append(s)

    def get(self, i, j):  # 0 based
        if i > j:
            return 0
        if i == 0:
            return self.sums[j]
        return self.sums[j] - self.sums[i-1]


    def get_min(self, i, j, n):  # 0 based
        if n == 0:
            return 0
        if n > (j - i + 1):
            return float('inf')
        return min(
            self.get(p, p + n - 1)
            for p in range(i, j - n + 2)
        )

    def __len__(self):
        return len(self.sums)


for _ in range(get_num_cases()):
    n, l, r = get_line()
    l -= 1
    arr = get_line()
    brr=arr[:l]+sorted(arr[l:])
    crr=sorted(arr[:r])[::-1]+arr[r:]
    print(min(sum(brr[l:r]),sum(crr[l:r])))






Solution 2 (runtime: 187 ms):
t = int(input())
for _ in range(t):
    cont = 0
    n, l, r = list(map(int, input().split()))
    lis = list(map(int, input().split()))
    lis1 = []
    lis2 = []
    min1 = 0
    min2 = 0
    for i in range(r):
        lis1.append(lis[i])
    for i in range(l - 1,n):
        lis2.append(lis[i])
    lis1 = sorted(lis1)
    lis2 = sorted(lis2)
    for i in range(r - l + 1):
        min1 += lis1[i]
    for i in range(r - l + 1):
        min2 += lis2[i]
    print(min(min1,min2))
Problem: 2063B - Subsequence Update
Language: python

Solution 1 (runtime: 140 ms):
def get_num_cases():
    return int(input())


def get_line():
    return [int(p) for p in input().strip().split()]



from itertools import accumulate
import sys


class ArraySum:

    def __init__(self, arr):
        self.sums = []
        s = 0
        for n in arr:
            s += n
            self.sums.append(s)

    def get(self, i, j):  # 0 based
        if i > j:
            return 0
        if i == 0:
            return self.sums[j]
        return self.sums[j] - self.sums[i-1]


    def get_min(self, i, j, n):  # 0 based
        if n == 0:
            return 0
        if n > (j - i + 1):
            return float('inf')
        return min(
            self.get(p, p + n - 1)
            for p in range(i, j - n + 2)
        )

    def __len__(self):
        return len(self.sums)


for _ in range(get_num_cases()):
    n, l, r = get_line()
    l -= 1
    arr = get_line()
    brr=arr[:l]+sorted(arr[l:])
    crr=sorted(arr[:r])[::-1]+arr[r:]
    print(min(sum(brr[l:r]),sum(crr[l:r])))






Solution 2 (runtime: 156 ms):
def summa(x,y):
    summma = 0
    count = r + 1 - l
    i = 0
    j = 0
    x.sort()
    y.sort()
    while count > 0:
        if x[i] >= y[j]:
            summma += y[j]
            j += 1
            count -= 1

        else:
            summma += x[i]
            i += 1
            count -= 1

    return(summma)

N=10**9
for _ in range(int(input())):
    n,l,r =map(int,input().split())
    numbers = list(map(int,input().split()))
    left = numbers[ : l-1]+[N]
    right = numbers[r: ]+[N]
    middle = numbers[l-1:r]

    uno_ = summa(left,middle)
    dos_ = summa(right,middle)

    print(min(uno_,dos_))
Problem: 2063B - Subsequence Update
Language: python

Solution 1 (runtime: 140 ms):
def get_num_cases():
    return int(input())


def get_line():
    return [int(p) for p in input().strip().split()]



from itertools import accumulate
import sys


class ArraySum:

    def __init__(self, arr):
        self.sums = []
        s = 0
        for n in arr:
            s += n
            self.sums.append(s)

    def get(self, i, j):  # 0 based
        if i > j:
            return 0
        if i == 0:
            return self.sums[j]
        return self.sums[j] - self.sums[i-1]


    def get_min(self, i, j, n):  # 0 based
        if n == 0:
            return 0
        if n > (j - i + 1):
            return float('inf')
        return min(
            self.get(p, p + n - 1)
            for p in range(i, j - n + 2)
        )

    def __len__(self):
        return len(self.sums)


for _ in range(get_num_cases()):
    n, l, r = get_line()
    l -= 1
    arr = get_line()
    brr=arr[:l]+sorted(arr[l:])
    crr=sorted(arr[:r])[::-1]+arr[r:]
    print(min(sum(brr[l:r]),sum(crr[l:r])))






Solution 2 (runtime: 140 ms):
import sys

input=lambda:sys.stdin.readline().rstrip()

 

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

    n,l,r=map(int,input().split());l-=1

    arr=[*map(int,input().split())]

    brr=arr[:l]+sorted(arr[l:])

    crr=sorted(arr[:r])[::-1]+arr[r:]

    print(min(sum(brr[l:r]),sum(crr[l:r])))
Problem: 2063B - Subsequence Update
Language: python

Solution 1 (runtime: 140 ms):
def get_num_cases():
    return int(input())


def get_line():
    return [int(p) for p in input().strip().split()]



from itertools import accumulate
import sys


class ArraySum:

    def __init__(self, arr):
        self.sums = []
        s = 0
        for n in arr:
            s += n
            self.sums.append(s)

    def get(self, i, j):  # 0 based
        if i > j:
            return 0
        if i == 0:
            return self.sums[j]
        return self.sums[j] - self.sums[i-1]


    def get_min(self, i, j, n):  # 0 based
        if n == 0:
            return 0
        if n > (j - i + 1):
            return float('inf')
        return min(
            self.get(p, p + n - 1)
            for p in range(i, j - n + 2)
        )

    def __len__(self):
        return len(self.sums)


for _ in range(get_num_cases()):
    n, l, r = get_line()
    l -= 1
    arr = get_line()
    brr=arr[:l]+sorted(arr[l:])
    crr=sorted(arr[:r])[::-1]+arr[r:]
    print(min(sum(brr[l:r]),sum(crr[l:r])))






Solution 2 (runtime: 249 ms):
t = int(input())
for T in range(0,t):
    st = input()
    S = st.split()
    n = int(S[0])
    l = int(S[1])
    r = int(S[2])
    num = r - l + 1
    
    An = input()
    A = An.split()
    B = []
    C = []
    for i in range(0,r):
        B.append(int(A[i]))
    for i in range(l-1,n):
        C.append(int(A[i]))
    BB = sorted(B)
    CC = sorted(C)

    sum1 = 0
    sum2 = 0
    for i in range(0,num):
        sum1 += int(BB[i])
        sum2 += int(CC[i])
    
    if(sum1 > sum2):
        print(sum2)
    else:
        print(sum1)
Problem: 2063B - Subsequence Update
Language: python

Solution 1 (runtime: 140 ms):
def get_num_cases():
    return int(input())


def get_line():
    return [int(p) for p in input().strip().split()]



from itertools import accumulate
import sys


class ArraySum:

    def __init__(self, arr):
        self.sums = []
        s = 0
        for n in arr:
            s += n
            self.sums.append(s)

    def get(self, i, j):  # 0 based
        if i > j:
            return 0
        if i == 0:
            return self.sums[j]
        return self.sums[j] - self.sums[i-1]


    def get_min(self, i, j, n):  # 0 based
        if n == 0:
            return 0
        if n > (j - i + 1):
            return float('inf')
        return min(
            self.get(p, p + n - 1)
            for p in range(i, j - n + 2)
        )

    def __len__(self):
        return len(self.sums)


for _ in range(get_num_cases()):
    n, l, r = get_line()
    l -= 1
    arr = get_line()
    brr=arr[:l]+sorted(arr[l:])
    crr=sorted(arr[:r])[::-1]+arr[r:]
    print(min(sum(brr[l:r]),sum(crr[l:r])))






Solution 2 (runtime: 249 ms):
for _ in range(int(input())):
    n, l, r = map(int, input().split())
    arr = list(map(int, input().split()))
    left = sorted(arr[:r])
    right = sorted(arr[l-1:])
    print(min(sum(left[:r-l+1]), sum(right[:r-l+1])))
Problem: 2063B - Subsequence Update
Language: python

Solution 1 (runtime: 140 ms):
def get_num_cases():
    return int(input())


def get_line():
    return [int(p) for p in input().strip().split()]



from itertools import accumulate
import sys


class ArraySum:

    def __init__(self, arr):
        self.sums = []
        s = 0
        for n in arr:
            s += n
            self.sums.append(s)

    def get(self, i, j):  # 0 based
        if i > j:
            return 0
        if i == 0:
            return self.sums[j]
        return self.sums[j] - self.sums[i-1]


    def get_min(self, i, j, n):  # 0 based
        if n == 0:
            return 0
        if n > (j - i + 1):
            return float('inf')
        return min(
            self.get(p, p + n - 1)
            for p in range(i, j - n + 2)
        )

    def __len__(self):
        return len(self.sums)


for _ in range(get_num_cases()):
    n, l, r = get_line()
    l -= 1
    arr = get_line()
    brr=arr[:l]+sorted(arr[l:])
    crr=sorted(arr[:r])[::-1]+arr[r:]
    print(min(sum(brr[l:r]),sum(crr[l:r])))






Solution 2 (runtime: 218 ms):
n = int(input())
for i in range(n):
    data = input().split(" ")
    arr = input().split(" ")
    arrint = [int(i) for i in arr]
    dataint = [int(i) for i in data]
    dataint[1] -= 1
    dataint[2] -= 1
    left = []
    mid = []
    right = []
    for v in range(dataint[0]):
        if v < dataint[1]:
            left += [arrint[v]]
        if v >= dataint[1] and v <= dataint[2]:
            mid += [arrint[v]]
        if v > dataint[2]:
            right += [arrint[v]]
    lsort = sorted(left)
    msort = sorted(mid, reverse = True)
    rsort = sorted(right)
    count = 0
    while count < min(len(lsort),len(msort)) and lsort[count] < msort[count]:
        lsort[count] , msort[count] =  msort[count], lsort[count]
        count += 1
    
    minimum = sum(msort)

    count = 0

    msort = sorted(mid, reverse = True)
    while count < min(len(rsort),len(msort)) and rsort[count] < msort[count]:
        rsort[count] , msort[count] =  msort[count], rsort[count]
        count += 1
    
    minimum = min(minimum, sum(msort))
    print(minimum)
Problem: 2063B - Subsequence Update
Language: python

Solution 1 (runtime: 140 ms):
def get_num_cases():
    return int(input())


def get_line():
    return [int(p) for p in input().strip().split()]



from itertools import accumulate
import sys


class ArraySum:

    def __init__(self, arr):
        self.sums = []
        s = 0
        for n in arr:
            s += n
            self.sums.append(s)

    def get(self, i, j):  # 0 based
        if i > j:
            return 0
        if i == 0:
            return self.sums[j]
        return self.sums[j] - self.sums[i-1]


    def get_min(self, i, j, n):  # 0 based
        if n == 0:
            return 0
        if n > (j - i + 1):
            return float('inf')
        return min(
            self.get(p, p + n - 1)
            for p in range(i, j - n + 2)
        )

    def __len__(self):
        return len(self.sums)


for _ in range(get_num_cases()):
    n, l, r = get_line()
    l -= 1
    arr = get_line()
    brr=arr[:l]+sorted(arr[l:])
    crr=sorted(arr[:r])[::-1]+arr[r:]
    print(min(sum(brr[l:r]),sum(crr[l:r])))






Solution 2 (runtime: 280 ms):
from itertools import accumulate, pairwise
import math
import bisect
import heapq
from collections import Counter, defaultdict
from functools import cache
def solve():
    n, l, r = map(int, input().split())
    arr = [int(x) for x in input().split()]
    # 
    if l == 1 or r == n or r - l == 0:
        arr.sort()
        print(sum(arr[: r - l + 1]))
    else:
        first = arr[:r]
        second = arr[l - 1:]
        first.sort()
        second.sort()
        print(min(sum(first[: r - l + 1]), sum(second[: r - l + 1])))
for _ in range(int(input())):
    solve()
Problem: 2063B - Subsequence Update
Language: python

Solution 1 (runtime: 140 ms):
def get_num_cases():
    return int(input())


def get_line():
    return [int(p) for p in input().strip().split()]



from itertools import accumulate
import sys


class ArraySum:

    def __init__(self, arr):
        self.sums = []
        s = 0
        for n in arr:
            s += n
            self.sums.append(s)

    def get(self, i, j):  # 0 based
        if i > j:
            return 0
        if i == 0:
            return self.sums[j]
        return self.sums[j] - self.sums[i-1]


    def get_min(self, i, j, n):  # 0 based
        if n == 0:
            return 0
        if n > (j - i + 1):
            return float('inf')
        return min(
            self.get(p, p + n - 1)
            for p in range(i, j - n + 2)
        )

    def __len__(self):
        return len(self.sums)


for _ in range(get_num_cases()):
    n, l, r = get_line()
    l -= 1
    arr = get_line()
    brr=arr[:l]+sorted(arr[l:])
    crr=sorted(arr[:r])[::-1]+arr[r:]
    print(min(sum(brr[l:r]),sum(crr[l:r])))






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

    n , l , r= [int(num) for num in input().split()]

    nums= [int(num) for num in input().split()]

    left = sum(sorted(nums[:r])[:r-l+1])

    right = sum(sorted(nums[l-1:])[:r-l+1])

    print(min(left,right))
Problem: 2063B - Subsequence Update
Language: python

Solution 1 (runtime: 140 ms):
def get_num_cases():
    return int(input())


def get_line():
    return [int(p) for p in input().strip().split()]



from itertools import accumulate
import sys


class ArraySum:

    def __init__(self, arr):
        self.sums = []
        s = 0
        for n in arr:
            s += n
            self.sums.append(s)

    def get(self, i, j):  # 0 based
        if i > j:
            return 0
        if i == 0:
            return self.sums[j]
        return self.sums[j] - self.sums[i-1]


    def get_min(self, i, j, n):  # 0 based
        if n == 0:
            return 0
        if n > (j - i + 1):
            return float('inf')
        return min(
            self.get(p, p + n - 1)
            for p in range(i, j - n + 2)
        )

    def __len__(self):
        return len(self.sums)


for _ in range(get_num_cases()):
    n, l, r = get_line()
    l -= 1
    arr = get_line()
    brr=arr[:l]+sorted(arr[l:])
    crr=sorted(arr[:r])[::-1]+arr[r:]
    print(min(sum(brr[l:r]),sum(crr[l:r])))






Solution 2 (runtime: 155 ms):

for _ in range(int(input())):
	n,l,r = list(map(int,input().split(" ")))
	a = list(map(int,input().split(" ")))
	left = sorted(a[:r])
	right = sorted(a[l-1:])
	print(min(sum(left[:r-l+1]),sum(right[:r-l+1])))
Problem: 2063B - Subsequence Update
Language: python

Solution 1 (runtime: 140 ms):
def get_num_cases():
    return int(input())


def get_line():
    return [int(p) for p in input().strip().split()]



from itertools import accumulate
import sys


class ArraySum:

    def __init__(self, arr):
        self.sums = []
        s = 0
        for n in arr:
            s += n
            self.sums.append(s)

    def get(self, i, j):  # 0 based
        if i > j:
            return 0
        if i == 0:
            return self.sums[j]
        return self.sums[j] - self.sums[i-1]


    def get_min(self, i, j, n):  # 0 based
        if n == 0:
            return 0
        if n > (j - i + 1):
            return float('inf')
        return min(
            self.get(p, p + n - 1)
            for p in range(i, j - n + 2)
        )

    def __len__(self):
        return len(self.sums)


for _ in range(get_num_cases()):
    n, l, r = get_line()
    l -= 1
    arr = get_line()
    brr=arr[:l]+sorted(arr[l:])
    crr=sorted(arr[:r])[::-1]+arr[r:]
    print(min(sum(brr[l:r]),sum(crr[l:r])))






Solution 2 (runtime: 374 ms):
for _ in range(int(input())):
    n,l,r=map(int,input().split())
    l-=1
    r-=1
    a=list(map(int,input().split()))
    if l==0 and r==n-1:
        print(sum(a[l:r+1]))
        continue
    if l==r:
        print(min(a))
        continue
    sub,subleft,subright,t,res=sorted(a[l:r+1],reverse=True),sorted(a[:l]),sorted(a[r+1:]),sum(a[l:r+1]),float('inf')
    if l>0:
        change=0
        for i in range(r-l+1):
            if i<len(subleft):
                if subleft[i]<sub[i]:
                    change+=subleft[i]-sub[i]
            else:
                break
        res=min(res,t+change)
    if r<n:
        change=0
        for i in range(r-l+1):
            if i<len(subright):
                if subright[i]<sub[i]:
                    change+=subright[i]-sub[i]
            else:
                break
        res=min(res,t+change)
    print(res)
Problem: 2063B - Subsequence Update
Language: python

Solution 1 (runtime: 140 ms):
def get_num_cases():
    return int(input())


def get_line():
    return [int(p) for p in input().strip().split()]



from itertools import accumulate
import sys


class ArraySum:

    def __init__(self, arr):
        self.sums = []
        s = 0
        for n in arr:
            s += n
            self.sums.append(s)

    def get(self, i, j):  # 0 based
        if i > j:
            return 0
        if i == 0:
            return self.sums[j]
        return self.sums[j] - self.sums[i-1]


    def get_min(self, i, j, n):  # 0 based
        if n == 0:
            return 0
        if n > (j - i + 1):
            return float('inf')
        return min(
            self.get(p, p + n - 1)
            for p in range(i, j - n + 2)
        )

    def __len__(self):
        return len(self.sums)


for _ in range(get_num_cases()):
    n, l, r = get_line()
    l -= 1
    arr = get_line()
    brr=arr[:l]+sorted(arr[l:])
    crr=sorted(arr[:r])[::-1]+arr[r:]
    print(min(sum(brr[l:r]),sum(crr[l:r])))






Solution 2 (runtime: 375 ms):
inp = lambda: int(input())
minp = lambda: map(int, input().split())
linp = lambda: list(map(int, input().split()))
tinp = lambda: tuple(map(int, input().split()))
import math

def solve():
    n, l, r = minp()
    left = []
    mid = []
    right = []
    for i, v in enumerate(minp()):
        if i < l-1:
            left.append(v)
        elif i < r:
            mid.append(v)
        else:
            right.append(v)
    left.sort()
    mid.sort()
    right.sort()
    
    ans1 = ans2 = sum(mid)
    a = 0
    b = len(mid)-1
    while a < len(left) and b >= 0 and left[a] < mid[b]:
        ans1 -= mid[b]-left[a]
        a+=1; b-=1
    a = 0
    b = len(mid)-1
    while a < len(right) and b >= 0 and right[a] < mid[b]:
        ans2 -= mid[b]-right[a]
        a+=1; b-=1
    
    print(min(ans1, ans2))

    
        

for _ in range(inp()):
    solve()
Problem: 2063B - Subsequence Update
Language: python

Solution 1 (runtime: 140 ms):
def get_num_cases():
    return int(input())


def get_line():
    return [int(p) for p in input().strip().split()]



from itertools import accumulate
import sys


class ArraySum:

    def __init__(self, arr):
        self.sums = []
        s = 0
        for n in arr:
            s += n
            self.sums.append(s)

    def get(self, i, j):  # 0 based
        if i > j:
            return 0
        if i == 0:
            return self.sums[j]
        return self.sums[j] - self.sums[i-1]


    def get_min(self, i, j, n):  # 0 based
        if n == 0:
            return 0
        if n > (j - i + 1):
            return float('inf')
        return min(
            self.get(p, p + n - 1)
            for p in range(i, j - n + 2)
        )

    def __len__(self):
        return len(self.sums)


for _ in range(get_num_cases()):
    n, l, r = get_line()
    l -= 1
    arr = get_line()
    brr=arr[:l]+sorted(arr[l:])
    crr=sorted(arr[:r])[::-1]+arr[r:]
    print(min(sum(brr[l:r]),sum(crr[l:r])))






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

for case in range(t):

    s=0

    n,l,r=map(int,input().split())

    seq=list(map(int,input().split()))

    a=seq[:l-1]+sorted(seq[l-1:])

    b=sorted(seq[:r])[::-1]+seq[r:]

    print(min(sum(a[l-1:r]),sum(b[l-1:r])))
Problem: 2063B - Subsequence Update
Language: python

Solution 1 (runtime: 140 ms):
def get_num_cases():
    return int(input())


def get_line():
    return [int(p) for p in input().strip().split()]



from itertools import accumulate
import sys


class ArraySum:

    def __init__(self, arr):
        self.sums = []
        s = 0
        for n in arr:
            s += n
            self.sums.append(s)

    def get(self, i, j):  # 0 based
        if i > j:
            return 0
        if i == 0:
            return self.sums[j]
        return self.sums[j] - self.sums[i-1]


    def get_min(self, i, j, n):  # 0 based
        if n == 0:
            return 0
        if n > (j - i + 1):
            return float('inf')
        return min(
            self.get(p, p + n - 1)
            for p in range(i, j - n + 2)
        )

    def __len__(self):
        return len(self.sums)


for _ in range(get_num_cases()):
    n, l, r = get_line()
    l -= 1
    arr = get_line()
    brr=arr[:l]+sorted(arr[l:])
    crr=sorted(arr[:r])[::-1]+arr[r:]
    print(min(sum(brr[l:r]),sum(crr[l:r])))






Solution 2 (runtime: 327 ms):
############ ---- Functions for inputs ---- ############
import math
from bisect import bisect_left, bisect_right
from collections import defaultdict, deque, Counter

def number(): return (int(input()))
def numbers(): return (map(int, input().split()))
def array(): return (list(map(int, input().split())))
def string(): return input()
############ ---- Functions for inputs ---- ############

t = number()

for _ in range(t):
  n, l, r = numbers()
  nums = array()
  left = nums[:l - 1]
  right = nums[r:]
  middle = nums[l - 1:r]
  option1 = sorted(left + middle)
  option2 = sorted(right + middle)
  print(min(sum(option1[:r - l + 1]), sum(option2[:r - l + 1])))
Problem: 2063B - Subsequence Update
Language: python

Solution 1 (runtime: 140 ms):
def get_num_cases():
    return int(input())


def get_line():
    return [int(p) for p in input().strip().split()]



from itertools import accumulate
import sys


class ArraySum:

    def __init__(self, arr):
        self.sums = []
        s = 0
        for n in arr:
            s += n
            self.sums.append(s)

    def get(self, i, j):  # 0 based
        if i > j:
            return 0
        if i == 0:
            return self.sums[j]
        return self.sums[j] - self.sums[i-1]


    def get_min(self, i, j, n):  # 0 based
        if n == 0:
            return 0
        if n > (j - i + 1):
            return float('inf')
        return min(
            self.get(p, p + n - 1)
            for p in range(i, j - n + 2)
        )

    def __len__(self):
        return len(self.sums)


for _ in range(get_num_cases()):
    n, l, r = get_line()
    l -= 1
    arr = get_line()
    brr=arr[:l]+sorted(arr[l:])
    crr=sorted(arr[:r])[::-1]+arr[r:]
    print(min(sum(brr[l:r]),sum(crr[l:r])))






Solution 2 (runtime: 140 ms):
for i in range(int(input())):

    n,l,r = map(int,input().split())

    a = list(map(int,input().split()))

    l-=1

    r-=1

    l1 = a[l:]

    l2 = a[:r+1]

    l1.sort()

    l2.sort()

    print(min(sum(l1[:r-l+1]),sum(l2[:r-l+1])))