引言

2×n布尔矩阵可以表示为四个字符的字符串. ':。该字符串有一个“上排”和一个“下排”，点代表1，空白代表0。例如2×6矩阵

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

可以表示为' '. :。您的任务是采用这种“压缩形式”的矩阵，并像传送带一样将其入口顺时针旋转一步。

输入项

您的输入是字符上的单个字符串. ':。它的长度保证至少为2。

输出量

您的输出应为输入字符串，但每个点均沿顺时针方向旋转一步。更明确地说，除了最右边的行向下移动之外，最上面一行的点向右多一个位置。除最左端的点向上移动外，下一行的点向左移动一级。特别是，输出字符串必须与原始字符串具有相同的长度，并且空格很重要。

例

考虑输入字符串:..:'.，它对应于2×6矩阵

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

该矩阵的旋转版本为

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

对应于字符串::. :'。

规则和计分

您可以编写完整的程序或函数。最低字节数获胜，并且不允许出现标准漏洞。您可以确定输入和输出是否用引号引起来，并且两个尾随的换行符也是可接受的。

测试用例

这些测试用例用双引号引起来。

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

JavaScript（ES6），100 97 93字节

@ edc65节省了4个字节

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

这个怎么运作

通过确定当前字符前后的字符，可以确定我们需要插入的字符。我们总结：

• 如果它是第一个字符，并且在底部有一个点，则为2；
• 否则，如果前面的一个在上面有一个点，则为2。
• 如果是最后一个字符，并且在上面有一个点，则为1；否则为0。
• 否则，如果其后的一个在底部有一个点，则为1。

对于一个空间，这总和为0，对于1为'2，对于.3为3 :。

测试片段

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字节

包括+2 -lp

在STDIN上使用输入字符串运行，例如

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

rotatedots.pl：

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

说明

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)

上面的代码未转换空间。对于计算/2，*2它将表现为和0。在其他位置，它将是“或”的一部分，但是空格的1位是1位的子集，其0效果0与对任何数字进行或运算的效果相同。仅当与它匹配的字符是空格时，它才会保留空格而不是变为0。但这没关系，因为0无论如何都会被转换回太空。

视网膜，66

• @daavko节省了2个字节
• @randomra节省了4个字节

：
1e
\。
1楼
'
0e

