Competitive Programming Solutions

D. Range Sum

Codeforces - Contest #2 · limit: 1s · memory: 256MB · view on codeforces

input

25
8 999999990
4 999999991
8 1000000000
8 999999996
8 999999998
2 999999998
4 999999991
9 999999994
6 999999998
4 999999994
10 999999997
10 999999992
10 999999998
6 999999999
1 999999992
6 999999998
1 999999994
9 999999998
5 1000000000
3 999999997
2 999999995
10 999999996
5 999999995
6 999999991
10 999999995

output

499999990500000017
499999991500000030
500000000499999972
499999996499999978
499999998499999973
499999998500000000
499999991500000030
499999994499999979
499999998499999986
499999994500000009
499999997499999958
499999992499999983
499999998499999956
499999999499999985
499999992500000028
499999998499999986
499999994500000015
499999998499999965
500000000499999990
499999997500000000
499999995500000009
499999996499999961
499999995500000000
499999991500000021
499999995499999965

Main.java

static void solve() {

        // Write your solution here
        int l = in.nextInt();
        int r = in.nextInt();
        if (l > r) {
        int temp = l;
        l = r;
        r = temp;
        }

        long count = (long) r - l + 1;
        long sum = (long) l + r;
        long result = count * sum / 2;

        out.println(result);
    }

import java.io.*;
import java.util.*;

public class Main {
    static final int MOD = 1_000_000_007;
    static final int MOD2 = 998_244_353;
    static final Random rnd = new Random();

    static FastReader in = new FastReader();
    static PrintWriter out = new PrintWriter(System.out);

    public static void main(String[] args) {
        int t = 1;
        // Comment if program has single input
        t = in.nextInt();
        while (t-- > 0) {
            solve();
        }
        out.flush();
    }

    static void solve() {

        // Write your solution here
        int l = in.nextInt();
        int r = in.nextInt();
        if (l > r) {
        int temp = l;
        l = r;
        r = temp;
        }

        long count = (long) r - l + 1;
        long sum = (long) l + r;
        long result = count * sum / 2;

        out.println(result);
    }

    // =========================
    // Array Input
    // =========================

    static int[] readIntArray(int n) {
        int[] a = new int[n];
        for (int i = 0; i < n; i++)
            a[i] = in.nextInt();
        return a;
    }

    static long[] readLongArray(int n) {
        long[] a = new long[n];
        for (int i = 0; i < n; i++)
            a[i] = in.nextLong();
        return a;
    }

    // =========================
    // Safe Sort
    // =========================

    static void safeSort(int[] a) {
        shuffle(a);
        Arrays.sort(a);
    }

    static void safeSort(long[] a) {
        shuffle(a);
        Arrays.sort(a);
    }

    static void shuffle(int[] a) {
        for (int i = a.length - 1; i > 0; i--) {
            int j = rnd.nextInt(i + 1);
            int temp = a[i];
            a[i] = a[j];
            a[j] = temp;
        }
    }

    static void shuffle(long[] a) {
        for (int i = a.length - 1; i > 0; i--) {
            int j = rnd.nextInt(i + 1);
            long temp = a[i];
            a[i] = a[j];
            a[j] = temp;
        }
    }

    // =========================
    // Math
    // =========================

    static long gcd(long a, long b) {
        while (b != 0) {
            long t = b;
            b = a % b;
            a = t;
        }
        return a;
    }

    static long lcm(long a, long b) {
        return a / gcd(a, b) * b;
    }

    static long power(long base, long exp, long mod) {
        long ans = 1;
        base %= mod;

        while (exp > 0) {
            if ((exp & 1) == 1)
                ans = (ans * base) % mod;

            base = (base * base) % mod;
            exp >>= 1;
        }

        return ans;
    }

    // =========================
    // Reverse
    // =========================

    static void reverse(int[] a) {
        int l = 0, r = a.length - 1;
        while (l < r) {
            int temp = a[l];
            a[l++] = a[r];
            a[r--] = temp;
        }
    }

    static void reverse(long[] a) {
        int l = 0, r = a.length - 1;
        while (l < r) {
            long temp = a[l];
            a[l++] = a[r];
            a[r--] = temp;
        }
    }

    // =========================
    // Fast Reader
    // =========================

    static class FastReader {
        BufferedReader br = new BufferedReader(new InputStreamReader(System.in));
        StringTokenizer st;

        String next() {
            while (st == null || !st.hasMoreTokens()) {
                try {
                    st = new StringTokenizer(br.readLine());
                } catch (IOException e) {
                    throw new RuntimeException(e);
                }
            }
            return st.nextToken();
        }

        int nextInt() {
            return Integer.parseInt(next());
        }

        long nextLong() {
            return Long.parseLong(next());
        }

        double nextDouble() {
            return Double.parseDouble(next());
        }

        String nextLine() {
            try {
                return br.readLine();
            } catch (IOException e) {
                throw new RuntimeException(e);
            }
        }
    }
}