text:
Rotate the dots
Introductions
A 2×n Boolean matrix can be represented as a string of the four characters . ':.
The string has an "upper row" and a "lower row", with dots representing 1s and empty spaces representing 0s.
For example, the 2×6 matrix
1 0 1 0 0 1
0 0 0 1 0 1

can be represented as ' '. :.
Your task is to take a matrix in this "compressed form", and rotate its entries one step clockwise, like a conveyor belt.
Input
Your input is a single string over the characters . ':.
Its length is guaranteed to be at least 2.
Output
Your output shall be the input string, but with every dot rotated one step in the clockwise direction.
More explicitly, the dots on the upper row more one place to the right, except the rightmost one, which moves down.
The dots on the lower row move one step to the left, except the leftmost one, which moves up.
In particular, the output string must have the same length as the original, and whitespace is significant.
Example
Consider the input string :..:'., which corresponds to the 2×6 matrix
1 0 0 1 1 0
1 1 1 1 0 1

The rotated version of this matrix is
1 1 0 0 1 1
1 1 1 0 1 0

which corresponds to the string ::. :'.
Rules and scoring
You can write a full program or a function.
The lowest byte count wins, and standard loopholes are disallowed.
You can decide whether the input and output are enclosed in quotes, and one trailing newline is also acceptable in both.
Test cases
These test cases are enclosed in double quotes.
"  " -> "  "
" ." -> ". "
". " -> "' "
"' " -> " '"
" '" -> " ."
": " -> "''"
"''" -> " :"
":." -> ":'"
":.'" -> ":'."
"..." -> ":. "
": :" -> "':."
"':." -> ".:'"
".:'" -> ": :"
"    " -> "    "
"::::" -> "::::"
":..:'." -> "::. :'"
" :  .:'" -> ". '.. :"
": ''. :" -> "'' :'.."
"........" -> ":...... "
"::::    " -> ":::''   "
"    ::::" -> "   ..:::"
" : : : : " -> ". : : : '"
".'.'.'.'.'" -> "'.'.'.'.'."
".. ::  '.' :." -> ": ..'' .' :.'"
".'  '.::  :.'. . ::.'  '. . .::'  :.'." -> "' ' .:.''..'.'. ..:' ' .'. ...'''..'.'"

JavaScript (ES6), 100 97 93 bytes
Saved 4 bytes thanks to @edc65
s=>s.replace(/./g,(c,i)=>" '.:"[(i?q>' '&q!=".":c>"'")+(q=c,s[++i]?s[i]>"'":c>' '&c!=".")*2])

How it works
This decides on the character we need to insert by performing some calculations on the chars before and after the current one. We sum:

If it's the first char, and it has a dot on the bottom, 2;
Otherwise, if the one before it has a dot on top, 2.
If it's the last char, and it has a dot on top, 1;
Otherwise, if the one after it has a dot on the bottom, 1.

This sums nicely to 0 for a space, 1 for ', 2 for ., and 3 for :.
Test snippet

f=s=>s.replace(/./g,(c,i)=>" '.:"[(i?q>' '&q!=".":c>"'")+(q=c,s[++i]?s[i]>"'":c>' '&c!=".")*2])
Try it out:
<input id=A type="text" value=".'  '.::  :.'. . ::.'  '. . .::'  :.'.">
<button onclick="B.innerHTML=f(A.value)">Run</button>

Well done. Save 4: s=>s.replace(/./g,(c,i)=>" '.:"[(i?q>' '&q!=".":c>"'")+(q=c,s[++i]?s[i]>"'":c>' '&c!=".")*2]) (flip 2 parts so I can increase i, less regexp and more simple test, save prev c in q)

@edc65 Thanks for the tip!

Jelly, 32 30 29 bytes
,Ṛe€"“':“.:”µṪ€;"ṚU1¦ZḄị“'.:

