[Question]
  [
Inspired by [this code review](https://codereview.stackexchange.com/questions/242563/check-if-array-has-the-same-number-of-even-and-odd-values-in-python) question, I am curious to see what happens if we turn that into a code-golf challenge!
The description is easy, the input is an array or any similar data structure with only unsigned integers, the output is a boolean if the number of odd numbers is equal to the number of even numbers inside (true or false doesn't matter, as long as the opposite is used in case the number doesn't match)
Here are some examples with true as output for matching (thanks to the original OP)
```
[5, 1, 0, 2]      ->  true 
[5, 1, 0, 2, 11]  ->  false
[]                ->  true 
```
Usual code-golf rules, shortest code wins.
  
[Answer]
# [Haskell](https://www.haskell.org/), 20 bytes
```
(==0).sum.map((-1)^)
```
[Try it online!](https://tio.run/##TYk9CoAgGIav8g4NChYaNHoSM5DIilQk6/p92db2/GyuHEsI5PVITGvJu3LHLrrMWKv4xCm6PUEjn3u60KAeeBgzCCgBKdBbgZ9VUF@xlp7ZB7cWauecXw "Haskell – Try It Online")
[Answer]
# [Python 2](https://docs.python.org/2/), 33 bytes
```
lambda l:sum(n%-2|1for n in l)==0
```
[Try it online!](https://tio.run/##K6gsycjPM/qfZhvzPycxNyklUSHHqrg0VyNPVdeoxjAtv0ghTyEzTyFH09bW4H95RmZOqoKhVUFRZl6JQppGZl5BaYmGpub/aFMdBUMdBQMdBaNYLiQOkGEIFIgFAA "Python 2 – Try It Online")
`n%-2|1` is a shorter way to do`(-1)**n`. It works like this:
```
   n  n%-2  n%-2|1
------------------
even     0       1
 odd    -1      -1
```
**36 bytes**
```
lambda l:sum(map((-1).__pow__,l))==0
```
[Try it online!](https://tio.run/##TchBCoAgEEDRfaeY5QxYpNAm8CQVYpQkqA1lRKe3lu3@@/zkbU@qOD2WYOO8WAj9eUWMlhFrSY0xvN/GiECkdVvuzYcVZM@HTxkc@sRXRqIydAKkgFaAmqofvpDfmF4 "Python 2 – Try It Online")
[Answer]
# [Jelly](https://github.com/DennisMitchell/jelly), 4 [bytes](https://github.com/DennisMitchell/jelly/wiki/Code-page)
Thanks to [Nick Kennedy](https://codegolf.stackexchange.com/users/42248/nick-kennedy) for fixing a bug after three years!
```
Ḃo-S
```
A monadic Link that accepts a list of integers and yields zero (falsey) if the odd and even counts are equal or a non-zero number (truthy) otherwise.
**[Try it online!](https://tio.run/##y0rNyan8///hjqZ83eD/Ryc93DnD@lHDHAVbO4VHDXNBzNK81MLSxBwgD8iBMQ@322tG/v8fHW2qo2Coo2Cgo2AEZBjG6nApgITMwQygkBGYYQiRhrGNdRRMYQpMdBTMwGxkhaj6jCGqYJoQNgK5sQA "Jelly – Try It Online")**
### How?
```
Ḃo-S - Link: list of integers              e.g. [ 1, 2, 3, 4, 6]
Ḃ    - least-significant bit (vectorises)       [ 1, 0, 1, 0, 0]
  -  - -1
 o   - logical OR                               [ 1,-1, 1,-1,-1]
   S - sum                                      -1
```
Alternatively, `ịØ+S`, [does the same thing](https://tio.run/##y0rNyan8///h7u7DM7SD/x@d9HDnDOtHDXMUbO0UHjXMBTFL81ILSxNzgDwgB8Y83G6vGfn/f3S0qY6CoY6CgY6CEZBhGKvDpQASMgczgEJGYIYhRBrGNtZRMIUpMNFRMAOzkRWi6jOGqIJpQtgI5MYCAA "Jelly – Try It Online") using modular indexing.
[Answer]
-2 bytes, BIG Thanks to Arnauld
# [JavaScript (V8)](https://v8.dev/), 31 bytes
```
s=>s.map(e=>d+=e&1||-1,d=0)&&!d
```
[Try it online!](https://tio.run/##y0osSyxOLsosKNEts/ifZvu/2NauWC83sUAj1dYuRds2Vc2wpkbXUCfF1kBTTU0x5X9yfl5xfk6qXk5@ukaaRrSpjoKhjoKBjoJRrKaOuoKunYJCSVFpqoK6pjUXTqVAhiFceVpiTnEqIeVGBJWjWA@U/w8A "JavaScript (V8) – Try It Online")
[Answer]
# perl -alp, 20 19 bytes
```
$_=@F-2*grep$_%2,@F
```
[Try it online!](https://tio.run/##K0gtyjH9/18l3tbBTddIK70otUAlXtVIx8Ht/39TBUMFAwUjLiitYGjIxWWoAIJGIIjMVjD6l19QkpmfV/xfNzGnAAA "Perl 5 – Try It Online")
Just checks whether the size of the input is twice the number of odd integers. Accepts a list of space separated integers on STDIN. Prints 0 if the number of even and odd numbers are equal, something else otherwise.
[Answer]
# [Wolfram Language (Mathematica)](https://www.wolfram.com/wolframscript/), 14 bytes
```
Tr[(-1)^#]==0&
```
[Try it online!](https://tio.run/##y00syUjNTSzJTE78n277P6QoWkPXUDNOOdbW1kDtf0BRZl6JQ7qDQnUtF4JtqmOoY6BjhEVIx9Cw9v9/AA "Wolfram Language (Mathematica) – Try It Online")
[Answer]
# [MathGolf](https://github.com/maxbergmark/mathgolf), 4 bytes
Port of @xnor's Haskell answer. In MathGolf, summing an empty list yields `0`.
```
b▬Σ┌
```
[Try it online!](https://tio.run/##y00syUjPz0n7/z/p0bQ15xY/mtLz/3@0qYKhgoGCUSwA "MathGolf – Try It Online")
## Explanation
```
b    Constant -1
 ▬   -1 ** input list (vectorizes)
  Σ  Sum the resulting list
   ┌ Convert to inverted boolean
```
[Answer]
# [Python 3](https://docs.python.org/3/), 30 bytes
```
lambda x:sum(i%2-.5for i in x)
```
[Try it online!](https://tio.run/##K6gsycjPM/6fZhvzPycxNyklUaHCqrg0VyNT1UhXzzQtv0ghUyEzT6FC839BUWZeiUaaRrSxjrGOqY6hjoGOUaymJhdcHCH2HwA "Python 3 – Try It Online")
[Answer]
# x86 32-bit machine code, 13 bytes
Input: `uint32_t *esi, size_t ecx`  
returns: EDX = `len - 2*even` = 0 for balanced, non-zero for unbalanced.  
This conveniently works even for len=0 = balanced. As part of this asm custom calling convention / ABI, my boolean data type is 0 / non-zero, rather than the 0 / 1 that C ABIs use.
This avoids needing to actually compare, just decrement twice *inside* the loop, starting with the list length.
```
     1                         boe:
     2 00000000 89CA               mov    edx, ecx           ; balance = len
     3 00000002 E309               jecxz  .end
     4                         .loop:                        ; do {
     5 00000004 AD                 lodsd                       ; eax = *p++
     6 00000005 A801               test   al, 1
     7 00000007 7502               jnz   .odd
     8 00000009 4A                 dec    edx
     9 0000000A 4A                 dec    edx                 ; more compact than sub edx,2 in 32-bit code
    10                         .odd:
    11 0000000B E2F7               loop   .loop              ; }while(--ecx);
    12                         .end:
    13                         ;    xchg   eax, edx          ; custom calling convention: return in EDX instead of spending a byte on xchg
    14 0000000D C3                 ret
```
[Try it online!](https://tio.run/##pVPBbtswDL3rK3hsFidIsrUobPS2/cOAYShoi7U1yJIhKYnTYd@ekbaHukVSDJthQCJFkY9PfBgjtaU9rRzG9nwuPeUK@Gv9QRbSfQZU9YPvB2@eAdbktFpb77scrnwFaA8/h0vW66ivhhH28AAfuuVyCE4UEy9oM9iOJR0XhLXXejA1VROqN@aF1K0PBJVvO6wSpAYdxH05NLQD4@DjblWaxAGalOTPJ7S@k4LT@irhr2NjLN2sVkzDolBCQ64KOeurphYcKGTNwRRQ7WPyLVRorXE1l3MHcsl4l0OgtA9OsHz5/HWozh6lFFpTO9jeqdr6Ei08xoQhqXGZvw5pkwGGsJ374gVfxbhu/0AqwHcCgBGdoMMYASE2PiQKYMnVqcnA89a7mj3JMyrU8EzBRwkXLgm49/VQQRoDnho1WMVUsBQisJ9jKEdu5i6ha8RpnDz7pr/fzGejN@lGct9IP5mAW8CCCYpUSQOwDl5jQiXHMopawy1nzGCTwY43Y27JxSdsvVxM1CfFmR8Pu/zC6KBNcKAQOfaVGPB/xTDNd3lKBN/4@b4zypew/v4OTARrUrK04sQGXcF0s49/od3643jZP/GrHRtvSbh7TyrYvzHh77WCopXrYokVvidtbZYPn/5NVZMYzuff "Assembly (nasm, x64, Linux) – Try It Online") (with a `_start` test case that exits with the return value as exit status)
An alternate version that calculates in EAX to return in the standard calling convention's register is 14 bytes. It uses `test byte [edi], 1` (1 byte longer than `test al,1`) and increments the pointer with `scasd` (without caring about the FLAGS result of the `eax - [edi]` it also does). See the TIO link.
Uncommenting the `xchg eax, edx` at the bottom of the 13-byte version would do the same thing, and that version's loop is more efficient.
---
For 8-bit integer input, use `lodsb` instead. Unfortunately, we can't use `and al, 1` / `add dl, al` or similar (without branching). That would only work for array sizes up to 255. `and eax,1` is 3 bytes.
Also, masking and adding only does one increment. `lea edx, [edx + eax*2]` could work but that's also 3 bytes. Branching on the low bit with test/jnz seems to be best for size, although it sucks for performance with branch mispredicts.
Of course if we wanted to go fast, we'd load 16 bytes at once with `movdqa`, isolate the low bits with `pand`, and sum with `paddd`. Then hsum at the end. Or hsum with `psadbw` against a zeroed register, then `paddq`. SIMD is of course especially good for 8-bit elements, 16 per vector instead of 4, with an outer loop to avoid overflowing 8-bit counters. e.g. [this AVX2 SO answer](https://stackoverflow.com/questions/54541129/how-to-count-character-occurrences-using-simd).
Something like this could maybe be smallish code-size if we limited it to a fixed-size 16-byte input array, or maybe 8-byte in MMX registers. Unfortunately we rarely get to play with SIMD in code golf because the instructions are larger and inputs can be odd lengths requiring cleanup loops.
[Answer]
Here is my version (Thanks to @ElPedro and to everyone in the comments for the corrections):
# [Python 3](https://docs.python.org/3/), 37 bytes
```
lambda x:sum(i%2for i in x)==len(x)/2
```
[Try it online!](https://tio.run/##K6gsycjPM/6fZhvzPycxNyklUaHCqrg0VyNT1Sgtv0ghUyEzT6FC09Y2JzVPo0JT3@h/QVFmXolGmka0qY6hjoGOUaym5n84GwA "Python 3 – Try It Online")
[Answer]
# [dc](https://www.gnu.org/software/bc/manual/dc-1.05/html_mono/dc.html), ~~25~~ ~~24~~ 23 bytes
```
?0[r_1r^+z1<F]sFz1<Fd/p
```
[Try it online!](https://tio.run/##S0n@/9/eILoo3rAoTrvK0MYtttgNRKXoF/z/b6pgqGCgYKRgaAgA "dc – Try It Online")
Or verify the [test examples](https://tio.run/##RY1BCsIwFET3/xRDcCfFfsFdrCuz9QBFJSbRFNqkpAVBvHtsteBmHrxhmJsefDZ6RNWn@Ei6g5TieFIiH8o6XTld1i@W6jyoGXbT56kkevqmdUhOW7RNcATYOAXgjI8oAsRq9thXEH//kwJvWIPijuXyuw4u78AosaWFYCb6AA).
---
Input on stdin: a line of space-separated integers.
Output on stdout: `0` for truthy, and `1` for falsey (dc doesn't have standard truthy/falsey values).
[Answer]
# [Ruby](https://www.ruby-lang.org/), 23 bytes
```
->x{x.sum{|n|~0**n}==0}
```
[Try it online!](https://tio.run/##KypNqvyfZvtf166iukKvuDS3uiavps5ASyuv1tbWoPZ/gUJadLSpjqGOgY5RbCwXlKtgqKNgoKNgBGQYwkRjY/8DAA "Ruby – Try It Online")
Special thanks to [Manatwork](https://codegolf.stackexchange.com/users/4198/manatwork), [Dingus](https://codegolf.stackexchange.com/users/92901/dingus) and to [histocrat](https://codegolf.stackexchange.com/users/6828/histocrat) for finding the shortest solution, all credit to them.
[Answer]
# [K (Kona)](https://github.com/kevinlawler/kona), ~~7~~ 6 bytes
-1 byte thanks to coltim
```
~+/-1^
```
[Try it online!](https://tio.run/##y9bNzs9L/P8/zapOW1/XMO5/mrqGqYKhgoGCkbUClKFgaGitYKBsoPkfAA "K (Kona) – Try It Online")
# [J](http://jsoftware.com/), 9 bytes
```
0=1#._1^]
```
[Try it online!](https://tio.run/##y/qvpKeepmBrpaCuoKNgoGAFxLp6Cs5BPm7/DWwNlfXiDeNi/2tyKXClJmfkK2hYp2mq6dkpmCoYAhUaWcMYCoaG1goGKgYKCgr/AQ "J – Try It Online")
Ports of [xnor's Haskell solution](https://codegolf.stackexchange.com/a/205112/75681) - please upvote him!
[Answer]
# [APL (Dyalog Extended)](https://github.com/abrudz/dyalog-apl-extended), 7 bytes
Port of xnor's Haskell solution. Prompts for the input; -2 thanks to @Graham.
-1 byte thanks to @Adám by switching the language.
```
=+/¯1*⎕
```
[Try it online!](https://tio.run/##SyzI0U2pTMzJT9dNrShJzUtJTfn/qKM97b@ttv6h9YZaj/qmgvj/07hMFQwVDBSMuOAsBUNDZI4BkPOodw0A "APL (Dyalog Extended) – Try It Online")
[Answer]
# [Excel], 28 bytes
Paste this into a cell outside of column A, the array goes in column A. 
```
=0=SUM(IF((A:A<>""),-1^A:A))
```
An example:
[![An example](https://i.stack.imgur.com/dphbb.png)](https://i.stack.imgur.com/dphbb.png)
[Answer]
# [Java (JDK)](http://jdk.java.net/), 28 bytes
```
a->a.map(n->-n%2|1).sum()==0
```
[Try it online!](https://tio.run/##bU/BSsNAEL33K8ZAYKPN0oi9pCbgwYMHUag38TCmu2VrdhN2JoGi/fZ1E@pB9PB4zLx5M28OOGJ@2H0EY/vOMxxiLQc2rbzcLP709OAaNp37VyT2Cu0kNS0SwSMaB58LgH54b00DxMiRxs7swEZNbNkbt399A/R7yuZRgGevdqZBVrcPjrfzyhp0FTCvUVrshcvr3KXXX0UmabAiq6pV2MxW3XkxogdWxOWvpQBTH6GCO@/xSOesYpqU1LeGRQJXSZZJbVpWXhDkNVyQNHRvez6KqMTbL13MJCLUXvmyHLEd1JPONucb2yOxsrIbWPbxM9YiSamElFKXLOdUS9ByYoHZ2XVaTDiFsIYCVnD9w1AUIRSR13DzDQ "Java (JDK) – Try It Online")
[Answer]
# [Burlesque](https://github.com/FMNSSun/Burlesque), ~~17~~ 14 bytes
```
ps{2.%}pt)L[sm
```
[Try it online!](https://tio.run/##SyotykktLixN/f@/oLjaSE@1tqBE0ye6OPf/f1MFQwUDBSMA "Burlesque – Try It Online")
Saved 3 bytes using shorthand map
Explanation:
```
ps                # Parse input as a block
  {2.%}pt         # Partition block based on modulo 2
         )L[      # Map blocks to their length
            sm    # Check lengths are the same
```
[Answer]
# [Befunge-98 (PyFunge)](https://pythonhosted.org/PyFunge/), ~~13~~ 12 bytes
*-1 byte thanks to @Jo King!*
```
#.&2%2*1-+#@
```
[Try it online!](https://tio.run/##S0pNK81LT9W1tNAtqAQz//9X1lMzUjXSMtTVVnb4/z/aVEfBUEfBQEfBKBYA)
This uses the same logic (`&2%2*1-+`) as @Abigail's answer, but has a different control flow structure. Befunge-98 adds extra "error handling" functionality to the `&` and `~` input instructions: when EOF is reached, they reflect the instruction pointer. When this happens, the program can execute a different section of code without the need for an explicit conditional.
```
#.&2%2*1-+#@
               
               (Implicit: the counter, the top of the (empty) stack, starts at 0)
               (Implicit in program structure: begin loop)
#              Skip the next instruction
 .             (skipped)
  &            Get integer from STDIN
   2%          Take the integer modulo 2
     2*        Multiply that by 2 (results in 2 if the number was odd and 0 if even)
       1-      Subtract 1 (results in 1 if the number was odd and -1 if even)
         +     Add that to the counter
          #    Skip the next instruction
           @   (skipped)
               Repeat
When the input runs out: 
  &            Catch the EOF and reverse direction
 .             Output the counter (0 if odds and evens are matched, nonzero otherwise) as an integer
#              Skip the next instruction (a space)
           @   End the program
```
[Answer]
# [MATL](https://github.com/lmendo/MATL), ~~6~~ 5 bytes
-1 bytes thanks to @LuisMendo
```
oEqs~
```
[Try it online!](https://tio.run/##y00syfn/P9@1sLju//9oUwVDBYNYAA "MATL – Try It Online")
## Explanation
```
oEqs~
o      % Replace each elements with its parity (i.e. mod 2)
 E     % Multiply all element by 2
  q    % Decrement all elements by 1
   s   % Sum the array
    ~  % Boolean not the sum
```
[Answer]
# sed `-E`, ~~78~~ 80 bytes
*+7 to account for 0's and empty lists, -5 from golfing*
Tried to have some fun:) Input is spaced separated unary numbers.
Ex: `echo "!!! !! !!!!" | sed -Ef main.sed` (if the code is saved to main.sed)
```
s/_/@/g
s/(!!)+/@/g
s/@*!/!/g
s/ //g
:l
s/(!@|@!)//g
tl
s/!+/true/g
s/^$/false/g
```
[Try it online!](https://tio.run/##TYq9CoAwEIP3PkUDDmqR2526@BqK4A@CtOLVzWf3bIuDIZB8JDxPzeouEaaBLK2KqQQq83Vbg5Cbphjtnnd7W1SJQ2IYCuc151df0DLuHEEESRp60ID6QzSUevwRNu9Ymu4F "sed – Try It Online")
[Answer]
# [Uiua](https://uiua.org), 8 [bytes](https://uiua.org/pad?src=U0JDUyDihpAgK0BcMOKKlwpEZWNvZGUg4oaQIOKHjOKKjy0x4pa9wrEu4o2Y4ouv4oav4oqCwq8x4qe74ouv4qe7LOKHjOKItSjihpjCrzHii68rMjU2KSAtQFwwKzEKJnAg4oqCIjggYml0IGVuY29kaW5nOlx0IiBTQkNTICLih4ziio8tMeKWvcKxLuKNmOKLr-KGr-KKgsKvMeKnu-KLr-Knuyzih4ziiLUo4oaYwq8x4ouvKzI1NikiIOKKgitAXDDih6ExMjkiLiziiLY74oiYwqzCscKv4oy14oia4peL4oyK4oyI4oGFPeKJoDziiaQ-4omlKy3Dl8O34pe_4oG_4oKZ4oan4oal4oig4qe74paz4oeh4oqi4oeM4pmt4ouv4o2J4o2P4o2W4oqa4oqb4oqd4pah4oqU4omF4oqf4oqC4oqP4oqh4oav4oaZ4oaY4oa74per4pa94oyV4oiK4oqXL-KIp1xc4oi14omh4oi64oqe4oqg4o2l4oqV4oqc4oip4oqT4oqD4oqZ4ouF4o2Y4o2c4o2a4qyaJz_ijaPijaQh4o6L4oas4pqCzrfPgM-E4oiefl9bXXt9KCnCr0AkXCLihpB8IyIKJnAg4oqCImRlY29kZWQ6XHQiIERlY29kZSAiwqPCsS0xwrjChy7DjMKlwrPCsMKIMcKfwqXCnyzCo8K_KMK1wogxwqUrMjU2KSIg4oqCK0BcMOKHoTEyOSIuLOKItjviiJjCrMKxwq_ijLXiiJril4vijIrijIjigYU94omgPOKJpD7iiaUrLcOXw7fil7_igb_igpnihqfihqXiiKDip7vilrPih6HiiqLih4zima3ii6_ijYnijY_ijZbiipriipviip3ilqHiipTiiYXiip_iioLiio_iiqHihq_ihpnihpjihrvil6vilr3ijJXiiIriipcv4oinXFziiLXiiaHiiLriip7iiqDijaXiipXiipziiKniipPiioPiipnii4XijZjijZzijZrirJonP-KNo-KNpCHijovihqzimoLOt8-Az4TiiJ5-X1tde30oKcKvQCRcIuKGkHwjIg==)
```
=0/+ⁿ∶¯1
```
[Try it!](https://uiua.org/pad?src=ZiDihpAgPTAvK-KBv-KItsKvMQoKZiBbNSAxIDAgMl0KZiBbNSAxIDAgMiAxMV0KZiBbXQpmIFsxIDNdCmYgWzEgMl0KZiBbMiAyIDIgMiAxXQ==)
```
=0/+ⁿ∶¯1
    ⁿ∶¯1  # raise -1 to input
  /+      # sum
=0        # is it equal to zero?
```
[Answer]
# [K (ngn/k)](https://codeberg.org/ngn/k), ~~6~~ 9 bytes
+3 bytes from fixing code per @Dominic van Essen's comment
```
~+/1 1'2!
```
[Try it online!](https://ngn.codeberg.page/k#eJxVi8FugzAQRO/+io1Uqa3KxjYpFyz1RxBSXLMOCLAb20Sgqvn2kjYS7Zxm3szY8vrCJcjHfMdYKj8fquUaSguzOvpePR2t7gY1q0WF5/prXVQFSBCQK1lvAaRU4pZ34j9/vWHGWZvSRyw5N76hkx/sPiZteppNq92J9saP/DxRTJ13keeikOLATUumx86idqhD0Av6gHSeuoseyCVsdcTUEkY9ErppfKeA3qJvmvXRIF3I3XFkrCoykBmIDPIafoRvAClMBH+71cj6t7N6iMSq+3rT9mPsG0vSWQM=)
* `2!` mod the (implicit) input by two
* `1 1'` convert `0`'s to `-1`'s, leave `1`s unchanged
* `~+/` not the sum of the above
[Answer]
# [05AB1E](https://github.com/Adriandmen/05AB1E), ~~6~~ 4 bytes
```
ÉD¢Ë
```
[Try it online!](https://tio.run/##yy9OTMpM/f//cKfLoUWHu///jzbVUTDUUTDQUTACMgxjAQ "05AB1E – Try It Online")
## Explanation
```
É    Is the number odd?
 D   Duplicate
  ¢  Count the occurances of the bits in the original copy
   Ë Are all items in the list equal?
```
[Answer]
# [Factor](https://factorcode.org/), 52 bytes
```
: f ( s -- ? ) [ odd? ] partition [ length ] bi@ = ;
```
[Try it online!](https://tio.run/##TU6xCsIwFNz9iht1iFjBpUXqJl26FKfSIbWvGmxfYpIKUvrtMYiD3HJ3HHfXy6vXNlyqojyneJBlGjBKf4ej50R8JQdjyfu3sYo9slVRpqjkSIKnsSUrdC901wnJnaAX8c92IUWPNRyEQI4NasRUjgZGWq@80hytgfgWpxq06oQjsjBjxgEJdthj@eNJ8pVLRB17m3jRYBs@ "Factor – Try It Online")
[Answer]
# [Pyth](https://github.com/isaacg1/pyth), 6 bytes
```
!sm^_1
```
[Try it online!](https://tio.run/##K6gsyfj/X7E4Ny7e8P//aFMdBUMdBQMdBaNYAA "Pyth – Try It Online")
## Explanation
```
!sm^_1
  m    : map
   ^_1 : -1 power value
       : over implicit input
 s     : sum it
!      : logical negate the sum (i.e. 0 -> True, -1 -> False, 10 -> False)
```
[Answer]
# [R](https://www.r-project.org/), ~~18~~ 17 bytes
```
!sum((-1)^scan())
```
[Try it online!](https://tio.run/##K/r/X7G4NFdDQ9dQM644OTFPQ1PzvyGXEZcxlwnXfwA "R – Try It Online")
*Edit: -1 byte thanks to Bart-Jan van Rossum*
[Answer]
# [C (gcc)](https://gcc.gnu.org/), ~~45~~ ~~44~~ 43 bytes
Saved a byte thanks to [ceilingcat](https://codegolf.stackexchange.com/users/52904/ceilingcat)!!! 
Saved a byte thanks to [Olivier Grégoire](https://codegolf.stackexchange.com/users/16236/olivier-gr%c3%a9goire)!!! 
```
b;f(int*a){for(b=0;~*a;b+=-*a++%2|1);b=!b;}
```
[Try it online!](https://tio.run/##vZBbS4RAFMff@xQnQfAywszYPrSTQURfoNfVB68l7NqiLhpmX92Ozrop7UO20ICI5/wv4y@0XsKw6wKRaGlWGr7eJG@5FjhUfBq@CEzHMnzTVPkH00XgXAei7XZ@mmk6NFeAB02QHXYF23jgQLMiwAhQApyAxVox0/CfGsbO6Gypm823cVbI8Q0BTKCTXVzv47CMI7mX2aM3fPVzA3K5Utz6ibv17SM@K4XA9NtW0DFY9jmGJprykOf@@xo2ii6jEAz0kCDFLCrwdSevRT0BppmOSIZrJSi9p/opDMuOMdMKNcKFxJd6x307u4TnZqOxr66wOtEGx3E6Cp/j4rAt16BGoBZoIlAR/O/KcU54qNd3zFzW@SNL/0aDXU6D/4LGNwm@nAT7FxL8chL2IhL2chJ8INF2Xw "C (gcc) – Try It Online")
**Input**: 
\$-1\$ terminated `int` array. 
**Output** 
C boolean values: \$1\$ if number of odd are equal to the number of even numbers, \$0\$ otherwise.
**How** 
Initialise a counter `b` to \$0\$. Then go through the elements in the array adding \$1\$ to `b` for every odd number and \$-1\$ to `b` for every even number. Return the boolean result of testing `b` equal to \$0\$.
[Answer]
# [brainfuck](https://github.com/TryItOnline/brainfuck), 34 bytes
```
+>+>>,[[-[->]<]<<+[>]>,]<<[-<->]<.
```
[Try it online!](https://fatiherikli.github.io/brainfuck-visualizer/#Kz4rPj4KLFtbLVstPl08XTw8K1s+XT4sXQo8PFstPC0+XTwuCgppbnB1dDogNDgsIDQ5LCA0OCwgNDkKITAxMDE=) (Check the `!` box to enter input automatically.)
Takes input as code points. Prints a null byte if there are equal number of odds and evens. Otherwise, prints a non-null byte.
**Memory layout**:
```
a b 0 n 0
```
where `a` is the current number of odds, `b` is the current number of evens, and `n` is the current element in the array.
**Explanation**:
```
+>+>>        set a and b to 1, and pointer to n
,[           for each element n in the array
  [-[->]<]     if n is even, pointer stops at n, else, pointer stops at left of n
                 in both case, n is set to 0
                 this requires the cells left and right of n to be 0
  <<+          increment a or b appropriately
  [>]>,        pointer back to n, read new n
]            stop if n = 0 (end of array)
<<[-<->]<.   find b - a, and print that value
```
[Answer]
# [Brainetry](https://github.com/rojergs/brainetry), 342 bytes
Golfed version:
```
a b c d
a b
a b c d
a bb
a b
a b c d e f
a b c d e f g h
a b c d e f g h
a b c d e
a b c d e f g h
a b c d e
a b
a b c d e f g h i
a b c
a b c d e f g h i
a b c
a b c
a b c d
a b c d e f g h
a b
a b c d e f g h i
a b
a b c d e f
a b c d e f g h i
a b c
a b c
a b c d e f g h
a b c d e
a b c
a b c d e
a b
a b c d e f g h i
a b c
a b c d e f g
```
To make our lives easier we use the `--numeric-io` flag, so that we can take input and give output as integers, but we don't really need to and the answer works without it. Read the program below for due credit.
The golfed version was adapted from the program found below. To try this online you can
* head over to this [replit](https://repl.it/github/rojergs/brainetry) link, copy&paste the code into the `btry/replit.btry` file and hit the green "Run" button (takes input as ASCII characters (converts them to codepoints) and outputs ASCII characters, use CTRL-D in a newline to terminate input, doesn't really work well for this challenge.);
* clone the [github repo](https://github.com/rojergs/brainetry) and from your terminal run `./brainetry btry/ppcg/evens_and_odds.btry --numeric-io` (give one integer per line, use CTRL-Z or CTRL-D in an empty line to stop giving input).
```
"Check if an array
(or equivalent)
has the same number
of odd
and even
numbers - Code Golf Edition !"
That is the title of the codegolf.stackexchange.com challenge
that this brainetry program solves. Once more, with
no shame at all ,
I am piggy backing on someone else's answer.
This time, Surculose Sputum's answer.
Oh boy!
You can check the original answer over here: https://codegolf.stackexchange.com/a/205621/75323
Go upvote that!
This is a very literal port of that answer.
I am pretty
sure I could
have used brainetry's builtins
to make this easier, like » or ≥,
except that
would mean I would have to think... ugh... nope!
For now
I will stick to the low
hanging fruit just to show that brainetry is out.
If this is
the first time
you find a brainetry program, welcome! By now
you probably understood you are
allowed to write
pretty much anything as source.
(source code)
You only have to write lines of correct size
and with the
correct line modifiers. (That's a recent addition.)
```
[Answer]
# [Brachylog](https://github.com/JCumin/Brachylog), 6 bytes
```
%₂ᵍlᵐ=
```
[Try it online!](https://tio.run/##SypKTM6ozMlPN/r/X/VRU9PDrb05D7dOsP3/P9pUR8FQR8FAR8EIyDCM/R8FAA "Brachylog – Try It Online")
### How it works
```
%₂ᵍlᵐ=
  ᵍ     group input based on result of …
%₂        mod 2
   lᵐ   map length over all groups
     =  are the lengths equal?
```
]