Introduções

Uma matriz booleana 2 × n pode ser representada como uma sequência de quatro caracteres . ':. A cadeia possui uma "linha superior" e uma "linha inferior", com pontos representando 1s e espaços vazios representando 0s. Por exemplo, a matriz 2 × 6

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

pode ser representado como ' '. :. Sua tarefa é pegar uma matriz nessa "forma compactada" e girar suas entradas um passo no sentido horário, como uma correia transportadora.

Entrada

Sua entrada é uma única sequência sobre os caracteres . ':. É garantido que seu comprimento seja pelo menos 2.

Resultado

Sua saída deve ser a sequência de entrada, mas com cada ponto girado um passo no sentido horário. Mais explicitamente, os pontos na linha superior mais um lugar à direita, exceto o mais à direita, que se move para baixo. Os pontos na linha inferior movem um passo para a esquerda, exceto o mais à esquerda, que se move para cima. Em particular, a cadeia de saída deve ter o mesmo comprimento que o original e o espaço em branco é significativo.

Exemplo

Considere a sequência de entrada :..:'., que corresponde à matriz 2 × 6

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

A versão rotacionada dessa matriz é

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

que corresponde à string ::. :'.

Regras e pontuação

Você pode escrever um programa completo ou uma função. A menor contagem de bytes vence e as brechas padrão não são permitidas. Você pode decidir se a entrada e a saída estão entre aspas, e uma nova linha à direita também é aceitável em ambas.

Casos de teste

Esses casos de teste estão entre aspas duplas.

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

JavaScript (ES6), 100 97 93 bytes

Guardado 4 bytes graças a @ edc65

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

Como funciona

Isso decide o caractere que precisamos inserir executando alguns cálculos nos caracteres antes e depois do atual. Nós somamos:

• Se for o primeiro caractere e tiver um ponto na parte inferior, 2;
• Caso contrário, se o anterior tiver um ponto no topo, 2.
• Se for o último caractere e tiver um ponto no topo, 1;
• Caso contrário, se o ponto seguinte tiver um ponto na parte inferior, 1.

Isso equivale a 0 para um espaço, 1 para ', 2 para .e 3 para :.

Snippet de teste

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

Inclui +2 para -lp

Execute com a string de entrada no STDIN, por exemplo

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

rotatedots.pl:

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

Explicação

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)

O espaço não é convertido no código acima. Para os cálculos /2e *2vai se comportar como e se tornar 0. Nas outras posições, ele fará parte do "ou", mas os 1 bits de espaço são um subconjunto dos bits um 0e terão o mesmo efeito que 0se fossem orados com qualquer um dos dígitos. Somente se o personagem com o qual ele é editado for um espaço, ele permanecerá um espaço em vez de se tornar um 0. Mas tudo bem, pois 0teria sido convertido de volta ao espaço de qualquer maneira.

Retina , 66

• 2 bytes salvos graças a @daavko
• 4 bytes salvos graças a @randomra

:
1e
\.
1f
"
0e

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

f1
.

Explicação

Começando com a entrada:

: ''. :

Os primeiros 4 estágios constroem a matriz, usando 1/ epara true e 0/ ffor false nas linhas superior / inferior, respectivamente. As linhas superior e inferior são entrelaçadas. Isso produziria uma string como:

e1f0e0e0f1f0e1

No entanto, esses quatro estágios também movem efetivamente a linha inferior 1 para a esquerda, simplesmente revertendo a ordem das letras e dígitos:

1e0f0e0e1f0f1e

O Testágio de ransliteração inverte dígitos hexadecimais apenas para o primeiro e o último caracteres, ou seja, substitui 0-9a-fpor f-a9-0. Isso tem o efeito de mover o caractere inferior esquerdo para a linha superior e o caractere superior direito para baixo na linha inferior:

ee0f0e0e1f0f11

O estágio seguinte troca todos os pares de dígitos de letras, movendo a linha superior 1 para a direita. Antes isso era (\D)(\d), mas acontece que (.)(\d)é suficiente porque as substituições sempre acontecem da esquerda para a direita e, portanto, os dois dígitos finais não serão erroneamente correspondidos por isso, porque o penúltimo caractere já terá sido substituído. A matriz agora foi totalmente rotacionada conforme necessário:

e0e0f0e1e0f1f1

As 4 etapas finais são convertidas novamente para o formato original:

'' :'..

Experimente online.

Todos os casos de teste, um por linha , foram madicionados à Tlinha para permitir o tratamento separado de cada linha de entrada.

Geléia, 32 30 29 bytes

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

Observe o espaço à direita. Experimente online! ou verifique todos os casos de teste .

fundo

