thảo luận Leetcode mỗi ngày

class Solution {
    public int[] decrypt(int[] code, int k) {
        return k == 0 ? new int[code.length] : IntStream.range(0, code.length).map(i -> IntStream.rangeClosed(
            1, Math.abs(k)).map(j -> code[(i + code.length + (k > 0 ? j : -j)) % code.length]).sum()).toArray();
    }
}

public static int[] decrypt(int[] code, int k) {
    int[] res = new int[code.length];
    int length = code.length;
    if (k == 0) {
        Arrays.fill(code, 0);
        return code;
    } else if (k > 0) {
        int sum = 0;
        for (int i = 1; i <= k; i++) {
            sum += code[i];
        }
        res[0] = sum;
        for (int i = 2; i <= length; i++) {
            sum -= code[i - 1];
            if (i + k - 1 >= length) {
                sum += code[(i + k - 1) % length];
            } else sum += code[i + k - 1];
            res[i - 1] = sum;
        }
    } else {
        int sum = 0;
        for (int i = length - 2; i >= length + k - 1; i--) {
            sum += code[i];
        }
        res[length - 1] = sum;
        for (int i = length - 3; i >= -1; i--) {
            sum -= code[i + 1];
            if (i + k + 1 < 0) {
                sum += code[length + (i + k + 1)];
            } else sum += code[i + k + 1];
            res[i + 1] = sum;
        }
    }
    return res;
}

class Solution:
    def decrypt(self, code: List[int], k: int) -> List[int]:
        n = len(code)
        if k == 0:
            return [0] * n
        sign = True if k > 0 else False
        k = abs(k)
        if not sign:
            code = code[::-1]
        code = code + code[:k]
        cur = sum(code[1:1+k])
        res = []
        res.append(cur)
        l = 1
        for r in range(k+1, len(code)):
            cur += code[r]
            cur -= code[l]
            res.append(cur)
            l += 1
        if not sign:
            return res[::-1]
        return res

class Solution:
    def decrypt(self, arr: List[int], k: int) -> List[int]:
        if k == 0:
            return [0] * len(arr)
        
        n = len(arr)
        arr = arr + arr

        res = []
        curr = 0

        if k > 0:
            for i in range(n + k):
                curr += arr[i]
                if i >= k:
                    curr -= arr[i - k]
                    res.append(curr)
        if k < 0:
            k = -k
            for i in range(n-k-1, 2*n-1):
                curr += arr[i]
                if i >= n-1:
                    curr -= arr[i - k]
                    res.append(curr)
    
        return res

class Solution:
    def decrypt(self, code: List[int], k: int) -> List[int]:
        n = len(code)
        if k == 0:
            return [0] * n
        if k > 0:
            l, r = 1, 1
        else:
            l, r = n - abs(k), n - abs(k)

        curr = 0
        res = []

        while len(res) < n:
            curr += code[r % n]
            if r - l + 1 == abs(k):
                res.append(curr)
                curr -= code[l % n]
                l += 1

            r += 1

        return res

public class Solution
{
    public int[] Decrypt(int[] code, int k)
    {
        var len = code.Length;
        var res = new int[len];
        if (k > 0)
        {
            var sum = 0;
            for (var i = 1; i <= k; i++)
            {
                sum += code[i];
            }

            for (int i = 0; i < len; i++)
            {
                res[i] = sum;
                sum += code[Normalize(i+k+1)] - code[Normalize(i+1)];
            }
        }
        else if (k < 0)
        {
            var sum = 0;
            for (var i = len - 1; i >= len + k; i--)
            {
                sum += code[i];
            }
            for (int i = 0; i < len; i++)
            {
                res[i] = sum;
                sum += code[Normalize(i)] - code[Normalize(i+k)];
            }
        }

        return res;

        int Normalize(int x)
        {
            while (x < 0)
            {
                x += len;
            }

            return x % len;
        }
    }
}

class Solution:
    def decrypt(self, code: List[int], k: int) -> List[int]:
        res = []

        n = len(code)
        code = code + code
        for i in range(n):
            if k < 0:
                res.append(sum(code[i + n + k:i + n + k + abs(k)]))
            else:
                res.append(sum(code[i + 1:(i + k + 1)]))
        return res

func decrypt(code []int, k int) []int {
    if k == 0 {
        return make([]int, len(code))
    }

    arr := make([]int, 0)
    n := len(code)

    for i := 0; i < n; i++ {
        sum := 0
        if k > 0 {
            for j := 1; j <= k; j++ {
                if i+j >= n {
                    sum += code[i+j-n]
                } else {
                    sum += code[i+j]
                }
            }

        } else {
            for j := 1; j <= -k; j++ {
                if i-j < 0 {
                    num := math.Abs(float64(i - j))
                    sum += code[n-int(num)]
                } else {
                    sum += code[i-j]
                }
            }
        }

        arr = append(arr, sum)
    }

    return arr
}

class Solution {
    public int[] decrypt(int[] code, int k) {
        int n = code.length;
        int[] res = new int[n];

        if (k == 0) {
            return res;
        }

        int sum = 0;
        int start = k > 0 ? 1 : n + k;
        int end = k > 0 ? k : n - 1;

        for (int i = start; i <= end; i++) {
            sum += code[i % n];
        }

        for (int i = 0; i < n; i++) {
            res[i] = sum;

            sum -= code[(start++ % n)];
            sum += code[(++end % n)];
        }

        return res;
    }
}

class Solution {
    public int[] decrypt(int[] code, int k) {
        int n = code.length;
        int[] res  = new int[n];
        if( k==0 )
            return res;
        int l=0,r=0;
        if(k<0){
            l=n+k;
            r = n-1;
        }else{
            l=1;
            r = k;
        }
        for(int i = l;i<=r;i++)
            res[0]+=code[i];
        for(int i = 1;i<n;i++){
            res[i]= res[i-1] + code[(r+i)%n] - code[(l+i-1)%n];
        }
        return res;
}
}

class Solution {

    /**
     * @param Integer[] $code
     * @param Integer $k
     * @return Integer[]
     */
    function decrypt($code, $k) {
        $length = count($code);
        $ans = array_fill(0, $length, 0);
        if ($k == 0) return $ans;

        for ($i=0; $i<$length; $i++) {
            $c = $k;
            while (($k > 0 && $c > 0) || ($k < 0 && $c < 0)) {
                $index = $c + $i;
                if ($k > 0) {
                    $ans[$i] += $index < $length ? $code[$index] : $code[abs($length - $index)];
                    $c--;
                    continue;
                }
                
                $ans[$i] += $index < 0 ? $code[$length + $index] : $code[$index];
                $c++;
            }
        }

        return $ans;
    }
}

public class Solution {
    public int[] Decrypt(int[] code, int k) {
        int[] result = new int[code.Length];
        int temp = 0;
        for(int i = 0; i < code.Length; i++)
        {
            for(int j = 1; j <= Math.Abs(k); j++)
            {
                temp = k > 0 ? j : -j;
                result[i] += code[(i+temp+code.Length) % code.Length];
            }
        }
        return result;
    }
}