Test results - Codility

Code: 02:11:40 UTC, java, autosave

1 2 3 4 5 6 7 8 9 10 11

// you can also use imports, for example:
// import java.util.*;

// you can write to stdout for debugging purposes, e.g.
// System.out.println("this is a debug message");

class Solution {
    public int solution(int[] A) {
        // write your code in Java SE 8
    }
}

Code: 02:11:50 UTC, cpp, autosave

1 2 3 4 5 6 7 8 9

// you can use includes, for example:
// #include <algorithm>

// you can write to stdout for debugging purposes, e.g.
// cout << "this is a debug message" << endl;

int solution(vector<int> &A) {
    // write your code in C++14 (g++ 6.2.0)
}

Code: 02:12:20 UTC, cpp, autosave

1 2 3 4 5 6 7 8 9 10 11 12 13

// you can use includes, for example:
// #include <algorithm>

// you can write to stdout for debugging purposes, e.g.
// cout << "this is a debug message" << endl;

int solution(vector<int> &A) {
    // write your code in C++14 (g++ 6.2.0)

    //i,j,k

    //store diff in vec
}

Code: 02:12:33 UTC, cpp, autosave

1 2 3 4 5 6 7 8 9 10 11 12 13 14

// you can use includes, for example:
// #include <algorithm>

// you can write to stdout for debugging purposes, e.g.
// cout << "this is a debug message" << endl;

int solution(vector<int> &A) {
    // write your code in C++14 (g++ 6.2.0)

    //i,j,k
    

    //store diff in vector and ret min element
}

Code: 02:13:04 UTC, cpp, autosave

1 2 3 4 5 6 7 8 9 10 11 12 13 14 15

// you can use includes, for example:
// #include <algorithm>

// you can write to stdout for debugging purposes, e.g.
// cout << "this is a debug message" << endl;

int solution(vector<int> &A) {
    // write your code in C++14 (g++ 6.2.0)

    //i,j,k
     int i = 0,j=1;
    //sum from i to j, sum for j to k

    //store diff in vector and ret min element
}

Code: 02:13:19 UTC, cpp, autosave

1 2 3 4 5 6 7 8 9 10 11 12 13 14 15

// you can use includes, for example:
// #include <algorithm>

// you can write to stdout for debugging purposes, e.g.
// cout << "this is a debug message" << endl;

int solution(vector<int> &A) {
    // write your code in C++14 (g++ 6.2.0)

    //i,j,k
     int i = 0,j=1;
    //sum from i to j, sum for j to k
       
    //store diff in vector and ret min element
}

Code: 02:16:55 UTC, cpp, autosave

1 2 3 4 5 6 7 8 9 10 11 12 13 14 15

// you can use includes, for example:
// #include <algorithm>

// you can write to stdout for debugging purposes, e.g.
// cout << "this is a debug message" << endl;

int solution(vector<int> &A) {
    // write your code in C++14 (g++ 6.2.0)

    //i,j,k
     int i = 0,j=1;
    //sum from i to j, sum for j to k
       1
    //store diff in vector and ret min element
}

Code: 02:17:06 UTC, cpp, autosave

1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16

// you can use includes, for example:
// #include <algorithm>

// you can write to stdout for debugging purposes, e.g.
// cout << "this is a debug message" << endl;

int solution(vector<int> &A) {
    // write your code in C++14 (g++ 6.2.0)

    //i,j,k
     int i = 0,j=1;
     int k = 
    //sum from i to j, sum for j to k
       
    //store diff in vector and ret min element
}

Code: 02:17:48 UTC, cpp, autosave

1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16

// you can use includes, for example:
// #include <algorithm>

// you can write to stdout for debugging purposes, e.g.
// cout << "this is a debug message" << endl;

int solution(vector<int> &A) {
    // write your code in C++14 (g++ 6.2.0)

    //i,j,k
     int i = 0,j=1;
     int k = A.
    //sum from i to j, sum for j to k
       
    //store diff in vector and ret min element
}

Code: 02:17:59 UTC, cpp, autosave

1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16

// you can use includes, for example:
// #include <algorithm>

// you can write to stdout for debugging purposes, e.g.
// cout << "this is a debug message" << endl;

int solution(vector<int> &A) {
    // write your code in C++14 (g++ 6.2.0)

    //i,j,k
     int i = 0,j=1;
     int k = A.size()-1;
    //sum from i to j, sum for j to k
       
    //store diff in vector and ret min element
}

Code: 02:18:27 UTC, cpp, autosave

1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17

// you can use includes, for example:
// #include <algorithm>

// you can write to stdout for debugging purposes, e.g.
// cout << "this is a debug message" << endl;

int solution(vector<int> &A) {
    // write your code in C++14 (g++ 6.2.0)

    //i,j,k
     int i = 0,j=1;
     int k = A.size()-1;
    //sum from i to j, sum for j to k
       for(j;j<=k;j++)

    //store diff in vector and ret min element
}

Code: 02:18:38 UTC, cpp, autosave

1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20

// you can use includes, for example:
// #include <algorithm>

// you can write to stdout for debugging purposes, e.g.
// cout << "this is a debug message" << endl;

int solution(vector<int> &A) {
    // write your code in C++14 (g++ 6.2.0)

    //i,j,k
     int i = 0,j=1;
     int k = A.size()-1;
    //sum from i to j, sum for j to k
       for(j;j<=k;j++)
       {
           
       }

    //store diff in vector and ret min element
}

Code: 02:19:33 UTC, cpp, autosave

1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20

// you can use includes, for example:
// #include <algorithm>

// you can write to stdout for debugging purposes, e.g.
// cout << "this is a debug message" << endl;

int solution(vector<int> &A) {
    // write your code in C++14 (g++ 6.2.0)

    //i,j,k
     int i = 0,j=1;
     int k = A.size()-1;
    //sum from i to j, sum for j to k
       for(j;j<=k;j++)
       {
           a
       }

    //store diff in vector and ret min element
}

Code: 02:19:50 UTC, cpp, autosave

1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20

// you can use includes, for example:
// #include <algorithm>

// you can write to stdout for debugging purposes, e.g.
// cout << "this is a debug message" << endl;

int solution(vector<int> &A) {
    // write your code in C++14 (g++ 6.2.0)

    //i,j,k
     int i = 0,j=1;
     int k = A.size()-1;
    //sum from i to j, sum for j to k
       for(j;j<=k;j++)
       {
           abs(A[j]-)
       }

    //store diff in vector and ret min element
}

Code: 02:20:01 UTC, cpp, autosave

1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20

// you can use includes, for example:
// #include <algorithm>

// you can write to stdout for debugging purposes, e.g.
// cout << "this is a debug message" << endl;

int solution(vector<int> &A) {
    // write your code in C++14 (g++ 6.2.0)

    //i,j,k
     int i = 0,j=1;
     int k = A.size()-1;
    //sum from i to j, sum for j to k
       for(j;j<=k;j++)
       {
           
       }

    //store diff in vector and ret min element
}

Code: 02:20:17 UTC, cpp, autosave

1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20

// you can use includes, for example:
// #include <algorithm>

// you can write to stdout for debugging purposes, e.g.
// cout << "this is a debug message" << endl;

int solution(vector<int> &A) {
    // write your code in C++14 (g++ 6.2.0)

    //i,j,k
     int i = 0,j=1;
     int k = A.size()-1;
    //sum from i to j, sum for j to k
       for(j;j<=k && ;j++)
       {
           
       }

    //store diff in vector and ret min element
}

Code: 02:21:15 UTC, cpp, autosave

1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20

// you can use includes, for example:
// #include <algorithm>

// you can write to stdout for debugging purposes, e.g.
// cout << "this is a debug message" << endl;

int solution(vector<int> &A) {
    // write your code in C++14 (g++ 6.2.0)

    //i,j,k
     int i = 0,j=1;
     int k = A.size()-1;
    //sum from i to j, sum for j to k
       for(j;j<=k;j++)
       {
           
       }

    //store diff in vector and ret min element
}

Code: 02:21:35 UTC, cpp, autosave

1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20

// you can use includes, for example:
// #include <algorithm>

// you can write to stdout for debugging purposes, e.g.
// cout << "this is a debug message" << endl;

int solution(vector<int> &A) {
    // write your code in C++14 (g++ 6.2.0)

    //i,j,k
     int i = 0,j=1;
     int k = A.size()-1;
    //sum from i to j, sum for j to k
       for(j;j<=k;j++)
       {
           abs()
       }

    //store diff in vector and ret min element
}

Code: 02:22:05 UTC, cpp, autosave

1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20

// you can use includes, for example:
// #include <algorithm>

// you can write to stdout for debugging purposes, e.g.
// cout << "this is a debug message" << endl;

int solution(vector<int> &A) {
    // write your code in C++14 (g++ 6.2.0)

    //i,j,k
     int i = 0,j=1;
     int k = A.size()-1;
    //sum from i to j, sum for j to k
       for(j;j<=k;j++)
       {
           abs(A[i]-accumulate(A.begin()+j, A))
       }

    //store diff in vector and ret min element
}

Code: 02:22:25 UTC, cpp, autosave

1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20

// you can use includes, for example:
// #include <algorithm>

// you can write to stdout for debugging purposes, e.g.
// cout << "this is a debug message" << endl;

int solution(vector<int> &A) {
    // write your code in C++14 (g++ 6.2.0)

    //i,j,k
     int i = 0,j=1;
     int k = A.size()-1;
    //sum from i to j, sum for j to k
       for(j;j<=k;j++)
       {
           abs(A[i]-accumulate(A.begin()+j, A.begin()+k))
       }

    //store diff in vector and ret min element
}

Code: 02:22:56 UTC, cpp, autosave

1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20

// you can use includes, for example:
// #include <algorithm>

// you can write to stdout for debugging purposes, e.g.
// cout << "this is a debug message" << endl;

int solution(vector<int> &A) {
    // write your code in C++14 (g++ 6.2.0)

    //i,j,k
     int i = 0,j=1;
     int k = A.size()-1;
    //sum from i to j, sum for j to k
       for(j;j<=k;j++)
       {
           abs(A[i]-accumulate(A.begin()+j, A.begin()+k));
       }

    //store diff in vector and ret min element
}

Code: 02:23:08 UTC, cpp, autosave

1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20

// you can use includes, for example:
// #include <algorithm>

// you can write to stdout for debugging purposes, e.g.
// cout << "this is a debug message" << endl;

int solution(vector<int> &A) {
    // write your code in C++14 (g++ 6.2.0)

    //i,j,k
     int i = 0,j=1;
     int k = A.size()-1;
    //sum from i to j, sum for j to k
       for(j;j<=k;j++)
       {
           int a = abs(A[i]-accumulate(A.begin()+j, A.begin()+k));
       }

    //store diff in vector and ret min element
}

Code: 02:23:18 UTC, cpp, autosave

1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21

// you can use includes, for example:
// #include <algorithm>

// you can write to stdout for debugging purposes, e.g.
// cout << "this is a debug message" << endl;

int solution(vector<int> &A) {
    // write your code in C++14 (g++ 6.2.0)

    //i,j,k
     int i = 0,j=1;
     int k = A.size()-1;
    //sum from i to j, sum for j to k
       for(j;j<=k;j++)
       {
           int a = abs(A[i]-accumulate(A.begin()+j, A.begin()+k));
           cout << a << endl;
       }

    //store diff in vector and ret min element
}

Code: 02:24:01 UTC, cpp, autosave

1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21

// you can use includes, for example:
// #include <algorithm>

// you can write to stdout for debugging purposes, e.g.
// cout << "this is a debug message" << endl;

int solution(vector<int> &A) {
    // write your code in C++14 (g++ 6.2.0)

    //i,j,k
     int i = 0,j=1;
     int k = A.size()-1;
    //sum from i to j, sum for j to k
       for(j;j<=k;j++)
       {
           int a = abs(-accumulate(A.begin()+j, A.begin()+k));
           cout << a << endl;
       }

    //store diff in vector and ret min element
}

Code: 02:24:13 UTC, cpp, autosave

1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21

// you can use includes, for example:
// #include <algorithm>

// you can write to stdout for debugging purposes, e.g.
// cout << "this is a debug message" << endl;

