Introducciones

Una matriz booleana 2 × n se puede representar como una cadena de los cuatro caracteres . ':. La cadena tiene una "fila superior" y una "fila inferior", con puntos que representan 1s y espacios vacíos que representan 0s. Por ejemplo, la matriz 2 × 6

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

se puede representar como ' '. :. Su tarea es tomar una matriz en esta "forma comprimida" y rotar sus entradas un paso en el sentido de las agujas del reloj, como una cinta transportadora.

Entrada

Su entrada es una sola cadena sobre los caracteres . ':. Su longitud está garantizada para ser al menos 2.

Salida

Su salida será la cadena de entrada, pero con cada punto girado un paso en el sentido de las agujas del reloj. Más explícitamente, los puntos en la fila superior más un lugar a la derecha, excepto el más a la derecha, que se mueve hacia abajo. Los puntos en la fila inferior se mueven un paso hacia la izquierda, excepto el extremo izquierdo, que se mueve hacia arriba. En particular, la cadena de salida debe tener la misma longitud que la original, y el espacio en blanco es significativo.

Ejemplo

Considere la cadena de entrada :..:'., que corresponde a la matriz 2 × 6

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

La versión rotada de esta matriz es

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

que corresponde a la cadena ::. :'.

Reglas y puntaje

Puede escribir un programa completo o una función. El conteo de bytes más bajo gana, y las lagunas estándar no se permiten. Puede decidir si la entrada y la salida están entre comillas, y una nueva línea final también es aceptable en ambas.

Casos de prueba

Estos casos de prueba están entre comillas dobles.

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

JavaScript (ES6), 100 97 93 bytes

Guardado 4 bytes gracias a @ edc65

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

Cómo funciona

Esto decide sobre el carácter que debemos insertar realizando algunos cálculos en los caracteres antes y después del actual. Sumamos:

• Si es el primer personaje y tiene un punto en la parte inferior, 2;
• De lo contrario, si el anterior tiene un punto en la parte superior, 2.
• Si es el último carácter, y tiene un punto en la parte superior, 1;
• De lo contrario, si el que está después tiene un punto en la parte inferior, 1.

Esto suma muy bien a 0 para un espacio, 1 para ', 2 para .y 3 para :.

Fragmento de prueba

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

Incluye +2 para -lp

Ejecutar con la cadena de entrada en STDIN, p. Ej.

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

rotatedots.pl:

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

Explicación

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)

El espacio no se convierte en el código anterior. Para los cálculos /2y *2se comportará como y se convertirá 0. En las otras posiciones formará parte de "o", pero los 1 bits de espacio son un subconjunto de los bits de uno 0y tendrán el mismo efecto que 0si se or-ed con cualquiera de los dígitos. Sólo si el personaje es o-ed con es un espacio que va a seguir siendo un espacio en lugar de convertirse en una 0. Pero eso está bien ya 0que de todos modos se habría convertido de nuevo al espacio.

Retina , 66

• 2 bytes guardados gracias a @daavko
• 4 bytes guardados gracias a @randomra

:
1e
\.
1f
'
0e

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

f1
.

Explicación

Comenzando con la entrada:

: ''. :

Las primeras 4 etapas construyen la matriz, usando 1/ epara verdadero y 0/ fpara falso para las filas superior / inferior, respectivamente. Las filas superior e inferior están entrelazadas juntas. Esto produciría una cadena como:

e1f0e0e0f1f0e1

Sin embargo, estas 4 etapas también mueven efectivamente la fila inferior 1 hacia la izquierda, simplemente invirtiendo el orden de las letras y los dígitos:

1e0f0e0e1f0f1e

La Tetapa de ransliteration invierte los dígitos hexadecimales solo para el primer y el último carácter, es decir, los reemplaza 0-9a-fpor f-a9-0. Esto tiene el efecto de mover el carácter inferior izquierdo hacia arriba a la fila superior y el carácter superior derecho hacia abajo a la fila inferior:

ee0f0e0e1f0f11

La siguiente etapa intercambia cada par de letras y dígitos, moviendo así la fila superior 1 a la derecha. Anteriormente esto era así (\D)(\d), pero resulta que (.)(\d)es suficiente porque las sustituciones siempre ocurren de izquierda a derecha y, por lo tanto, los dos últimos dígitos no coincidirán erróneamente con esto, porque el penúltimo personaje ya habrá sido sustituido. La matriz ahora se ha rotado completamente según sea necesario:

e0e0f0e1e0f1f1

Las 4 etapas finales se traducen nuevamente al formato original:

'' :'..

Pruébalo en línea.

Todas las cajas de prueba, una por línea , se magregan a la Tlínea para permitir el tratamiento por separado de cada línea de entrada.

Jalea, 32 30 29 bytes

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

Tenga en cuenta el espacio final. Pruébalo en línea! o verificar todos los casos de prueba .

Antecedentes