Note the trailing space. Try it online! or verify all test cases.
Background
We begin by considering the input string (e.g., :..:'.) and its reverse.
:..:'.
.':..:

For each character in the top row, we check if it belongs to ':, and for each character of the bottom row if it belongs to .:. This gives the 2D array of Booleans
100110
101111

which is the matrix from the question, with reversed bottom row.
We remove the last Boolean of each row, reverse the order of the rows, prepend the Booleans in their original order, and finally reverse the top row.
100110    10011    10111    010111    111010
101111    10111    10011    110011    110011

This yields the rotated matrix from the question.
Finally, we consider each column of Booleans a binary number and index into '.:  to obtain the appropriate characters.
332031    ::. :'

How it works
,Ṛe€"“':“.:”µṪ€;"ṚU1¦ZḄ‘ị“'.:   Main link. Argument: S (string)

 Ṛ                              Reverse S.
,                               Form a pair of S and S reversed.
     “':“.:”                    Yield ["':" ".:"].
  e€"                           For each character in S / S reversed, check if it
                                is an element of "':" / ".:".
                                Yield the corresponding 2D array of Booleans.

            µ                   Begin a new, monadic chain.
                                Argument: A (2D array of Booleans)
             Ṫ€                 Pop the last Boolean of each list.
                 Ṛ              Yield the reversed array of popped list.
               ;"               Prepend the popped items to the popped lists.
                  U1¦           Reverse the first list.
                     Z          Zip to turn top and bottom rows into pairs.
                      Ḅ         Convert each pair from base 2 to integer.
                        “'.:    Yield "'.: ".
                       ị        Retrieve the characters at the corr. indices.

Perl, 70 69 64 63 61 60 bytes
Includes +2 for -lp
Run with the input string on STDIN, e.g.
perl -lp rotatedots.pl <<< ":..:'."

rotatedots.pl:
y/'.:/02/r=~/./;y/.':/01/;$_=$'.2*chop|$&/2 .$_;y;0-3; '.:

Explanation
y/'.:/02/r                                        Construct bottom row but
                                                  with 2's instead of 1's
                                                  Return constructed value
                                                  (for now assume space
                                                  becomes 0 too)
          =~/./                                   Match first digit on bottom
                                                  row into $&. $' contains
                                                  the rest of the bottom row
                y/.':/01/                         Convert $_ to top row
                                                  (again assume space
                                                  becomes 0 too)
                             $'.2*chop            Remove last digit from
                                                  the top row, multiply by 2
                                                  and append to bottom row
                                       $&/2 .$_   Divide removed digit by
                                                  2 and prepend it to the
                                                  top row
                          $_=         |           "or" the top and bottom
                                                  row together. The ASCII
                                                  values of 0,1,2,3 have
                                                  00,01,10,11 as their last
                                                  two bits.

y;0-3; '.:                  Convert the smashed together top and bottom rows
                            to the corresponding representation characters.
                            Drop the final ; since it is provided by -p
                            (after a newline which doesn't matter here)

Space   is not converted in the above code. For the calculations /2 and *2 it will behave like and become 0. In the other positions it will be part of the "or", but the 1 bits of space are a subset of the one bits of 0 and will have the same effect as 0 if or-ed with any of the digits. Only if the character it is or-ed with is a space will it remain a space instead of becoming a 0. But that's ok since 0 would have been converted back to space anyways.

Retina, 66

2 bytes saved thanks to @daavko
4 bytes saved thanks to @randomra

:
1e
\.
1f
'
0e

0f
T`h`Rh`^.|.$
(.)(\d)
$2$1
e1
:
e0
'
f0

f1
.

Explanation
Starting with input:
: ''. :

The first 4 stages construct the matrix, using 1/e for true and 0/f for false for the top/bottom rows, respectively.  Top and bottom rows are interlaced together.  This would yield a string like:
e1f0e0e0f1f0e1

However, these 4 stages also effectively move the lower row 1 to the left, simply by reversing the order of the letters and digits:
1e0f0e0e1f0f1e

The Transliteration stage reverses hex digits for the first and last characters only, i.e. replaces 0-9a-f with f-a9-0.  This has the effect of moving the bottom-left character up to the top row and the top-right character down to the bottom row:
ee0f0e0e1f0f11

The next stage then swaps every letter-digit pair, thereby moving the upper row 1 to the right.  Previously this was (\D)(\d), but it turns out that (.)(\d) is sufficient because the substitutions always happen left-to-right and so the final two digits won't be erroneously matched by this, because penultimate character will have been already substituted.  The matrix has now been fully rotated as required:
e0e0f0e1e0f1f1

The final 4 stages then translate back to the original format:
'' :'..

Try it online.
All testcases, one per line, m added to T line to allow separate treatment of each input line.

Python 3, 145 141 130 bytes
def f(s):a=[i in"':"for i in s]+[i in".:"for i in s][::-1];return''.join(" '.:"[i+2*j]for i,j in zip([a[-1]]+a,a[-2:len(s)-2:-1]))

Explanation
The golfed solution use the following property of zip : zip('ABCD', 'xy') --> Ax By
so zip(a[:l],a[l:])  can be replace by zip(a,a[l:]) and that allow to remove the definition of l
def f(s):
 l=len(s)-1
 #                ┌───── unfold input string :  123  -> 123456
 #                │                             654
 #  ──────────────┴──────────────────────────────
 a=[i in"':"for i in s]+[i in".:"for i in s][::-1]
 # ─────────┬─────────   ────────────┬───────────
 #          │                        └──── generate the second row and reverse it
 #          └─────────── generate the first row

 return''.join(" '.:"[i+2*j]for i,j in zip([a[-1]]+a[:l],a[l:-1][::-1]))
 #             ──────┬──────           ─┬    ────────────┬───────────
 #                   │                  │                └──── rotate and create first/second new row :  123456  -> 612345  -> 612
 #                   │                  │                                                                                543
 #                   │                  └ group pair of the first and second row : 612 -> (6,5),(1,4),(2,3)
 #                   │                                                             543
 #                   └─────────── replace pair by symbol

Results
>>> f(".'  '.::  :.'. . ::.'  '. . .::'  :.'.")
"' ' .:.''..'.'. ..:' ' .'. ...'''..'.'"
>>> f(".....''''''")
":...  '''':"

You can save a few bytes by putting the last three lines on one line, separated by semicolons.

Pyth, 38 36
L,hb_ebsXCyc2.>syCXzJ" .':"K.DR2T1KJ

2 bytes thanks to Jakube!
Try it here or run the Test Suite.
Explanation:
L,hb_eb         ##  Redefine the function y to take two lists
                ##  and return them but with the second one reversed
                ##  Uses W to apply a function only if it's first argument is truthy
XzJ" .':"K.DR2T ##  Does a translation from the string " .':" to
                ##  .DR2T which is [0,1,2,3...,9] mapped to divmod by 2
                ##  (which is [0,0],[0,1],[1,0],[1,1], then some extra, unused values)
                ##  we also store the string and the list for later use in J and K
.>syC ... 1     ##  zip the lists to get the bits on top and below as two separate lists
                ##  apply the function y from before, flatten and rotate right by 1
Cyc2            ##  split the list into 2 equal parts again, then apply y and zip again
sX ... KJ       ##  apply the list to string transformation from above but in reverse
                ##  then flatten into a string

Seems like I did it way too complicated ^^ Would you mind adding an explanation?

@DenkerAffe Was in the middle of adding one :) Added!

Did the same approach as you. Two things I've noticed: this lambda L,hb_eb is one byte shorter, and .DR2T creates also the Cartesian product and a few more pairs, but doesn't and in a digit and helps saving a space.

@Jakube thanks, that .D trick is really cool!

Pyth, 66 bytes
KlQJ.nCm@[,1Z,Z1,ZZ,1 1)%Cd5Qjkm@" .':"id2Ccs[:JKhK<JtK>JhK:JtKK)K

Try it here!
Explanation
This can be broken down in 3 parts:

Convert the input into a flat array of ones and zeros.
Do the rotation.
Convert it back into ASCII.

Convert input
This is fairly trivial. Each character is mapped in the following way:

  -> (0,0)
. -> (0,1)
' -> (1,0)
: -> (1,0)

First one is a whitespace.
We get a list of 2-tuples which we transpose to get the 2 rows of the matrix which then gets flattened.
Code

KlQJ.nCm@[,1Z,Z1,ZZ,1 1)%Cd5Q   # Q = input

KlQ                             # save the width of the matrix in K (gets used later)
       m                    Q   # map each character d
                        %Cd5    # ASCII-code of d modulo 5
        @[,1Z,Z1,ZZ,1 1)        # use this as index into a lookup list
   J.nC                         # transpose, flatten and assign to J

Rotate
We have the matrix as flat array in J and the width of the matrix in K. The rotation can be described as:
J[K] + J[:K-1] + J[K+1:] + J[K-1]

Code

s[:JKhKJhK:JtKK)    # J = flat array, K = width of matrix

s[                  )    # Concat all results in this list
  :JKhK                  # J[K]
       JhK          # J[K+1:]
               :JtKK     # J[K-1]

Convert it back

jkm@" .':"id2Cc[)K    # [) = resulting list of the step above

              c[)K    # chop into 2 rows
             C        # transpose to get the 2-tuples back
  m                   # map each 2-tuple d
          id2         # interpret d as binary and convert to decimal
   @" .':"            # use that as index into a lookup string to get the correct char
jk                    # join into one string

Python 3, 166 154 153 150 146 138 137 135 132 127 bytes
Edit: I've borrowed the use of zip from Erwan's Python answer at the end of the function. and their idea to use [::-1] reversals, though I put in my own twist. As it turns out, reversals were not a good idea for my function. I have changed my use of format for further golfing. Moved a and b directly into zip for further golfing (ungolfing remains unchanged because the separation of a and b there is useful for in avoiding clutter in my explanation)
Edit: Borrowed (some number)>>(n)&(2**something-1) from this answer by xnor on the Music Interval Solver challenge. The clutter that is zip(*[divmod(et cetera, 2) for i in input()]) can probably be golfed better, though I do like the expediency it grants from using two tuples t and v.
t,v=zip(*[divmod(708>>2*(ord(i)%5)&3,2)for i in input()])
print("".join(" '.:"[i+j*2]for i,j in zip((v[0],*t),(*v[1:],t[-1]))))

Ungolfed:
def rotate_dots(s):
    # dots to 2 by len(s) matrix of 0s and 1s (but transposed)
    t = []
    v = []
    for i in s:
        m = divmod(708 >> 2*(ord(i)%5) & 3, 2)
            # ord(i)%5 of each char in . :' is in range(1,5)
            # so 708>>2 * ord & 3 puts all length-2 01-strings as a number in range(0,4)
            # e.g. ord(":") % 5 == 58 % 5 == 3
            # 708 >> 2*3 & 3 == 0b1011000100 >> 6 & 3 == 0b1011 == 11
            # divmod(11 & 3, 2) == divmod(3, 2) == (1, 1)
            # so, ":" -> (1, 1)
        t.append(m[0])
        v.append(m[1])

    # transposing the matrix and doing the rotations
    a = (v[0], *t)          # a tuple of the first char of the second row
                            # and every char of the first row except the last char
    b = (v[1:], t[-1])      # and a tuple of every char of the second row except the first
                            # and the last char of the first row

    # matrix to dots
    z = ""
    for i, j in zip(a, b):
        z += " '.:"[i + j*2]    # since the dots are binary
                                # we take " '.:"[their binary value]
    return z

MATL, 40 39 bytes
' ''.:'tjw4#mqBGnXKq:QKEh1Kq:K+hv!)XBQ)

Try it online! The linked version has v repaced by &v, because of changes in the language after this answer was posted.
' ''.:'               % pattern string. Will indexed into, twice: first for reading
                      % the input and then for generating the ouput
t                     % duplicate this string
j                     % input string
w                     % swap
4#m                   % index of ocurrences of input chars in the pattern string
qB                    % subtract 1 and convert to binay. Gives 2-row logical array
GnXKq:QKEh1Kq:K+hv!   % (painfully) build two-column index for rotation
)                     % index into logical array to perform the rotation
XBQ                   % transform each row into 1, 2, 3 or 4
)                     % index into patter string. Implicitly display

Ruby, 166 163 bytes
->s{a=s.tr(f=" .':",t='0-3').chars.map{|x|sprintf('%02b',x).chars}.transpose;a[1]+=[a[0].pop];a[0]=[a[1].shift]+a[0];a.transpose.map{|x|x.join.to_i 2}.join.tr t,f}

Yuck... transpose is too long.
Tricks used here:

sprintf('%02b',x) to convert "0", "1", "2", "3" into "00", "01", "10", and "11" respectively. Surprisingly, the second argument does not have to be converted into an integer first.
The rotation is done via a[1].push a[0].pop;a[0].unshift a[1].shift;, which I thought was at least a little clever (if not excessively verbose in Ruby). The symmetry is aesthetically nice, anyway :P

May I suggest to golf it a little? ->s{a=s.tr(f=" .':",'001').chars;b=s.tr(f,'0101').chars;b<(n=[...q].map(a=>(S=` .':`).indexOf(a))).map((a,i)=>(i?n[i-1]&2:n[0]&1&&2)|((I=n[i+1])>-1?I&1:n[i]&2&&1)).map(a=>S[a]).join``

I map each character to a two digit binary equivalent
 : becomes 3   11
 ' becomes 2   10
 . becomes 1   01
   becomes 0   00

and I'm thinking of them as being one on top of the other
3212021 becomes
1101010
1010001

I save that to n
For each character (0-3) of n, I check it's neighbors, adding the highest order bit of the left neighbor to the lowest order bit of the right neighbor.
if i==0 (first character) I use it's own lower order bit instead of the left neighbor's higher order bit.
if n[i+1]>-1 it means we got 0,1,2,3 so when that's false we hit the last element.
When that happens I use the character's own highest order bit instead of the right neighbor's lower bit
map that back to  .': land and join that array back together

Common Lisp, 253 247 bytes
(defun R(i &aux(n(length i))(u #1=(make-list n))(b #1#))(dotimes(k n)(setf(elt u k)(find #2=(elt i k)"':")(elt b k)(find #2#".:")))(map'string(lambda(u b)(cond((and u b)#\:)(u #\')(b #\.)(t #\ )))`(,(car b),@(butlast u))`(,@(cdr b),(nth(1- n)u))))

Try it online!
Tests included in TIO.
(defun R (i &aux (n (length i))  ; take the length of input
                 (u #1=(make-list n))   ; create the top (up) list
                 (b #1#))  ; create the bottom list
  (dotimes (k.. n)
    (setf (elt u k) (find #2=(elt i k) "':")
; set the k'th element of the top list to a non-falsey value if k'th element of input is #\' or #\:
          (elt b k) (find #2# ".:")
; set the k'th element of the bottom list to a non-falsey value if k'th element of input is #\. or #\:
(map 'string  ; collect the results into a string
     (lambda (u b) ; for each element of the rotated up and bottom lists
       (cond
        ((and u b) #\:) ; if both top and bottom are non-falsey add #\:
        (u #\')         ; if only top is non-falsey add #\'
        (b #\.)         ; if only bottom is non-falsey add #\.
        (t #\ )))       ; if both are falsey add '#\ ' (#\Space)
     `(,(car b),@(butlast u))   ; first element of the bottom and the all but last element of the top
     `(,(cdr b),(nth(1- n)u)))) ; all but first element of the bottom and the last element of the top

Saved 6 bytes using #= notation for (make-list n) and (elt i k)

JavaScript, 311 bytes
Can probably be improved alot:
a=(s=prompt()).length-1;o=s[0]==":"||s[0]=="."?s[1]==":"||s[1]=="."?":":"'":s[1]==":"||s[1]=="."?".":" ";for(i=1;i<a;i++)o+=s[i-1]=="'"||s[i-1]==":"?s[i+1]=="."||s[i+1]==":"?":":"'":s[i+1]=="."||s[i+1]==":"?".":" ";alert(o+=s[a]==":"||s[a]=="'"?s[a-1]==":"||s[a-1]=="'"?":":"'":s[a-1]==":"||s[a-1]=="'"?".":" ")

Maybe set something to s[i-1]?  That could save some bytes.

Same with s[i+1].

Try using ES6 arrow functions and a lookup, also using < instead of == might save you quite a few bytes. You may also want to checkout Tips for Golfing in JS and Tips for golfing in ES6

@Downgoat How can you use < instead of ==

Perl, 144 142 137 131 bytes
y/.':/1-3/;s/./sprintf'%02b ',$&/ge;@a=/\b\d/g;@b=(/\d\b/g,pop@a);@a=(shift@b,@a);say map{substr" .':",oct"0b$a[$_]$b[$_]",1}0..@a

Byte added for the -n flag.
Pretty much the same algorithm as my Ruby answer, just shorter, because... Perl.
y/.':/1-3/;                         # transliterate [ .':] to [0123]
s/./sprintf'%02b ',$&/ge;           # convert each digit to 2-digit binary
@a=/\b\d/g;                         # grab the 1st digit of each pair
@b=(/\d\b/g,                        # 2nd digit of each pair
pop@a);                             # push the last element of a to b
@a=(shift@b,@a);                    # unshift the first element of b to a
say                                 # output...
map{                                # map over indices of a/b
substr" .':",oct"0b$a[$_]$b[$_]",1  # convert back from binary, find right char
}0..@a                              # @a is length of a

Obnoxiously, @a=(shift@b,@a) is shorter than unshift@a,shift@b.
Alas, these are the same length:
y/ .':/0-3/;s/./sprintf'%02b ',$&/ge;
s/./sprintf'%02b ',index" .':",$&/ge;

Thanks to Ton Hospel for 5 bytes and msh210 for a byte!

Can you use ..@a instead of ..$#a? (Perhaps oct dies or returns 0 or something. I haven't tried it.)

No need to convert space to 0. It will evaluate as 0 for the sprintf anyways. Also get rid of the parenthesis in the regex. If there is no capture the whole match is returned for a //g

@msh210 That does indeed work; thanks!

@TonHospel Thanks, incorporated those into the answer (although obviously yours still completely blows mine out of the water).

That sprintf is soooo long. map$_%2,/./g and map$_/2|0,//g almost has to be shorter (untested)

JavaScript (ES6), 237 210 204 188 182 178 bytes
Credit to @Downgoat for saving 16 bytes in the 188-byte revision
Update: I had a brainwave and reduced the first operation on s to a single map call instead of two separate ones
s=>(r=" .':",a=[],s=[...s].map(c=>(t=('00'+r.indexOf(c).toString(2)).slice(-2),a.push(t[0]),t[1])),a.splice(0,0,s.shift()),s.push(a.pop()),a.map((v,i)=>r[+('0b'+v+s[i])]).join``)

Pretty Print & Explanation
s => (
  r = " .':", // Map of characters to their (numerical) binary representations (e.g. r[0b10] = "'")
  a = [],     // extra array needed
  // Spread `s` into an array
  s = [...s].map(c => (
    // Map each character to a `0`-padded string representation of a binary number, storing in `t`
    t = ('00' + r.indexOf(c).toString(2)).slice(-2)),
    // Put the first character of `t` into `a`
    a.push(t[0]),
    // Keep the second character for `s`
    t[1]
  )),
  // Put the first character of `s` in the first index of `a`
  a.splice(0,0,s.shift()),
  // Append the last character of `a` to `s`
  s.push(a.pop(),
  // Rejoin the characters, alternating from `a` to `s`, representing the rotated matrix, and map them back to their string representation
  // Use implicit conversion of a binary number string using +'0b<num>'
  a.map((v,i) => r[+('0b' + v + s[i])]).join``
)

does: s=>(r=" .':",a=[],s=[...s].map(c=>('00'+r.indexOf(c).toString(2)).slice(-2)).map(n=>(a.push(n[0]),n[1]),a.splice(0,0,s.shift()),s.push(a.pop()),a.map((v,i)=>r[parseInt(v+s[i],2)]).join\`)` work?

Sorry for not replying to this earlier, didn't see the notification - my developer tools are giving me an "illegal character" exception

Got it to work as you put it - apparently when I copied it there were some extra invisible characters in it that didn't show up in the browser developer tools.

Vyxal, 44 bytes
f`:'. `f⁺↑b2ẇĿ2ẇÞT÷ḣ„ṫ$„p‟JWÞT⁺↑b2ẇ`:'. `fĿ∑

Try it Online!
Yuck.

Python 3, 124 bytes
def f(a,s=" .':",j="".join):q=j(bin(4+s.find(i))for i in a);return j(s[int(j(x),2)]for x in zip(q[4]+q[3::5],q[9::5]+q[-2]))

Try it online!
How it works :

q="".join(bin(4+s.find(i))for i in a) store an unpacked version of our starting string a by using binary conversion

If a is equal to
ABCD
EFGH

then q is equal to ---ae---bf---cg---dh with a to h equal to "1" if there is a dot in the corresponding emplacement and "0" otherwise (and --- equal to 0b1)

zip(q[4]+q[3::5],q[9::5]+q[-2]) reshapes q to have : (eabcd),(fghd) (the last d in the first part is ignored since the second part is shorter)

s[int("".join(x),2)] reverse the process converting back the binary number into their dot version. Result :

EABC
FGHD

05AB1E, 41 bytes
Â)εS„':„.:‚Nèså¤ˆ¨}R¯øí˜2äćR¸ìζJC" '.:"sè

Try it online! Outputs as a list of characters. Link includes a footer to format the output.
Â)εS„':„.:‚Nèså¤ˆ¨}R¯øí˜2äćR¸ìζJC"..."sè  # trimmed program
                                       è  # push character...
                                          # (implicit) s...
                                       è  # in...
                                 "..."s   # literal...
                                       è  # at...
                                      s   # (implicit) indices in...
                              ζ           # list of elements with same indices in each element of...
                            ¸             # list of...
                          ć               # first element of...
 )                                        # list of...
Â                                         # implicit input...
 )                                        # and...
                                          # implicit input...
Â                                         # reversed...
  ε                                       # with each element replaced by...
              å¤                          # is...
             s                            # (implicit) each element of...
   S                                      # list of characters of...
                                          # (implicit) current element in map...
              å                           # in...
            ès                            # element in...
          ‚                               # list of...
    „':                                   # literal...
          ‚                               # and...
       „.:                                # literal...
            è                             # at index...
           N                              # current index in map...
                 ¨                        # excluding the last element...
                ˆ                         # and append...
               ¤                          # last element of...
              å¤                          # is...
             s                            # (implicit) each element of...
   S                                      # list of characters of...
                                          # (implicit) current element in map...
              å                           # in...
            ès                            # element in...
          ‚                               # list of...
    „':                                   # literal...
          ‚                               # and...
       „.:                                # literal...
            è                             # at index...
           N                              # current index in map...
                ˆ                         # to global array...
                   R                      # reversed...
                      í                   # with...
                    ¯                     # global array...
                     ø                    # with each element paired with corresponding element in...
                    ¯                     # global array...
                      í                   # prepended...
                       ˜                  # flattened...
                         ä                # split into...
                        2                 # literal...
                         ä                # equal pieces...
                           R              # reversed...
                             ì            # with...
 )                                        # list of...
Â                                         # implicit input...
 )                                        # and...
                                          # implicit input...
Â                                         # reversed...
  ε                                       # with each element replaced by...
              å¤                          # is...
             s                            # (implicit) each element of...
   S                                      # list of characters of...
                                          # (implicit) current element in map...
              å                           # in...
            ès                            # element in...
          ‚                               # list of...
    „':                                   # literal...
          ‚                               # and...
       „.:                                # literal...
            è                             # at index...
           N                              # current index in map...
                 ¨                        # excluding the last element...
                ˆ                         # and append...
               ¤                          # last element of...
              å¤                          # is...
             s                            # (implicit) each element of...
   S                                      # list of characters of...
                                          # (implicit) current element in map...
              å                           # in...
            ès                            # element in...
          ‚                               # list of...
    „':                                   # literal...
          ‚                               # and...
       „.:                                # literal...
            è                             # at index...
           N                              # current index in map...
                ˆ                         # to global array...
                   R                      # reversed...
                      í                   # with...
                    ¯                     # global array...
                     ø                    # with each element paired with corresponding element in...
                    ¯                     # global array...
                      í                   # prepended...
                       ˜                  # flattened...
                         ä                # split into...
                        2                 # literal...
                         ä                # equal pieces...
                          ć               # excluding the first element...
                             ì            # prepended...
                                          # (implicit) with each element...
                               J          # joined...
                                          # (implicit) with each element...
                                C         # converted from binary to decimal

Python 3, 105 104 bytes
s=" .':"
a=[*map(s.find,input())]
b=a[0]*2,*a,a[-1]//2
print(*map(lambda x,y:s[x&2|y&1],b,b[2:]),sep='')

Try it online!

Python 3, 294 287 283 bytes
Waaayyyyyy too long, but I will try to golf of some bytes:
z=input()
x=len(z)
M=[0,1,2,3]
for Q in M:z=z.replace(":'. "[Q],"11100100"[Q*2:Q*2+2])
a=[]
b=[]
for X in range(x):a+=[z[X*2]];b+=[z[X*2+1]]
b=b[1:]+[a.pop()]
c=[b[0]]+a
z=""
for X in range(len(c)):
 y=c[X]+b[X]
 for Q in M:y=y.replace("11100100"[Q*2:Q*2+2],":'. "[Q])
 z+=y
print(z)

Lua, 139 bytes
print(((...):gsub(".",{[" "]="NN@",["."]="YN@",["'"]="NY@",[":"]="YY@"}):gsub("(.)@(.?)","%2%1"):gsub("..",{NN=" ",NY=".",YN="'",YY=":"})))

Usage:
$ lua conveyor.lua ".'  '.::  :.'. . ::.'  '. . .::'  :.'."
' ' .:.''..'.'. ..:' ' .'. ...'''..'.'

Excel, 139 bytes
=LET(e,LEN(A1),q,SEQUENCE(e),x,CODE(MID(A1,q,1))-32,l,x>7,u,x>l*14,CONCAT(MID(" '.:",IF(q=1,l,INDEX(u,q-1))+IF(q=e,u,INDEX(l,q+1))*2+1,1)))

Link to Spreadsheet
How it works
=LET(
*Assignments*
e,LEN(A1),              'e = length of A1
q,SEQUENCE(e),          'q = (1 .. e)
x,CODE(MID(A1,q,1))-32, 'x = list of ASCII codes of each character - 32
l,x>7,                  'l = array of lower numbers = 1 if x>7 (.:)
u,x>l*14,               'u = array of upper numbers = 1 if x>l*14 (':)

*Result*
IF(q=1,l,INDEX(u,q-1)) +   'String indices = if q = 1 then l[1] else u[q-1]
IF(q=e,u,INDEX(l,q+1))*2+1 '               + (if q=e then u[e] else l[q+1]) * 2 + 1
CONCAT(MID(" '.:",~,1)))   'Concatenate all the results

J, 55 bytes
' .'':'&([{~([:g@($$_1|.,)g=.|.@{:1}_2{.])&.(|:@#:)@i.)

Try it online!


text:
Hexagon-In or Hexagon-Out?
There is a great story to tell about regular hexagons found for example in honeycombs. But this busy bee needs your help in telling him which point is inside or outside his honeypot. So, given a regular hexagon as pictured below, centered at the origin and with edge size l, determine if a set of coordinates (x,y) are inside, exactly on the edge or outside of my regular hexagon.

Input, output and rules
The rules are:

Input and output methods follow the default rules.
Input consists of three integers: x,y,l.
x and y are of any convenient signed integer format. l is positive (never 0).
Your program must output/return a 1 if the point (x,y) is inside the regular hexagon, -1 if it's outside or 0 if it's exactly on the edge.
This is a code-golf, so shortest code wins. In case of a tie, the earliest post wins.
For output to stdout: leading/trailing spaces or newlines in the output are permitted.
Standard loopholes apply.

Test cases
Here are some test cases:
0,0,1        --> 1
0,1,1        --> -1
0,-1,1       --> -1
1,0,1        --> 0
-1,0,1       --> 0
-1,-1,1      --> -1
1,1,1        --> -1
-2,-3,4      --> 1
32,45,58     --> 1
99,97,155    --> -1
123,135,201  --> 1

I assume this is a regular hexagon, but you should make that explicit.

@LevelRiverSt yes. A regular. I'll add that in a moment.

Can we take x,y as a complex number x+yi?

Related.

@lirtosiast the question is about a hexagon in the euclidian plane, not in the complex plane. Because of that complex input isn't allowed.

@agtoever There is usually no need to specify a certain value range that we have to support. Going with something like the integer limit of the chosen language is enough most of the time.

The input range should be what can reasonably handled with the language of choice - see this meta post http://meta.codegolf.stackexchange.com/q/8471/21348 (ok already done. Thank you)

MATL, 29 25 bytes
3X^/Eh|-IG2G-IX^*1G-hZSX<

Inputs are y, x, l in that order.
Try it online!

Just a tad overdue, but your code is shortest! Well done! ;-)

@agtoever Hey, thanks! People don't tend to accept answers these days... (I usually do) :-)

JavaScript (ES6) 77 83
(a,b,l,h=Math.sqrt(3)*l,x=a<0?-a:a,y=b<0?-b:b)=>y|x!=l?2*y<h&x/l+y/h<1?1:-1:0

Test

f=(a,b,l,h=Math.sqrt(3)*l,x=a<0?-a:a,y=b<0?-b:b)=>y|x!=l?2*y<h&x/l+y/h<1?1:-1:0

// TEST

function go() {
  C.width=400;C.height=300;
  var l=+I.value, x,y, cols={0:'#ff0',1:'#0f0','-1':'#888'},
  ctx = C.getContext("2d")
  ctx.translate(200,150)
  ctx.strokeStyle='#000'
  ctx.lineWidth=1;
  ctx.beginPath();
  ctx.moveTo(0,-150);ctx.lineTo(0,150);ctx.moveTo(-200,0);ctx.lineTo(200,0);
  ctx.stroke();
  ctx.strokeStyle='#f00'
  ctx.beginPath();
  ctx.moveTo(l*10,0);ctx.lineTo(l*5,l*Math.sqrt(3)*5);ctx.lineTo(-l*5,l*Math.sqrt(3)*5)
  ctx.lineTo(-l*10,0);ctx.lineTo(-l*5,-l*Math.sqrt(3)*5);ctx.lineTo(l*5,-l*Math.sqrt(3)*5)
  ctx.closePath();
  ctx.stroke();

  for(y=-14;y<15;y++)
    for(x=-19;x<20;x++) {
      ctx.beginPath();
      ctx.moveTo(x*10,y*10-3);ctx.lineTo(x*10,y*10+3);
      ctx.moveTo(x*10-3,y*10);ctx.lineTo(x*10+3,y*10);
      ctx.strokeStyle=cols[f(x,y,l)]
      ctx.stroke()
    }
}

go()
#C {
  border: 1px solid #000
}
L <input id=I value=15><button onclick="go()">GO</button>

<canvas id=C width=400 height=300></canvas>

Ruby, 150 145 137 127 125 106 88 76 bytes
76 bytes
->(x,y,l){x,y,t=x.abs,y.abs,3**0.5;d=t*l;z=d-t*x-y;2*y>d ?-1:2*x<l ?1:z<=>0}

Changed triple comparison to a rocket.
88 bytes
->(x,y,l){x,y,t=x.abs,y.abs,3**0.5;d=t*l;z=d-t*x-y;2*y>d ?-1:2*x<l ?1:z==0 ?0:0<z ?1:-1}

Remove the y equal to apothem test for points on the hexagon, because for integers, that can never be true.
106 bytes:
->(x,y,l){x,y,t=x.abs,y.abs,3**0.5;d=t*l;z=d-t*x-y;2*y==d&&2*x<=l ?0:2*y>d ?-1:2*x<l ?1:z==0 ?0:0<z ?1:-1}

Poster suggested not using epsilon, so replaced epsilon with zero and rearranged, removed an abs, etc.
125 bytes:
->(x,y,l){x,y,t,e=x.abs,y.abs,3**0.5,1e-9;d=t*l;z=d-t*x-y;(2*y-d).abs<=e&&2*x<=l ?0:2*y>d ?-1:2*x<l ?1:z.abs<=e ?0:0<z ?1:-1}

Incorporate y into definition of z and remove some parentheses.
127 bytes:
->(x,y,l){x,y,t,e=x.abs,y.abs,3**0.5,1e-9;d=t*l;z=d-t*x;(2*y-d).abs<=e&&2*x<=l ?0:2*y>d ?-1:2*x<l ?1:(z-y).abs<=e ?0:y<z ?1:-1}

Rearranged terms to avoid necessity of to_f cast. Use d (double the apothem) instead of a (the apothem). Combine multiple assignments.
137 bytes:
->(x,y,l){x=x.abs.to_f;y=y.abs.to_f;a=3**0.5*l/2;e=1e-9;z=2*a*(1-x/l);(y-a).abs<=e&&2*x<=l ?0:y>a ?-1:2*x<l ?1:(z-y).abs<=e ?0:y<z ?1:-1}

Inlined 'c'.
150 bytes:
->(x,y,l){c=l/2.0;x=x.abs.to_f;y=y.abs.to_f;a=3**0.5*l/2;e=1e-10;z=2*a*(1-x/l);(y-a).abs<=e&&x<=c ?0:(y>a ?-1:(x<c ?1:((z-y).abs<=e ?0:(y<z ?1:-1))))}

This works for integers or floats! The epsilon test is so that points within round off error of being on the edge are correctly identified.
The absolute values move everything into quadrant one.
The value 'a' is the apothem distance (the y-intercept of the hexagon).
The value 'c' is the x-value of the upper right corner of the hexagon.
The value 'z' is to see if the point is above or below the slant line from the corner to the x-intercept.
Ungolfed:
hex = ->(x,y,l){
    c = l/2.0;
    x = x.abs.to_f;
    y = y.abs.to_f;
    a = 3**0.5 * l / 2;
    e = 1e-10;
    z = 2*a*(1 - x/l);
    if (y-a).abs <= e && x <= c then 0
    elsif (y>a) then -1
    elsif (x<c) then 1
    elsif (z-y).abs <= e then 0
    elsif y < z then 1
    else -1
    end
}

Test
hex = ->(x,y,l){x,y,t=x.abs,y.abs,3**0.5;d=t*l;z=d-t*x-y;2*y>d ?-1:2*x<l ?1:z<=>0}

cases = [
    [0,0,1,1],
    [0,1,1,-1],
    [0,-1,1,-1],
    [1,0,1,0],
    [-1,0,1,0],
    [-1,-1,1,-1],
    [1,1,1,-1],
    [-2,-3,4,1],
    [32,45,58,1],
    [99,97,155,-1],
    [123,135,201,1]
]

cases.each { |test|
  expected = test[3]
  actual = hex.call(test[0],test[1],test[2])
  status = expected == actual ? "PASS" : "FAIL";
  p "#{status}. #(x,y) L = (#{test[0]},#{test[1]}) #{test[2]} Expects #{expected}. Actual #{actual}"
}
"Done!"

This could be shorter, you don't need the epsilon for integers

By introducing the square root of three, I am forced to use floating point. I could round the numbers before comparison, or use epsilon calculations. Since epsilon allows the code to be more general and work for floats, I left in the epsilon. I have only been programming Ruby a short while, so am not sure how it deals with rounding errors.

The slope of the left and right side is not rational. The apotheme is not rational. The are only 2 points with integer coordinates lying on the perimeter: [l,0] and [-l,0]

You are probably right that for integer inputs there are no other possible integer points that are "on" the hexagon. Proving that to myself was harder than making the code not care, using epsilon.

Yeah! Just passed the Python solution!

Ouch. Passed me too. +1

Pyth, 41 bytes
?<=d.5K+?>ZJ-c.ahQeQdZJ.acchtQeQ^3d_1s>dK

Test it here

JavaScript (ES6), 67 bytes
with(Math)(a,b,l)=>sign(min(l*l*3-b*b*4,(l-abs(a))*sqrt(3)-abs(b)))

Note: To assign this to a variable so that you can call it, put the f= after the with(Math).
I used l*l and b*b in the first parameter to min to avoid calls to abs and sqrt but I couldn't work out whether I could do a similar trick with the second parameter.

Julia, 65 58 bytes
f(x,l)=(t=maxabs(x/l*[[0 1 1];[2 1 -1]/3^.5]);(t<1)-(t>1))

x is a row vector [x y]. Call like this: f([0 0],1).

Python 2, 89 bytes
almost the same solution as Julia answer but we can use operation on vector without numpy
lambda x,y,L,K=3**0.5/2.:cmp(K*L,max([abs(x*i+y*j)for i,j in[[K,1/2.],[0,1],[-K,1/2.]]]))

Results
>>> f(0,0,1)
1
>>> f(32,45,58)
1
>>> f(99,97,155)
-1
>>> f(-1,0,1)
0
>>> [f(0,0,1)== 1,f(0,1,1)== -1,f(0,-1,1)== -1,f(1,0,1)== 0,f(-1,0,1)== 0,f(-1,-1,1)== -1,f(1,1,1)== -1,f(-2,-3,4)== 1,f(32,45,58)== 1,f(99,97,155)== -1,f(123,135,201)== 1,f(0,0,1)== 1,f(0,1,1)== -1,f(0,-1,1)== -1,f(1,0,1)== 0,f(-1,0,1)== 0,f(-1,-1,1)== -1,f(1,1,1)== -1,f(-2,-3,4)== 1,f(32,45,58)== 1,f(99,97,155)== -1,f(123,135,201)== 1]
[True, True, True, True, True, True, True, True, True, True, True, True, True, True, True, True, True, True, True, True, True, True]

source: Stack Exchange

license: Creative Commons - Attribution Share-Alike - https://creativecommons.org/licenses/by-sa/3.0/

sort: votes


text:
Randomize the test
I'm a teacher, and in a few days I have to give my students a test. Now, I'm always worried about my loveliest students being hurt by the least loveliest ones when they cheat, so I want to randomize the tests so no one can cheat off of anyone.
Right now, I have my tests saved in this format:
When was Java invented?
  Why does this matter?
  1941
  War was beginning
  None of the above

What is the increment operator in Java?
  Stack Overflow>how 2 incrememnt
  Google>how 2 incrememnt
  increment
  ++

That is, the questions are separated by a single blank line, and the answers are all preceded by two spaces. This is the output I need:
What is the increment operator in Java?
  ++
  increment
  Google>how 2 incrememnt
  Stack Overflow>how 2 incrememnt

When was Java invented?
  War was beginning
  1941
  Why does this matter?
  None of the above

That is, each answer on a question in a random order, and the question order randomized as well. Keep in mind that if the answer choice is "None of the above", it should stay at the bottom. Every question always has exactly four answers, and "None of the above" only ever appears as the last answer choice -- and never appears as a substring of an answer choice that is not "None of the above". Unfortunately, I can't rewrite all of my tests, so you'll have to take them in that format. Also, my students have to be able to read it, so I can't really take output any other way (except as described below).
I don't need it to be perfectly random. As long as it's close.
Standard loopholes are banned.

Bonus
Now, my students are used to that plain format, but if you can make it look like this...
1. What is the increment operator in Java?
  A. ++
  B. increment
  C. Google>how 2 incrememnt
  D. Stack Overflow>how 2 incrememnt

2. When was Java invented?
  A. War was beginning
  B. 1941
  C. Why does this matter?
  D. None of the above

I'll take 25% off of your final score. You'll get input the same way, though.
That is, if you number the questions and label the answers. Please keep in mind that questions should start at 1, and the answers are from A to D.

NB: The examples are different from the ones in the answers because I changed them after the fact. The specific examples aren't the point anyway; answers had to work with any arbitrary question(s).

Bonuses in code golf are generally discouraged. None of the current submissions take the bonus (except this one, but with the bonus is a worse score than without), so that's a pretty good indicator that the challenge would be better without the bonus.

@Mego It fits the theme of the question and is easy to understand. There's no harm in it.

Pyth - 48 42 41 39 bytes
Will packed string.
js.Sm++hd/D"None of the above".Stdkc.zk

Try it online here.

Accepting this answer because this question was [code-golf] and this answer is the shortest. Well done!

JavaScript ES6, 170 bytes
Is an anonymous function, name it. Note: this uses the random sort method, which isn't entirely random, but is sufficient, provided you aren't a probability teacher.
t=>t.split`

`.map(x=>(x=x.split`
`,R=[],(k=x.pop())=="  None of the above"?(R=[k]):x.push(k),[x.shift(),...x.sort(r=_=>.5-Math.random()),...R].join`
`)).sort(r).join`

`

With the bonus, 180.75 bytes
t=>t.split`

`.map(x=>(x=x.split`
`,R=[],(k=x.pop())=="  None of the above"?(R=[k]):x.push(k),[x.shift(),...x.sort(r=_=>.5-Math.random()),...R].map((k,i)=>(i?`  ${" ABCD"[i]}. `:"")+k.trim()).join`
`),a=0).sort(r).map(e=>++a+". "+e).join`

`

Test it out!

F=t=>t.split`

`.map(x=>(x=x.split`
`,R=[],(k=x.pop())=="  None of the above"?(R=[k]):x.push(k),[x.shift(),...x.sort(r=_=>.5-Math.random()),...R].join`
`)).sort(r).join`

`;

g.onclick=function(){o.innerHTML = ""; o.appendChild(document.createTextNode(F(i.value)));}
g.click();
textarea{width:100%;height:14em;}textarea,div,button{font-family:Consolas,monospace;white-space:pre;}
<textarea id=i>When was the War of 1812?
  1812.5
  1776
  1812
  1821

What is the capital of France?
  46
  F
  Nice
  None of the above

What is the square root of -1 (simplified)?
  i
  i don't know
  square root of -1
  wait this is a math test?</textarea><button id=g>go →</button>

Did you try going for the bonus?

@CatsAreFluffy No, net yet ;)

What's a net? Is it like a not?

@CatsAreFluffy Well, it's a highly technical... thing.

"Mostly random" is perfectly acceptable.

What's a highly? What's a thing? What's a technical? What's a ? What's a ...? What's a 493 characters left?

Pretty sure you can save two bytes by removing an "=_" from your random sort. Thanks for the intro to ES6!

@fond42518 My pleasure! However, in that random sort, I am saving the function _=>.5-Math.random() to the variable r, which I reference later on the fifth line. I am actually performing two random sorts: one on the items, and the other on the questions. If you want to learn more ES6, I suggest reading here.

CJam, 54 53 55 52 bytes
Saved 1 byte from using a later release (avaliable on TIO). Gained 2 bytes because I forgot to randomize order of questions. Saved 2 bytes from yet another bug fixed on TIO.
qNN+/mr{N/(\mr_"  None of the above"#3e\N*N\++}%NN+*

Try it online!

Only two bytes gained? o_O

@CᴏɴᴏʀO'Bʀɪᴇɴ lol yeah, I split based on questions at the beginning, then so I just added the mr operator (randomize) to randomize order of questions before the answer logic takes place.

all_licenses: Creative Commons - Attribution Share-Alike - https://creativecommons.org/licenses/by-sa/3.0/


text:
Word Search Helper
I've been doing word searches recently, and I thought it would be so much easier if all of the words read left-to-right. But rewriting all the lines takes a lot of effort! So I'm enlisting code golfers to help.
(Disclaimer: The above story may or may not be remotely accurate.)
Your code will take a rectangular grid and output all of the lines through it in both directions.
The output must contain all 8 rotations of the grid (cardinals and main diagonals), 'read off' top to bottom, left to right. (This means that every "row" will be duplicated - once forwards, and once backwards.)
The line divisions can either be a space or a line break. If you choose spaces, the grid rotation divisions must be line breaks; otherwise, the grid rotation divisions must be two line breaks.
Example input (taken as an array of characters, multiline string, or other reasonable format)
ABCDE
FGHIJ
KLMNO
PQRST

Example output (using the first option for divisions)
ABCDE FGHIJ KLMNO PQRST
E DJ CIO BHNT AGMS FLR KQ P
EJOT DINS CHMR BGLQ AFKP
T OS JNR EIMQ DHLP CGK BF A
TSRQP ONMLK JIHGF EDBCA
P QK RLF SMGA TNHB OIC JD E
PKFA QLGB RMHC SNID TOJE
A FB KGC PLHD QMIE RNJ SO T

The order of the rotations "read off" does not matter as long as all eight cardinals and primary intercardinals are done once.
This is code-golf, so shortest code wins. Standard loopholes apply.

Does the grid only contain uppercase letters or can it be the whole printable ASCII?

Almost duplicate (without the diagonals) http://codegolf.stackexchange.com/questions/37940/word-search-puzzle

@DigitalTrauma: No, not really - this one doesn't ask you to find any words at all.

Python 3, 181 bytes
def f(s):
 for k in [1,0]*4:
  b=list(zip(*[([' ']*(len(s)-1-n)*k+list(i)+[' ']*n*k)[::-1] for n,i in enumerate(s)]))
  print([' '.join(i).replace(' ','') for i in b])
  if k==0:s=b

Explanation
def f(s):
 for k in [0]*4:                  # loop 4 times, we don't need the index so [0]*4 is shorter than range(4)
  l=len(s)-1                      # number of line

  # rotation of 45°
  a=[(['.']*(l-n)+list(i)+['.']*n)[::-1] for n,i in enumerate(s)]
  # tranform matrice :
  #  ABC      ..ABC      CBA..
  #  DEF  --> .DEF.  --> .FED.
  #  GHI      GHI..      ..IHG
  b=list(zip(*a))                 # transpose
  #  CBA..      C..
  #  .FED.  --> BF.
  #  ..IHG      AEI
  #             .DH
  #             ..G
  print(' '.join(''.join(i).replace('.','') for i in b))

  # rotation of 90°
  a=[(list(i))[::-1] for n,i in enumerate(s)]
  # tranform matrice :
  #  ABC      CBA
  #  DEF  --> FED
  #  GHI      IHG
  b=list(zip(*a))                 # transpose
  #  CBA       CFI
  #  FED   --> BEH
  #  IHG       ADG
  print(' '.join(''.join(i) for i in b))
  s=b

Results
>>> f(['ABCDE','FGHIJ','KLMNO','PQRST'])
['E', 'DJ', 'CIO', 'BHNT', 'AGMS', 'FLR', 'KQ', 'P']
['EJOT', 'DINS', 'CHMR', 'BGLQ', 'AFKP']
['T', 'OS', 'JNR', 'EIMQ', 'DHLP', 'CGK', 'BF', 'A']
['TSRQP', 'ONMLK', 'JIHGF', 'EDCBA']
['P', 'QK', 'RLF', 'SMGA', 'TNHB', 'OIC', 'JD', 'E']
['PKFA', 'QLGB', 'RMHC', 'SNID', 'TOJE']
['A', 'FB', 'KGC', 'PLHD', 'QMIE', 'RNJ', 'SO', 'T']
['ABCDE', 'FGHIJ', 'KLMNO', 'PQRST']

>>> f(['ABCDEF','GHIJKL','MNOPQR','STUVWX'])
['F', 'EL', 'DKR', 'CJQX', 'BIPW', 'AHOV', 'GNU', 'MT', 'S']
['FLRX', 'EKQW', 'DJPV', 'CIOU', 'BHNT', 'AGMS']
['X', 'RW', 'LQV', 'FKPU', 'EJOT', 'DINS', 'CHM', 'BG', 'A']
['XWVUTS', 'RQPONM', 'LKJIHG', 'FEDCBA']
['S', 'TM', 'UNG', 'VOHA', 'WPIB', 'XQJC', 'RKD', 'LE', 'F']
['SMGA', 'TNHB', 'UOIC', 'VPJD', 'WQKE', 'XRLF']
['A', 'GB', 'MHC', 'SNID', 'TOJE', 'UPKF', 'VQL', 'WR', 'X']
['ABCDEF', 'GHIJKL', 'MNOPQR', 'STUVWX']

with a cleaner output (189 bytes)
j=' '.join
def f(s):
 for k in [1,0]*4:
  b=list(zip(*[([' ']*(len(s)-1-n)*k+list(i)+[' ']*n*k)[::-1] for n,i in enumerate(s)]))
  print(j(j(i).replace(' ','') for i in b))
  if k==0:s=b

.
>>> f(['ABCDE','FGHIJ','KLMNO','PQRST'])
E DJ CIO BHNT AGMS FLR KQ P
EJOT DINS CHMR BGLQ AFKP
T OS JNR EIMQ DHLP CGK BF A
TSRQP ONMLK JIHGF EDCBA
P QK RLF SMGA TNHB OIC JD E
PKFA QLGB RMHC SNID TOJE
A FB KGC PLHD QMIE RNJ SO T
ABCDE FGHIJ KLMNO PQRST

How do you tranforme a matrix? (code block 2)

@CatsAreFluffy I added one more step in explanations

I'm pretty sure tranforme isn't a word. (transform?)

@CatsAreFluffy ^^ ok, i think that was obvious that English is not my native language

Very nice answer!

MATL, 40 bytes
t!tP!tP!GXKZyqXI"IZ}w_w2$:"K@2$Xd!]K!XKx

Input is a 2D char array in Matlab notation:
['ABCDE'; 'FGHIJ'; 'KLMNO'; 'PQRST']

The output contains each "word" on a separate line.
Try it online!
t          % input 2D char array. Duplicate. The original copy will produce
           % the words left to right when displayed
!          % transpose. This will produce the words up to down
tP!        % duplicate, flip upside down, transpose. This will produce the
           % words right to left
tP!        % Same. This will produce the words down to up
GXK        % push input again. Copy to clipboard K
Zy         % get size (length-2 vector; [4 5] in the example)
q          % decrement by 1 (gives  [3 4] in the example)
XI         % copy to clipboard I
"          % loop: do this twice, consuming the decremented length-2 vector
  I        %   push decremented size vector again
  Z}       %   split into its two elements (pushes 3 and 4 in the example)
  w_w      %   swap, negave, swap (results in -3, 4 in the example)
  2$:      %   binary range: indices of diagonals  ([-3 -2 -1 0 1 2 3 4]
           %   in the first iteration in the example, [-4 -3 -2 -1 0 1 2 3]
           %   in the second)
  "        %   for each
    K      %     push input (first iteration) or its tranposed version (second)
    @      %     push index of diagonal
    2$Xd!  %     extract that diagonal as a row vector
  ]        %   end for each
  K!XKx    %   update clipboard K with transposed version for next iteration
           % end loop. Display

05AB1E (legacy), 24 bytes
4F=íøDεÐS0:«NFÁ}}øí0мõK,

Input as a list of lines; outputs as list of strings as well, each on a separated newline to STDOUT.
Try it online.
Explanation:
Unfortunately 05AB1E doesn't have an (anti-)diagonals builtin, so 17 of the bytes are to accomplish that in a similar matter as my 05AB1E answer for the Diamondize a Matrix challenge.
Uses the legacy version of 05AB1E, since it can zip/transpose on a list of strings, whereas the new 05AB1E version requires it to be a character-matrix.
4F             # Loop 4 times:
  =            #  Print the current list with trailing newline (without popping)
               #  (which will use the implicit input-list in the first iteration)
   íø          #  Rotate once 90 degrees clockwise:
   í           #   Reverse each line
    ø          #   Zip/transpose; swapping rows/columns
     D         #  Duplicate this rotated grid
      ε        #  Map over each line:
       ÐS0:«   #   Append the length amount of "0"s:
       Ð       #    Triplicate the string
        S      #    Convert the top copy to a list of characters
         0:    #    Replace all these characters in another copy to "0"
           NF  #   Loop the (0-based) map-index amount of times:
             Á #    Rotate once towards the right
            }  #   Close the loop
      }        #  Close the map
       øí      #  Rotate once 90 degrees counterclockwise
         0м    #  Remove all "0"s from each inner string
           õK  #  Remove potential empty strings
             , #  Pop and output this list of diagonals with trailing newline

Jelly, 13 bytes
KṄḲ
ZUÇƊƬŒDÇ€

Try it online!
Ok, so this is fairly liberal with I/O, but I don't think any of the assumptions are a major issue:

The output for each row is in a different order than specified in the question. Because of

The order of the rotations "read off" does not matter as long as all eight cardinals and primary intercardinals are done once.

I assumed this was OK

The output for half of the diagonals is in "reverse" order (i.e. the output includes PLHD instead of DHLP)
If this isn't ok, then +3 bytes

This is a "link" in Jelly, which is Jelly's version of a function. This takes takes input via ARGV and outputs to STDIN rather than "returning" a value. The ȧ“” in the Footer suppresses Jelly implicitly outputting the return value for the link

This takes input as a matrix of characters. This seems to be allowed by

Example input (taken as an array of characters, multiline string, or other reasonable format)

How it works
KṄḲ - Helper link. Takes a string S on the left
K   - Join S by spaces
 Ṅ  - Print S
  Ḳ - Split S on spaces

ZUÇƊƬŒDÇ€ - Main link. Takes a matrix M of characters
   Ɗ      - Group the previous 3 links into a monad f(M):
Z         -   Transpose
 U        -   Reverse
  Ç       -   Call the helper link
    Ƭ     - Yield [f(M), f(f(M)), f(f(f(M))), f(f(f(f(M))) = M]
            This outputs and returns all rotations of M
     ŒD   - Get the diagonals of each
       Ç€ - Call the helper link on each diagonal

"(i.e. the output includes PLHD instead of DHLP)" it correctly includes both, as per spec

JavaScript (Node.js), 135 bytes
f=(s,n=8)=>n?[s.flatMap(t=>t.join``||[]),...f([...Array(L=(s+0).length)].map((_,y,p)=>p.map((_,x)=>(s[y+x-L>>1]||0)[(x-y)/2])),n-1)]:[]

Try it online!
Slow. Complexity O(n^256) Proof that the rotation work Fast run

all_licenses: Creative Commons - Attribution Share-Alike - https://creativecommons.org/licenses/by-sa/4.0/


text:
Decompose binary into alternating subsequences
This was inspired by Problem 13 - Non-Repeating Binary of HP CodeWars' recent competition.
Let's take a random decimal number, say
727429805944311

and look at its binary representation:
10100101011001011111110011001011101010110111110111

Now split that binary representation into subsequences where the digits 0 and 1 alternate.
1010 010101 10 0101 1 1 1 1 1 10 01 10 0101 1 1010101 101 1 1 1 101 1 1

And convert each subsequence back into decimal.
10 21 2 5 1 1 1 1 1 2 1 2 5 1 85 5 1 1 1 5 1 1

The Task
Take a single, positive integer as input and output the sequence of positive integers obtained by the above process.
Details

Input and output must be in decimal or unary.
Numbers in the output must be separated in a sensible, human-readable fashion, and they must be in decimal or unary. No restriction on white space. Valid output styles: [1,2,3], 1 2 3, 1\n2\n3 where \n are literal newlines, etc.

Test cases
 Input | Output
     0 | 0
     1 | 1
     2 | 2
     3 | 1 1
     4 | 2 0
     5 | 5
     6 | 1 2
     7 | 1 1 1
     8 | 2 0 0
     9 | 2 1
    10 | 10
    50 | 1 2 2
   100 | 1 2 2 0
  1000 | 1 1 1 1 10 0 0
 10000 | 2 1 1 2 0 2 0 0 0
 12914 | 1 2 2 1 1 2 2
371017 | 5 42 10 2 1

Additional note: all numbers in the output should be of the form (2^k-1)/3 or 2*(2^k-1)/3. That is, 0 1 2 5 10 21, 42, 85, 170, ..., which is A000975 in the OEIS.

@DigitalTrauma: Hmmm......no, I don't think that's within the spirit of the challenge.

Ok.  |tac will remain in my answer then :)

is it reversible ? I think so ...

Pyth, 17 16 bytes
1 byte thanks to Jakube
iR2cJ.BQx1qVJ+dJ

Demonstration
A nice, clever solution. Uses some lesser known features of Pyth, like x<int><list> and c<str><list>.
iR2cJ.BQx1qVJ+dJ
                    Q = eval(input())
    J.BQ            Store in J the input in binary.
          qV        Vectorize equality function over
            J+dJ    J and J with a leading dummy char, to get the offset right.
                    This calculates whether each element matches its successor.
        x1          Find all of the indexes of 1 (True) in this list.
   cJ                Chop J at those locations.
iR2                  Convert from binary back to base ten and output.

If you replace tJ by +dJ you can remove hM.

@Jakube Nice one!

Mathematica, 47 bytes
#+##&~Fold~#&/@#~IntegerDigits~2~Split~Unequal&

Ungolfed:
FromDigits[#,2]&/@Split[IntegerDigits[#,2],Unequal]&

Split[list,f] splits a list into multiple lists, breaking at the position between a and b iff f[a,b] does not return True.
FromDigits[n,2] => Fold[#+##&,n] is a neat tip from alephalpha.

Python, 86 bytes
Since I got horribly outgolfed in Pyth, lets just do it in Python again.
import re
lambda n:[int(s,2)for s in re.sub("(?<=(.))(?=\\1)"," ",bin(n)[2:]).split()]

Try it here!
Explanation
We start with converting the input number n into a binary string. bin(n)[2:] takes care of that. We need to discard the first 2 chars of this string since bin() returns the string in the format 0b10101.
Next we need to identify the borders of the subsequences. This can be done with the regex (?<=(.))(?=\1) which matches the zero-length positions in the string which have the same number to the left and right.
The obvious way to get a list of all subsequences would be to use re.split() which splits a string on a certain regex. Unfortunately this function does not work for zero-length matches. But luckily re.sub() does, so we just replace those zero-length matches with spaces and split the string on those after that.
Then we just have to parse each of those subsequences back into a decimal number with int(s,2) and are done.

JavaScript (ES6) 58 62 63
Edit 1 byte saved thx @ETHproductions
Edit 4 bytes saved thx @Neil
x=>x.toString(2).replace(/((.)(?!\2))*./g,x=>'0b'+x-0+' ')

f=x=>x.toString(2).replace(/((.)(?!\2))*./g,x=>'0b'+x-0+' ')

console.log=x=>O.textContent+=x+'\n'

;[
[     0,'0'],
[     1,'1'],
[     2,'2'],
[     3,'1 1'],
[     4,'2 0'],
[     5,'5'],
[     6,'1 2'],
[     7,'1 1 1'],
[     8,'2 0 0'],
[     9,'2 1'],
[    10,'10'],
[    50,'1 2 2'],
[   100,'1 2 2 0'],
[  1000,'1 1 1 1 10 0 0'],
[ 10000,'2 1 1 2 0 2 0 0 0'],
[ 12914,'1 2 2 1 1 2 2'],
[371017,'5 42 10 2 1']
].forEach(t=>{
  var i=t[0],k=t[1],r=f(i)
  console.log(i+' -> '+r+(r.trim()==k.trim() ? ' ok':'ko (should be '+k+')'))
})

Could you save two bytes with the regex /(01)*0?|(10)*1?/g, or would that mess something up??

Also, I think you could do x=>'0b'+x-0+' ' to save a byte.

@ETHproductions I tried the shorter regexp, no good :(. Thx for the other hint

The Leadboard says you have a 1 byte answer. I assume it's because you have the corrected number (62) before the old number (63) instead of after.

I think the regex /((.)(?!\2))*./g saves you a cool 4 bytes.

@KyleKanos The leadboard (uh what leadbord?) is wrong, it's a pity but not my problem. We have tons of questions with leadboard scripts that do works correctly. http://meta.codegolf.stackexchange.com/q/8428/21348

@Neil wow! I'll use that regex when I will able to understand it (give me a couple years) (just kidding)

There's not much to understand; all it does is use negative lookahead to ensure that it never matches a double character.

@Neil thanks I was wondering about "why the 3rd capture group" but I found it's not a capture group at all, it's part of the sintax for negative look ahead

please @shaggy I like the best score at left position

That's causing it to show up on the leaderboard as just 1 byte, though.

@Shaggy the leaderboard is poorly coded then, see my previous comment (and again: what leaderboard? is it a site extension? we have many challenges that include a leaderboard that has not this problem) (see also https://codegolf.meta.stackexchange.com/questions/8428/avoid-useless-edit-about-byte-count)

Jelly, 12 bytes
BI¬-ẋż@BFṣ-Ḅ

Try it online! or verify all test cases.
How it works
BI¬-ẋż@BFṣ-Ḅ  Main link. Argument: n

B             Convert n to base 2.
 I            Compute the increments, i.e., the differences of consecutive digits.
  ¬           Apply logical NOT.
   -ẋ         Repeat -1 that many times, for the logical NOT of each difference.
              [0, 0] / [1, 1] ->   0    -> 1 -> [-1]
              [0, 1] / [1, 0] -> 1 / -1 -> 0 -> []
       B      Yield n in base 2.
     ż@       Zip the result to the right with the result to the left.
        F     Flatten the resulting list of pairs.
         ṣ-   Split at occurrences of -1.
           Ḅ  Convert each chunk from base 2 to integer.

Surely 12 characters but 20 bytes.   Or are you using a system with CHAR_BIT >> 8?

@JamesYoungman Jelly doesn't use UTF-8 by default. In fact, it has its own code page that encodes each of the 256 characters it understands as a single byte each.

Bash + GNU utilities, 51
dc -e2o?p|sed -r ':;s/(.)\1/\1 \1/;t'|dc -e2i?f|tac

Input taken from STDIN.

dc -e2o?p reads input integer from STDIN and outputs a base 2 string
sed -r ':;s/(.)\1/\1 \1/;t' splits the base 2 string with a space everywhere there are same consecutive digits
dc -e2i?f reads the split binary in one go, putting the each part on the stack, then f dumps the whole dc stack (output numbers in reverse order) ...
... which is corrected by tac.

Pyth, 22 21 bytes
&Qu?q%G2H&
GH+yGHjQ2Z

Try it online: Demonstration
Really a tedious task in Pyth.
Explanation:
&Qu?q%G2H&\nGH+yGHjQ2Z   implicit: Q = input number
                  jQ2    convert Q to base 2
  u               jQ2Z   reduce ^: for each digit H update the variable G=0:
   ?q%G2H                   if G%2 == H:
          \nG                  print G
         &   H                 then update G with H
              +yGH           else: update G with 2*G+H
  u                      print the last G also
&Q                       handle Q=0 special: only print 0 once

Pyth, 26 bytes
iR2c:.BQ"(?<=(.))(?=\\1)"d

Try it here!
Explanation

iR2c:.BQ"(?<=(.))(?=\\1)"d   # Q = input number

     .BQ                     # Convert input to binary
    :   "(?<=(.))(?=\\1)"d   # insert a whitespace between the subsequences
   c                         # split string on whitespaces
iR2                          # convert each subsequence into decimal

Since Python's split() function doesn't split on zero-length matches, I have to replace those matches with a space and split the result on that.

05AB1E, 18 bytes
Code:
b2FNð«N«Dð-s:}ð¡)C

Explanation:
b                   # Convert input to binary
 2F          }      # Do the following twice ( with N as range variable)
   Nð«N«            #    N + space + N
        D           #    Duplicate this
         ð-         #    Delete spaces from the duplicate string
           s        #    Swap the top two elements
            :       #    Replace the first string with the second
              ð¡    # Split on spaces
                )   # Wrap into an array
                 C  # Convert all element back to decimal

Try it online!
Uses CP-1252 encoding.

MATL, 18 17 bytes
YBTyd~Thhfd1wY{ZB

Try it online!
YB      % input number. Convert to binary string
T       % push true value
y       % duplicate binary string and push it at the top of the stack
d~      % true for each value that equals the previous one
T       % push true value
hh      % concatenate: true, indices, true
f       % find indices of true values
d       % consecutive differences: lenghts of alternating sequences
1wY{    % split binary string according to those lengths
ZB      % convert each substring into decimal number

zsh, 67 63 55 bytes
for i in `grep -oP '1?(01)*0?'<<<$[[##2]$1]`;<<<$[2#$i]

I don't know why, but this doesn't work in Bash.
Thanks to Dennis for 8 bytes!

It's the for syntax. ...Wait, no fors?

Bash's arithmetic expansion doesn't let you specify an output base. To get rid of the xargs, you could use for i in `grep -oP '1?(01)*0?'<<<$[[##2]$1]`;<<<$[2#$i].

APL (APL), 21 25 bytes
Now handles 0 as well.
{0::0⋄2⊥¨⍵⊂⍨1,2=/⍵}2⊥⍣¯1⊢

Try it online!
2⊥⍣¯1⊢ convert to base-2, using as many bits as needed (lit. inverse from-base-2 conversion)
{…} apply the following anonymous function
0:: if any error happens:
  0 return 0
 ⋄ now try:
  2=/⍵ pairwise equality of the argument (will fail one 0's length-0 binary representation)
  1, prepend 1
  ⍵⊂⍨ use that to partition the argument (begins new section on each 1)
  2⊥¨ convert each from base-2

⊂ is really useful here. I should add that to Jelly.

@Dennis Be aware of the two versions of R←X⊂Y: With ⎕ML<3 (i.e. Dyalog style), a new partition is started in the result corresponding to each 1 in X up to the position before the next 1 in X (or the last element of X) become the successive items of R. With ⎕ML=3 (i.e. IBM style), a new partition is started in the result whenever the corresponding element in X is greater than the previous one. Items in Y corresponding to 0s in X are not included in the result. So ⎕ML←1 ⋄ 1 0 0 1 0 1 1 ⊂ ⍳7 is equivalent to ⎕ML←3 ⋄ 4 3 2 4 4 5 7 ⊂ ⍳7`

PHP, 171 168 162 160 158 121 120 131 124 118 116 113 112 bytes
function d($i){for(;$d<$l=strlen($b=decbin($i));){$c.=$u=$b[$d];echo$u==$b[++$d]||$d==$l?bindec($c).$c=" ":"";}}

Exploded view
function d($i) {
  for ( ; $d < $l = strlen($b = decbin($i)); ) {
    $c .= $u = $b[$d];
    echo $u == $b[++$d] || $d == $l ? bindec($c) . $c = " "
                                    : "";
  }
}

Use d(int) and you're off, output is an echoed string of ints separated by a space.
Edits:
-3: Moved $b definition into strlen() call.
-6: Removed $c instantiation.
-2: Finally fixed the concatenation issue.
-2: No brackets for single-line for().
-37: Total overhaul.  Going with Array chunklets instead of repeated Array->String->Array calls.
-1: Sneaky $c reset.
+11: Bugfix. Was missing final chunk. No more.
-7: Don't need to instantiate $d at all? Nice.
-6: return->echo.
-2: Crunching $c.
-3: Ternary, my first love.
-1: Sneaky sneaky $u.

I think you can save 2 bytes: function d($i){for(;$d<$l=strlen($b=decbin($i));print$u==$b[++$d]||$d==$l?bindec($c).$c=" ":"")$c.=$u=$b[$d];}.

Java 8, 127 119 bytes
l->new java.util.ArrayList<Long>(){{for(String s:l.toBinaryString(l).split("(?<=(.))(?=\\1)"))add(l.parseLong(s,2));}};

There's probably a better regular expression out there to split the string on. I'm not proficient at regex, but I'll keep experimenting.
-8 bytes thanks to @FryAmTheEggman

Convex 0.2+, 25 bytes
Convex is a new language that I am developing that is heavily based on CJam and Golfscript. The interpreter and IDE can be found here. Input is an integer into the command line arguments. This uses the CP-1252 encoding.
2bs®(?<=(.))(?=\\1)"ö2fbp

Explanation:
2bs                         Convert to binary string
   ®(?<=(.))(?=\\1)"        Regex literal
                    ö       Split string on regex
                     2fb    Convert each split string into decimal integer
                        p   Print resulting array

Japt, 7 bytes
¤ò¥ mn2

Test it

Explanation
¤ò¥ mn2
           :Implicit input of integer U.
¤          :Convert to binary string.
 ò¥        :Split to an array by checking for equality.
    m      :Map over array.
     n2    :Convert to base-10 integer.

C, 137 129 bytes
main(){unsigned long a,b=scanf("%lu",&a),c=!!a;while(a>=b*2)b*=2;while(b)b/=2,c=c*(~(a^a/2)&b|!b?!printf("%lu\n",c):2)+!!(a&b);}

Input and output are on the standard streams.

I don't think you need the puts, even though it would be unpleasant to use, the spec doesn't require a trailing newline.

@FryAmTheEggman I'd rather not generate an incomplete last line. But for the cost of one byte (still a net reduction) I can change the separator from space to newline.

Haskell, 147, 145 bytes
x%[]=[x]
x%(y:z)|or.(zipWith(==)<*>tail)$y:x=x:[]%(y:z)|1<2=(y:x)%z
b x|x<2=[x]|1<2=b(div x 2)++[mod x 2]
map(sum.zipWith((*).(2^))[0..]).([]%).b

map(sum.zipWith((*).(2^))[0..]).([]%).b is an unnamed function that computes the list.
Less golfed:
alternating :: Eq a => [a] -> Bool
alternating = or . (zipWith (==) <*> tail)

-- (%) is the partitioning function
(%) :: Eq a => [a] -> [a] -> [[a]]
x % [] = [x]

x % (y:z) | alternating (y : x) = x : [] % (y:z)
          | otherwise = (y : x) % z

bits :: Integral t => t -> [t]
bits x | x < 2     = [x]
       | otherwise = bits (div x 2) ++ [mod x 2]

unBits :: Num c => [c] -> c
unBits = sum . zipWith ((*) . (2^)) [0..]

f :: Integer -> [Integer]
f = map unBits . ([]%) . bits

Python 3, 115 bytes
def f(s):
 s=bin(s);r=[s[2]]
 for i in s[3:]:
  if i==r[-1][-1]:r+=[i]
  else:r[-1]+=i
 return[int(x,2)for x in r]

Explanation
def f(s):
 s=bin(s)                   # convert input in binary
 r=[s[2]]                   # initialize the result with the first char after the 'b' in binary string
 for i in s[3:]:            # loop on other element
  if i==r[-1][-1]:          # if the last element of the last string equal the current element
   r+=[i]                   # we add the current element in a new string
  else:
   r[-1]+=i                 # we add the current element to the last sting
 return[int(x,2)for x in r] # convert binary string in integer

Results
>>> [print(i,f(i)) for i in [0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 50, 100, 1000, 10000, 12914, 371017]]
0 [0]
1 [1]
2 [2]
3 [1, 1]
4 [2, 0]
5 [5]
6 [1, 2]
7 [1, 1, 1]
8 [2, 0, 0]
9 [2, 1]
10 [10]
50 [1, 2, 2]
100 [1, 2, 2, 0]
1000 [1, 1, 1, 1, 10, 0, 0]
10000 [2, 1, 1, 2, 0, 2, 0, 0, 0]
12914 [1, 2, 2, 1, 1, 2, 2]
371017 [5, 42, 10, 2, 1]

previous solution (118 bytes)
def f(s):
 s=bin(s);r=s[2]
 for i in s[3:]:
  if i==r[-1]:r+='a'+i
  else:r+=i
 return[int(x,2)for x in r.split('a')]

Perl, 53 bytes
Includes +1 for -p
Run with the number on STDIN
perl -p alterbits.pl <<< 371017

alterbits.pl:
$_=sprintf"0b%b",$_;s/(.)\K(?=\1)/ 0b/g;s/\S+/$&/eeg

PowerShell, 103 bytes
[regex]::Matches([convert]::ToString($args[0],2),"(01)+0?|(10)+1?|.").Value|%{[convert]::toint32($_,2)}

Since I'm horrible at regex, I'm using the same expression as edc65's answer.
Absolutely destroyed by the lengthy .NET calls to do conversion to/from binary, and the .NET call to get the regex matches. Otherwise pretty straightforward. Takes the input $args[0], converts it to binary, feeds it into Matches, takes the resultant .Values, pipes them through a loop |%{...} and converts those values back to int. Output is left on the pipeline and implicitly printed with newlines.

For extra credit - a (mostly) non-regex version at 126 bytes
$l,$r=[char[]][convert]::ToString($args[0],2);$l+-join($r|%{(" $_",$_)[$l-bxor$_];$l=$_})-split' '|%{[convert]::toint32($_,2)}

We again take input $args[0] and convert it to binary. We re-cast as a char-array, storing the first character in $l and the remaining characters in $r. We then send $r through a loop |%{...} where every iteration we select from either the character prepended with a space or just the character, depending upon the result of a binary xor with $l, and then set $l equal to the character. This effectively ensures that if we have the same character twice in a row, we prepend a space between them.
The output of the loop is -joined together and appended to the first character $l, then -split on spaces (which is technically a regex, but I'm not going to count it). We then do the same loop as the regex answer to convert and output integers.

Java 345 bytes
package com.ji.golf;
import java.util.regex.*;
public class Decompose {
  public static String decompose(long l) {
    String o="";
    String s=Long.toBinaryString(l);
    Matcher m=Pattern.compile("(01)+(0)?|(10)+(1)?|(1)|(0)").matcher(s);
    while(m.find()){String c=s.substring(m.start(),m.end());o+=Integer.parseInt(c, 2)+" ";}
    return o;
  }
}

Test
package com.ji.golf;
public class DecompseTest {
  public static void main(String[] args) {
    String[] inOut = new String[]{
        "0,0",
        "1,1",
        "2,2",
        "3,1 1",
        "4,2 0",
        "5,5",
        "6,1 2",
        "7,1 1 1",
        "8,2 0 0",
        "9,2 1",
        "10,10",
        "50,1 2 2",
        "100,1 2 2 0",
        "1000,1 1 1 1 10 0 0",
        "10000,2 1 1 2 0 2 0 0 0",
        "12914,1 2 2 1 1 2 2",
        "371017,5 42 10 2 1"
    };
    for (String s : inOut) {
      String[] io = s.split(",");
      String result = Decompose.decompose(Long.parseLong(io[0]));
      System.out.println("in: " + io[0] + ", reusult: [" +  result.trim() + "], validates? " + result.trim().equals(io[1].trim()));
    }
  }
}

Output
in: 0, reusult: [0], validates? true
in: 1, reusult: [1], validates? true
in: 2, reusult: [2], validates? true
in: 3, reusult: [1 1], validates? true
in: 4, reusult: [2 0], validates? true
in: 5, reusult: [5], validates? true
in: 6, reusult: [1 2], validates? true
in: 7, reusult: [1 1 1], validates? true
in: 8, reusult: [2 0 0], validates? true
in: 9, reusult: [2 1], validates? true
in: 10, reusult: [10], validates? true
in: 50, reusult: [1 2 2], validates? true
in: 100, reusult: [1 2 2 0], validates? true
in: 1000, reusult: [1 1 1 1 10 0 0], validates? true
in: 10000, reusult: [2 1 1 2 0 2 0 0 0], validates? true
in: 12914, reusult: [1 2 2 1 1 2 2], validates? true
in: 371017, reusult: [5 42 10 2 1], validates? true

Welcome to Programming Puzzles & Code Golf! Since this is a [tag:code-golf] competition, you should make your code as short as possible. Here are some tips for golfing in Java. You can start by defining your function without the boilerplate package and class, and removing unnecessary whitespace. Let me know if you have any questions!

Julia, 70 57 bytes
n->map(i->parse(Int,i,2),split(bin(n),r"(?<=(.))(?=\1)"))

This is an anonymous function that accepts an integer and returns an integer array. To call it, assign it to a variable.
The approach here is similar to DenkerAffe's nice Python answer. We get the binary representation of n using bin(n), and split the resulting string at all matches of the regular expression (?<=(.))(?=\1). It's actually a zero-length match; (?<=(.)) is a positive lookbehind that finds any single character, and (?=\1) is a positive lookahead that finds the matched character in the lookbehind. This locates the places where a number is followed by itself in the binary representation. Just parse each as an integer in base 2 using map and voila!

J, 16 bytes
#:#.;.1~1,2=/\#:

Try it online!
Explanation
#:#.;.1~1,2=/\#:  Input: integer n
              #:  Convert from decimal to list of binary digits
          2  \    For each overlapping sublist of size 2
           =/       Reduce using equals
        1,        Prepend 1
#:                Binary digits
    ;.1~          Partition those binary digits at the 1s in the previous list
  #.                Convert each partition from a list of binary digits to decimal

Jelly, 9 bytes
BI¬0;œṗBḄ

Try it online!

q/kdb+, 52 bytes
Solution:
{2 sv'cut[0,(&)(~)differ a]a:(63^(*)(&)a)_a:0b vs x}

Examples:
q){2 sv'cut[0,(&)(~)differ a]a:(63^(*)(&)a)_a:0b vs x}0
,0
q){2 sv'cut[0,(&)(~)differ a]a:(63^(*)(&)a)_a:0b vs x}1
,1
q){2 sv'cut[0,(&)(~)differ a]a:(63^(*)(&)a)_a:0b vs x}3
1 1
q){2 sv'cut[0,(&)(~)differ a]a:(63^(*)(&)a)_a:0b vs x}8
2 0 0
q){2 sv'cut[0,(&)(~)differ a]a:(63^(*)(&)a)_a:0b vs x}10000
2 1 1 2 0 2 0 0 0
q){2 sv'cut[0,(&)(~)differ a]a:(63^(*)(&)a)_a:0b vs x}12914
1 2 2 1 1 2 2
q){2 sv'cut[0,(&)(~)differ a]a:(63^(*)(&)a)_a:0b vs x}371017
5 42 10 2 1
q){2 sv'cut[0,(&)(~)differ a]a:(63^(*)(&)a)_a:0b vs x}727429805944311
10 21 2 5 1 1 1 1 1 2 1 2 5 1 85 5 1 1 1 5 1 1

Explanation:
q is interpreted right-to-left.
Cast input to binary, trim off leading zeros, find indices where different, invert to get indices where the same, split list on these indices, convert back to base-10. Looks a little heavy compared to the APL solution though...
{2 sv'cut[0,where not differ a]a:(63^first where a)_a:0b vs x} / ungolfed solution
{                                                            } / lambda function
      cut[                    ]                                / cut a list at indices, cut[indices]list
                                                      0b vs x  / converts to 64bit binary representation
                                                    a:         / save as a
                                                   _           / drop 'n' elements from a
                                 (                )            / evaluate this
                                     first where a             / returns first occurance of true in list a
                                  63^                          / fill result with 63 if null (to handle input of 0)
                               a:                              / save as a, we've stripped off all the left-most 0s
                      differ a                                 / whether or not item in list a is different to previous
                  not                                          / the inversion of this result
            where                                              / these are the points where we have 00 or 11
          0,                                                   / add the first index too!
  2 sv'                                                        / 2 sv converts binary back to base-10, ' for each list

PHP, 98 bytes
function($x){foreach(str_split(decbin($x))as$c)$o[$p+=$c==$d].=$d=$c;return array_map(bindec,$o);}

Try it online!

Husk, 5 bytes
mḋġ≠ḋ

Try it online!

Ruby, 49 48 bytes
-1 byte thanks to Sʨɠɠan
Uses the regexp from edc65’s JavaScript answer.
->n{("%b"%n).scan(/((.)(?!\2))*./){p $&.to_i 2}}

Attempt This Online!

n.to_s(2) => ("%b"%n) for -1

@Sʨɠɠan Of course. Thanks!

PHP, 147
$b=decbin($argv[1]);$a=[$t=$b[0]];$k=0;for($i=1;$i<strlen($b);$i++){$v=$b[$i];if($v==$t)$k++;$t=$v;$a[$k].=$v;}foreach($a as$c)echo bindec($c).' ';

Need to put extra space at last of output as their are no restriction. Notices are displayed for short coding.
Ungolfed version
$n=$argv[1];
$b=decbin($n);
$l=strlen($b);
$t=$b[0];
$a=[0=>$t];$k=0;
for($i=1;$i<$l;$i++){
    $v=$b[$i];
    if($v==$t){
        $k++;
    }
    $t=$v;$a[$k].=$v;
}
foreach($a as $c){
    echo bindec($c).' ';
}

Retina, 60
+`(1+)\1
$1a
a1
1
(?<=(.))(?=\1)
¶
+`1(a*)\b
a$.1$*1;
a

;
1

Try it online! Or try a slightly modified version for all test cases (with decimal I/O).
Unfortunately, zero length matches seem to have two "sides", causing duplication when used with the regex from the third stage. Only costs one byte though.
Takes input as unary, outputs as unary. Not really sure about using different in/out unary values, but that would save 4 bytes.

Factor + math.unicode, 45 bytes
[ >bin [ ≠ ] monotonic-split [ bin> ] map ]

Try it online!


text:
Hungarian alphabetical order
For those who wish a lot more challenge then the old Spanish alphabetical order, let's take a look at how the Hungarian alphabet is ordered.

a, á, b, c, cs, d, dz, dzs, e, é, f, g, gy, h, i, í, j, k, l, ly, m, n, ny, o, ó, ö, ő, p, q, r, s, sz, t, ty, u, ú, ü, ű, v, w, x, y, z, zs

actually, q, w, x and y are not used in Hungarian words, but they are included for loanwords and foreign names. Foreign accented characters which are not part of the Hungarian alphabet (like ñ), have the same priority as the non-accented ones, but we disregard them for this challenge.
The rules, summarized:

Digraphs (cs, sz, etc.) and the trigraph (dzs) are considered as they were letters on their own.

cudar
cukor
cuppant
csalit
csata

If the same digraph or trigraph occurs twice directly after each other in a word, they are written in a simplified way: ssz instead of szsz, ddzs instead of dzsdzs but for the alphabetical order the non-simplified order is used. For example kasza < kaszinó < kassza, because kassza is used as k+a+sz+sz+a for the sake of ordering. Sometimes you can find the non-contracted version in a word, in case of compound words.

kasza
kaszinó
kassza
kaszt
nagy
naggyá
nagygyakorlat
naggyal
nagyít

capitalization doesn't matter, with the exception when the two words would be exactly the same without capitalization, in which case the lower case letter has priority

jácint
Jácint
Zoltán
zongora

The short and long versions of accented vowels have the same priority (a - á, e -é, i - í, o - ó, ö - ő, u - ú ü - ű), with a single exception: if the two words would otherwise be exactly the same, the short vowel has priority over the long vowel. Note, that the vowels with umlaut (ö and ü) are completely different characters from o and u.

Eger
egér
író
iroda
irónia
kerek
kerék
kérek
szúr
szül

Hyphens or spaces (for example, in compound words, names, etc.) are completely ignored

márvány
márványkő
márvány sírkő
Márvány-tenger
márványtömb

The task
Your program/function receives strings, composed of characters from the Hungarian alphabet (both lower- and upper-case), but a string might contain spaces or hyphens. For simplicity's sake, the minus sign (ASCII 45) can be used as a hyphen. Note that some characters (like the ő) are not part of ASCII. You can use any encoding you wish, if it supports all the required characters.
You have to order the lines correctly and display/return the result.
You can use any randomly ordered subset of the above examples for testing.
EDIT:
Please don't use any built-in or other way which already knows the Hungarian alphabetical ordering by itself. It would make the competition pointless, and take all the challenge from finding the best regular expression or the best code golfing tricks.
EDIT2:
To clear a clarification asked by isaacg: "two strings that only differ by capitalization and long vs. short vowels, but differs in both ways" : Although no rule in the official document explicitly addresses this question, an example found within points to the length of the vowel having more importance than the capitalization.

@FryAmTheEggman Where do you see that?

@FryAmTheEggman : I don't quite understand it, what functions did i disallow?

I didn't post challenges for a while, is it now a custom to allow for the input to already have been read and stored in some container, so that your code doesn't have to do the reading? It might make sense, specialized golfing languages would have an unfair advantage otherwise, as they can read input with little to no code.

@FryAmTheEggman : ok, if no one argues otherwise, let's accept such solutions as well. I was only wondering because in previous questions it happened that i wrote programs and there were plenty of HTML submissions or other cases where the definition of "program" was quite ambiguous.

@FryAmTheEggman> I recommended the output format only because the words might include spaces. I would argue that having them in separate lines was not a "cumbersome" format.

For reference, we've got a meta post with default I/O formats (although I think that one might be linked from the post Fry already posted).

@MartinBüttner : Seems OK to me. However, how would you guarantee that the output in unambiguous regarding spaces. As there is at least one example, a word can, in fact, contain whitespace, and it can be regarded as a single "word" for the sake of ordering. Or is the word "display" which you don't agree with? What would you suggest instead?

Man, I can't even memorize our proper alphabetical order. How am I going to program this? ;)

Clarification: what is the proper ordering for two strings that only differ by capitalization and long vs. short vowels, but differs in both ways?

@isaacg : good point, and interestingly, it's nowhere specified in the official document of the Hungarian Academy. Maybe I'll have to write them to ask for a clarification? However, an example in that very document has Eger preceding egér, so it seems the vowel length has priority.

I've been trying to come up with a bound-to-fail counterexample, where an apparent digraph is actually two letters, such as malacsült or nyílászáró. I wonder if there are any (but you'd need a vocabulary to check for that, which is presumably not part of this challenge)

There is no example containing dzs

@vsz vowel length doesn't affect order unless it's the only thing that remains. For example, "Eger" comes before "egér", but "mámor" comes before "maradi"

Grammar. Level: Hungarian!

I haven't realized just how complex our ordering is up until this point

Perl, 250
Includes +11 for -Mutf8 -CS.
use Unicode::Normalize;$r="(?=cs|zs|dz|sz|[glnt]y)";print map/\PC*
/g,sort map{$d=$_;s/d\Kd(zs)|(.)\K$r\2(.)/\L$+\E$&/gi;s/d\Kzs/~$&/gi;s/$r.\K./~$&/gi;s/(\p{Ll}*)(\w?)\s*-*/\U$1\L$2/g;$c=$_;$b=$_=NFD lc;y/̈̋/~~/d;join$;,$_,$b,$c,$d}<>

Uses the decorate-sort-undecorate idiom (AKA Schwartzian Transform), and multilevel sorting†, where the levels are:

L1: compare base letters, ignore diacritics, case, and some punctuation.
L2: compare base letters and diacritics, ignore case and some punctuation.
L3: compare base letters, diacritics and case, ignore some punctuation.
Ln: tie-breaking byte-level comparison.

Internally, ␜ (ASCII 0x1C Field Separator — whose value is less than any character in the alphabet for this challenge) is used as a level separator.
This implementation has many limitations, amongst them:

No support for foreign characters.
Cannot disambiguate between contracted geminated (long) digraphs/trigraphs, and consonant+digraph/trigraph, e.g: könnyű should collate as <k><ö><ny><ny><ű>, while tizennyolc should collate as <t><i><z><e><n><ny><o><l><c>; házszám 'address = house (ház) number (szám)' should collate as <h><á><z><sz><á><m> and not as *<h><á><zs><z><á><m>.‡
Collation for contracted long digraphs is not that consistent (but it is stable): we disambiguate at the identical level (ssz <n szsz, ..., zszs <n zzs ); glibc collates the short forms before the full forms (ssz < szsz, ..., zzs < zszs ), ICU collates the long forms before the short forms starting at L3 Case and Variants (szsz <3 ssz, ..., zszs <3 zzs )

Expanded version:
use Unicode::Normalize;

$r="(?=cs|zs|dz|sz|[glnt]y)";   # look-ahead for digraphs

print map/\PC*\n/g,             # undecorate
  sort                          # sort
  map{                          # decorate

          $d=$_;                # Ln: identical level

          # expand contracted digraphs and trigraphs
          s/d\Kd(zs)|(.)\K$r\2(.)/\L$+\E$&/gi;

          # transform digraphs and trigraphs so they
          #  sort correctly
          s/d\Kzs/~$&/gi;s/$r.\K./~$&/gi;

          # swap case, so lower sorts before upper
          # also, get rid of space, hyphen, and newline
          s/(\p{Ll}*)(\w?)\s*-*/\U$1\L$2/g;

          $c=$_;                # L3: Case

          $b=$_=NFD lc;         # L2: Diacritics

          # transform öő|üű so they sort correctly
          # ignore diacritics (acute) at this level
          y/\x{308}\x{30b}\x{301}/~~/d;

                                # L1: Base characters
          join$;,$_,$b,$c,$d
  }<>

†. Some well-known multi-level collation algorithms are the Unicode Collation Algorithm (UCA, Unicode UTS#10), ISO 14651 (available at the ISO ITTF site) the LC_COLLATE parts at ISO TR 30112 (draft available at the ISO/IEC JTC1/SC35/WG5 home) which obsoletes ISO/IEC TR 14652 (available at the ISO/IEC JTC1/SC22/WG20 home) and LC_COLLATE at POSIX.
‡. Doing this correctly would require a dictionary. ICU treats weirdly capitalized groups as non-contractions/non-digraphs/non-trigraphs, e.g: ccS <3 CcS <3 cCs <3 cCS <3 CCs <3 cS <3 cs <3 Cs <3 CS <3 ccs <3 Ccs <3 CCS

You should be able to save some bytes using my expansion RegExp.

Java 8, 742 bytes
Could reduce by another 3 bytes naming the function s instead of sort or another 16 bytes if not counting class-definition.
public class H{String d="cs|dzs?|gy|ly|sz|ty|zs";void sort(java.util.List<String>l){l.sort((a,b)->{String o="-a-á-b-cs-dzs-e-é-f-gy-h-i-í-j-k-ly-m-ny-o-ó-ö-ő-p-q-r-sz-ty-u-ú-ü-ű-v-w-x-y-zs-";int i=c(r(a),r(b),r(o));return i!=0?i:(i=c(a,b,o))!=0?i:b.charAt(0)-a.charAt(0);});}String r(String a){for(int i=0;i<8;i++)a=a.toLowerCase().replace("ááéíóőúű".charAt(i),"aaeioöuü".charAt(i));return a;}int c(String a,String b,String o){a=n(a);b=n(b);while(!"".equals(a+b)){int i=p(a,o),j=p(b,o);if(i!=j)return i-j;a=a.substring(i%4);b=b.substring(j%4);}return 0;}int p(String a,String o){a=(a+1).replaceAll("("+d+"|.).*","-$1");return o.indexOf(a)*4+a.length()-1;}String n(String a){return a.toLowerCase().replaceAll("(.)(?=\\1)("+d+")| |-","$2$2");}}

Can be used like this:
new H().sort(list);

Test-suite:
public static void main(String[] args) {
    test(Arrays.asList("cudar", "cukor", "cuppant", "csalit", "csata"));
    test(Arrays.asList("kasza", "kaszinó", "kassza", "kaszt", "nagy", "naggyá", "nagygyakorlat", "naggyal",
            "nagyít"));
    test(Arrays.asList("jácint", "Jácint", "Zoltán", "zongora"));
    test(Arrays.asList("Eger", "egér", "író", "iroda", "irónia", "kerek", "kerék", "kérek", "szúr", "szül"));
    test(Arrays.asList("márvány", "márványkő", "márvány sírkő", "Márvány-tenger", "márványtömb"));
}

private static void test(final List<String> input) {
    final ArrayList<String> random = randomize(input);
    System.out.print(input + " -> " + random);
    new H().sort(random);
    System.out.println(" -> " + random + " -> " + input.equals(random));
}

private static ArrayList<String> randomize(final List<String> input) {
    final ArrayList<String> temp = new ArrayList<>(input);
    final ArrayList<String> randomOrder = new ArrayList<>(input.size());
    final Random r = new Random();
    for (int i = 0; i < input.size(); i++) {
        randomOrder.add(temp.remove(r.nextInt(temp.size())));
    }
    return randomOrder;
}

yielding
[cudar, cukor, cuppant, csalit, csata] -> [csata, cudar, cuppant, csalit, cukor] -> [cudar, cukor, cuppant, csalit, csata] -> true
[kasza, kaszinó, kassza, kaszt, nagy, naggyá, nagygyakorlat, naggyal, nagyít] -> [naggyá, kassza, kaszinó, nagygyakorlat, nagyít, nagy, kaszt, kasza, naggyal] -> [kasza, kaszinó, kassza, kaszt, nagy, naggyá, nagygyakorlat, naggyal, nagyít] -> true
[jácint, Jácint, Zoltán, zongora] -> [Zoltán, jácint, zongora, Jácint] -> [jácint, Jácint, Zoltán, zongora] -> true
[Eger, egér, író, iroda, irónia, kerek, kerék, kérek, szúr, szül] -> [egér, Eger, kerék, iroda, író, kerek, kérek, szúr, irónia, szül] -> [Eger, egér, író, iroda, irónia, kerek, kerék, kérek, szúr, szül] -> true
[márvány, márványkő, márvány sírkő, Márvány-tenger, márványtömb] -> [márványtömb, márványkő, Márvány-tenger, márvány sírkő, márvány] -> [márvány, márványkő, márvány sírkő, Márvány-tenger, márványtömb] -> true

Ungolfed:
public class HungarianOrder {

    String d = "cs|dzs?|gy|ly|sz|ty|zs";

    void sort(java.util.List<String> l) {
        l.sort((a, b) -> {
            String o = "-a-á-b-cs-dzs-e-é-f-gy-h-i-í-j-k-ly-m-ny-o-ó-ö-ő-p-q-r-sz-ty-u-ú-ü-ű-v-w-x-y-zs-";
            int i = c(r(a), r(b), r(o));
            return i != 0 ? i
                    : (i = c(a, b, o)) != 0 ? i
                            : b.charAt(0) - a.charAt(0);
        });
    }

    // toLower + remove long accent
    String r(String a) {
        for (int i = 0; i < 8; i++)
            a = a.toLowerCase().replace("ááéíóőúű".charAt(i), "aaeioöuü".charAt(i));
        return a;
    }

    // iterate over a and b comparing positions of chars in o
    int c(String a, String b, String o) {
        a = n(a);
        b = n(b);
        while (!"".equals(a + b)) {
            int i = p(a, o), j = p(b, o);
            if (i != j)
                return i - j;
            a = a.substring(i % 4);
            b = b.substring(j % 4);
        }
        return 0;
    }

    // find index in o, then looking if following characters match
    // return is index * 4 + length of match; if String is empty or first character is unknown -1 is returned
    int p(String a, String o) {
        a = (a+1).replaceAll("("+d+"|.).*", "-$1");
        return o.indexOf(a) * 4 + a.length() - 1;
    }

    // expand ddz -> dzdz and such
    String n(String a) {
        return a.toLowerCase().replaceAll("(.)(?=\\1)("+ d +")| |-", "$2$2");
    }
}

I am using Java's List-type and the order()-function of it, but the comparator is all mine.

Impressive! I imagine you should be able to drop the list type specifier <String> and save a few characters at the cost of a few warnings?

@Josh nah, it would produce two casts as Java would infer Object as type of a and b then. I could probably get away defining a class-generic-parameter extending String, though. Also I am not expecting to have the shortest code. ;-)

Python 3, 70
Saved 8 bytes thanks to shooqie.
I love Python. :D
Expects a list of strings.
from locale import*;setlocale(0,'hu')
f=lambda x:sorted(x,key=strxfrm)

Isn't this a standard loophole?

@vsz Not as far as I know. Using built-ins is part of lots of challenges.

@vsz It has too low an up- to down-vote ratio on the standard loopholes post to be counted as a standard, you'd have to explicitly ban it.

Ok, done it. I considered explicitly banning it but i though it should be obvious that it would make the whole challenge a moot point. I'm sorry for the inconvenience.

I'll still upvote this answer as soon as a different, conforming answer appears from anyone, to give credit where credit is due.

from locale import* saves a lot of bytes

This isn't a standard loophole. It's a built-in. Built-ins are allowed by default. This shouldn't have a single downvote in my opinion.