int solution(vector<int> &A) {
    // write your code in C++14 (g++ 6.2.0)

    //i,j,k
     int i = 0,j=1;
     int k = A.size()-1;
    //sum from i to j, sum for j to k
       for(j;j<=k;j++)
       {
           int a = abs(accumulate(A.begin()+j, A.begin()+k)-accumulate(A.begin()+j, A.begin()+k));
           cout << a << endl;
       }

    //store diff in vector and ret min element
}

Code: 02:25:05 UTC, cpp, autosave

1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21

// you can use includes, for example:
// #include <algorithm>

// you can write to stdout for debugging purposes, e.g.
// cout << "this is a debug message" << endl;

int solution(vector<int> &A) {
    // write your code in C++14 (g++ 6.2.0)

    //i,j,k
     int i = 0,j=1;
     int k = A.size()-1;
    //sum from i to j, sum for j to k
       for(j;j<=k;j++)
       {
           int a = abs(accumulate(A.begin()+, A.begin()+k)-accumulate(A.begin()+j, A.begin()+k));
           cout << a << endl;
       }

    //store diff in vector and ret min element
}

Code: 02:25:17 UTC, cpp, autosave

1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21

// you can use includes, for example:
// #include <algorithm>

// you can write to stdout for debugging purposes, e.g.
// cout << "this is a debug message" << endl;

int solution(vector<int> &A) {
    // write your code in C++14 (g++ 6.2.0)

    //i,j,k
     int i = 0,j=0;
     int k = A.size()-1;
    //sum from i to j, sum for j to k
       for(j;j<=k;j++)
       {
           int a = abs(accumulate(A.begin()+i, A.begin()+j)-accumulate(A.begin()+j, A.begin()+k));
           cout << a << endl;
       }

    //store diff in vector and ret min element
}

Code: 02:26:11 UTC, cpp, verify, result: Failed

1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21

// you can use includes, for example:
// #include <algorithm>

// you can write to stdout for debugging purposes, e.g.
// cout << "this is a debug message" << endl;

int solution(vector<int> &A) {
    // write your code in C++14 (g++ 6.2.0)

    //i,j,k
     int i = 0,j=0;
     int k = A.size()-1;
    //sum from i to j, sum for j to k
       for(j;j<=k;j++)
       {
           int a = abs(accumulate(A.begin()+i, A.begin()+j)-accumulate(A.begin()+j, A.begin()+k));
           cout << a << endl;
       }

    //store diff in vector and ret min element
}

The submission is being evaluated.

Code: 02:26:20 UTC, cpp, autosave

1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22

// you can use includes, for example:
// #include <algorithm>

// you can write to stdout for debugging purposes, e.g.
// cout << "this is a debug message" << endl;

int solution(vector<int> &A) {
    // write your code in C++14 (g++ 6.2.0)

    //i,j,k
     int i = 0,j=0;
     int k = A.size()-1;
    //sum from i to j, sum for j to k
       for(j;j<=k;j++)
       {
           int a = abs(accumulate(A.begin()+i, A.begin()+j)-accumulate(A.begin()+j, A.begin()+k));
           cout << a << endl;
       }

    //store diff in vector and ret min element
    ret
}

Code: 02:26:29 UTC, cpp, verify, result: Failed

1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22

// you can use includes, for example:
// #include <algorithm>

// you can write to stdout for debugging purposes, e.g.
// cout << "this is a debug message" << endl;

int solution(vector<int> &A) {
    // write your code in C++14 (g++ 6.2.0)

    //i,j,k
     int i = 0,j=0;
     int k = A.size()-1;
    //sum from i to j, sum for j to k
       for(j;j<=k;j++)
       {
           int a = abs(accumulate(A.begin()+i, A.begin()+j)-accumulate(A.begin()+j, A.begin()+k));
           cout << a << endl;
       }

    //store diff in vector and ret min element
    return 0;
}

The submission is being evaluated.

Code: 02:26:50 UTC, cpp, autosave

1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22

// you can use includes, for example:
 #include <algorithm>
#include <vector>
// you can write to stdout for debugging purposes, e.g.
// cout << "this is a debug message" << endl;

int solution(vector<int> &A) {
    // write your code in C++14 (g++ 6.2.0)

    //i,j,k
     int i = 0,j=0;
     int k = A.size()-1;
    //sum from i to j, sum for j to k
       for(j;j<=k;j++)
       {
           int a = abs(accumulate(A.begin()+i, A.begin()+j)-accumulate(A.begin()+j, A.begin()+k));
           cout << a << endl;
       }

    //store diff in vector and ret min element
    return 0;
}

Code: 02:27:15 UTC, cpp, autosave

1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22

// you can use includes, for example:
 #include <algorithm>
#include <vector>
// you can write to stdout for debugging purposes, e.g.
// cout << "this is a debug message" << endl;
using name
int solution(vector<int> &A) {
    // write your code in C++14 (g++ 6.2.0)

    //i,j,k
     int i = 0,j=0;
     int k = A.size()-1;
    //sum from i to j, sum for j to k
       for(j;j<=k;j++)
       {
           int a = abs(accumulate(A.begin()+i, A.begin()+j)-accumulate(A.begin()+j, A.begin()+k));
           cout << a << endl;
       }

    //store diff in vector and ret min element
    return 0;
}

Code: 02:27:24 UTC, cpp, verify, result: Failed

1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22

// you can use includes, for example:
 #include <algorithm>
#include <vector>
// you can write to stdout for debugging purposes, e.g.
// cout << "this is a debug message" << endl;
using namespace std;
int solution(vector<int> &A) {
    // write your code in C++14 (g++ 6.2.0)

    //i,j,k
     int i = 0,j=0;
     int k = A.size()-1;
    //sum from i to j, sum for j to k
       for(j;j<=k;j++)
       {
           int a = abs(accumulate(A.begin()+i, A.begin()+j)-accumulate(A.begin()+j, A.begin()+k));
           cout << a << endl;
       }

    //store diff in vector and ret min element
    return 0;
}

The submission is being evaluated.

Code: 02:28:05 UTC, cpp, autosave

1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23

// you can use includes, for example:
 #include <algorithm>
#include <vector>

// you can write to stdout for debugging purposes, e.g.
// cout << "this is a debug message" << endl;
using namespace std;
int solution(vector<int> &A) {
    // write your code in C++14 (g++ 6.2.0)

    //i,j,k
     int i = 0,j=0;
     int k = A.size()-1;
    //sum from i to j, sum for j to k
       for(j;j<=k;j++)
       {
           int a = abs(accumulate(A.begin()+i, A.begin()+j)-accumulate(A.begin()+j, A.begin()+k));
           cout << a << endl;
       }

    //store diff in vector and ret min element
    return 0;
}

Code: 02:28:07 UTC, cpp, verify, result: Failed

1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24

// you can use includes, for example:
 #include <algorithm>
#include <vector>
#include <numeric>

// you can write to stdout for debugging purposes, e.g.
// cout << "this is a debug message" << endl;
using namespace std;
int solution(vector<int> &A) {
    // write your code in C++14 (g++ 6.2.0)

    //i,j,k
     int i = 0,j=0;
     int k = A.size()-1;
    //sum from i to j, sum for j to k
       for(j;j<=k;j++)
       {
           int a = abs(accumulate(A.begin()+i, A.begin()+j)-accumulate(A.begin()+j, A.begin()+k));
           cout << a << endl;
       }

    //store diff in vector and ret min element
    return 0;
}

The submission is being evaluated.

Code: 02:29:04 UTC, cpp, autosave

1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24

// you can use includes, for example:
 #include <algorithm>
#include <vector>
#include <numeric>

// you can write to stdout for debugging purposes, e.g.
// cout << "this is a debug message" << endl;
using namespace std;
int solution(vector<int> &A) {
    // write your code in C++14 (g++ 6.2.0)

    //i,j,k
     int i = 0,
     int k = A.size()-1;
    //sum from i to j, sum for j to k
       for(j;j<=k;j++)
       {
           int a = abs(accumulate(A.begin()+i, A.begin()+j)-accumulate(A.begin()+j, A.begin()+k));
           cout << a << endl;
       }

    //store diff in vector and ret min element
    return 0;
}

Code: 02:29:13 UTC, cpp, verify, result: Failed

1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24

// you can use includes, for example:
 #include <algorithm>
#include <vector>
#include <numeric>

// you can write to stdout for debugging purposes, e.g.
// cout << "this is a debug message" << endl;
using namespace std;
int solution(vector<int> &A) {
    // write your code in C++14 (g++ 6.2.0)

    //i,j,k
     int i = 0;
     int k = A.size()-1;
    //sum from i to j, sum for j to k
       for(int j=0;j<=k;j++)
       {
           int a = abs(accumulate(A.begin()+i, A.begin()+j)-accumulate(A.begin()+j, A.begin()+k));
           cout << a << endl;
       }

    //store diff in vector and ret min element
    return 0;
}

The submission is being evaluated.

Code: 02:29:58 UTC, cpp, autosave

1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24

// you can use includes, for example:
 #include <algorithm>
#include <vector>
#include <numeric>

// you can write to stdout for debugging purposes, e.g.
// cout << "this is a debug message" << endl;
using namespace std;
int solution(vector<int> &A) {
    // write your code in C++14 (g++ 6.2.0)

    //i,j,k
     int i = 0;
     int k = A.size()-1;
    //sum from i to j, sum for j to k
       for(int j=0;j<=k;j++)
       {
           int a = abs(-accumulate(A.begin()+j, A.begin()+k));
           cout << a << endl;
       }

    //store diff in vector and ret min element
    return 0;
}

Code: 02:30:15 UTC, cpp, autosave

1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25

// you can use includes, for example:
 #include <algorithm>
#include <vector>
#include <numeric>

// you can write to stdout for debugging purposes, e.g.
// cout << "this is a debug message" << endl;
using namespace std;
int solution(vector<int> &A) {
    // write your code in C++14 (g++ 6.2.0)

    //i,j,k
     int i = 0;
     int k = A.size()-1;
    //sum from i to j, sum for j to k
       for(int j=0;j<=k;j++)
       {
           int sum1 = accumulate(A.begin()+i, A.begin()+j);
           int a = abs(-accumulate(A.begin()+j, A.begin()+k));
           cout << a << endl;
       }

    //store diff in vector and ret min element
    return 0;
}

Code: 02:30:25 UTC, cpp, autosave

1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25

// you can use includes, for example:
 #include <algorithm>
#include <vector>
#include <numeric>

// you can write to stdout for debugging purposes, e.g.
// cout << "this is a debug message" << endl;
using namespace std;
int solution(vector<int> &A) {
    // write your code in C++14 (g++ 6.2.0)

    //i,j,k
     int i = 0;
     int k = A.size()-1;
    //sum from i to j, sum for j to k
       for(int j=0;j<=k;j++)
       {
           int sum1 = saccumulate(A.begin()+i, A.begin()+j);
           int a = abs(-accumulate(A.begin()+j, A.begin()+k));
           cout << a << endl;
       }

    //store diff in vector and ret min element
    return 0;
}

Code: 02:30:36 UTC, cpp, autosave

1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25

// you can use includes, for example:
 #include <algorithm>
#include <vector>
#include <numeric>

// you can write to stdout for debugging purposes, e.g.
// cout << "this is a debug message" << endl;
using namespace std;
int solution(vector<int> &A) {
    // write your code in C++14 (g++ 6.2.0)

    //i,j,k
     int i = 0;
     int k = A.size()-1;
    //sum from i to j, sum for j to k
       for(int j=0;j<=k;j++)
       {
           int sum1 = std::accumulate(A.begin()+i, A.begin()+j);
           int a = abs(-accumulate(A.begin()+j, A.begin()+k));
           cout << a << endl;
       }

    //store diff in vector and ret min element
    return 0;
}

Code: 02:30:46 UTC, cpp, autosave

1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25

// you can use includes, for example:
 #include <algorithm>
#include <vector>
#include <numeric>