Comenzamos considerando la cadena de entrada (por ejemplo, :..:'.) y su reverso.

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

Para cada carácter en la fila superior, verificamos si pertenece ':, y para cada carácter de la fila inferior si pertenece .:. Esto le da a la matriz 2D de booleanos

100110
101111

cuál es la matriz de la pregunta, con la fila inferior invertida.

Eliminamos el último booleano de cada fila, invierte el orden de las filas, anteponemos los booleanos en su orden original y finalmente invierte la fila superior.

100110    10011    10111    010111    111010
101111    10111    10011    110011    110011

Esto produce la matriz rotada de la pregunta.

Finalmente, consideramos que cada columna de Booleanos es un número binario e indexamos '.:para obtener los caracteres apropiados.

332031    ::. :'

Cómo 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 gracias a Jakube!

Pruébelo aquí o ejecute Test Suite .

Explicación:

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

Explicación

La solución de golf utiliza la siguiente propiedad de zip: zip('ABCD', 'xy') --> Ax By por lo que zip(a[:l],a[l:])puede reemplazarse por zip(a,a[l:])y permitir eliminar la definición 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(".....''''''")
":...  '''':"

Pyth, 66 bytes

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

Pruébalo aquí!

Explicación

Esto se puede dividir en 3 partes:

• Convierta la entrada en una matriz plana de unos y ceros.
• Haz la rotación.
• Conviértalo nuevamente en ASCII.

Convertir entrada

Esto es bastante trivial. Cada personaje se mapea de la siguiente manera:

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

El primero es un espacio en blanco.
Obtenemos una lista de 2 tuplas que transponemos para obtener las 2 filas de la matriz que luego se aplana.

Código

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

KlQ # guarda el ancho de la matriz en K (se usa más adelante)
       m Q # asigna cada carácter d
                        % Cd5 # Código ASCII del módulo d 5
        @ [, 1Z, Z1, ZZ, 1 1) # use esto como índice en una lista de búsqueda
   J.nC # transponer, aplanar y asignar a J

Girar

Tenemos la matriz como matriz plana en Jy el ancho de la matriz en K. La rotación se puede describir como:

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

Código

s [: JKhKJhK: JtKK) # J = matriz plana, K = ancho de matriz

s [) # Concat todos los resultados en esta lista
  : JKhK # J [K]
       JhK # J [K + 1:]
               : JtKK # J [K-1]

Convertirlo de nuevo

jkm @ ". ':" id2Cc [) K # [) = lista resultante del paso anterior

              c [) K # cortar en 2 filas
             Transposición de C # para recuperar las 2 tuplas
  m # mapear cada 2-tuplas d
          id2 # interpreta d como binario y convierte a decimal
   @ ". ':" # use eso como índice en una cadena de búsqueda para obtener el carácter correcto
jk # unirse en una cadena

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

Editar: He tomado prestado el uso de la respuesta Pythonzip de Erwan al final de la función. y su idea de usar [::-1]reversiones, aunque puse mi propio giro. Resulta que las reversiones no fueron una buena idea para mi función. He cambiado mi uso de formatgolf para más. Movido ay bdirectamente a zipjugar más golf (el no golfismo permanece sin cambios porque la separación de ay ballí es útil para evitar el desorden en mi explicación)

Editar: Tomado (some number)>>(n)&(2**something-1)de esta respuesta por xnor en el desafío Music Interval Solver . El desorden que existe zip(*[divmod(et cetera, 2) for i in input()])probablemente se pueda jugar mejor, aunque me gusta la conveniencia que otorga el uso de dos tuplas ty 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]))))

Sin golf:

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 ... transposees demasiado largo.

Trucos usados ​​aquí:

• sprintf('%02b',x)Para convertir "0", "1", "2", "3"en "00", "01", "10", y "11"respectivamente. Sorprendentemente, el segundo argumento no tiene que convertirse en un entero primero.

• La rotación se realiza a través de a[1].push a[0].pop;a[0].unshift a[1].shift;, lo que pensé que era al menos un poco inteligente (si no excesivamente detallado en Ruby). La simetría es estéticamente agradable, de todos modos: 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``

Asigno cada carácter a un equivalente binario de dos dígitos

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

y estoy pensando en ellos como uno encima del otro

3212021 becomes
1101010
1010001

Lo guardo en n

Para cada carácter (0-3) de n, verifico sus vecinos, agregando el bit de orden más alto del vecino izquierdo al bit de orden más bajo del vecino derecho. si i == 0 (primer carácter) uso su propio bit de orden inferior en lugar del bit de orden superior del vecino izquierdo.

si n [i + 1]> - 1 significa que tenemos 0,1,2,3, así que cuando eso es falso, tocamos el último elemento.

Cuando eso sucede, uso el bit de orden más alto del personaje en lugar del bit más bajo del vecino correcto

mapear eso de regreso a .':tierra y unir esa matriz nuevamente

MATL , 40 39 bytes

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

Pruébalo en línea! La versión vinculada ha sido vreparada por los &vcambios en el idioma después de que se publicó esta respuesta .

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

Probablemente se puede mejorar mucho:

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 a @Downgoat por guardar 16 bytes en la revisión de 188 bytes

Actualización: tuve una onda cerebral y reduje la primera operación sa una sola mapllamada en lugar de dos llamadas 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``)

Impresión bonita y explicación

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 agregado para la -nbandera.

Prácticamente el mismo algoritmo que mi respuesta de Ruby , solo que más corto, 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

Obviamente, @a=(shift@b,@a)es más corto que unshift@a,shift@b.

Por desgracia, estos son de la misma longitud:

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

¡Gracias a Ton Hospel por 5 bytes y msh210 por un byte!

Python 3, 294 287 283 bytes

Waaayyyyyy demasiado tiempo, pero intentaré jugar al golf de algunos 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 ".'  '.::  :.'. . ::.'  '. . .::'  :.'."
' ' .:.''..'.'. ..:' ' .'. ...'''..'.'