Вступ

Булева матриця розміром 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якщо б або -ед будь-який з цифр. Тільки якщо пробіл, яким він є або є, є пробіл, він залишиться пробілом, а не стати а 0. Але це нормально, оскільки все 0одно повернувся б у космос.

Сітківка , 66

• 2 байти збережено завдяки @daavko
• 4 байти збережено завдяки @randomra

:
1е
\.
1f
'
0е

0f
Т`х`Рх` ^. |. $
(.) (\ d)
$ 2 $ 1
e1
:
e0
'
f0

f1
.

Пояснення

Починаючи з введення:

: ''. :

Перші 4 етапи будують матрицю, використовуючи 1/ eдля true та 0/ fдля false для верхнього / нижнього рядків відповідно. Верхній і нижній рядки переплітаються між собою. Це дасть рядок типу:

e1f0e0e0f1f0e1

Однак ці 4 етапи також ефективно переміщують нижній рядок 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Ḅị“'.: 

Зверніть увагу на пробіл. Спробуйте в Інтернеті! або перевірити всі тестові випадки .

Фон

Почнемо з розгляду вхідного рядка (наприклад, :..:'.) та його зворотного.

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

Для кожного символу у верхньому рядку ми перевіряємо, чи належить він ':, і для кожного символу нижнього ряду, якщо він належить .:. Це дає 2D масив булів

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 байти завдяки Jakube!

Спробуйте тут або запустіть тестовий набір .

Пояснення:

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(".....''''''")
":...  '''':"

Піт, 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-кортезів, які ми перекладаємо, щоб отримати 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 [) # Підключіть усі результати у цьому списку
  : 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 # приєднатись до одного рядка

Пітон 3, 166 154 153 150 146 138 137 135 132 127 байт

Змінити: Я запозичив використання zipвід відповіді Python ЕРВА в кінці функції. і їх ідея використовувати [::-1]реверси, хоча я вклав власну скруту. Як виявляється, розвороти не були гарною ідеєю для моєї функції. Я змінив своє використання formatдля подальшого гольфу. Переміщений aта bбезпосередньо zipдля подальшого проведення гольфу (ungolfing залишається незмінним, оскільки розділення aта bкорисне для того, щоб уникнути безладу в моєму поясненні)

Edit: Запозичені (some number)>>(n)&(2**something-1)з цієї відповіді на XNOR на виклик Музика 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]))))

Безголівки:

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;, що, на мою думку, було хоч трохи розумним (якщо не надто багатослівним у Рубі). Симетрія естетична, все одно: 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

Для кожного символу (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прапора.

Приблизно той самий алгоритм, що і моя відповідь Рубі , просто коротший, тому що ... 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;

Дякую Тону Євангелію за 5 байт та msh210 за байт!

Python 3, 294 287 283 байт

Waaayyyyy занадто довго, але я спробую пограти в декілька байтів:

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