// you can write to stdout for debugging purposes, e.g.
// cout << "this is a debug message" << endl;
using namespace std;
int solution(vector<int> &A) {
    // write your code in C++14 (g++ 6.2.0)

    //i,j,k
     int i = 0;
     int k = A.size()-1;
    //sum from i to j, sum for j to k
       for(int j=0;j<=k;j++)
       {
           int sum1 = accumulate(A.begin()+i, A.begin()+j);
           int a = abs(-accumulate(A.begin()+j, A.begin()+k));
           cout << a << endl;
       }

    //store diff in vector and ret min element
    return 0;
}

Code: 02:31:05 UTC, cpp, autosave

1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26

// you can use includes, for example:
 #include <algorithm>
#include <vector>
#include <numeric>

// you can write to stdout for debugging purposes, e.g.
// cout << "this is a debug message" << endl;
using namespace std;
int solution(vector<int> &A) {
    // write your code in C++14 (g++ 6.2.0)

    //i,j,k
     int i = 0;
     int k = A.size()-1;
    //sum from i to j, sum for j to k
       for(int j=0;j<=k;j++)
       {
           int sum1 = accumulate(A.begin()+i, A.begin()+j);
           int sum2 = accumulate(A.begin()+j, A.begin()+k)
           int a = abs(sum1-sum2);
           cout << a << endl;
       }

    //store diff in vector and ret min element
    return 0;
}

Code: 02:31:21 UTC, cpp, autosave

1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26

// you can use includes, for example:
 #include <algorithm>
#include <vector>
#include <numeric>

// you can write to stdout for debugging purposes, e.g.
// cout << "this is a debug message" << endl;
using namespace std;
int solution(vector<int> &A) {
    // write your code in C++14 (g++ 6.2.0)

    //i,j,k
     int i = 0;
     int k = A.size()-1;
    //sum from i to j, sum for j to k
       for(int j=0;j<=k;j++)
       {
           int sum1 = accumulate(A.begin()+i, A.begin()+j);
           int sum2 = accumulate(A.begin()+(j+1), A.begin()+k);
           int a = abs(sum1-sum2);
           cout << a << endl;
       }

    //store diff in vector and ret min element
    return 0;
}

Code: 02:31:23 UTC, cpp, verify, result: Failed

1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26

// you can use includes, for example:
 #include <algorithm>
#include <vector>
#include <numeric>

// you can write to stdout for debugging purposes, e.g.
// cout << "this is a debug message" << endl;
using namespace std;
int solution(vector<int> &A) {
    // write your code in C++14 (g++ 6.2.0)

    //i,j,k
     int i = 0;
     int k = A.size()-1;
    //sum from i to j, sum for j to k
       for(int j=0;j<=k;j++)
       {
           int sum1 = accumulate(A.begin()+i, A.begin()+j);
           int sum2 = accumulate(A.begin()+(j+1), A.begin()+k);
           int a = abs(sum1-sum2);
           cout << a << endl;
       }

    //store diff in vector and ret min element
    return 0;
}

The submission is being evaluated.

Code: 02:32:41 UTC, cpp, autosave

1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26

// you can use includes, for example:
 #include <algorithm>
#include <vector>
#include <numeric>

// you can write to stdout for debugging purposes, e.g.
// cout << "this is a debug message" << endl;
using namespace std;
int solution(vector<int> &A) {
    // write your code in C++14 (g++ 6.2.0)

    //i,j,k
     int i = 0;
     int k = A.size()-1;
    //sum from i to j, sum for j to k
       for(int j=0;j<=k;j++)
       {
           int sum1 = accumulate(A.begin()+i, A.begin()+j,);
           int sum2 = accumulate(A.begin()+(j+1), A.begin()+k);
           int a = abs(sum1-sum2);
           cout << a << endl;
       }

    //store diff in vector and ret min element
    return 0;
}

Code: 02:32:51 UTC, cpp, autosave

1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26

// you can use includes, for example:
 #include <algorithm>
#include <vector>
#include <numeric>

// you can write to stdout for debugging purposes, e.g.
// cout << "this is a debug message" << endl;
using namespace std;
int solution(vector<int> &A) {
    // write your code in C++14 (g++ 6.2.0)

    //i,j,k
     int i = 0;
     int k = A.size()-1;
    //sum from i to j, sum for j to k
       for(int j=0;j<=k;j++)
       {
           int sum1 = accumulate(A.begin()+i, A.begin()+j,0);
           int sum2 = accumulate(A.begin()+(j+1), A.begin()+k,0);
           int a = abs(sum1-sum2);
           cout << a << endl;
       }

    //store diff in vector and ret min element
    return 0;
}

Code: 02:33:09 UTC, cpp, verify, result: Failed

1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26

// you can use includes, for example:
 #include <algorithm>
#include <vector>
#include <numeric>

// you can write to stdout for debugging purposes, e.g.
// cout << "this is a debug message" << endl;
using namespace std;
int solution(vector<int> &A) {
    // write your code in C++14 (g++ 6.2.0)

    //i,j,k
     int i = 0;
     int k = A.size()-1;
    //sum from i to j, sum for j to k
       for(int j=0;j<=k;j++)
       {
           int sum1 = accumulate(A.begin()+i, A.begin()+j,0);
           int sum2 = accumulate(A.begin()+(j+1), A.begin()+k,0);
           int a = abs(sum1-sum2);
           cout << a << endl;
       }

    //store diff in vector and ret min element
    return 0;
}

The submission is being evaluated.

Code: 02:33:30 UTC, cpp, autosave

1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26

// you can use includes, for example:
 #include <algorithm>
#include <vector>
#include <numeric>

// you can write to stdout for debugging purposes, e.g.
// cout << "this is a debug message" << endl;
using namespace std;
int solution(vector<int> &A) {
    // write your code in C++14 (g++ 6.2.0)

    //i,j,k
     int i = 0;
     int k = A.size()-1;
    //sum from i to j, sum for j to k
       for(int j=0;j<=k;j++)
       {
           int sum1 = accumulate(A.begin()+i, A.begin()+j,0);
           int sum2 = accumulate(A.begin()+(j), A.begin()+k,0);
           int a = abs(sum1-sum2);
           cout << a << endl;
       }

    //store diff in vector and ret min element
    return 0;
}

Code: 02:33:50 UTC, cpp, autosave

1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26

// you can use includes, for example:
 #include <algorithm>
#include <vector>
#include <numeric>

// you can write to stdout for debugging purposes, e.g.
// cout << "this is a debug message" << endl;
using namespace std;
int solution(vector<int> &A) {
    // write your code in C++14 (g++ 6.2.0)

    //i,j,k
     int i = 0;
     int k = A.size()-1;
    //sum from i to j, sum for j to k
       for(int j=0;j<=k;j++)
       {
           int sum1 = accumulate(A.begin()+i, A.begin()+j,0);
           int sum2 = accumulate(A.begin()+(j), A.begin()+k,0) - A[j];
           int a = abs(sum1-sum2);
           cout << a << endl;
       }

    //store diff in vector and ret min element
    return 0;
}

Code: 02:33:58 UTC, cpp, verify, result: Failed

1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26

// you can use includes, for example:
 #include <algorithm>
#include <vector>
#include <numeric>

// you can write to stdout for debugging purposes, e.g.
// cout << "this is a debug message" << endl;
using namespace std;
int solution(vector<int> &A) {
    // write your code in C++14 (g++ 6.2.0)

    //i,j,k
     int i = 0;
     int k = A.size()-1;
    //sum from i to j, sum for j to k
       for(int j=0;j<=k;j++)
       {
           int sum1 = accumulate(A.begin()+i, A.begin()+j,0);
           int sum2 = accumulate(A.begin()+(j), A.begin()+k,0) - A[j];
           int a = abs(sum1-sum2);
           cout << a << endl;
       }

    //store diff in vector and ret min element
    return 0;
}

The submission is being evaluated.

Code: 02:34:43 UTC, cpp, autosave

1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26

// you can use includes, for example:
 #include <algorithm>
#include <vector>
#include <numeric>

