Pyth, 18 17 bytes

iR2c.[t.B+C1z\0QQ 

Thanks to @lirtosiast for a byte!

 z get input +C1 prepend a 0x01 to prevent leading zeroes from disappearing .B convert to binary string t remove the leading 1 from ^^ .[ \0Q pad right with zeroes to multiple of second input c Q get chunks/slices of length second input iR2 map(x: int(x, 2)) 

Jelly, 13 bytes

1;ḅ256æ«BḊsḄṖ 

This takes the input as a list of integers. Try it online!

How it works

1;ḅ256æ«BḊsḄṖ Main link. Arguments: A (list), n (integer) 1; Prepend 1 to A. ḅ256 Convert from base 256 to integer. æ« Bitshift the result n units to the left. B Convert to binary. Ḋ Discard the first binary digit (corresponds to prepended 1). s Split into chunks of length n. Ḅ Convert each chunk from binary to integer. Ṗ Discard the last integer (corresponds to bitshift/padding). 

JavaScript (ES6), 120 bytes

f=(a,n,b=0,t=0,r=[])=>b<n?a.length?f(a.slice(1),n,b+8,t*256+a[0],r):b?[...r,t<<n-b]:r:f(a,n,b-=n,t&(1<<b)-1,[...r,t>>b]) 

Recursive bit twiddling on integer arrays. Ungolfed:

function bits(array, nbits) { var count = 0; var total = 0; var result = []; for (;;) { if (nbits <= count) { // We have enough bits to be able to add to the result count -= nbits; result.push(total >> count); total &= (1 << count) - 1; } else if (array.length) { // Grab the next 8 bits from the array element count += 8; total <<= 8; total += array.shift(); } else { // Deal with any leftover bits if (count) result.push(total << nbits - count); return result; } } } 

Julia, 117 bytes

f(x,n,b=join(map(i->bin(i,8),x)),d=endof,z=rpad(b,d(b)+d(b)%n,0))=map(i->parse(Int,i,2),[z[i:i+n-1]for i=1:n:d(z)-n]) 

This is a function that accepts an integer array and an integer and returns an integer array. It's an exercise in function argument abuse.

Ungolfed:

function f(x::Array{Int,1}, # Input array n::Int, # Input integer b = join(map(i -> bin(i, 8), x)), # `x` joined as a binary string d = endof, # Store the `endof` function z = rpad(b, d(b) + d(b) % n, 0)) # `b` padded to a multiple of n # Parse out the integers in base 2 map(i -> parse(Int, i, 2), [z[i:i+n-1] for i = 1:n:d(z)-n]) end 

Ruby, 114 bytes

->s,n{a=s.bytes.map{|b|b.to_s(2).rjust 8,?0}.join.split"" r=[] r<<a.shift(n).join.ljust(n,?0).to_i(2)while a[0] r} 

Slightly cleaner:

f = -> str, num { arr = str.bytes.map {|byte| byte.to_s(2).rjust(8, "0") }.join.split("") result = [] while arr.size > 0 result << arr.shift(num).join.ljust(num, "0").to_i(2) end result } puts f["f0oBaR", 5] 

Python 3, 102 bytes

j=''.join lambda s,n:[int(j(k),2)for k in zip(*[iter(j([bin(i)[2:].zfill(8)for i in s+[0]]))]*n)][:-1] 

use iter trick to group string

Results

>>> f([102,48,111,66,97,82],4) [6, 6, 3, 0, 6, 15, 4, 2, 6, 1, 5, 2, 0] >>> f([102,48,111,66,97,82],5) [12, 24, 24, 6, 30, 16, 19, 1, 10, 8] >>> f([102,48,111,66,97,82],6) [25, 35, 1, 47, 16, 38, 5, 18] >>> f([102,48,111,66,97,82],8) [102, 48, 111, 66, 97, 82] 

Perl 6, 93 68 bytes

{@^a».&{sprintf "%08b",$_}.join.comb($^b)».&{:2($_~0 x$b-.chars)}} 

PHP, 262217189 bytes

function f($b,$n){$M='array_map';return$M('bindec',$M(function($x)use($n){return str_pad($x,$n,0);},str_split(implode('',$M(function($s){return str_pad($s,8,0,0);},$M('decbin',$b))),$n)));} 

(updated with tips from Ismael Miguel)

Formatted for readability:

function f($b, $n) { $M = 'array_map'; return $M('bindec', $M(function ($x) use ($n) { return str_pad($x, $n, 0); }, str_split(implode('', $M(function ($s) { return str_pad($s, 8, 0, 0); }, $M('decbin', $b))), $n))); } 

Example:

> implode(', ',f(array_map('ord',str_split('f0oBaR')),5)); "12, 24, 24, 6, 30, 16, 19, 1, 10, 8" 

CJam, 30 bytes

{_@{2b8 0e[}%e_0a@*+/-1<{2b}%} 

Try it online!

This is an unnamed block which expects the int buffer and the amount of chunks on the stack and leaves the result on the stack.

Decided to give CJam a try. Only took me 2 hours to get it done ^^ This is probably too long, suggestions are very welcome!

Explanation

 _ e# duplicate the chunk count @ e# rotate stack, array now on top and chunk counts on the bottom { e# start a new block 2b e# convert to binary 8 0e[ e# add zeros on the left, so the binary is 8 bits } e# end previous block % e# apply this block to each array-element (map) e_ e# flatten array 0a e# push an array with a single zero to the stack @ e# rotate stack, stack contain now n [array] [0] n * e# repeat the array [0] n times + e# concat the two array / e# split into chunks of length n, now the stacks only contains the array -1< e# discard the last chunk {2b}% e# convert every chunk back to decimal 

JavaScript (ES6) 104

Iterative bit by bit fiddling,

Edit 5 bytes save thx @Neil

(s,g,c=g,t=0)=>(s.map(x=>{for(i=8;i--;--c||(s.push(t),c=g,t=0))t+=t+(x>>i)%2},s=[]),c-g&&s.push(t<<c),s) 

Less golfed

( // parameters s, // byte source array g, // output bit group size // default parameters used as locals c = g, // output bit counter t = 0 // temp bit accumulator ) => ( s.map(x => { // for each byte in s for(i = 8; // loop for 8 bits i--; ) // loop body t += t + (x>>i) % 2, // shift t to left and add next bit --c // decrement c,if c==0 add bit group to output and reset count and accumulator ||(s.push(t), c=g, t=0) }, s=[] // init output, reusing s to avoid wasting another global ), c-g && s.push(t<<c), // add remaining bits, if any s // return result ) 

Test

f=(s,g,c=g,t=0)=>(s.map(x=>{for(i=8;i--;--c||(s.push(t),c=g,t=0))t+=t+(x>>i)%2},s=[]),c-g&&s.push(t<<c),s) function test() { var a = A.value.match(/\d+/g)||[] var g = +G.value var r = f(a,g) O.textContent = r K.innerHTML = a.map(x=>`<i>${(256- -x).toString(2).slice(-8)}</i>`).join`` + '\n'+ r.map(x=>`<i>${(256*256*256*256+x).toString(2).slice(-g)}</i>`).join`` } test()

#A { width: 50% } #G { width: 5% } i:nth-child(even) { color: #00c } i:nth-child(odd) { color: #c00 }

Input array <input id=A value="102,48,111,66,97,82"> Group by bits <input id=G value=5> (up to 32)<br> Output <button onclick="test()">-></button> <span id=O></span> <pre id=K></pre>

J, 24 bytes

[:#.-@[>\;@(_8:{."1#:@]) 

This is an anonymous function, which takes n as its left argument and b as numbers as its right argument.

Test:

 5 ([:#.-@[>\;@(_8:{."1#:@])) 102 48 111 66 97 82 12 24 24 6 30 16 19 1 10 8 

Explanation:

[:#.-@[>\;@(_8:{."1#:@]) #:@] NB. Convert each number in `b` to bits _8:{."1 NB. Take the last 8 items for each NB. (padding with zeroes at the front) ;@ NB. Make a list of all the bits -@[ NB. Negate `n` NB. (\ gives non-overlapping infixes if [<0) >\ NB. Get non-overlapping n-sized infixes [:#. NB. Convert those back to decimal 

Haskell, 112 109 bytes

import Data.Digits import Data.Lists n#x=unDigits 2.take n.(++[0,0..])<$>chunksOf n(tail.digits 2.(+256)=<<x) 

Usage example: 5 # [102,48,111,66,97,82] -> [12,24,24,6,30,16,19,1,10,8].

How it works

import Data.Digits -- needed for base 2 conversion import Data.Lists -- needed for "chunksOf", i.e. splitting in -- sublists of length n ( =<<x) -- map over the input list and combine the -- results into a single list: tail.digits 2.(+256) -- convert to base two with exactly 8 digits chunksOf n -- split into chunks of length n <$> -- convert every chunk (<$> is map) take n.(++[0,0..]) -- pad with 0s unDigits 2 -- convert from base 2 

Java, 313306 322 bytes

I hope this beats PHP... And nope. Stupid long function names.

-7 thanks to @quartata for getting rid of public +16 to fix an error when the split was exact, thanks to @TheCoder for catching it

int[] f(String b,int s){int i=0,o[]=new int[(int)Math.ceil(b.length()*8.0/s)],a=0;String x="",t;for(char c:b.toCharArray()){t=Integer.toString(c,2);while(t.length()<8)t="0"+t;x+=t;a+=8;while(a>=s){o[i++]=Integer.parseInt(x.substring(0,s),2);x=x.substring(s,a);a-=s;}}while(a++<s)x+="0";o[i]=Integer.parseInt(x,2);return o;} 

Powershell 146 bytes

param([int[]][char[]]$b,$n)-join($b|%{[convert]::ToString($_,2).PadLeft(8,"0")})-split"(.{$n})"|?{$_}|%{[convert]::ToInt32($_.PadRight($n,"0"),2)} 

Take in the buffer and convert it to a char array and then an integer array. For each of those convert to binary, pad the entries with 0's where needed, and join as one large string. Split that string on n characters and drop the blanks that are created. Each element from the split is padded (only the last element really would need it) and converted back into an integer. Output is an array

Python 3.5 - 312 292 bytes:

def d(a, b): o=[];o+=([str(bin(g)).lstrip('0b')if str(type(g))=="<class 'int'>"else str(bin(ord(g))).lstrip('0b')for g in a]);n=[''.join(o)[i:i+b]for i in range(0,len(''.join(o)),b)];v=[] for t in n: if len(t)!=b:n[n.index(t)]=str(t)+'0'*(b-len(t)) v+=([int(str(f),2)for f in n]) return v 

Although this may be long, this is, in my knowledge, is the shortest way to accept both functions and arrays without errors, and still being able to retain some accuracy in Python 3.5.

Java, 253 247 bytes

Golfed

int i,l,a[];Integer I;String f="";int[]c(String s,int n){for(char c:s.toCharArray())f+=f.format("%08d",I.parseInt(I.toString(c, 2)));while(((l=f.length())%n)>0)f+="0";for(a=new int[l=l/n];i<l;)a[i]=I.parseInt(f.substring(i*n,i++*n+n),2);return a;} 

UnGolfed

int i,l,a[]; Integer I; String f=""; int[]c(String s,int n) { for(char c:s.toCharArray()) f+=f.format("%08d",I.parseInt(I.toString(c,2))); while(((l=f.length())%n)>0) f+="0"; for(a=new int[l=l/n];i<l;) a[i]=I.parseInt(f.substring(i*n,i++*n+n),2); return a; }