0f
T`h`Rh` ^。|。$
（。）（\ d）
$ 2 $ 1
1号
：
00
'
00

f1
。

说明

从输入开始：

: ''. :

前4个阶段构造矩阵，分别对顶行/底行使用1/ e表示true和0/ f表示false。顶部和底部行交错在一起。这将产生类似以下的字符串：

e1f0e0e0f1f0e1

但是，这四个阶段还可以通过简单地颠倒字母和数字的顺序将下一行1有效地移到左侧：

1e0f0e0e1f0f1e

在T第一个和最后一个字符ransliteration阶段逆转十六进制数字只，即替换0-9a-f用f-a9-0。这具有将左下角字符向上移动到顶部行，将右上角字符向下移动到底部行的效果：

ee0f0e0e1f0f11

然后，下一阶段交换每个字母数字对，从而将上一行1向右移动。以前是(\D)(\d)，但是事实证明这(.)(\d)是足够的，因为替换总是从左到右进行，因此最后两位数字不会与此错误地匹配，因为倒数第二个字符已经被替换了。现在，矩阵已根据需要完全旋转：

e0e0f0e1e0f1f1

然后将最后的4个阶段转换回原始格式：

'' :'..

在线尝试。

所有测试用例，每行一个，m加到T线，以允许每个输入行的单独处理。

果冻，32 30 29字节

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

注意尾随空格。在线尝试！或验证所有测试用例。

背景

我们首先考虑输入字符串（例如:..:'.）及其反向。

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

对于第一行中的每个字符，我们检查它是否属于；对于第二行中的每个字符，我们检查它':是否属于.:。这给出了二维的布尔数组

100110
101111

这是问题的矩阵，底部反了。

我们删除每行的最后一个布尔值，颠倒各行的顺序，将布尔值按其原始顺序放在最前面，最后颠倒第一行。

100110    10011    10111    010111    111010
101111    10111    10011    110011    110011

这从问题中得出了旋转矩阵。

最后，我们将布尔值的每一列视为一个二进制数，并对其进行索引'.:以获得适当的字符。

332031    ::. :'

这个怎么运作

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

感谢Jakube 2个字节！

在这里尝试或运行测试套件。

说明：

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字节

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

说明

高尔夫解决方案使用zip的以下属性：zip('ABCD', 'xy') --> Ax By 因此zip(a[:l],a[l:])可以替换为，zip(a,a[l:])并允许删除的定义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 

结果

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

Pyth，66个字节

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

在这里尝试！

说明

这可以分为三个部分：

• 将输入转换为一个由零组成的平面数组。
• 进行旋转。
• 将其转换回ASCII。

转换输入

这是相当琐碎的。每个字符的映射方式如下：

  ->（0,0）
。->（0,1）
'->（1,0）
：->（1,0）

第一个是空格。
我们得到一个2元组的列表，我们对其进行转置以获得矩阵的2行，然后将其展平。

码

KlQJ.nCm @ [，1Z，Z1，ZZ，1 1）％Cd5Q＃Q =输入

KlQ＃将矩阵的宽度保存为K（稍后使用）
       m Q＃映射每个字符d
                        ％Cd5＃d模5的ASCII码
        @ [，1Z，Z1，ZZ，1 1）＃使用它作为查找列表的索引
   J.nC＃转置，展平并分配给J

旋转

我们将矩阵设为平面数组J，将矩阵的宽度设为K。旋转可以描述为：

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

码

s [:: JKhKJhK：JtKK）＃J =平面阵列，K =矩阵宽度

s [）＃Concat此列表中的所有结果
  ：JKhK＃J [K]
       JhK＃J [K + 1：]
               ：JtKK＃J [K-1]

转换回去

jkm @“。'：” id2Cc [）K＃[）=上面步骤的结果列表

              c [] K＃切成两行
             C＃转置以获取2元组
  m＃映射每个2元组d
          id2＃将d解释为二进制并转换为十进制
   @“。'：”＃使用它作为查找字符串的索引以获取正确的字符
jk＃加入一个字符串

Python 3、166 154 153 150 146 138 137 135 132 127字节

编辑：我借来使用的zip，从二万的Python的答案在函数结束。和他们使用[::-1]逆转的想法，尽管我自己做了一些修改。事实证明，反转对我的职能不是一个好主意。我已经更改了format对进一步打高尔夫球的用途。移动a并b直接进入zip用于进一步打高尔夫球（ungolfing保持不变，因为分离a而b那里是有用的避免我的解释杂波）

编辑：在音乐间隔求解挑战中，(some number)>>(n)&(2**something-1)从xnor的答案中借来了。这是杂乱zip(*[divmod(et cetera, 2) for i in input()])大概可以golfed更好，虽然我不喜欢它使用两个元授予权宜之计t和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]))))

取消高尔夫：

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

红宝石，166个 163字节

->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}

uck ... transpose太长了。

这里使用的技巧：

• sprintf('%02b',x)转换"0"，"1"，"2"，"3"为"00"，"01"，"10"，和"11"分别。令人惊讶的是，第二个参数没有必须首先转换为一个整数。

• 旋转是通过进行的a[1].push a[0].pop;a[0].unshift a[1].shift;，我认为它至少有点聪明（如果不是在Ruby中过于冗长）。无论如何，对称性在美学上都不错：P

Javascript ES6 125字节

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

我将每个字符映射到两位数的二进制等效项

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

我认为它们是彼此之上的一个

3212021 becomes
1101010
1010001

我将其保存到n

对于n的每个字符（0-3），我检查它的邻居，将左邻居的最高位添加到右邻居的最低位。如果i == 0（第一个字符），我用它自己的低位代替左邻居的高位。

如果n [i + 1]>-1意味着我们得到了0、1、2、3，所以当它为假时，我们命中了最后一个元素。

发生这种情况时，我将使用角色自己的最高位，而不是右侧邻居的低位

将其映射回.':着陆并将该阵列重新组合在一起

MATL，40 39字节

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

在线尝试！ 由于发布此答案后语言的更改，链接版本已被v撤消&v。

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

可能可以进行很多改进：

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字节

感谢@Downgoat保存16在188字节修改字节

更新：我很头脑，将第一次操作简化s为单个map呼叫，而不是两个单独的呼叫

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

漂亮的印刷品和说明

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字节

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

为-n标志添加的字节。

与我的Ruby回答几乎相同的算法，只是较短，因为... 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

令人讨厌的@a=(shift@b,@a)是，它比短unshift@a,shift@b。

,，它们的长度相同：

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

感谢Ton Hospel提供了5个字节，而msh210提供了1个字节！

Python 3中，294个 287 283字节

Waaayyyyyy太长了，但是我会尝试打一些字节：

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个字节

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

用法：

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