Введения

Булева матрица 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 байта

Сохранено 4 байта благодаря @ edc65

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

Как это устроено

Это решает, какой символ нам нужно вставить, выполняя некоторые вычисления символов до и после текущего. Мы суммируем:

• Если это первый символ, и у него есть точка внизу, 2;
• В противном случае, если предыдущий имеет точку сверху, 2.
• Если это последний символ, и он имеет точку сверху, 1;
• В противном случае, если после него есть точка внизу, 1.

Это хорошо суммируется с 0 для пробела, 1 для ', 2 для .и 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 бит пробела является подмножеством одного бита 0и будет иметь такой же эффект, как 0если бы он был или-ed с любой из цифр. Только если символ, с которым он или является, является пробелом, он останется пробелом, а не станет 0. Но это нормально, так как все 0равно был бы возвращен в космос.

Сетчатка , 66

• 2 байта сохранены благодаря @daavko
• 4 байта сохранены благодаря @randomra

:
1e
\.
1f
'
0e

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

f1
,

объяснение

Начиная с ввода:

: ''. :

Первые 4 этапа строят матрицу, используя 1/ eдля true и 0/ fдля false для верхней / нижней строк соответственно. Верхний и нижний ряды переплетены вместе. Это даст строку вроде:

e1f0e0e0f1f0e1

Тем не менее, эти 4 этапа также эффективно перемещают нижний ряд 1 влево, просто изменяя порядок букв и цифр:

1e0f0e0e1f0f1e

Этап Tтранслитерации меняет шестнадцатеричные цифры только на первый и последний символы, т.е. заменяется 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

2 байта благодаря Якубе!

Попробуйте здесь или запустите Test Suite .

Объяснение:

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

Попробуй это здесь!

объяснение

Это можно разбить на 3 части:

• Преобразуйте входные данные в плоский массив единиц и нулей.
• Делай вращение.
• Преобразуйте его обратно в ASCII.

Преобразовать ввод

Это довольно тривиально. Каждый символ отображается следующим образом:

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

Первый - это пробел.
Мы получаем список из двух кортежей, которые мы транспонируем, чтобы получить 2 строки матрицы, которые затем сглаживаются.

Код

KlQJ.nCm @ [, 1Z, Z1, ZZ, 1 1)% Cd5Q # Q = вход

KlQ # сохранить ширину матрицы в K (будет использовано позже)
       m Q # отобразить каждый символ d
                        % Cd5 # ASCII-код d по модулю 5
        @ [, 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 # нарезать на 2 ряда
             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 дальнейшую игру в гольф (разминка остается неизменной, потому что в моем объяснении разделение полезно aи помогает bизбежать беспорядка)

Изменить: Заимствовано (some number)>>(n)&(2**something-1)из этого ответа xnor на вызове Music Interval Solver . zip(*[divmod(et cetera, 2) for i in input()])Беспорядок, который, вероятно, может быть лучше в гольфе, хотя мне нравится целесообразность, которую он дает от использования двух кортежей 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]))))

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

Рубин, 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}

Тьфу ... 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

Я сохраняю это

Для каждого символа (0-3) из n я проверяю его соседей, добавляя бит старшего разряда левого соседа к биту младшего разряда правого соседа. если я == 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 за байт!

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)

Луа, 139 байт

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

Использование:

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