Code golf seems to be all the rage these days, so I figured it might be fun to give it a try here. Let's try the following rules:
1) One challenge will be active at a time.
2) Each challenge should last for a few days, at the discretion of whoever started it.
3) Any commonly-used language is valid (TI-BASIC, ASM, C/C++, Python, Javascript, and Java might be a reasonable set from which to select).
4) You will be on the honor system for the originality of your solution (ie, not just Googling the answer).
5) All discussion and tentative solutions will be put in this topic.
6) Whoever selects a particular challenge can't enter that challenge, but can enter other ones.

Challenge 1: Binary Digits
Let's start with a simple one: Given a 32-bit unsigned (positive) integer, count the number of 0s in the binary representation of the number and display the result. You can assume that the number is given in a variable, like X or x.

Excellent idea.

TI-BASIC, 17


Code:


Standard method. not(int(2... and 1>2... are the same size, and round(,0 and ...seq(... are larger.

Rather unremarkable C (GCC, x86 -msse4.2). 34 characters or something.
Code:

In "hexified" z80 assembly:
06207829EBED6AEBDE0010F7

Code:

24 characters (hex code), 12 bytes. For an extra three bytes, you could put a call to MirageOS' vputa.

In ARM assembly:

Code:
16 bytes, 40-50 characters.

Haskell, Prelude only (no imports)
Written for clarity over source code size, though you could flip stuff around and remove some spaces to make it a bit smaller.


Code:

Reminder:

Rust. (Runnable)
Code:
I made it a bit smaller.
Code:

And with printing.
Code:


Or being kind of cheaty but more efficient (though the optimizer managed to bring even my above code down to just a constant load):
Code:

But mah purity!
*Sigh* Fine...

Code:

Okay, I'm bad at this, but Lua, 74 bytes

Code:

Keeping this going a bit.

Challenge 2

Implement an RLE compressor frontend. Given a list/stream/whatever of input bytes emit pairs of (value, length) in an output list/stream/whatever.
For example, [1, 2, 2, 5, 9, 0, 0, 0, 0, 0, 1] becomes [(1,1), (2,2), (5,1), (9,1), (0,5), (1,1)].

Will the input bytes ever be negative?

They're bytes. Interpret as you like, as long as it's lossless.

Code:

That's a boring and reasonable solution. How badly does it break if the input is empty?

I built a kind of weird iterator-based version in Rust:
Code:
Playpen link.

It'll throw an IndexError if 'i' is empty

I'm trying to think up a TI-BASIC solution using seq(), but so far I'm coming up blank. I'm afraid that perhaps seq() can only perform O(1) operations on lists, not O(n) operations.

cumSum and/or ΔList are almost certainly your friends here.

[edit]
Assuming input in L1, the upper index on your seq should be
Code:
and not
Code:


[edit 2]
Okay, haven't run this, but I'm 99% sure it works:

Code:


[edit 3]
Meh: now actually works.

Code:

Double post, but here's a cute implementation in Pyret:

Code:


(the streams implementation is my own library and not a standard API, but the same RLE implementation would work almost trivially for the built-in list type, using even less code, since the tails wouldn't need to be thunked).

Pyret is a good language for golf, because the typing is optional (except for cases), and the end token has ; as a synonym. Here's the same program written verbosely:

Code: