Einführungen

Eine 2 × n-Boolesche Matrix kann als Zeichenfolge der vier Zeichen dargestellt werden . ':. Die Zeichenfolge hat eine "obere Reihe" und eine "untere Reihe", wobei Punkte Einsen und Leerzeichen Nullen darstellen. Zum Beispiel die 2 × 6-Matrix

1 0 1 0 0 1
0 0 0 1 0 1

kann dargestellt werden als ' '. :. Ihre Aufgabe ist es, eine Matrix in dieser "komprimierten Form" zu nehmen und ihre Einträge wie ein Förderband einen Schritt im Uhrzeigersinn zu drehen.

Eingang

Ihre Eingabe ist eine einzelne Zeichenfolge über den Zeichen . ':. Ihre Länge beträgt garantiert mindestens 2.

Ausgabe

Ihre Ausgabe soll die Eingabezeichenfolge sein, wobei jedoch jeder Punkt um einen Schritt im Uhrzeigersinn gedreht wird. Genauer gesagt befinden sich die Punkte in der oberen Reihe weiter rechts, mit Ausnahme des am weitesten rechts stehenden Punkts, der sich nach unten bewegt. Die Punkte in der unteren Reihe bewegen sich einen Schritt nach links, mit Ausnahme des am weitesten links stehenden Punkts, der nach oben bewegt wird. Insbesondere muss die Ausgabezeichenfolge dieselbe Länge wie das Original haben, und Leerzeichen sind von Bedeutung.

Beispiel

Betrachten Sie die Eingabezeichenfolge :..:'., die der 2 × 6-Matrix entspricht

1 0 0 1 1 0
1 1 1 1 0 1

Die gedrehte Version dieser Matrix ist

1 1 0 0 1 1
1 1 1 0 1 0

das entspricht der Zeichenfolge ::. :'.

Regeln und Wertung

Sie können ein vollständiges Programm oder eine Funktion schreiben. Die niedrigste Byteanzahl gewinnt, und Standardlücken sind nicht zulässig. Sie können entscheiden, ob die Eingabe und Ausgabe in Anführungszeichen gesetzt werden soll, und in beiden Fällen ist auch eine nachgestellte Zeile zulässig.

Testfälle

Diese Testfälle sind in doppelte Anführungszeichen eingeschlossen.

"  " -> "  "
" ." -> ". "
". " -> "' "
"' " -> " '"
" '" -> " ."
": " -> "''"
"''" -> " :"
":." -> ":'"
":.'" -> ":'."
"..." -> ":. "
": :" -> "':."
"':." -> ".:'"
".:'" -> ": :"
"    " -> "    "
"::::" -> "::::"
":..:'." -> "::. :'"
" :  .:'" -> ". '.. :"
": ''. :" -> "'' :'.."
"........" -> ":...... "
"::::    " -> ":::''   "
"    ::::" -> "   ..:::"
" : : : : " -> ". : : : '"
".'.'.'.'.'" -> "'.'.'.'.'."
".. ::  '.' :." -> ": ..'' .' :.'"
".'  '.::  :.'. . ::.'  '. . .::'  :.'." -> "' ' .:.''..'.'. ..:' ' .'. ...'''..'.'"

JavaScript (ES6), 100 97 93 Byte

4 Bytes gespart dank @ edc65

s=>s.replace(/./g,(c,i)=>" '.:"[(i?q>' '&q!=".":c>"'")+(q=c,s[++i]?s[i]>"'":c>' '&c!=".")*2])

Wie es funktioniert

Dies entscheidet über das Zeichen, das wir einfügen müssen, indem wir einige Berechnungen an den Zeichen vor und nach dem aktuellen durchführen. Wir summieren:

• Wenn es das erste Zeichen ist und es unten einen Punkt hat, 2;
• Andernfalls, wenn der vorhergehende Punkt oben ist, 2.
• Wenn es das letzte Zeichen ist und ein Punkt oben ist, 1;
• Andernfalls, wenn der dahinter stehende Punkt unten steht, 1.

Das ergibt 0 für ein Leerzeichen, 1 für ', 2 für .und 3 für :.

Testschnipsel

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>
<pre id=B></pre>

Perl, 70 69 64 63 61 60 Bytes

Beinhaltet +2 für -lp

Führen Sie mit der Eingabezeichenfolge auf STDIN aus, z

perl -lp rotatedots.pl <<< ":..:'."

rotatedots.pl:

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

Erläuterung

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)

Leerzeichen werden im obigen Code nicht konvertiert. Für die Berechnungen /2und *2es wird sich so verhalten und werden 0. In den anderen Positionen ist es Teil des "oder", aber die 1 Bits des Leerzeichens sind eine Teilmenge der einen Bits von 0und haben den gleichen Effekt, als 0ob sie mit einer der Ziffern verknüpft wären. Nur wenn das Zeichen, mit dem es verknüpft ist, ein Leerzeichen ist, bleibt es ein Leerzeichen, anstatt ein zu werden 0. Aber das ist 0in Ordnung, da sowieso wieder in den Weltraum konvertiert worden wäre.

Netzhaut , 66

• 2 Bytes gespart dank @daavko
• Dank @randomra 4 Bytes gespart

:
1e
\.
1f
'
0e

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

f1
.

Erläuterung

Beginnend mit der Eingabe:

: ''. :

In den ersten 4 Schritten wird die Matrix erstellt, wobei für die oberen / unteren Zeilen 1/ efür true bzw. 0/ ffür false verwendet wird. Obere und untere Reihe sind miteinander verschachtelt. Dies würde eine Zeichenkette ergeben wie:

e1f0e0e0f1f0e1

Durch diese 4 Stufen wird jedoch auch die untere Reihe 1 nach links verschoben, indem einfach die Reihenfolge der Buchstaben und Ziffern umgekehrt wird:

1e0f0e0e1f0f1e

Die TRansliterationsstufe kehrt die Hexadezimalziffern nur für das erste und das letzte Zeichen um, dh ersetzt 0-9a-fdurch f-a9-0. Dies hat zur Folge, dass das Zeichen von links unten in die oberste Zeile und das Zeichen von rechts oben in die unterste Zeile verschoben wird:

ee0f0e0e1f0f11

In der nächsten Stufe wird dann jedes Buchstaben-Ziffern-Paar vertauscht, wodurch die obere Reihe 1 nach rechts verschoben wird. Bisher war dies der Fall (\D)(\d), aber es stellt sich heraus, dass dies (.)(\d)ausreichend ist, da die Ersetzungen immer von links nach rechts erfolgen und die letzten beiden Ziffern nicht fälschlicherweise damit übereinstimmen, da das vorletzte Zeichen bereits ersetzt wurde. Die Matrix wurde nun wie erforderlich vollständig gedreht:

e0e0f0e1e0f1f1

Die letzten 4 Stufen werden dann wieder in das ursprüngliche Format übersetzt:

'' :'..

Probieren Sie es online aus.

Alle Testfälle, einer pro Zeile , werden mzur TZeile hinzugefügt, um die getrennte Behandlung jeder Eingabezeile zu ermöglichen.

Jelly, 32 30 29 Bytes

,Ṛe€"“':“.:”µṪ€;"ṚU1¦ZḄị“'.: 

Beachten Sie das nachfolgende Leerzeichen. Probieren Sie es online! oder überprüfen Sie alle Testfälle .

Hintergrund

Wir beginnen mit der Betrachtung der Eingabezeichenfolge (zB :..:'.) und ihrer Umkehrung.

:..:'.
.':..:

Für jedes Zeichen in der oberen Reihe prüfen wir, ob es dazu gehört ':, und für jedes Zeichen in der unteren Reihe, ob es dazu gehört .:. Dies ergibt das 2D-Array von Booleschen Werten

100110
101111

Das ist die Matrix aus der Frage, mit umgekehrter unterer Reihe.

Wir entfernen den letzten Booleschen Wert jeder Zeile, kehren die Reihenfolge der Zeilen um, stellen die Booleschen Werte in der ursprünglichen Reihenfolge voran und kehren schließlich die oberste Zeile um.

100110    10011    10111    010111    111010
101111    10111    10011    110011    110011

Dies ergibt die gedrehte Matrix aus der Frage.

Schließlich betrachten wir jede Spalte von Booleschen Werten als Binärzahl und Index '.:, um die entsprechenden Zeichen zu erhalten.

332031    ::. :'

Wie es funktioniert

,Ṛ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.

Pyth, 38 36

L,hb_ebsXCyc2.>syCXzJ" .':"K.DR2T1KJ

2 Bytes dank Jakube!

Probieren Sie es hier aus oder starten Sie die Test Suite .

Erläuterung:

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

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]))

Erläuterung

Die golfed Lösung die folgende Eigenschaft Zip verwenden: zip('ABCD', 'xy') --> Ax By so zip(a[:l],a[l:])kann durch ersetzen sein zip(a,a[l:])und dass die Definition entfernen , damit derl

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 

Ergebnisse

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

Pyth, 66 Bytes

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

Probieren Sie es hier aus!

Erläuterung

Dies kann in 3 Teile zerlegt werden:

• Konvertieren Sie die Eingabe in ein flaches Array aus Einsen und Nullen.
• Mach die Rotation.
• Konvertieren Sie es wieder in ASCII.

Eingabe konvertieren

Das ist ziemlich trivial. Jedes Zeichen wird folgendermaßen zugeordnet:

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

Das erste ist ein Leerzeichen.
Wir erhalten eine Liste von 2 Tupeln, die wir transponieren, um die 2 Zeilen der Matrix zu erhalten, die dann abgeflacht werden.

Code

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

KlQ # speichere die Breite der Matrix in K (wird später verwendet)
       m Q # ordnet jedes Zeichen zu d
                        % Cd5 # ASCII-Code von d modulo 5
        @ [, 1Z, Z1, ZZ, 1 1) # Verwenden Sie dies als Index für eine Nachschlageliste
   J.nC # transponieren, abflachen und J zuweisen

Drehen

Wir haben die Matrix als flaches Array in Jund die Breite der Matrix in K. Die Rotation kann beschrieben werden als:

