[Question]
  [
Your task is to write a function that takes an even-digit integer and compares the 2 halves of the integer. If the sum of the digits in the first half is greater than the sum of the digits in the second half, output a truthy value, otherwise, output falsey.
For example:
```
12345678
1234 5678
(1+2+3+4)>(5+6+7+8)
10>26
Output falsey
```
### Input
A single integer.
* This must be passed as a single whole integer in base 10, a single string, an array of integers, or an array of characters. Please specify which format your answer accepts
* The input can be passed via Command Line Arguments, STDIN, or any other standard method of input supported by your language
* Assume the input will always have an even digit count
* Assume the input will always be positive and greater than 0
* Assume the input will be within feasible number handling capacities for your language
* The input will not contain leading zeroes
### Output
A truthy value if the sum of the digits in the first half is greater than the sum of the digits in the second half.
A falsey value if the sum of the digits in the first half is less than **or equal** to the sum of the digits in the second half.
### Test cases
```
Input > Output
12345678 > False
87654321 > True
12344321 > False
12 > False
214758392639543385 > False
1001 > False
100000 > True
```
### Scoring
This is [code-golf](/questions/tagged/code-golf "show questions tagged 'code-golf'") so fewest bytes wins.
  
[Answer]
# [Brachylog](https://github.com/JCumin/Brachylog), 5 bytes
```
ḍ+ᵐ>₁
```
[Try it online!](https://tio.run/nexus/brachylog2#@/9wR6/2w60T7B41Nf7/b2hkbGJqZm4BAA "Brachylog – TIO Nexus")
## How it works
```
ḍ+ᵐ>₁                     example input: 12345678
ḍ        split in half                   [[1,2,3,4],[5,6,7,8]]
 +ᵐ      sum each half                   [10,26]
   >₁    results in a decreasing list    false
```
[Answer]
# Octave, ~~39~~ ~~35~~ 28 bytes
```
@(x)sum(x)/2<sum(x(1:end/2))
```
Input integers as a string `'12345678'`.
Takes the `sum` of all the digits (as ASCII-values), and divides it by two, to get the mean of the two sides. Compares this to the sum of the first half of the integer, to check if it's smaller or not.
[Answer]
# [Retina](https://github.com/m-ender/retina), 34 bytes
```
\d
$*1;
+`;(.*);(.)
$1$2
1(1*);\1;
```
[Try it online!](https://tio.run/nexus/retina#LYnBDcAgDAP/mYNKQKWqTggEMUCX4MGj@69AQaoflu98@GfM/pKLaHSO5q8YVgVycEzwWNjR5gRL0lyMrGRNwqBt/kGMVNSkcpa6XjHdFvfOBw "Retina – TIO Nexus") Works by inserting `;`s after each digit as they are converted to unary. The `;`s are then deleted in pairs until only the middle and final `;`s remain and the numbers can then be compared.
[Answer]
# Regex, 226 bytes
```
^(9(){9}|8(?<2>){8}|7(?<2>){7}|6(?<2>){6}|5(?<2>){5}|4(?<2>){4}|3(?<2>){3}|2(?<2>){2}|1(?<2>)|0)+(?<-1>9(?<-2>){9}|8(?<-2>){8}|7(?<-2>){7}|6(?<-2>){6}|5(?<-2>){5}|4(?<-2>){4}|3(?<-2>){3}|2(?<-2>){2}|1(?<-2>)|0)+(?<-2>)(?(1)^)$
```
[Try it online!](https://tio.run/nexus/retina#Tc1LCgMxCIDh/ZyjhYQijJonlJllbzH0HqNnTxPqQjd@6OJ/hs93XKGHeHeVFs43HfFuKtVYVYqxqGRjVknGpMJGViEjqeCfssfXFODR11pPK4FLgWuBi4GrgcuB64ELgitOhjNgvOJjDCROudS2tVpyYsJtXQwbYaq5cafCfX655XXFfc0P "Retina – TIO Nexus") (uses Retina to check)
[Answer]
# [Haskell](https://www.haskell.org/), 34 bytes
```
g(h:t)=h-g(reverse t)
g _=0
(>0).g
```
[Try it online!](https://tio.run/nexus/haskell#bU3NCsIwDL73KXLw0EKUdbXrFOqLlCIDu26H/VCLr1/DhuLBBJLw/eQrkQ/XLOxwjDyFV0jPAFmwCHdbsd7yWyVOsUzdOIOFx8KAak3jnOEAU7dCD861aLBBjWdUWKP06CRWn/b@r0eSUpFDk9Ngu3l25PdLTZNuwgwpW2IuxDXb3vMUofqbKL0vbw "Haskell – TIO Nexus") Take list as input. 
Computes the sum of the first half minus that of the second half by recursively taking the first element and subtracting the recursive result on the reverse. For example:
```
g [1,2,3,4]    =
1-g[4,3,2]     =
1-(4-g[2,3])   =
1-(4-(2-g[3])) =
1-(4-(2-3))    =
1-4+2-3        =
(1+2)-(3+4)
```
[Answer]
# [05AB1E](https://github.com/Adriandmen/05AB1E), 5 bytes
```
2äO`›
```
[Try it online!](https://tio.run/nexus/05ab1e#qymrDP5vdHiJf8Kjhl3/K5UO77dSOLxfSee/oZGxiamZuQWXhbmZqYmxkSEXSATK4DIyNDE3tTC2NDIztgTKGluYchkaGBiCCCAAAA "05AB1E – TIO Nexus")
**Explanation**
Takes input as list of digits.
```
2ä     # split in half
  O    # sum each part
   `›  # is the first half greater than the second
```
To take input as an integer you could just add `S` for
```
S2äO`›
```
[Answer]
# [Retina](https://github.com/m-ender/retina), ~~60~~ 40 bytes
*Saved some bytes thanks to @MartinEnder*
```
^(.)+?(?=(?<-1>.)+$)
$&;
\d
$*
.(1*);\1$
```
[Try it online!](https://tio.run/nexus/retina#LYlLDoAgDAX3PQeagpFYyjeoLL0EMS68/xUQEt9qZt6E19Nu1HIpWA4s@0pnFyFBzBnqC0KBRlIyVxKtkWHrfIgQg3eWDcEoP4AhG1zkZDyn/nJ0o9I29gE "Retina – TIO Nexus")
[Answer]
# PHP, 54 bytes
```
for($n=$argn;~$n[2*$i];)$s+=$n[$i]-$n[-++$i];echo$s>0;
```
takes input from STDIN; empty output for falsy. Requires PHP 7.1. Run with `-nR`.
**breakdown**
```
for($n=$argn;       # import input
    ~$n[2*$i];      # loop while there is a 2*$i-th digit (0-indexed)
)
    $s+=$n[$i]          # 1. add $i-th digit
        -$n[-++$i];     # 2. subtract -1-$i-th digit
echo$s>0;           # if $s>0, print "1" , else print nothing
```
[Answer]
# [Python 2](https://docs.python.org/2/), ~~78~~ ~~62~~ ~~44~~ 35 bytes
Crossed out 44 is still regular 44. :c
*-16 bytes thanks to LeakyNun. -18 bytes on allowance of integer array input. -9 bytes thanks to Dennis.*
Takes input as an array of integers and returns True/False. Note that it relies on Python 2's integer division.
```
lambda s:sum(s[:len(s)/2])*2>sum(s)
```
[Try it online!](https://tio.run/nexus/python2#S7ON@Z@TmJuUkqhQbFVcmqtRHG2Vk5qnUaypbxSrqWVkBxbT/F9QlJlXopGmEW2oo2Cko2Cso2Cio2Cqo2Cmo2Cuo2ARq6nJBVdiARYzA8ubgNUCdRiiKEE2BY8SFAGQCrBqc7DJFmBtlmCdZjA23EZjsAJTdBMNYMgQpwwIASX/AwA "Python 2 – TIO Nexus")
### Explanation:
*I know this (or anything in Python) doesn't need an explanation but I'm doing it anyways for good practise. :P*
```
    s[:len(s)/2]             # Gets first half of array
sum(s[:len(s)/2])            # Calculates the sum of the values
sum(s[:len(s)/2])*2          # Multiplies it by 2 (explanations...)
                    sum(s)   # Total sum of the digits
sum(s[:len(s)/2])*2>sum(s)   # Compares the two sums
```
[Answer]
# Python 3, ~~68~~ 62 bytes
```
i=input()
print(sum(map(int,i))>2*sum(map(int,i[len(i)//2:])))
```
### Short explanation:
* `input()` reads a string from `stdin`.
* `i[len(i)//2:]` takes the second half of the string.
* The `map` functions turn the string to an integer list.
* `sum`, `>`, `*2` and `print` do what they say.
[Answer]
# Python 2, 52 Bytes thanks to help in comments
```
lambda x:sum(x[i]-x[~i] for i in range(len(x)//2))>0
```
The idea was to substract the first digit from the last, second from second last... and check if the sum of all substractions is greater then 0.
[Try it online!](https://tio.run/nexus/python2#fY3NCsIwEITvPsUeE9hi098o6IvEHCK2EmhTiQp5@9iutFhBYQ7LzDez7eEUO9OfLwbC/v7smQrK6iSornEs8MQmQreDBwvWgTfu2rB3ss245sc03rx1D9YyJRAyhByhQCgRKoQaQWrONwsiyasoL4gdG2KFfK78QVbGRBBd07Kk2o6a1XwvH3MCyu/FdJb4mUwaw/gC "Python 2 – TIO Nexus")
[Answer]
# [Actually](https://github.com/Mego/Seriously), 7 bytes
```
2,╡♂Σi>
```
Input is taken as a list of digits. [Try it online!](https://tio.run/nexus/actually#@2@k82jqwkczm84tzrT7/z/aUMdIx1jHRMdUx0zHXMciFgA "Actually – TIO Nexus")
Explanation:
```
2,╡♂Σi>
2,╡      split input into two equal sublists
   ♂Σ    sum each sublist
     i>  is first sum greater than second sum?
```
[Answer]
# [Jelly](https://github.com/DennisMitchell/jelly), ~~10~~ 7 bytes
```
œs2S€>/
```
Saved a byte by changing the input to a list of digits.
Saved several more thanks to Leaky Nun!
[Try it online!](https://tio.run/nexus/jelly#AR4A4f//RMWTczJT4oKswrXhuKI84bmq////NTY3ODEyMzQ "Jelly – TIO Nexus")
Explanation:
```
œs2    Split that list into 2 chunks
   S€  Sum each chunk individually
>/     Reduce the resulting list by relative compare.
Prepend this to work with integer input instead of a list:
D       Turn the integer into a list of digits
```
[Answer]
## JavaScript (ES6), 44 bytes
```
f=([n,...a],d=0)=>1/n?f(a,d-=n-=a.pop()):d<0
```
```
<input oninput=o.textContent=this.value.length%2?``:f(this.value)><pre id=o>
```
Takes input as a string or array of digits as characters or integers.
[Answer]
# C#, 148 bytes
```
void q(){var a=Console.ReadLine();int b=0,c=0,i=0,d=a.Length/2;for(;i<d;i++){b+=int.Parse(a[i]+"");c+=int.Parse(a[i+d]+"");}Console.WriteLine(b>c);}
```
[Answer]
# [Husk](https://github.com/barbuz/Husk), 5 bytes
```
F<mΣ½
```
[Try it online!](https://tio.run/##yygtzv7/qKkx5b@bTe65xYf2/v//39DI2MTUzNwCAA "Husk – Try It Online")
Input as an array of integers.
[Answer]
# [GolfScript](http://www.golfscript.com/golfscript/), 13 bytes
```
.,2//{{+}*}/>
```
[Try it online!](https://tio.run/##S8/PSStOLsosKPn/X0/HSF@/ulq7VqtW3@7/f0MjYxNTM3MLAA "GolfScript – Try It Online")
```
.,              # Get the length of the input                        "12345678" 8
  2/            # Half it                                            "12345678" 4
    /           # Divide the string in groups of that many digits    ["1234" "5678"]
     {    }/    # For each string
      {+}*      # Add the ascii values                               202 218
            >   # Is the first bigger than the second?               0
```
It actually adds the ascii values of the numbers, but both groups of digits have `d` digits, so both results are `48*d` more than the actual value. This would only be a problem if the groups had different lengths.
[Answer]
# [C (gcc)](https://gcc.gnu.org/), 79 or 75, 74
better version (80 char -> 79 thanks to titus )
```
f(char*s){int i=0,n=strlen(s--)/2;for(;*(++s+n);)i-=*s-s[n];putchar(48+(i<0));}
```
[Try it online!](https://tio.run/nexus/c-gcc#VYzLCoMwFET3foW4utcYzFMjqV9SupBSaaBNi7Er8dttUuhrVucwzGwjHM/DVAZcnJ9z17PK92GeLicPgVKshR1vE9gSCAnEo0VH@zLQsPcHe3/MaQzKEHA7hmjXLb1cB@cBsyXLRyi4kEo3rSnQvty0jVZS8Len/t8T1XVkVrGq@DaCq1Yb2YlGdvFCGv3ZMMZ/OCbZuj0B "C (gcc) – TIO Nexus")
next, 75 bytes if we rely on constant undefined behaviour,
```
f(char*s){int i=0,n=strlen(s)/2;for(;s[n];)i-=*s-s++[n];putchar(48+(i<0);}
```
[Try it online!](https://tio.run/nexus/c-gcc#VYzLCoMwFET3foW4utcYzFMjqV9SupBSaaBNi7Er8dttUuhrVucwzGwjHM/DVAZcnJ9z17PK92GeLicPgVKshR1vE9gSCAnEo0VH@zLQsPcHe3/MaQzKEHA7hmjXLb1cB@cBsyXLRyi4kEo3rSnQvty0jVZS8Len/t8T1XVkVrGq@DaCq1Yb2YlGdvFCGv3ZMMZ/OCbZuj0B "C (gcc) – TIO Nexus")
input valid string in C (a zero terminated array of char)
output 1 for true, 0 for false
ungolfed version
```
f(char*s)
{
    int i=0;
    int n=strlen(s)/2; /* n is the length of each strings  so we have 
                          the start of the first string at *s or s[0],
                          and the start of the second sequence at s[n] 
                        */
    for(;s[n];) /* until we get 0, all string in C are terminated by 0 */
        i-=*s-s++[n]; /* i is the difference between the two characters *s and s[n], 
        then we move the cursor to the next character (s++) :) 
        on the string 12345678, after the first iteration we have 
        i == -4 and 234,678 the proceed
        */
    putchar(48+(i<0)); /* put char '0' if i<0, char '0'+1 otherwise (the char '1')
 } 
```
and now 74 thanks to "a stone arachnid"
# [C (gcc)](https://gcc.gnu.org/), 74 bytes
```
f(char*s){int i=0,n=strlen(s)/2;for(;s[n];)i-=*s-s++[n];printf("%d",i<0);}
```
[Try it online!](https://tio.run/##VYxLDoMgFEXnrsKQNAHFyEcUQ11J04Gh1ZK0tAFnxrVTaNLfG92Tc9/V1ax1CBPUl9EVHq3GLrkZCLaDX9z1bKFHNVPT3UHlD/aokKmGwle@LBM9XOxPEOxOAJs9QWoLaeA2GgtRtmZ5dJTxRrSdBEi9WHataDijb07@n1Oq65gJJhh8DaNNJyTvWcv7OMGl@PwQQn9yvERbeAI "C (gcc) – Try It Online")
[Answer]
# [Vyxal](https://github.com/Lyxal/Vyxal), ~~8~~ ~~7~~ 6 bytes
*Thanks to @Razetime for saving 1 byte due to the `⌊` command auto-vectorising.*
```
½⌊v∑>t
```
[Try it Online!](http://lyxal.pythonanywhere.com?flags=&code=%C2%BD%E2%8C%8Av%E2%88%91%3Et&inputs=%2212345678%22&header=&footer=)
Takes input in the form of `"12345678"`. Alternatively, the quotes can be left out if the `Ṡ` flag is used.
I’m gonna be honest, I’m not really sure what the `>` is doing since `(a:string, b:list)` isn’t documented for that command, but I was messing with it and found that in this case it returns `<1|0>` or `<1|1>`, so I take the last value of the list and that’s the answer.
Explanation:
```
        # Implicit input
½       # Split the input into two chunks
 ⌊      # Convert both chunks to integers
  v∑    # Sum the digits of each chunk
    >   # Some sort of a>b thing?
     t  # Tail; last item
        # Implicit output
```
[Answer]
# [Braingolf](https://github.com/gunnerwolf/braingolf), 20 bytes
```
dl2/2->[+]>l3->[+],-
```
[Try it online!](https://tio.run/nexus/python3#xVlLc9s2EL7rVyBuU5GNpEh2TpLtdqaTzPTUHjq9KKqHIUEJDU2yAOnY007/ursLgHiQkCxNpvbFFheLfXz7ILB8zHl1S8SDIOy2rnhDEr69W40kNW/LtKmqwqxxmrUp1atpVRQ0bVhVmvWM/tXCsn6qxKxOmp19rilPmoobAmsol/JXo1FaJEIQISVE8m@8HBGQmJObmy1tgPf25iYStMgnhJUZvZfrhLCcMMFK0SRlSiO5MiGiYCnVDATMblpekuahplJAHBnNMyZZXbkzEMUb@1DV9jet43jkiJSGzvYZOBqh@WhdEwlpTcMftNWS5Ir6jbcUnul9SuuG/J4ULX3PecWXLtOHpBBUiVVo0qhDdUJyxgXYLWhalZlUp3d1LJHPsVKCwHbwOP18lxSR/DEhNaeC8js6AQl3UhKg3BE9g@SG9XyDDMBLKNinidPFZoUOAWW4ZVZXdUHzJoqHO3EtClgnDppX0FKtx@SaLExu@FYTgkrJ1RF2S4vZdme5F0Huc81t/fSVHONpQNtx26zS/a76Tsz3mzvQr3TosEXINVFMXXDqhAsapVWmaq3mmNbjX4HKyi15LcbkNZGrKEeKRfGqxiVNxw17DobtQlmkON9cyV60vlhuVoEQzxWv1vlzWbfNUqtcI4nFJK84YVBqWiB2io2CrczAEFlMK2m3As6lQYXcQY9wSRAECv66JNFw9NShUJEmtcdz2xYNk2Z6Oz@z2n1muWeSYOCstyEv5AZsE/hYVJW3f8spzR5cCnLIVgbE@aoLT1q1Uu7ZmbEt3SXcUO477i87MAEeLyXsJsaADHDg4/pep9I9hmoBKYEPiPkDYs6Tckuj@cQGzfRjCIRKxgeoKEHKqsF@2K0Su3il@qR@jLUK3A7oOdLApCsy/mdMQLn6vRw74npQd9uyPhFi3rAS8e30IIYDPRtHtnEFWonJSdcLoE8lOnYBITbBsQtuRcqq7EXYk2vbg10amm9Tz3FCvY/S2OpyEgMimYYkhkzsUgnFWRGxakVGomxbCxd3GXCV4K6/upLHsz8rVkbrdMcjJu2FFFwsFu8Wi3MlbN6v7LXNsalUutxs4glW@dV4HA9U9/ukbTldk1z2BW6skHA5dy4MG4mWP6jnAfSqAk2Gy84yyL2zMUmgeaEbqtO4VdPvRa5rENh1xTOvLZrq77vndQQVeGPBx49@@odMcdpg16@G6WM12aRTelTr7ThVvid1DfGM0IU0jp2K7Xdpz9ilhQvq3Uj87LVSb8fZ2OrVeAb5bsZObFC@asDLY/P8qVMXvmlCOXxqivmY@3XjWrXX3K8x2MHryuClxIXf0Zvhxh@fAtoryP3phuH0cvoQGpIZ0/JAE1oN0Qt1lsHBZ73xtu4PqAIKTXE2DN/zHlrfGLRsaQTz99@xvR11x5og47e2ILoEC/JNjiiI0BldhwJvJsOzp4FQ3lgOrLs9Qsrav2xuP@Es8WKlscm6E8zA6@@M1yYwQXRm42A7MzeOoeS/zQ5zaVQXx1q@cuG4G/mvNqB5iOJZaIfZ3VsIddRdHO8/iHjs04VFTl1V3//ywbmo7t/g@FaE0XCOioMtmdkCDQgQOKodrUaHayxwovehg@KLQEO8xzd5kNoFrP3ha6yVsWykXnJ55R4qBy8ue5B1aSe561i9Nlbrs6cr1L1O3A@2vnmq@vH@7gMhnkain6q9kccsybJJh5WA@3nsPM03cXzEe/Ng@a9Fe6szcnN8D377IljkECCesbv/FxA1AQxpPRmm718EJjgtPC9CUuHJ4ExfBBzRfnpecKTCk8H540XAqasvzwuOVHgyOK9fpqyq7JnLChWeAE5/6jF8jwde46@cS4sxOni@u@ydaHjVID6hw891mDXAuTKcamCpNI@Co53ThzHBG19oCHPUuCX2hPYvQr3xijdU2TdQCefJ8JbbzSDKzJ0IOxeF4ehY4SCvqSNvBH2pRtBmqAz5yzIcQ4tX6k6rV36qOKdpQ1qRbCmOncllXiTba3Ipqpan9Jqs1Q@5d/OxRMM0y5K8Z82OcjLNcV45TWf4i5UZSyEPBGl2SWPlMEESuB0VlDQV@UShMJOM4Pe3iZ7QTtNDez/xhJXbqsjlyLaT0ZYznJPL8fpcj8TvmbxQjG6RT4/e8UuI9kNT8GsHQqa48EWVj13EiNhVbZGhCjCGKq0Mf4Mx6EY3o1dipWokl8kt6lBUHVX9/XDGBHJEHZsu4S8AIn7ZgrgqUSQBDSbhOqvzGSLWXZXUBwtHt2062oMPiOlrNZTOIUuzV2it0a1rtANLFqvFIj2ABfiPYAT87xnVmdRLQkwenYRa/ePj4zR9zIrzt@fT6/WbzXVxIf9Ppo@L84t37y4Wi/8A "Python 3 – TIO Nexus")
Figured nobody else is likely to post a braingolf answer, so here's mine.
Takes input as an integer, Prints a positive number for truthy, and a negative number or zero for falsey
Explanation:
```
dl2/2->[+]>l3->[+],-
d                     Split last item on stack into digits, push each digit to stack
 l                    Push length of stack to stack
  2/                  Halve last item on stack
    2-                Subtract 2 from last item on stack
      >               Move last item on stack to start of stack
       [+]            Sum last 2 items of stack 3 times (last 4 items)
          >           Move last item on stack to start of stack
           l          Push length of stack to stack
            3-        Subtract 3 from last item on stack
              [+]     Sum last 2 items of stack 3 times (last 4 items)
                 ,-   Subtract last item (sum of first half) from 2nd to last (sum of 2nd half)
                      Implicit: Print last item on stack
```
[Answer]
## Batch, 122 bytes
```
@set/al=r=0
@set/ps=
:l
@set/al+=%s:~,1%,r+=%s:~-1%
@set s=%s:~1,-1%
@if not "%s%"=="" goto l
@if %l% gtr %r% echo 1
```
Takes input on STDIN and outputs `1` if the value is significant.
[Answer]
# [Java](http://openjdk.java.net/), ~~95~~ 94 bytes
```
boolean f(long n){int x=10,a=x,s=0;for(;a<n;n/=x,a*=x)s+=n%x;for(;n>0;n/=x)s-=n%x;return s<0;}
```
[Try it online!](https://tio.run/nexus/java-openjdk#ZU/LboMwEDzjr/Clkt2mLm@ICP2CtheOVQ8ONcSVs0bYJFQo307tJLfuSuvVjGdGO0x7JVvcKm4MfucSlnWvtRIccEeUhh4DXSRYPNdRuOH1vDF1WHV6JBXfQQUvDuGP9UzNUw0P842B1/DKUPN8BUdhpxGw2YXVZR1uicZy656Tlt/46HJJY0cJ/ecX5mNv6IKCH37ibLJSsablAGLEpsU1BnHG/yjS/BorjkwCrVBwPkgliGnZgZsPMds3CYJQ7xnc/@nJssHlWQXEG/rLCWWdF4FXuMudwptdkOs1ipM0y4sSlUWepUkcIY/cFxRHaZGVyTbOk61jkzJDURhGfrj6Aw "Java (OpenJDK 8) – TIO Nexus")
[Answer]
# [Haskell](https://www.haskell.org/), ~~40~~ 38 bytes
```
f s=sum s<2*sum(take(div(length s)2)s)
```
[Try it online!](https://tio.run/nexus/haskell#bU3NDsIgDL77FD14ANODgAxM3JMQDiTblCi4CPr62GzReLBN@jXfT9smKH15JignuSNkNVxHNsQXu435XC9QuOSFtxRihh6G@wao5kfMFbaQwgwTOGfRYIcaD6hQovDoBO4/7f3fjCCnooSmpEG7ZFbm94qkSTtxhpyWlCNp3YLrP0Ws/n4U3rc3 "Haskell – TIO Nexus") Takes the integer as list of digits and returns either `True` or `False`. Example usage: `f [1,2,3,4]`.
```
f s=                                   -- function f takes a list s
    sum s                              -- return whether the sum of s
         <2*sum(                     ) -- is smaller than two times the sum of
                take(div(length s)2)s  -- the first (length s/2) elements of s
```
**Edit:** Thanks to @nimi for -2 bytes.
[Answer]
# [Japt](https://github.com/ETHproductions/japt), ~~29~~ 17 bytes
*Saved 12 bytes thanks to ETHproductions and obarakon*
```
¯½*Ul)x >Us½*Ul)x
```
[Try it online!](https://tio.run/nexus/japt#@39o/aG9WqE5mhUKdqHFUOb//9GGOmY6xjrmsQA)
[Answer]
## Mathematica 36 Bytes
```
#>#2&@@BlockMap[Total,#,Length@#/2]&
```
[Answer]
## Lua, 65 bytes
`s=...load("x="..s:gsub(".","+%0"):gsub("+","-",#s/2))()print(x<0)`
Steps of conversion:
```
1234
+1+2+3+4
-1-2+3+4
x=-1-2+3+4
eval the last string
print(x<0)
```
Usage:
```
$ lua program.lua 1234
false
```
[Answer]
# JavaScript (ES6), ~~67~~ 65 bytes
I think it might be too early in the morning for golf; this seems much longer than it needs to be!
Takes input as an array of individual digits.
```
n=>(g=(a,b)=>eval(n.slice(a,b).join`+`))(0,l=n.length/2)>g(l,l+l)
```
---
## Try it
```
f=
n=>(g=(a,b)=>eval(n.slice(a,b).join`+`))(0,l=n.length/2)>g(l,l+l)
console.log(f([1,2,3,4,5,6,7,8])) // false
console.log(f([8,7,6,5,4,3,2,1])) // true
console.log(f([1,2,3,4,4,3,2,1])) // false
console.log(f([1,2])) // false
console.log(f([2,1,4,7,5,8,3,9,2,6,3,9,5,4,3,3,8,5])) // false
console.log(f([1,0,0,1])) // false
console.log(f([1,0,0,0,0,0])) // true
```
[Answer]
# [K (oK)](https://github.com/JohnEarnest/ok), ~~13~~ ~~10~~ 9 bytes
-4 bytes by making tacit
```
>/+/0N 2#
```
[Try it online!](https://tio.run/##PUrLCYAwFLs7RamHKqJ9n/4FR3CMXnpwA1evLYoJJCFJWa9Sa06HXrQiAedYQaCAj3hntSWlJonExjof5C6Dd9YwYYu9/WMTQuNt4EiOY/twsH0BwNca5DzUBw "K (oK) – Try It Online")
Takes a list of integers as the input.
* `0N 2#` split input into pairs
* `+/` sum the pairs column-wise
* `>/` is the sum of the first chunk larger than the sum of the second?
[Answer]
# [Factor](https://factorcode.org/) + `math.unicode`, 20 bytes
```
[ halves v- Σ 0 > ]
```
[Try it online!](https://tio.run/##ZY/NCoJQEIX3PsV5gSTzJytoG23aRKtocblNKOrVrlchxKfpfXql26gQhAzMzzfnDMxDSFNqezkfT4ctano2pCTVKIRJxuS2NCgm4jYqleWdUGky5lXpVBlkpBXl2DmdA3TwsIKPACEirBGjH2nMfcQs4N2KNf2fdk6nbmABO0P2@9jwHI11uuMzDWceD8tf9E5vr0hE3vJL7QKfN8M9brYQFWojZObaLw "Factor – Try It Online")
## Explanation:
It's a quotation (anonymous function) that takes a sequence of integers from the data stack as input and leaves a boolean value on the data stack as output. Assuming `{ 1 2 3 4 5 6 7 8 }` is on top of the data stack when this quotation is called...
* `halves` Split a sequence in half.
**Stack:** `{ 1 2 3 4 } { 5 6 7 8 }`
* `v-` Element-wise subtraction of two vectors. (This is shorter than summing each sequence individually.)
**Stack:** `{ -4 -4 -4 -4 }`
* `Σ` Sum.
**Stack:** `-16`
* `0 >` Is it greater than zero?
**Stack:** `f`
[Answer]
# [Thunno 2](https://github.com/Thunno/Thunno2), 5 [bytes](https://github.com/Thunno/Thunno2/blob/main/docs/codepage.md)
```
2ẆʂØv
```
[Try it online!](https://Not-Thonnu.github.io/run#aGVhZGVyPWQmY29kZT0yJUUxJUJBJTg2JUNBJTgyJUMzJTk4diZmb290ZXI9JmlucHV0PTEyMzQ1Njc4JTIwLSUzRSUyMEZhbHNlJTBBODc2NTQzMjElMjAtJTNFJTIwVHJ1ZSUwQTEyMzQ0MzIxJTIwLSUzRSUyMEZhbHNlJTBBMTIlMjAtJTNFJTIwRmFsc2UlMEEyMTQ3NTgzOTI2Mzk1NDMzODUlMjAtJTNFJTIwRmFsc2UlMEExMDAxJTIwLSUzRSUyMEZhbHNlJTBBMTAwMDAwJTIwLSUzRSUyMFRydWUmZmxhZ3M9Qw==)
#### Explanation
```
2ẆʂØv  # Implicit input
2Ẇ     # Split into 2 pieces
  ʂ    # Sum each inner list
   Øv  # Strictly decreasing?
       # Implicit output
```
]