// you can write to stdout for debugging purposes, e.g.
// cout << "this is a debug message" << endl;
using namespace std;
int solution(vector<int> &A) {
    // write your code in C++14 (g++ 6.2.0)

    //i,j,k
     int i = 0;
     int k = A.size()-1;
    //sum from i to j, sum for j to k
       for(int j=0;j<=k;j++)
       {
           int sum1 = accumulate(A.begin()+i, A.begin()+j,0);
           int sum2 = accumulate(A.begin()+(j), A.begin()+k,0) - A[j;
           int a = abs(sum1-sum2);
           cout << a << endl;
       }

    //store diff in vector and ret min element
    return 0;
}

Code: 02:34:45 UTC, cpp, verify, result: Failed

1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26

// you can use includes, for example:
 #include <algorithm>
#include <vector>
#include <numeric>

// you can write to stdout for debugging purposes, e.g.
// cout << "this is a debug message" << endl;
using namespace std;
int solution(vector<int> &A) {
    // write your code in C++14 (g++ 6.2.0)

    //i,j,k
     int i = 0;
     int k = A.size()-1;
    //sum from i to j, sum for j to k
       for(int j=0;j<=k;j++)
       {
           int sum1 = accumulate(A.begin()+i, A.begin()+j,0);
           int sum2 = accumulate(A.begin()+(j), A.begin()+k,0);
           int a = abs(sum1-sum2);
           cout << a << endl;
       }

    //store diff in vector and ret min element
    return 0;
}

The submission is being evaluated.

Code: 02:36:00 UTC, cpp, autosave

1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26

// you can use includes, for example:
 #include <algorithm>
#include <vector>
#include <numeric>

// you can write to stdout for debugging purposes, e.g.
// cout << "this is a debug message" << endl;
using namespace std;
int solution(vector<int> &A) {
    // write your code in C++14 (g++ 6.2.0)

    //i,j,k
     int i,l = 0;
     int k = A.size()-1;
    //sum from i to j, sum for j to k
       for(int j=0;j<=k;j++)
       {
           int sum1 = accumulate(A.begin()+i, A.begin()+j,0);
           int sum2 = accumulate(A.begin()+(j), A.begin()+k,0);
           int a = abs(sum1-sum2);
           cout << a << endl;
       }

    //store diff in vector and ret min element
    return 0;
}

Code: 02:37:04 UTC, cpp, autosave

1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26

// you can use includes, for example:
 #include <algorithm>
#include <vector>
#include <numeric>

// you can write to stdout for debugging purposes, e.g.
// cout << "this is a debug message" << endl;
using namespace std;
int solution(vector<int> &A) {
    // write your code in C++14 (g++ 6.2.0)

    //i,j,k
     int i,l = 0;
     int k = A.size()-1;
    //sum from i to j, sum for j to k
       for(int j=0;j>=k;j++)
       {
           int sum1 = accumulate(A.begin()+i, A.begin()+j,0);
           int sum2 = accumulate(A.begin()+(j), A.begin()+k,0);
           int a = abs(sum1-sum2);
           cout << a << endl;
       }

    //store diff in vector and ret min element
    return 0;
}

Code: 02:37:44 UTC, cpp, autosave

1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26

// you can use includes, for example:
 #include <algorithm>
#include <vector>
#include <numeric>

// you can write to stdout for debugging purposes, e.g.
// cout << "this is a debug message" << endl;
using namespace std;
int solution(vector<int> &A) {
    // write your code in C++14 (g++ 6.2.0)

    //i,j,k
     int i,l = 0;
     int k = A.size()-1;
    //sum from i to j, sum for j to k
       for(int j=1;j>=k;j++)
       {
           int sum1 = accumulate(A.begin()+i, A.begin()+j,0);
           int sum2 = accumulate(A.begin()+(j), A.begin()+k,0);
           int a = abs(sum1-sum2);
           cout << a << endl;
       }

    //store diff in vector and ret min element
    return 0;
}

Code: 02:37:57 UTC, cpp, autosave

1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26

// you can use includes, for example:
 #include <algorithm>
#include <vector>
#include <numeric>

// you can write to stdout for debugging purposes, e.g.
// cout << "this is a debug message" << endl;
using namespace std;
int solution(vector<int> &A) {
    // write your code in C++14 (g++ 6.2.0)

    //i,j,k
     int i,l = 0;
     int k = A.size()-1;
    //sum from i to j, sum for j to k
       for(int j=1;j>=k ;j++)
       {
           int sum1 = accumulate(A.begin()+i, A.begin()+j,0);
           int sum2 = accumulate(A.begin()+(j), A.begin()+k,0);
           int a = abs(sum1-sum2);
           cout << a << endl;
       }

    //store diff in vector and ret min element
    return 0;
}

Code: 02:38:11 UTC, cpp, autosave

1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26

// you can use includes, for example:
 #include <algorithm>
#include <vector>
#include <numeric>

// you can write to stdout for debugging purposes, e.g.
// cout << "this is a debug message" << endl;
using namespace std;
int solution(vector<int> &A) {
    // write your code in C++14 (g++ 6.2.0)

    //i,j,k
     int i,l = 0;
     int k = A.size()-1;
    //sum from i to j, sum for j to k
       for(int j=1;j>=k && l<=k-1;j++)
       {
           int sum1 = accumulate(A.begin()+i, A.begin()+j,0);
           int sum2 = accumulate(A.begin()+(j), A.begin()+k,0);
           int a = abs(sum1-sum2);
           cout << a << endl;
       }

    //store diff in vector and ret min element
    return 0;
}

Code: 02:38:22 UTC, cpp, autosave

1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26 27

// you can use includes, for example:
 #include <algorithm>
#include <vector>
#include <numeric>

// you can write to stdout for debugging purposes, e.g.
// cout << "this is a debug message" << endl;
using namespace std;
int solution(vector<int> &A) {
    // write your code in C++14 (g++ 6.2.0)

    //i,j,k
     int i,l = 0;
     int k = A.size()-1;
    //sum from i to j, sum for j to k
       for(int j=1;j>=k && l<=k-1;j++)
       {
           int sum1 = accumulate(A.begin()+i, A.begin()+j,0);
           int sum2 = accumulate(A.begin()+(j), A.begin()+k,0);
           int a = abs(sum1-sum2);
           cout << a << endl;
           l++;
       }

    //store diff in vector and ret min element
    return 0;
}

Code: 02:38:37 UTC, cpp, autosave

1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26 27

// you can use includes, for example:
 #include <algorithm>
#include <vector>
#include <numeric>

// you can write to stdout for debugging purposes, e.g.
// cout << "this is a debug message" << endl;
using namespace std;
int solution(vector<int> &A) {
    // write your code in C++14 (g++ 6.2.0)

    //i,j,k
     int i,l = 0;
     int k = A.size()-1;
    //sum from i to j, sum for j to k
       for(int j=1;j>=k && l<=k-1;j++)
       {
           int sum1 = accumulate(A.begin()+i, A.begin()+l,0);
           int sum2 = accumulate(A.begin()+(j), A.begin()+k,0);
           int a = abs(sum1-sum2);
           cout << a << endl;
           l++;
       }

    //store diff in vector and ret min element
    return 0;
}

Code: 02:38:49 UTC, cpp, verify, result: Failed

1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26 27

// you can use includes, for example:
 #include <algorithm>
#include <vector>
#include <numeric>

// you can write to stdout for debugging purposes, e.g.
// cout << "this is a debug message" << endl;
using namespace std;
int solution(vector<int> &A) {
    // write your code in C++14 (g++ 6.2.0)

    //i,j,k
     int i,l = 0;
     int k = A.size()-1;
    //sum from i to j, sum for j to k
       for(int j=1;j>=k && l<=k-1;j++)
       {
           int sum1 = accumulate(A.begin()+i, A.begin()+l,0);
           int sum2 = accumulate(A.begin()+(j), A.begin()+k,0);
           int a = abs(sum1-sum2);
           cout << a << endl;
           l++;
       }

    //store diff in vector and ret min element
    return 0;
}

The submission is being evaluated.

Code: 02:39:10 UTC, cpp, autosave

1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26 27

// you can use includes, for example:
 #include <algorithm>
#include <vector>
#include <numeric>

// you can write to stdout for debugging purposes, e.g.
// cout << "this is a debug message" << endl;
using namespace std;
int solution(vector<int> &A) {
    // write your code in C++14 (g++ 6.2.0)

    //i,j,k
     int i,l = 0;
     int k = A.size()-1;
    //sum from i to j, sum for j to k
       for(int j=1;j>=k && l<=k-1;j++)
       {
           int sum1 = accumulate(A.begin()+i, A.begin()+l,0);l++;
           int sum2 = accumulate(A.begin()+(j), A.begin()+k,0);
           int a = abs(sum1-sum2);
           cout << a << endl;
           
       }

    //store diff in vector and ret min element
    return 0;
}

Code: 02:39:18 UTC, cpp, verify, result: Failed

1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26 27 28

// you can use includes, for example:
 #include <algorithm>
#include <vector>
#include <numeric>

// you can write to stdout for debugging purposes, e.g.
// cout << "this is a debug message" << endl;
using namespace std;
int solution(vector<int> &A) {
    // write your code in C++14 (g++ 6.2.0)

    //i,j,k
     int i,l = 0;
     int k = A.size()-1;
    //sum from i to j, sum for j to k
       for(int j=1;j>=k && l<=k-1;j++)
       {
           int sum1 = accumulate(A.begin()+i, A.begin()+l,0);
           l++;
           int sum2 = accumulate(A.begin()+(j), A.begin()+k,0);
           int a = abs(sum1-sum2);
           cout << a << endl;
           
       }

    //store diff in vector and ret min element
    return 0;
}

The submission is being evaluated.

Code: 02:39:41 UTC, cpp, autosave

1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26 27 28

// you can use includes, for example:
 #include <algorithm>
#include <vector>
#include <numeric>

// you can write to stdout for debugging purposes, e.g.
// cout << "this is a debug message" << endl;
using namespace std;
int solution(vector<int> &A) {
    // write your code in C++14 (g++ 6.2.0)

    //i,j,k
     int i,l = 0;
     int k = A.size()-1;
    //sum from i to j, sum for j to k
       for(int j=1;j>=k && l<=k-1;j++)
       {
           int sum1 = accumulate(A.begin()+i, A.begin()+l,0);
           int sum2 = accumulate(A.begin()+(j), A.begin()+k,0);
           int a = abs(sum1-sum2);
           cout << a << endl;
                      l++;

       }

    //store diff in vector and ret min element
    return 0;
}

Code: 02:39:41 UTC, cpp, verify, result: Failed

1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26 27 28

// you can use includes, for example:
 #include <algorithm>
#include <vector>
#include <numeric>

// you can write to stdout for debugging purposes, e.g.
// cout << "this is a debug message" << endl;
using namespace std;
int solution(vector<int> &A) {
    // write your code in C++14 (g++ 6.2.0)

    //i,j,k
     int i,l = 0;
     int k = A.size()-1;
    //sum from i to j, sum for j to k
       for(int j=1;j>=k && l<=k-1;j++)
       {
           int sum1 = accumulate(A.begin()+i, A.begin()+l,0);
           int sum2 = accumulate(A.begin()+(j), A.begin()+k,0);
           int a = abs(sum1-sum2);
           cout << a << endl;
                      l++;

       }

    //store diff in vector and ret min element
    return 0;
}

The submission is being evaluated.

Code: 02:40:21 UTC, cpp, autosave

1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26 27 28

// you can use includes, for example:
 #include <algorithm>
#include <vector>
#include <numeric>

// you can write to stdout for debugging purposes, e.g.
// cout << "this is a debug message" << endl;
using namespace std;
int solution(vector<int> &A) {
    // write your code in C++14 (g++ 6.2.0)

    //i,j,k
     int i,l = 0;
     int k = A.size();
    //sum from i to j, sum for j to k
       for(int j=1;j>=k && l<=k-1;j++)
       {
           int sum1 = accumulate(A.begin()+i, A.begin()+l,0);
           int sum2 = accumulate(A.begin()+(j), A.begin()+k,0);
           int a = abs(sum1-sum2);
           cout << a << endl;
                      l++;

       }

    //store diff in vector and ret min element
    return 0;
}

Code: 02:40:31 UTC, cpp, autosave

1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26 27 28

// you can use includes, for example:
 #include <algorithm>
#include <vector>
#include <numeric>

// you can write to stdout for debugging purposes, e.g.
// cout << "this is a debug message" << endl;
using namespace std;
int solution(vector<int> &A) {
    // write your code in C++14 (g++ 6.2.0)

    //i,j,k
     int i, = 0;
     int k = A.size();
    //sum from i to j, sum for j to k
       for(int j=1;j>=k && l<=k-1;j++)
       {
           int sum1 = accumulate(A.begin()+i, A.begin()+l,0);
           int sum2 = accumulate(A.begin()+(j), A.begin()+k,0);
           int a = abs(sum1-sum2);
           cout << a << endl;
                      l++;

       }

    //store diff in vector and ret min element
    return 0;
}

Code: 02:40:41 UTC, cpp, autosave

1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26 27 28

// you can use includes, for example:
 #include <algorithm>
#include <vector>
#include <numeric>

// you can write to stdout for debugging purposes, e.g.
// cout << "this is a debug message" << endl;
using namespace std;
int solution(vector<int> &A) {
    // write your code in C++14 (g++ 6.2.0)

    //i,j,k
     int i = 0;
     int k = A.size();
    //sum from i to j, sum for j to k
       for(int j=1;j>=k && l<=k-1;j++)
       {
           int sum1 = accumulate(A.begin()+i, A.begin()+l,0);
           int sum2 = accumulate(A.begin()+(j), A.begin()+k,0);
           int a = abs(sum1-sum2);
           cout << a << endl;
                      l++;

       }

    //store diff in vector and ret min element
    return 0;
}

Code: 02:40:53 UTC, cpp, autosave

1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26 27 28

// you can use includes, for example:
 #include <algorithm>
#include <vector>
#include <numeric>

// you can write to stdout for debugging purposes, e.g.
// cout << "this is a debug message" << endl;
using namespace std;
int solution(vector<int> &A) {
    // write your code in C++14 (g++ 6.2.0)

    //i,j,k
     int i = 0;
     int k = A.size();
    //sum from i to j, sum for j to k
       for(int j=1;j<=k;j++)
       {
           int sum1 = accumulate(A.begin()+i, A.begin()+l,0);
           int sum2 = accumulate(A.begin()+(j), A.begin()+k,0);
           int a = abs(sum1-sum2);
           cout << a << endl;
                      l++;

       }

    //store diff in vector and ret min element
    return 0;
}

Code: 02:41:05 UTC, cpp, autosave

1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26 27 28

// you can use includes, for example:
 #include <algorithm>
#include <vector>
#include <numeric>

// you can write to stdout for debugging purposes, e.g.
// cout << "this is a debug message" << endl;
using namespace std;
int solution(vector<int> &A) {
    // write your code in C++14 (g++ 6.2.0)

    //i,j,k
     int i = 0;
     int k = A.size();
    //sum from i to j, sum for j to k
       for(int j=1;j<=k;j++)
       {
           int sum1 = accumulate(A.begin()+i, A.begin()+j,0);
           int sum2 = accumulate(A.begin()+(j+1), A.begin()+k,0);
           int a = abs(sum1-sum2);
           cout << a << endl;
                      l++;

       }

    //store diff in vector and ret min element
    return 0;
}

Code: 02:41:16 UTC, cpp, autosave

1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26 27 28

// you can use includes, for example:
 #include <algorithm>
#include <vector>
#include <numeric>

// you can write to stdout for debugging purposes, e.g.
// cout << "this is a debug message" << endl;
using namespace std;
int solution(vector<int> &A) {
    // write your code in C++14 (g++ 6.2.0)

    //i,j,k
     int i = 0;
     int k = A.size();
    //sum from i to j, sum for j to k
       for(int j=1;j<=k;j++)
       {
           int sum1 = accumulate(A.begin()+i, A.begin()+j,0);
           int sum2 = accumulate(A.begin()+(j+1), A.begin()+k-1,0);
           int a = abs(sum1-sum2);
           cout << a << endl;
                      l++;

       }

    //store diff in vector and ret min element
    return 0;
}

Code: 02:41:26 UTC, cpp, verify, result: Failed

1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26 27 28

// you can use includes, for example:
 #include <algorithm>
#include <vector>
#include <numeric>

// you can write to stdout for debugging purposes, e.g.
// cout << "this is a debug message" << endl;
using namespace std;
int solution(vector<int> &A) {
    // write your code in C++14 (g++ 6.2.0)

    //i,j,k
     int i = 0;
     int k = A.size();
    //sum from i to j, sum for j to k
       for(int j=1;j<=k;j++)
       {
           int sum1 = accumulate(A.begin()+i, A.begin()+j,0);
           int sum2 = accumulate(A.begin()+(j+1), A.begin()+k-1,0);
           int a = abs(sum1-sum2);
           cout << a << endl;
                    

       }

    //store diff in vector and ret min element
    return 0;
}

The submission is being evaluated.

Code: 02:41:41 UTC, cpp, autosave

1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26 27 28

// you can use includes, for example:
 #include <algorithm>
#include <vector>
#include <numeric>

// you can write to stdout for debugging purposes, e.g.
// cout << "this is a debug message" << endl;
using namespace std;
int solution(vector<int> &A) {
    // write your code in C++14 (g++ 6.2.0)

    //i,j,k
     int i = 0;
     int k = A.size()-1;
    //sum from i to j, sum for j to k
       for(int j=1;j<=k;j++)
       {
           int sum1 = accumulate(A.begin()+i, A.begin()+j,0);
           int sum2 = accumulate(A.begin()+(j+1), A.begin()+k-1,0);
           int a = abs(sum1-sum2);
           cout << a << endl;
                    

       }

    //store diff in vector and ret min element
    return 0;
}

Code: 02:45:41 UTC, cpp, autosave

1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26 27 28

// you can use includes, for example:
 #include <algorithm>
#include <vector>
#include <numeric>

// you can write to stdout for debugging purposes, e.g.
// cout << "this is a debug message" << endl;
using namespace std;
int solution(vector<int> &A) {
    // write your code in C++14 (g++ 6.2.0)

    //i,j,k
     int i = 0;
     int k = A.size();
    //sum from i to j, sum for j to k
       for(int j=1;j<=k;j++)
       {
           int sum1 = accumulate(A.begin()+i, A.begin()+j,0);
           int sum2 = accumulate(A.begin()+(j+1), A.begin()+k-1,0);
           int a = abs(sum1-sum2);
           cout << a << endl;
                    

       }

    //store diff in vector and ret min element
    return 0;
}

Code: 02:46:00 UTC, cpp, autosave

1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26 27 28

// you can use includes, for example:
 #include <algorithm>
#include <vector>
#include <numeric>

// you can write to stdout for debugging purposes, e.g.
// cout << "this is a debug message" << endl;
using namespace std;
int solution(vector<int> &A) {
    // write your code in C++14 (g++ 6.2.0)

    //i,j,k
     int i = 0;
     int k = A.size();
    //sum from i to j, sum for j to k
       for(int j=1;j<=k;j++)
       {
           int sum1 = accumulate(A.begin()+i, A.begin()+j,0);
           int sum2 = accumulate(A.begin()+(j+1), A.begin()+k,0);
           int a = abs(sum1-sum2);
           cout << a << endl;
                    

       }

    //store diff in vector and ret min element
    return 0;
}

Code: 02:46:30 UTC, cpp, autosave

1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26 27 28

// you can use includes, for example:
 #include <algorithm>
#include <vector>
#include <numeric>

// you can write to stdout for debugging purposes, e.g.
// cout << "this is a debug message" << endl;
using namespace std;
int solution(vector<int> &A) {
    // write your code in C++14 (g++ 6.2.0)

    //i,j,k
     int i = 0;
     int k = A.size();
    //sum from i to j, sum for j to k
       for(int j=1;j<=k;j++)
       {
           int sum1 = accumulate(A.begin()+i, A.begin()+j,0);
           int sum2 = accumulate(A.begin()+(j, A.begin()+k,0);
           int a = abs(sum1-sum2);
           cout << a << endl;
                    

       }

    //store diff in vector and ret min element
    return 0;
}

Code: 02:46:44 UTC, cpp, autosave

1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26 27 28

// you can use includes, for example:
 #include <algorithm>
#include <vector>
#include <numeric>

// you can write to stdout for debugging purposes, e.g.
// cout << "this is a debug message" << endl;
using namespace std;
int solution(vector<int> &A) {
    // write your code in C++14 (g++ 6.2.0)

    //i,j,k
     int i = 0;
     int k = A.size();
    //sum from i to j, sum for j to k
       for(int j=1;j<=k;j++)
       {
           int sum1 = accumulate(A.begin()+i, A.begin()+j,0);
           int sum2 = accumulate(A.begin()+(j+1), A.begin()+k,0);
           int a = abs(sum1-sum2);
           cout << a << endl;
                    

       }

    //store diff in vector and ret min element
    return 0;
}

Code: 02:47:33 UTC, cpp, autosave

1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26 27 28

// you can use includes, for example:
 #include <algorithm>
#include <vector>
#include <numeric>

// you can write to stdout for debugging purposes, e.g.
// cout << "this is a debug message" << endl;
using namespace std;
int solution(vector<int> &A) {
    // write your code in C++14 (g++ 6.2.0)

    //i,j,k
     int i = 0;
     int k = A.size();
    //sum from i to j, sum for j to k
       for(int j=1;j.=k;j++)
       {
           int sum1 = accumulate(A.begin()+i, A.begin()+j,0);
           int sum2 = accumulate(A.begin()+(j+1), A.begin()+k,0);
           int a = abs(sum1-sum2);
           cout << a << endl;
                    

       }

    //store diff in vector and ret min element
    return 0;
}

Code: 02:47:41 UTC, cpp, verify, result: Failed

1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26 27 28

// you can use includes, for example:
 #include <algorithm>
#include <vector>
#include <numeric>

// you can write to stdout for debugging purposes, e.g.
// cout << "this is a debug message" << endl;
using namespace std;
int solution(vector<int> &A) {
    // write your code in C++14 (g++ 6.2.0)

    //i,j,k
     int i = 0;
     int k = A.size();
    //sum from i to j, sum for j to k
       for(int j=1;j>=k;j++)
       {
           int sum1 = accumulate(A.begin()+i, A.begin()+j,0);
           int sum2 = accumulate(A.begin()+(j+1), A.begin()+k,0);
           int a = abs(sum1-sum2);
           cout << a << endl;
                    

       }

    //store diff in vector and ret min element
    return 0;
}

The submission is being evaluated.

Code: 02:48:12 UTC, cpp, autosave

1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26 27 28

// you can use includes, for example:
 #include <algorithm>
#include <vector>
#include <numeric>

// you can write to stdout for debugging purposes, e.g.
// cout << "this is a debug message" << endl;
using namespace std;
int solution(vector<int> &A) {
    // write your code in C++14 (g++ 6.2.0)

    //i,j,k
     int i = 0;
     int k = A.size()-1;
    //sum from i to j, sum for j to k
       for(int j=1;j>=k;j++)
       {
           int sum1 = accumulate(A.begin()+i, A.begin()+j,0);
           int sum2 = accumulate(A.begin()+(j+1), A.begin()+k,0);
           int a = abs(sum1-sum2);
           cout << a << endl;
                    

       }

    //store diff in vector and ret min element
    return 0;
}

Code: 02:48:13 UTC, cpp, verify, result: Failed

1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26 27 28

// you can use includes, for example:
 #include <algorithm>
#include <vector>
#include <numeric>

// you can write to stdout for debugging purposes, e.g.
// cout << "this is a debug message" << endl;
using namespace std;
int solution(vector<int> &A) {
    // write your code in C++14 (g++ 6.2.0)

    //i,j,k
     int i = 0;
     int k = A.size()-1;
    //sum from i to j, sum for j to k
       for(int j=1;j>=k;j++)
       {
           int sum1 = accumulate(A.begin()+i, A.begin()+j,0);
           int sum2 = accumulate(A.begin()+(j+1), A.begin()+k,0);
           int a = abs(sum1-sum2);
           cout << a << endl;
                    

       }

    //store diff in vector and ret min element
    return 0;
}

The submission is being evaluated.

Code: 02:48:51 UTC, cpp, autosave

1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26 27 28

// you can use includes, for example:
 #include <algorithm>
#include <vector>
#include <numeric>

// you can write to stdout for debugging purposes, e.g.
// cout << "this is a debug message" << endl;
using namespace std;
int solution(vector<int> &A) {
    // write your code in C++14 (g++ 6.2.0)

    //i,j,k
     int i = 0;
     int k = A.size()-1;
    //sum from i to j, sum for j to k
    //    for(int j=1;j>=k;j++)
    //    {
    //        int sum1 = accumulate(A.begin()+i, A.begin()+j,0);
    //        int sum2 = accumulate(A.begin()+(j+1), A.begin()+k,0);
    //        int a = abs(sum1-sum2);
    //        cout << a << endl;
                    

    //    }

    //store diff in vector and ret min element
    return 0;
}

Code: 02:49:02 UTC, cpp, autosave

1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26 27 28 29

// you can use includes, for example:
 #include <algorithm>
#include <vector>
#include <numeric>

// you can write to stdout for debugging purposes, e.g.
// cout << "this is a debug message" << endl;
using namespace std;
int solution(vector<int> &A) {
    // write your code in C++14 (g++ 6.2.0)

    //i,j,k
     int i = 0;
     int k = A.size()-1;
    //sum from i to j, sum for j to k
    //    for(int j=1;j>=k;j++)
    //    {
    //        int sum1 = accumulate(A.begin()+i, A.begin()+j,0);
    //        int sum2 = accumulate(A.begin()+(j+1), A.begin()+k,0);
    //        int a = abs(sum1-sum2);
    //        cout << a << endl;
                    

    //    }
    accumulate(A.begin()+i, A.begin()+j,0);

    //store diff in vector and ret min element
    return 0;
}

Code: 02:49:19 UTC, cpp, verify, result: Failed

1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26 27 28 29

// you can use includes, for example:
 #include <algorithm>
#include <vector>
#include <numeric>

// you can write to stdout for debugging purposes, e.g.
// cout << "this is a debug message" << endl;
using namespace std;
int solution(vector<int> &A) {
    // write your code in C++14 (g++ 6.2.0)

    //i,j,k
     int i = 0;
     int k = A.size()-1;
    //sum from i to j, sum for j to k
    //    for(int j=1;j>=k;j++)
    //    {
    //        int sum1 = accumulate(A.begin()+i, A.begin()+j,0);
    //        int sum2 = accumulate(A.begin()+(j+1), A.begin()+k,0);
    //        int a = abs(sum1-sum2);
    //        cout << a << endl;
                    

    //    }
    cout << accumulate(A.begin()+4, A.begin()+4,0);

    //store diff in vector and ret min element
    return 0;
}

The submission is being evaluated.

Code: 02:49:29 UTC, cpp, autosave

1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26 27 28

// you can use includes, for example:
 #include <algorithm>
#include <vector>
#include <numeric>

// you can write to stdout for debugging purposes, e.g.
// cout << "this is a debug message" << endl;
using namespace std;
int solution(vector<int> &A) {
    // write your code in C++14 (g++ 6.2.0)

    //i,j,k
     int i = 0;
     int k = A.size()-1;
    //sum from i to j, sum for j to k
    //    for(int j=1;j>=k;j++)
    //    {
    //        int sum1 = accumulate(A.begin()+i, A.begin()+j,0);
    //        int sum2 = accumulate(A.begin()+(j+1), A.begin()+k,0);
    //        int a = abs(sum1-sum2);
    //        cout << a << endl;
                    

    //    }

    //store diff in vector and ret min element
    return 0;
}

Code: 02:49:40 UTC, cpp, autosave

1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26 27 28

// you can use includes, for example:
 #include <algorithm>
#include <vector>
#include <numeric>

// you can write to stdout for debugging purposes, e.g.
// cout << "this is a debug message" << endl;
using namespace std;
int solution(vector<int> &A) {
    // write your code in C++14 (g++ 6.2.0)

    //i,j,k
     int i = 0;
     int k = A.size()-1;
    //sum from i to j, sum for j to k
       for(int j=1;j>=k;j++)
       {
           int sum1 = accumulate(A.begin()+i, A.begin()+j,0);
           int sum2 = accumulate(A.begin()+(j+1), A.begin()+k,0);
           int a = abs(sum1-sum2);
           cout << a << endl;
                    

       }

    //store diff in vector and ret min element
    return 0;
}

Code: 02:51:10 UTC, cpp, autosave

1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26 27 28 29

// you can use includes, for example:
 #include <algorithm>
#include <vector>
#include <numeric>

// you can write to stdout for debugging purposes, e.g.
// cout << "this is a debug message" << endl;
using namespace std;
int solution(vector<int> &A) {
    // write your code in C++14 (g++ 6.2.0)

    //i,j,k
     int i = 0;
     int 
     int k = A.size()-1;
    //sum from i to j, sum for j to k
       for(int j=1;j>=k;j++)
       {
           int sum1 = accumulate(A.begin()+i, A.begin()+j,0);
           int sum2 = accumulate(A.begin()+(j+1), A.begin()+k,0);
           int a = abs(sum1-sum2);
           cout << a << endl;
                    

       }

    //store diff in vector and ret min element
    return 0;
}

Code: 02:51:29 UTC, cpp, autosave

1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26 27 28 29

// you can use includes, for example:
 #include <algorithm>
#include <vector>
#include <numeric>

// you can write to stdout for debugging purposes, e.g.
// cout << "this is a debug message" << endl;
using namespace std;
int solution(vector<int> &A) {
    // write your code in C++14 (g++ 6.2.0)

    //i,j,k
     int i = 0;
     int j = 1;
     int k = A.size()-1;
    //sum from i to j, sum for j to k
       while(j!=k)
       {
           int sum1 = accumulate(A.begin()+i, A.begin()+j,0);
           int sum2 = accumulate(A.begin()+(j+1), A.begin()+k,0);
           int a = abs(sum1-sum2);
           cout << a << endl;
                    

       }

    //store diff in vector and ret min element
    return 0;
}

Code: 02:51:40 UTC, cpp, autosave

1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26 27 28 29 30

// you can use includes, for example:
 #include <algorithm>
#include <vector>
#include <numeric>

// you can write to stdout for debugging purposes, e.g.
// cout << "this is a debug message" << endl;
using namespace std;
int solution(vector<int> &A) {
    // write your code in C++14 (g++ 6.2.0)

    //i,j,k
     int i = 0;
     int j = 1;
     int k = A.size()-1;
    //sum from i to j, sum for j to k
       while(j!=k)
       {
           int sum1 = accumulate(A.begin()+i, A.begin()+j,0);
           int sum2 = accumulate(A.begin()+(j+1), A.begin()+k,0);
           int a = abs(sum1-sum2);
           cout << a << endl;
           j++;
                    

       }

    //store diff in vector and ret min element
    return 0;
}

Code: 02:51:51 UTC, cpp, autosave

1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26 27 28 29 30

// you can use includes, for example:
 #include <algorithm>
#include <vector>
#include <numeric>

// you can write to stdout for debugging purposes, e.g.
// cout << "this is a debug message" << endl;
using namespace std;
int solution(vector<int> &A) {
    // write your code in C++14 (g++ 6.2.0)

    //i,j,k
     int i = 0;
     int j = 1;
     int k = A.size()-1;
    //sum from i to j, sum for j to k
       while(j!=k)
       {
           int sum1 = accumulate(A.begin()+i, A.begin()+j,0);
           int sum2 = accumulate(A.begin()+(j), A.begin()+k,0);
           int a = abs(sum1-sum2);
           cout << a << endl;
           j++;
                    

       }

    //store diff in vector and ret min element
    return 0;
}

Code: 02:52:20 UTC, cpp, autosave

1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26 27 28 29 30

// you can use includes, for example:
 #include <algorithm>
#include <vector>
#include <numeric>

// you can write to stdout for debugging purposes, e.g.
// cout << "this is a debug message" << endl;
using namespace std;
int solution(vector<int> &A) {
    // write your code in C++14 (g++ 6.2.0)

    //i,j,k
     int i = 0;
     int j = 0;
     int k = A.size()-1;
    //sum from i to j, sum for j to k
       while(j!=k)
       {
           int sum1 = accumulate(A.begin()+i, A.begin()+j,0);
           int sum2 = accumulate(A.begin()+(j), A.begin()+k,0);
           int a = abs(sum1-sum2);
           cout << a << endl;
           j++;
                    

       }

    //store diff in vector and ret min element
    return 0;
}

Code: 02:54:15 UTC, cpp, autosave

1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26 27 28 29 30 31

// you can use includes, for example:
 #include <algorithm>
#include <vector>
#include <numeric>

// you can write to stdout for debugging purposes, e.g.
// cout << "this is a debug message" << endl;
using namespace std;
int solution(vector<int> &A) {
    // write your code in C++14 (g++ 6.2.0)

    //i,j,k
     int i = 0;
     int j = 0;
     int k = A.size()-1;
    //sum from i to j, sum for j to k
       while(j!=k)
       {
           
           int sum1 = accumulate(A.begin()+i, A.begin()+j,0);
           int sum2 = accumulate(A.begin()+(j), A.begin()+k,0);
           int a = abs(sum1-sum2);
           cout << a << endl;
           j++;
                    

       }

    //store diff in vector and ret min element
    return 0;
}

Code: 02:54:25 UTC, cpp, autosave

1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26 27 28 29 30 31

// you can use includes, for example:
 #include <algorithm>
#include <vector>
#include <numeric>

// you can write to stdout for debugging purposes, e.g.
// cout << "this is a debug message" << endl;
using namespace std;
int solution(vector<int> &A) {
    // write your code in C++14 (g++ 6.2.0)

    //i,j,k
     int i = 0;
     int j = 1;
     int k = A.size()-1;
    //sum from i to j, sum for j to k
       while(j!=k)
       {

           int sum1 = accumulate(A.begin()+i, A.begin()+j,0);
           int sum2 = accumulate(A.begin()+(j), A.begin()+k,0);
           int a = abs(sum1-sum2);
           cout << a << endl;
           j++;
                    

       }

    //store diff in vector and ret min element
    return 0;
}

Code: 02:54:46 UTC, cpp, autosave

1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26 27 28 29 30 31 32 33 34

// you can use includes, for example:
 #include <algorithm>
#include <vector>
#include <numeric>

// you can write to stdout for debugging purposes, e.g.
// cout << "this is a debug message" << endl;
using namespace std;
int solution(vector<int> &A) {
    // write your code in C++14 (g++ 6.2.0)

    //i,j,k
     int i = 0;
     int j = 1;
     int k = A.size()-1;
    //sum from i to j, sum for j to k
       while(j!=k)
       {
           if(i==0 && j==1)
           {
               
           }
           int sum1 = accumulate(A.begin()+i, A.begin()+j,0);
           int sum2 = accumulate(A.begin()+(j), A.begin()+k,0);
           int a = abs(sum1-sum2);
           cout << a << endl;
           j++;
                    

       }

    //store diff in vector and ret min element
    return 0;
}

Code: 02:54:57 UTC, cpp, autosave

1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26 27 28 29 30 31 32 33 34

// you can use includes, for example:
 #include <algorithm>
#include <vector>
#include <numeric>

// you can write to stdout for debugging purposes, e.g.
// cout << "this is a debug message" << endl;
using namespace std;
int solution(vector<int> &A) {
    // write your code in C++14 (g++ 6.2.0)

    //i,j,k
     int i = 0;
     int j = 1;
     int k = A.size()-1;
    //sum from i to j, sum for j to k
       while(j!=k)
       {
           if(i==0 && j==1)
           {
            int sum1 = accumulate(A.begin()+i, A.begin()+j,0);
           }
           int sum1 = accumulate(A.begin()+i, A.begin()+j,0);
           int sum2 = accumulate(A.begin()+(j), A.begin()+k,0);
           int a = abs(sum1-sum2);
           cout << a << endl;
           j++;
                    

       }

    //store diff in vector and ret min element
    return 0;
}

Code: 02:55:16 UTC, cpp, autosave

1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26 27 28 29 30 31 32 33 34

// you can use includes, for example:
 #include <algorithm>
#include <vector>
#include <numeric>

// you can write to stdout for debugging purposes, e.g.
// cout << "this is a debug message" << endl;
using namespace std;
int solution(vector<int> &A) {
    // write your code in C++14 (g++ 6.2.0)

    //i,j,k
     int i = 0;
     int j = 1;
     int k = A.size()-1;
    //sum from i to j, sum for j to k
       while(j!=k)
       {
           if(i==0 && j==1)
           {
            int sum1 = accumulate(A[0], A.begin()+j,0);
           }
           int sum1 = accumulate(A.begin()+i, A.begin()+j,0);
           int sum2 = accumulate(A.begin()+(j), A.begin()+k,0);
           int a = abs(sum1-sum2);
           cout << a << endl;
           j++;
                    

       }

    //store diff in vector and ret min element
    return 0;
}

Code: 02:56:20 UTC, cpp, autosave

1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26 27 28 29 30 31 32 33 34

// you can use includes, for example:
 #include <algorithm>
#include <vector>
#include <numeric>

// you can write to stdout for debugging purposes, e.g.
// cout << "this is a debug message" << endl;
using namespace std;
int solution(vector<int> &A) {
    // write your code in C++14 (g++ 6.2.0)

    //i,j,k
     int i = 0;
     int j = 1;
     int k = A.size()-1;
    //sum from i to j, sum for j to k
       while(j!=k)
       {
           if(i==0 && j==1)
           {
            int sum1 = a[0]
           }
           int sum1 = accumulate(A.begin()+i, A.begin()+j,0);
           int sum2 = accumulate(A.begin()+(j), A.begin()+k,0);
           int a = abs(sum1-sum2);
           cout << a << endl;
           j++;
                    

       }

    //store diff in vector and ret min element
    return 0;
}

Code: 02:56:30 UTC, cpp, autosave

1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26 27 28 29 30 31 32 33 34

// you can use includes, for example:
 #include <algorithm>
#include <vector>
#include <numeric>

// you can write to stdout for debugging purposes, e.g.
// cout << "this is a debug message" << endl;
using namespace std;
int solution(vector<int> &A) {
    // write your code in C++14 (g++ 6.2.0)

    //i,j,k
     int i = 0;
     int j = 1;
     int k = A.size()-1;
    //sum from i to j, sum for j to k
       while(j!=k)
       {
           if(i==0 && j==1)
           {
            int sum1 = A[0];
           }
           int sum1 = accumulate(A.begin()+i, A.begin()+j,0);
           int sum2 = accumulate(A.begin()+(j), A.begin()+k,0);
           int a = abs(sum1-sum2);
           cout << a << endl;
           j++;
                    

       }

    //store diff in vector and ret min element
    return 0;
}

Code: 02:57:01 UTC, cpp, autosave

1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26 27 28 29 30 31 32 33 34 35 36 37

// you can use includes, for example:
 #include <algorithm>
#include <vector>
#include <numeric>

// you can write to stdout for debugging purposes, e.g.
// cout << "this is a debug message" << endl;
using namespace std;
int solution(vector<int> &A) {
    // write your code in C++14 (g++ 6.2.0)

    //i,j,k
     int i = 0;
     int j = 1;
     int k = A.size()-1;
    //sum from i to j, sum for j to k
       while(j!=k)
       {
           if(i==0 && j==1)
           {
            int sum1 = A[0];
           }
           else{
               
           }
           int sum1 = accumulate(A.begin()+i, A.begin()+j,0);
           int sum2 = accumulate(A.begin()+(j), A.begin()+k,0);
           int a = abs(sum1-sum2);
           cout << a << endl;
           j++;
                    

       }

    //store diff in vector and ret min element
    return 0;
}

Code: 02:57:13 UTC, cpp, autosave

1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26 27 28 29 30 31 32 33 34 35 36 37

// you can use includes, for example:
 #include <algorithm>
#include <vector>
#include <numeric>

// you can write to stdout for debugging purposes, e.g.
// cout << "this is a debug message" << endl;
using namespace std;
int solution(vector<int> &A) {
    // write your code in C++14 (g++ 6.2.0)

    //i,j,k
     int i = 0;
     int j = 1;
     int k = A.size()-1;
    //sum from i to j, sum for j to k
       while(j!=k)
       {
           if(i==0 && j==1)
           {
            int sum1 = A[0];
           }
           else{
            int sum1 = accumulate(A.begin()+i, A.begin()+j,0);
           int sum2 = accumulate(A.begin()+(j), A.begin()+k,0);
           }
           
           int a = abs(sum1-sum2);
           cout << a << endl;
           j++;
                    

       }

    //store diff in vector and ret min element
    return 0;
}

Code: 02:57:24 UTC, cpp, autosave

1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26 27 28 29 30 31 32 33 34 35 36 37

// you can use includes, for example:
 #include <algorithm>
#include <vector>
#include <numeric>

// you can write to stdout for debugging purposes, e.g.
// cout << "this is a debug message" << endl;
using namespace std;
int solution(vector<int> &A) {
    // write your code in C++14 (g++ 6.2.0)

    //i,j,k
     int i = 0;
     int j = 1;
     int k = A.size()-1;
    //sum from i to j, sum for j to k
       while(j!=k)
       {
           if(i==0 && j==1)
           {
            int sum1 = A[0];
           }
           else{
           int sum1 = accumulate(A.begin()+i, A.begin()+j,0);
           int sum2 = accumulate(A.begin()+(j), A.begin()+k,0);
           }
           
           int a = abs(sum1-sum2);
           cout << a << endl;
           j++;
                    

       }

    //store diff in vector and ret min element
    return 0;
}

Code: 03:00:07 UTC, cpp, autosave

1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26 27 28 29 30 31 32 33 34 35 36 37 38

// you can use includes, for example:
 #include <algorithm>
#include <vector>
#include <numeric>

// you can write to stdout for debugging purposes, e.g.
// cout << "this is a debug message" << endl;
using namespace std;
int solution(vector<int> &A) {
    // write your code in C++14 (g++ 6.2.0)

    //i,j,k
     int i = 0;
     int j = 1;
     int k = A.size()-1;
    //sum from i to j, sum for j to k
       while(j!=k)
       {
           if(i==0 && j==1)
           {
            int sum1 = A[0];
            
           }
           else{
           int sum1 = accumulate(A.begin()+i, A.begin()+j,0);
           int sum2 = accumulate(A.begin()+(j), A.begin()+k,0);
           }
           
           int a = abs(sum1-sum2);
           cout << a << endl;
           j++;
                    

       }

    //store diff in vector and ret min element
    return 0;
}

Code: 03:00:17 UTC, cpp, autosave

1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26 27 28 29 30 31 32 33 34 35 36 37 38

// you can use includes, for example:
 #include <algorithm>
#include <vector>
#include <numeric>

// you can write to stdout for debugging purposes, e.g.
// cout << "this is a debug message" << endl;
using namespace std;
int solution(vector<int> &A) {
    // write your code in C++14 (g++ 6.2.0)

    //i,j,k
     int i = 0;
     int j = 1;
     int k = A.size()-1;
    //sum from i to j, sum for j to k
       while(j!=k)
       {
           if(i==0 && j==1)
           {
            int sum1 = A[0];
            j--;
           }
           else{
           int sum1 = accumulate(A.begin()+i, A.begin()+j,0);
           int sum2 = accumulate(A.begin()+(j), A.begin()+k,0);
           }
           
           int a = abs(sum1-sum2);
           cout << a << endl;
           j++;
                    

       }

    //store diff in vector and ret min element
    return 0;
}

Code: 03:01:15 UTC, cpp, autosave

1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26 27 28 29 30 31 32 33 34 35 36 37 38

// you can use includes, for example:
 #include <algorithm>
#include <vector>
#include <numeric>

// you can write to stdout for debugging purposes, e.g.
// cout << "this is a debug message" << endl;
using namespace std;
int solution(vector<int> &A) {
    // write your code in C++14 (g++ 6.2.0)

    //i,j,k
     int i = 0;
     int j = 1;
     int k = A.size()-1;
    //sum from i to j, sum for j to k
       while(j!=k)
       {
           if(i==0 && j==1)
           {
            int sum1 = A[0];
            j-
           }
           else{
           int sum1 = accumulate(A.begin()+i, A.begin()+j,0);
           int sum2 = accumulate(A.begin()+(j), A.begin()+k,0);
           }
           
           int a = abs(sum1-sum2);
           cout << a << endl;
           j++;
                    

       }

    //store diff in vector and ret min element
    return 0;
}

Code: 03:01:26 UTC, cpp, autosave

1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26 27 28 29 30 31 32 33 34 35 36 37 38

// you can use includes, for example:
 #include <algorithm>
#include <vector>
#include <numeric>

// you can write to stdout for debugging purposes, e.g.
// cout << "this is a debug message" << endl;
using namespace std;
int solution(vector<int> &A) {
    // write your code in C++14 (g++ 6.2.0)

    //i,j,k
     int i = 0;
     int j = 1;
     int k = A.size()-1;
    //sum from i to j, sum for j to k
       while(j!=k)
       {
           if(i==0 && j==1)
           {
            int sum1 = A[0];
            
           }
           else{
           int sum1 = accumulate(A.begin()+i, A.begin()+j,0);
           int sum2 = accumulate(A.begin()+(j), A.begin()+k,0);
           }
           
           int a = abs(sum1-sum2);
           cout << a << endl;
           j++;
                    

       }

    //store diff in vector and ret min element
    return 0;
}

Code: 03:01:47 UTC, cpp, autosave

1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26 27 28 29 30 31 32 33 34 35 36 37 38 39

// you can use includes, for example:
 #include <algorithm>
#include <vector>
#include <numeric>

// you can write to stdout for debugging purposes, e.g.
// cout << "this is a debug message" << endl;
using namespace std;
int solution(vector<int> &A) {
    // write your code in C++14 (g++ 6.2.0)

    //i,j,k
     int i = 0;
     int j = 1;
     int k = A.size()-1;
    //sum from i to j, sum for j to k
       while(j!=k)
       {
           if(i==0 && j==1)
           {
            int sum1 = A[0];
            int sum2 = accumulate(A.begin()+(j), A.begin()+k,0);

           }
           else{
           int sum1 = accumulate(A.begin()+i, A.begin()+j,0);
           int sum2 = accumulate(A.begin()+(j), A.begin()+k,0);
           }
           
           int a = abs(sum1-sum2);
           cout << a << endl;
           j++;
                    

       }

    //store diff in vector and ret min element
    return 0;
}

Code: 03:03:54 UTC, cpp, verify, result: Failed

1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26 27 28 29 30 31 32 33 34 35 36 37 38 39

// you can use includes, for example:
 #include <algorithm>
#include <vector>
#include <numeric>

// you can write to stdout for debugging purposes, e.g.
// cout << "this is a debug message" << endl;
using namespace std;
int solution(vector<int> &A) {
    // write your code in C++14 (g++ 6.2.0)

    //i,j,k
     int i = 0;
     int j = 1;
     int k = A.size()-1;
    //sum from i to j, sum for j to k
       while(j!=k)
       {
           if(i==0 && j==1)
           {
            int sum1 = A[0];
            int sum2 = accumulate(A.begin()+(j), A.begin()+k,0);

           }
           else{
           int sum1 = accumulate(A.begin()+i, A.begin()+j,0);
           int sum2 = accumulate(A.begin()+(j), A.begin()+k,0);
           }
           
           int a = abs(sum1-sum2);
           cout << a << endl;
           j++;
                    

       }

    //store diff in vector and ret min element
    return 0;
}

The submission is being evaluated.

Code: 03:04:09 UTC, cpp, autosave

1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26 27 28 29 30 31 32 33 34 35 36 37 38 39 40

// you can use includes, for example:
 #include <algorithm>
#include <vector>
#include <numeric>

// you can write to stdout for debugging purposes, e.g.
// cout << "this is a debug message" << endl;
using namespace std;
int solution(vector<int> &A) {
    // write your code in C++14 (g++ 6.2.0)

    //i,j,k
     int i = 0;
     int j = 1;
     
     int k = A.size()-1;
    //sum from i to j, sum for j to k
       while(j!=k)
       {
           if(i==0 && j==1)
           {
            int sum1 = A[0];
            int sum2 = accumulate(A.begin()+(j), A.begin()+k,0);

           }
           else{
           int sum1 = accumulate(A.begin()+i, A.begin()+j,0);
           int sum2 = accumulate(A.begin()+(j), A.begin()+k,0);
           }
           
           int a = abs(sum1-sum2);
           cout << a << endl;
           j++;
                    

       }

    //store diff in vector and ret min element
    return 0;
}

Code: 03:04:24 UTC, cpp, verify, result: Failed

1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26 27 28 29 30 31 32 33 34 35 36 37 38 39 40

// you can use includes, for example:
 #include <algorithm>
#include <vector>
#include <numeric>

// you can write to stdout for debugging purposes, e.g.
// cout << "this is a debug message" << endl;
using namespace std;
int solution(vector<int> &A) {
    // write your code in C++14 (g++ 6.2.0)

    //i,j,k
     int i = 0;
     int j = 1;
     int sum1,sum2=0;
     int k = A.size()-1;
    //sum from i to j, sum for j to k
       while(j!=k)
       {
           if(i==0 && j==1)
           {
            sum1 = A[0];
            sum2 = accumulate(A.begin()+(j), A.begin()+k,0);

           }
           else{
           sum1 = accumulate(A.begin()+i, A.begin()+j,0);
           sum2 = accumulate(A.begin()+(j), A.begin()+k,0);
           }
           
           int a = abs(sum1-sum2);
           cout << a << endl;
           j++;
                    

       }

    //store diff in vector and ret min element
    return 0;
}

The submission is being evaluated.

Code: 03:04:43 UTC, cpp, autosave

1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26 27 28 29 30 31 32 33 34 35 36 37 38 39 40

// you can use includes, for example:
 #include <algorithm>
#include <vector>
#include <numeric>

// you can write to stdout for debugging purposes, e.g.
// cout << "this is a debug message" << endl;
using namespace std;
int solution(vector<int> &A) {
    // write your code in C++14 (g++ 6.2.0)

    //i,j,k
     int i = 0;
     int j = 1;
     int sum1,sum2=0;
     int k = A.size();
    //sum from i to j, sum for j to k
       while(j!=k)
       {
           if(i==0 && j==1)
           {
            sum1 = A[0];
            sum2 = accumulate(A.begin()+(j), A.begin()+k,0);

           }
           else{
           sum1 = accumulate(A.begin()+i, A.begin()+j,0);
           sum2 = accumulate(A.begin()+(j), A.begin()+k,0);
           }
           
           int a = abs(sum1-sum2);
           cout << a << endl;
           j++;
                    

       }

    //store diff in vector and ret min element
    return 0;
}

Code: 03:04:44 UTC, cpp, verify, result: Failed

1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26 27 28 29 30 31 32 33 34 35 36 37 38 39 40

// you can use includes, for example:
 #include <algorithm>
#include <vector>
#include <numeric>

// you can write to stdout for debugging purposes, e.g.
// cout << "this is a debug message" << endl;
using namespace std;
int solution(vector<int> &A) {
    // write your code in C++14 (g++ 6.2.0)

    //i,j,k
     int i = 0;
     int j = 1;
     int sum1,sum2=0;
     int k = A.size();
    //sum from i to j, sum for j to k
       while(j!=k)
       {
           if(i==0 && j==1)
           {
            sum1 = A[0];
            sum2 = accumulate(A.begin()+(j), A.begin()+k,0);

           }
           else{
           sum1 = accumulate(A.begin()+i, A.begin()+j,0);
           sum2 = accumulate(A.begin()+(j), A.begin()+k,0);
           }
           
           int a = abs(sum1-sum2);
           cout << a << endl;
           j++;
                    

       }

    //store diff in vector and ret min element
    return 0;
}

The submission is being evaluated.

Code: 03:05:42 UTC, cpp, autosave

1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26 27 28 29 30 31 32 33 34 35 36 37 38 39 40 41

// you can use includes, for example:
 #include <algorithm>
#include <vector>
#include <numeric>

// you can write to stdout for debugging purposes, e.g.
// cout << "this is a debug message" << endl;
using namespace std;
int solution(vector<int> &A) {
    // write your code in C++14 (g++ 6.2.0)

    //i,j,k
     int i = 0;
     int j = 1;
     int sum1,sum2=0;
     int k = A.size();
    //sum from i to j, sum for j to k
       while(j!=k)
       {
           if(i==0 && j==1)
           {
            sum1 = A[0];
            sum2 = accumulate(A.begin()+(j), A.begin()+k,0);

           }
           else{
           sum1 = accumulate(A.begin()+i, A.begin()+j,0);
           sum2 = accumulate(A.begin()+(j), A.begin()+k,0);
           }
           
           int a = abs(sum1-sum2);
           cout << a << endl;
           
           j++;
                    

       }

    //store diff in vector and ret min element
    return 0;
}

Code: 03:05:53 UTC, cpp, autosave

1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26 27 28 29 30 31 32 33 34 35 36 37 38 39 40 41

// you can use includes, for example:
 #include <algorithm>
#include <vector>
#include <numeric>

// you can write to stdout for debugging purposes, e.g.
// cout << "this is a debug message" << endl;
using namespace std;
int solution(vector<int> &A) {
    // write your code in C++14 (g++ 6.2.0)

    //i,j,k
     int i = 0;
     int j = 1;
     int sum1,sum2=0;
     int k = A.size();
    //sum from i to j, sum for j to k
       while(j!=k)
       {
           if(i==0 && j==1)
           {
            sum1 = A[0];
            sum2 = accumulate(A.begin()+(j), A.begin()+k,0);

           }
           else{
           sum1 = accumulate(A.begin()+i, A.begin()+j,0);
           sum2 = accumulate(A.begin()+(j), A.begin()+k,0);
           }
           
           int a = abs(sum1-sum2);
           cout << a << endl;
           b.push_back(a);
           j++;
                    

       }

    //store diff in vector and ret min element
    return 0;
}

Code: 03:06:06 UTC, cpp, autosave

1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26 27 28 29 30 31 32 33 34 35 36 37 38 39 40 41 42

// you can use includes, for example:
 #include <algorithm>
#include <vector>
#include <numeric>

// you can write to stdout for debugging purposes, e.g.
// cout << "this is a debug message" << endl;
using namespace std;
int solution(vector<int> &A) {
    // write your code in C++14 (g++ 6.2.0)

    //i,j,k
     int i = 0;
     int j = 1;
     vector<int>b;
     int sum1,sum2=0;
     int k = A.size();
    //sum from i to j, sum for j to k
       while(j!=k)
       {
           if(i==0 && j==1)
           {
            sum1 = A[0];
            sum2 = accumulate(A.begin()+(j), A.begin()+k,0);

           }
           else{
           sum1 = accumulate(A.begin()+i, A.begin()+j,0);
           sum2 = accumulate(A.begin()+(j), A.begin()+k,0);
           }
           
           int a = abs(sum1-sum2);
           cout << a << endl;
           b.push_back(a);
           j++;
                    

       }

    //store diff in vector and ret min element
    return 0;
}

Code: 03:06:28 UTC, cpp, autosave

1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26 27 28 29 30 31 32 33 34 35 36 37 38 39 40 41 42

// you can use includes, for example:
 #include <algorithm>
#include <vector>
#include <numeric>

// you can write to stdout for debugging purposes, e.g.
// cout << "this is a debug message" << endl;
using namespace std;
int solution(vector<int> &A) {
    // write your code in C++14 (g++ 6.2.0)

    //i,j,k
     int i = 0;
     int j = 1;
     vector<int>b;
     int sum1,sum2=0;
     int k = A.size();
    //sum from i to j, sum for j to k
       while(j!=k)
       {
           if(i==0 && j==1)
           {
            sum1 = A[0];
            sum2 = accumulate(A.begin()+(j), A.begin()+k,0);

           }
           else{
           sum1 = accumulate(A.begin()+i, A.begin()+j,0);
           sum2 = accumulate(A.begin()+(j), A.begin()+k,0);
           }
           
           int a = abs(sum1-sum2);
           cout << a << endl;
           b.push_back(a);
           j++;
                    

       }

    //store diff in vector and ret min element
    return *min_element(b.begin(),b.end());
}

Code: 03:06:31 UTC, cpp, verify, result: Passed

1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26 27 28 29 30 31 32 33 34 35 36 37 38 39 40 41 42

// you can use includes, for example:
 #include <algorithm>
#include <vector>
#include <numeric>

// you can write to stdout for debugging purposes, e.g.
// cout << "this is a debug message" << endl;
using namespace std;
int solution(vector<int> &A) {
    // write your code in C++14 (g++ 6.2.0)

    //i,j,k
     int i = 0;
     int j = 1;
     vector<int>b;
     int sum1,sum2=0;
     int k = A.size();
    //sum from i to j, sum for j to k
       while(j!=k)
       {
           if(i==0 && j==1)
           {
            sum1 = A[0];
            sum2 = accumulate(A.begin()+(j), A.begin()+k,0);

           }
           else{
           sum1 = accumulate(A.begin()+i, A.begin()+j,0);
           sum2 = accumulate(A.begin()+(j), A.begin()+k,0);
           }
           
           int a = abs(sum1-sum2);
           cout << a << endl;
           b.push_back(a);
           j++;
                    

       }

    //store diff in vector and ret min element
    return *min_element(b.begin(),b.end());
}

The submission is being evaluated.

Code: 03:06:59 UTC, cpp, autosave

1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26 27 28 29 30 31 32 33 34 35 36 37 38 39 40 41 42

// you can use includes, for example:
 #include <algorithm>
#include <vector>
#include <numeric>

// you can write to stdout for debugging purposes, e.g.
// cout << "this is a debug message" << endl;
using namespace std;
int solution(vector<int> &A) {
    // write your code in C++14 (g++ 6.2.0)

    //i,j,k
     int i = 0;
     int j = 1;
     vector<int>b;
     int sum1,sum2=0;
     int k = A.size();
    //sum from i to j, sum for j to k
       while(j!=k)
       {
           if(i==0 && j==1)
           {
            sum1 = A[0];
            sum2 = accumulate(A.begin()+(j), A.begin()+k,0);

           }
           else{
           sum1 = accumulate(A.begin()+i, A.begin()+j,0);
           sum2 = accumulate(A.begin()+(j), A.begin()+k,0);
           }
           
           int a = abs(sum1-sum2);
           cout << a << endl;
           b.push_back(a);
           j++;
                    

       }
     std::sort(b.begin(),b.end)
    //store diff in vector and ret min element
    return *min_element(b.begin(),b.end());
}

Code: 03:07:10 UTC, cpp, autosave

1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26 27 28 29 30 31 32 33 34 35 36 37 38 39 40 41 42

// you can use includes, for example:
 #include <algorithm>
#include <vector>
#include <numeric>

// you can write to stdout for debugging purposes, e.g.
// cout << "this is a debug message" << endl;
using namespace std;
int solution(vector<int> &A) {
    // write your code in C++14 (g++ 6.2.0)

    //i,j,k
     int i = 0;
     int j = 1;
     vector<int>b;
     int sum1,sum2=0;
     int k = A.size();
    //sum from i to j, sum for j to k
       while(j!=k)
       {
           if(i==0 && j==1)
           {
            sum1 = A[0];
            sum2 = accumulate(A.begin()+(j), A.begin()+k,0);

           }
           else{
           sum1 = accumulate(A.begin()+i, A.begin()+j,0);
           sum2 = accumulate(A.begin()+(j), A.begin()+k,0);
           }
           
           int a = abs(sum1-sum2);
           cout << a << endl;
           b.push_back(a);
           j++;
                    

       }
     std::sort(b.begin(),b.end());
    //store diff in vector and ret min element
    return *min_element(b.begin(),b.end());
}

Code: 03:07:13 UTC, cpp, verify, result: Passed

1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26 27 28 29 30 31 32 33 34 35 36 37 38 39 40 41 42

// you can use includes, for example:
 #include <algorithm>
#include <vector>
#include <numeric>

// you can write to stdout for debugging purposes, e.g.
// cout << "this is a debug message" << endl;
using namespace std;
int solution(vector<int> &A) {
    // write your code in C++14 (g++ 6.2.0)

    //i,j,k
     int i = 0;
     int j = 1;
     vector<int>b;
     int sum1,sum2=0;
     int k = A.size();
    //sum from i to j, sum for j to k
       while(j!=k)
       {
           if(i==0 && j==1)
           {
            sum1 = A[0];
            sum2 = accumulate(A.begin()+(j), A.begin()+k,0);

           }
           else{
           sum1 = accumulate(A.begin()+i, A.begin()+j,0);
           sum2 = accumulate(A.begin()+(j), A.begin()+k,0);
           }
           
           int a = abs(sum1-sum2);
           cout << a << endl;
           b.push_back(a);
           j++;
                    

       }
     std::sort(b.begin(),b.end());
    //store diff in vector and ret min element
    return b[0];
}

The submission is being evaluated.

Code: 03:07:35 UTC, cpp, verify, result: Passed

1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26 27 28 29 30 31 32 33 34 35 36 37 38 39 40 41

// you can use includes, for example:
 #include <algorithm>
#include <vector>
#include <numeric>

// you can write to stdout for debugging purposes, e.g.
// cout << "this is a debug message" << endl;
using namespace std;
int solution(vector<int> &A) {
    // write your code in C++14 (g++ 6.2.0)

    //i,j,k
     int i = 0;
     int j = 1;
     vector<int>b;
     int sum1,sum2=0;
     int k = A.size();
    //sum from i to j, sum for j to k
       while(j!=k)
       {
           if(i==0 && j==1)
           {
            sum1 = A[0];
            sum2 = accumulate(A.begin()+(j), A.begin()+k,0);

           }
           else{
           sum1 = accumulate(A.begin()+i, A.begin()+j,0);
           sum2 = accumulate(A.begin()+(j), A.begin()+k,0);
           }
           
           int a = abs(sum1-sum2);
           b.push_back(a);
           j++;
                    

       }
     
    //store diff in vector and ret min element
    return *min_element(b.begin(),b.end());
}

The submission is being evaluated.

Code: 03:07:46 UTC, cpp, verify, result: Passed

1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26 27 28 29 30 31 32 33 34 35 36 37 38 39 40 41

// you can use includes, for example:
 #include <algorithm>
#include <vector>
#include <numeric>

// you can write to stdout for debugging purposes, e.g.
// cout << "this is a debug message" << endl;
using namespace std;
int solution(vector<int> &A) {
    // write your code in C++14 (g++ 6.2.0)

    //i,j,k
     int i = 0;
     int j = 1;
     vector<int>b;
     int sum1,sum2=0;
     int k = A.size();
    //sum from i to j, sum for j to k
       while(j!=k)
       {
           if(i==0 && j==1)
           {
            sum1 = A[0];
            sum2 = accumulate(A.begin()+(j), A.begin()+k,0);

           }
           else{
           sum1 = accumulate(A.begin()+i, A.begin()+j,0);
           sum2 = accumulate(A.begin()+(j), A.begin()+k,0);
           }
           
           int a = abs(sum1-sum2);
           b.push_back(a);
           j++;
                    

       }
     
    //store diff in vector and ret min element
    return *min_element(b.begin(),b.end());
}

The submission is being evaluated.

Code: 03:07:49 UTC, cpp, final, score: 69

1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26 27 28 29 30 31 32 33 34 35 36 37 38 39 40 41

// you can use includes, for example:
 #include <algorithm>
#include <vector>
#include <numeric>

// you can write to stdout for debugging purposes, e.g.
// cout << "this is a debug message" << endl;
using namespace std;
int solution(vector<int> &A) {
    // write your code in C++14 (g++ 6.2.0)

    //i,j,k
     int i = 0;
     int j = 1;
     vector<int>b;
     int sum1,sum2=0;
     int k = A.size();
    //sum from i to j, sum for j to k
       while(j!=k)
       {
           if(i==0 && j==1)
           {
            sum1 = A[0];
            sum2 = accumulate(A.begin()+(j), A.begin()+k,0);

           }
           else{
           sum1 = accumulate(A.begin()+i, A.begin()+j,0);
           sum2 = accumulate(A.begin()+(j), A.begin()+k,0);
           }
           
           int a = abs(sum1-sum2);
           b.push_back(a);
           j++;
                    

       }
     
    //store diff in vector and ret min element
    return *min_element(b.begin(),b.end());
}

The submission is being evaluated.