Começamos considerando a sequência de entrada (por exemplo, :..:'.) e seu reverso.

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

Para cada caractere na linha superior, verificamos se ele pertence ':e para cada caractere da linha inferior, se ele pertence .:. Isso fornece à matriz 2D de booleanos

100110
101111

qual é a matriz da pergunta, com a linha inferior invertida.

Removemos o último booleano de cada linha, invertemos a ordem das linhas, acrescentamos os booleanos na ordem original e, finalmente, invertemos a linha superior.

100110    10011    10111    010111    111010
101111    10111    10011    110011    110011

Isso gera a matriz rotacionada a partir da pergunta.

Por fim, consideramos cada coluna dos booleanos um número binário e um índice '.:para obter os caracteres apropriados.

332031    ::. :'

Como funciona

,Ṛ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 graças a Jakube!

Experimente aqui ou execute o Test Suite .

Explicação:

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

Explicação

A solução golfed usa a seguinte propriedade zip: zip('ABCD', 'xy') --> Ax By portanto, zip(a[:l],a[l:])pode ser substituída por zip(a,a[l:])e que permite remover a definição del

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 

Resultados

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

Pitão, 66 bytes

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

Experimente aqui!

Explicação

Isso pode ser dividido em 3 partes:

• Converta a entrada em uma matriz plana de zeros e uns.
• Faça a rotação.
• Converta-o novamente em ASCII.

Converter entrada

Isso é bastante trivial. Cada personagem é mapeado da seguinte maneira:

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

O primeiro é um espaço em branco.
Nós obtemos uma lista de duas tuplas que transpomos para obter as 2 linhas da matriz que são achatadas.

Código

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

KlQ # salva a largura da matriz em K (é usado mais tarde)
       m Q # mapeia cada caractere d
                        % Cd5 # código ASCII do módulo d 5
        @ [, 1Z, Z1, ZZ, 1 1) # use isso como índice em uma lista de pesquisa
   J.nC # transpõe, achata e atribui a J

Rodar

Temos a matriz como matriz plana Je a largura da matriz em K. A rotação pode ser descrita como:

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

Código

s [: JKhKJhK: JtKK) # J = matriz plana, K = largura da matriz

s [) # Concatide todos os resultados nesta lista
  : JKhK # J [K]
       JhK # J [K + 1:]
               : JtKK # J [K-1]

Converta de volta

jkm @ ". ':" id2Cc [) K # [) = lista resultante da etapa acima

              c [) K # pique em 2 linhas
             C # transpose para obter as 2 tuplas de volta
  m # mapeia cada d
          id2 # interpreta d como binário e converte em decimal
   @ ". ':" # use isso como índice em uma string de pesquisa para obter o caractere correto
jk # junção em uma sequência

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

Edit: Eu peguei emprestado o uso da resposta Pythonzip de Erwan no final da função. e a ideia deles de usar [::-1]inversões, embora eu tenha dado o meu toque. Acontece que as reversões não eram uma boa ideia para minha função. Eu mudei meu uso de formatpara mais golfe. Movido ae bdiretamente zippara jogar golfe (o golfe continua inalterado porque a separação de ae bé útil para evitar a confusão na minha explicação)

Edit: Borrowed (some number)>>(n)&(2**something-1)de esta resposta por xnor o desafio Música Interval Solver . A confusão que é zip(*[divmod(et cetera, 2) for i in input()])provavelmente pode ser melhorada, embora eu goste da conveniência que concede ao usar duas tuplas te 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}

Eca ... transposeé muito longo.

Truques usados ​​aqui:

• sprintf('%02b',x)Para converter "0", "1", "2", "3"em "00", "01", "10", e "11", respectivamente. Surpreendentemente, o segundo argumento não precisa ser convertido em um número inteiro primeiro.

• A rotação é feita via a[1].push a[0].pop;a[0].unshift a[1].shift;, o que eu pensei que era pelo menos um pouco inteligente (se não excessivamente detalhado em Ruby). A simetria é esteticamente agradável, de qualquer maneira: 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``

Mapeio cada caractere para um equivalente binário de dois dígitos

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

e eu estou pensando neles como sendo um em cima do outro

3212021 becomes
1101010
1010001

Eu guardo isso em n

Para cada caractere (0-3) de n, verifico seus vizinhos, adicionando o bit de ordem mais alta do vizinho esquerdo ao bit de ordem mais baixa do vizinho direito. se i == 0 (primeiro caractere) eu uso seu próprio bit de ordem inferior, em vez do bit de ordem superior do vizinho esquerdo.

se n [i + 1]> - 1 significa que obtivemos 0,1,2,3; portanto, quando isso é falso, atingimos o último elemento.

Quando isso acontece, eu uso o bit de ordem mais alta do personagem em vez do bit mais baixo do vizinho certo

mapear isso de volta à .':terra e juntar essa matriz novamente

MATL , 40 39 bytes

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

Experimente online! A versão vinculada foi vsubstituída por &v, devido a alterações no idioma após a postagem desta resposta .

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

Provavelmente pode ser melhorado muito:

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

Crédito para @Downgoat por salvar 16 bytes na revisão de 188 bytes

Atualização: Eu tive uma onda cerebral e reduzi a primeira operação sa uma única mapchamada em vez de duas chamadas separadas

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 & Explicação

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 adicionado para o -nsinalizador.

Praticamente o mesmo algoritmo da minha resposta Ruby , apenas mais curto, porque ... 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)é mais curto que unshift@a,shift@b.

Infelizmente, estes têm o mesmo comprimento:

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

Graças a Ton Hospel por 5 bytes e msh210 por um byte!

Python 3, 294 287 283 bytes

Waaayyyyyy por muito tempo, mas vou tentar jogar golfe de alguns 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=":"})))

Uso:

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