J[K] + J[:K-1] + J[K+1:] + J[K-1]

Code

s [: JKhKJhK: JtKK) # J = flaches Array, K = Breite der Matrix

s [) # Alle Ergebnisse in dieser Liste zusammenfassen
  : JKhK # J [K]
       JhK # J [K + 1:]
               : JtKK # J [K-1]

Konvertiere es zurück

jkm @ ". ':" id2Cc [) K # [) = Ergebnisliste des obigen Schritts

              c [) K # in 2 Reihen teilen
             C # transponieren, um die 2-Tupel zurückzubekommen
  m # ordne jedes 2-Tupel zu d
          id2 # interpretiere d als binär und konvertiere in dezimal
   @ ". ':" # Verwenden Sie dies als Index für eine Suchzeichenfolge, um das richtige Zeichen zu erhalten
jk # zu einer Zeichenkette zusammenfügen

Python 3, 166 154 153 150 146 138 137 135 132 127 Bytes

Edit: Ich habe die Verwendung zipvon Erwans Python-Antwort am Ende der Funktion ausgeliehen. und ihre Idee, [::-1]Umkehrungen zu verwenden , obwohl ich meine eigene Wendung legte. Es stellte sich heraus, dass Umkehrungen für meine Funktion keine gute Idee waren. Ich habe meine Verwendung formatfür das weitere Golfen geändert . Verschoben aund bdirekt zipzum weiteren Golfen (Ungolfing bleibt unverändert, da die Trennung von aund bdort nützlich ist, um Unordnung in meiner Erklärung zu vermeiden)

Edit: Borrowed (some number)>>(n)&(2**something-1)aus dieser Antwort von xnor auf der Musik - Intervall Solver Herausforderung . Die Unordnung, die ist, zip(*[divmod(et cetera, 2) for i in input()])kann wahrscheinlich besser golfen werden, obwohl ich die Zweckmäßigkeit mag, die es von der Verwendung von zwei Tupeln tund gewährt 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

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 ... transposeist zu lang.

Hier verwendete Tricks:

• sprintf('%02b',x)zu konvertieren "0", "1", "2", "3"in "00", "01", "10", und "11"jeweils. Überraschenderweise muss das zweite Argument nicht zuerst in eine Ganzzahl umgewandelt werden.

• Die Rotation erfolgt über a[1].push a[0].pop;a[0].unshift a[1].shift;, was ich zumindest für ein wenig clever hielt (wenn auch nicht übermäßig ausführlich in Ruby). Die Symmetrie ist jedenfalls ästhetisch schön: P

Javascript ES6 125 Bytes

q=>(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``

Ich ordne jedes Zeichen einem zweistelligen binären Äquivalent zu

 : becomes 3   11
 ' becomes 2   10
 . becomes 1   01
   becomes 0   00

und ich stelle sie mir übereinander vor

3212021 becomes
1101010
1010001

Ich speichere das bis n

Für jedes Zeichen (0-3) von n überprüfe ich seine Nachbarn und addiere das höchstwertige Bit des linken Nachbarn zum niedrigstwertigen Bit des rechten Nachbarn. Wenn i == 0 (erstes Zeichen), verwende ich ein eigenes Bit niedrigerer Ordnung anstelle des höherwertigen Bits des linken Nachbarn.

Wenn n [i + 1]> - 1 bedeutet dies, dass wir 0,1,2,3 haben. Wenn dies falsch ist, treffen wir das letzte Element.

In diesem Fall verwende ich das höchstwertige Bit des Charakters anstelle des niedrigeren Bits des rechten Nachbarn

Ordne das zurück zu .':landen und verbinde das Array wieder miteinander

MATL , 40 39 Bytes

' ''.:'tjw4#mqBGnXKq:QKEh1Kq:K+hv!)XBQ)

Probieren Sie es online! Die verknüpfte Version wurde aufgrund von Änderungen in der Sprache nach dem vPosten &vdieser Antwort von ersetzt .

' ''.:'               % 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

JavaScript, 311 Byte

Kann wahrscheinlich viel verbessert werden:

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]=="'"?".":" ")

JavaScript (ES6), 237 210 204 188 182 178 Bytes

Dank an @Downgoat für das Speichern von 16 Bytes in der 188-Byte-Revision

Update: Ich hatte eine Gehirnwelle und reduzierte die erste Operation auf seinen einzigen mapAnruf anstatt auf zwei separate

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``)

Hübscher Druck u. Erklärung

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``
)

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 für die -nFlagge hinzugefügt .

Ziemlich derselbe Algorithmus wie meine Ruby-Antwort , nur kürzer, weil ... 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

Widerlich, @a=(shift@b,@a)ist kürzer als unshift@a,shift@b.

Leider sind diese gleich lang:

y/ .':/0-3/;s/./sprintf'%02b ',$&/ge;
s/./sprintf'%02b ',index" .':",$&/ge;

Danke an Ton Hospel für 5 Bytes und msh210 für ein Byte!

Python 3, 294 287 283 Bytes

Waaayyyyyy zu lange, aber ich werde versuchen, einige Bytes Golf:

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=":"})))

Verwendungszweck:

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