Introduzioni

Una matrice booleana 2 × n può essere rappresentata come una stringa di quattro caratteri . ':. La stringa ha una "riga superiore" e una "riga inferiore", con punti che rappresentano 1 e spazi vuoti che rappresentano 0. Ad esempio, la matrice 2 × 6

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

può essere rappresentato come ' '. :. Il tuo compito è prendere una matrice in questa "forma compressa" e ruotare le sue entrate di un passo in senso orario, come un nastro trasportatore.

Ingresso

Il tuo input è una singola stringa sopra i caratteri . ':. La sua lunghezza è garantita per essere almeno 2.

Produzione

L'output deve essere la stringa di input, ma con ogni punto ruotato di un passo in senso orario. Più esplicitamente, i punti sulla riga superiore più un posto a destra, tranne quello più a destra, che si sposta verso il basso. I punti sulla riga inferiore si spostano di un passo verso sinistra, tranne quello più a sinistra, che si sposta verso l'alto. In particolare, la stringa di output deve avere la stessa lunghezza dell'originale e gli spazi bianchi sono significativi.

Esempio

Considera la stringa di input :..:'., che corrisponde alla matrice 2 × 6

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

La versione ruotata di questa matrice è

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

che corrisponde alla stringa ::. :'.

Regole e punteggio

È possibile scrivere un programma completo o una funzione. Vince il conteggio di byte più basso e non sono consentite scappatoie standard. Puoi decidere se l'input e l'output sono racchiusi tra virgolette e in entrambi è accettabile anche una riga finale.

Casi test

Questi casi di test sono racchiusi tra virgolette doppie.

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

JavaScript (ES6), 100 97 93 byte

Salvato 4 byte grazie a @ edc65

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

Come funziona

Questo decide sul personaggio che dobbiamo inserire eseguendo alcuni calcoli sui caratteri prima e dopo quello attuale. Sommiamo:

• Se è il primo carattere e ha un punto in basso, 2;
• Altrimenti, se quello precedente ha un punto in alto, 2.
• Se è l'ultimo carattere e ha un punto in alto, 1;
• Altrimenti, se quello dopo ha un punto in basso, 1.

Ciò equivale a 0 per uno spazio, 1 per ', 2 per .e 3 per :.

Test snippet

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 byte

Include +2 per -lp

Esegui con la stringa di input su STDIN, ad es

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

rotatedots.pl:

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

Spiegazione

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)

Lo spazio non è convertito nel codice sopra. Per i calcoli /2e *2si comporterà come e diventerà 0. Nelle altre posizioni farà parte del "o", ma i 1 bit di spazio sono un sottoinsieme dell'uno bit di 0e avranno lo stesso effetto che 0se fossero o-eded con una qualsiasi delle cifre. Solo se il personaggio con cui è organizzato è uno spazio, rimarrà uno spazio invece di diventare uno 0. Ma va bene dato che 0sarebbe comunque stato riconvertito nello spazio.

Retina , 66

• 2 byte salvati grazie a @daavko
• 4 byte salvati grazie a @randomra

:
1e
\.
1f
'
0e

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

f1
.

Spiegazione

A partire dall'input:

: ''. :

Le prime 4 fasi costruiscono la matrice, usando 1/ eper true e 0/ fper false per le righe superiore / inferiore, rispettivamente. Le righe superiore e inferiore sono intrecciate insieme. Ciò produrrebbe una stringa come:

e1f0e0e0f1f0e1

Tuttavia, queste 4 fasi spostano efficacemente anche la riga inferiore 1 a sinistra, semplicemente invertendo l'ordine delle lettere e delle cifre:

1e0f0e0e1f0f1e

La Tfase di riscrittura inverte le cifre esadecimali solo per il primo e l'ultimo carattere, ovvero sostituisce 0-9a-fcon f-a9-0. Ciò ha l'effetto di spostare il carattere in basso a sinistra nella riga superiore e il carattere in alto a destra nella riga inferiore:

ee0f0e0e1f0f11

La fase successiva scambia quindi ogni coppia di lettere e cifre, spostando così la riga superiore 1 verso destra. In precedenza lo era (\D)(\d), ma si scopre che (.)(\d)è sufficiente perché le sostituzioni avvengono sempre da sinistra a destra e quindi le ultime due cifre non verranno erroneamente coordinate da questo, perché il penultimo carattere sarà già stato sostituito. La matrice ora è stata completamente ruotata come richiesto:

e0e0f0e1e0f1f1

Le 4 fasi finali poi si traducono nuovamente nel formato originale:

'' :'..

Provalo online.

Tutti i test, uno per riga , sono stati maggiunti alla Triga per consentire il trattamento separato di ciascuna riga di input.

Gelatina, 32 30 29 byte

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

Nota lo spazio finale. Provalo online! o verifica tutti i casi di test .

sfondo

Iniziamo considerando la stringa di input (ad es. :..:'.) E il suo contrario.

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

Per ogni personaggio nella riga superiore, controlliamo se appartiene ':, e per ogni personaggio della riga inferiore se appartiene .:. Questo dà l'array 2D di booleani

100110
101111

che è la matrice della domanda, con la riga inferiore invertita.

Rimuoviamo l'ultimo booleano di ogni riga, invertiamo l'ordine delle righe, anteponiamo i booleani nel loro ordine originale e infine invertiamo la riga superiore.

100110    10011    10111    010111    111010
101111    10111    10011    110011    110011

Ciò produce la matrice ruotata dalla domanda.

Infine, consideriamo ogni colonna di booleani un numero binario e un indice in '.:per ottenere i caratteri appropriati.

332031    ::. :'

Come funziona

,Ṛ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 byte grazie a Jakube!

Provalo qui o esegui Test Suite .

Spiegazione:

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 byte

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

Spiegazione

La soluzione golfizzata utilizza la seguente proprietà di zip: in questo zip('ABCD', 'xy') --> Ax By modo zip(a[:l],a[l:])può essere sostituita da zip(a,a[l:])e che consente di rimuovere la definizione dil

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 

risultati

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

Pyth, 66 byte

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

Provalo qui!

Spiegazione

Questo può essere suddiviso in 3 parti:

• Converti l'input in una matrice piatta di uno e zero.
• Fai la rotazione.
• Convertire nuovamente in ASCII.

Converti input

Questo è abbastanza banale. Ogni personaggio è mappato nel modo seguente:

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

Il primo è uno spazio bianco.
Otteniamo un elenco di 2 tuple che trasponiamo per ottenere le 2 file della matrice che poi vengono appiattite.

Codice

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

KlQ # salva la larghezza della matrice in K (viene utilizzata in seguito)
       m Q # mappa ogni personaggio d
                        % Cd5 # Codice ASCII di d modulo 5
        @ [, 1Z, Z1, ZZ, 1 1) # usa questo come indice in un elenco di ricerca
   J.nC # traspone, appiattisce e assegna a J

Ruotare

Abbiamo la matrice come matrice piatta in Je la larghezza della matrice in K. La rotazione può essere descritta come:

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

Codice

s [: JKhKJhK: JtKK) # J = matrice piatta, K = larghezza della matrice

s [) # Concatta tutti i risultati in questo elenco
  : JKhK # J [K]
       JhK # J [K + 1:]
               : JtKK # J [K-1]

Converti indietro

jkm @ ". ':" id2Cc [) K # [) = elenco risultante del passaggio precedente

              c [) K # tritare in 2 file
             C # trasporre per ripristinare le 2 tuple
  m # mappa ogni 2 tuple d
          id2 # interpreta d come binario e converte in decimale
   @ ". ':" # usa questo come indice in una stringa di ricerca per ottenere il carattere corretto
jk # join in una stringa

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

Edit: Ho preso in prestito l'uso di zipdalla risposta Python di Erwan al termine della funzione. e la loro idea di usare [::-1]inversioni, anche se ho messo la mia svolta. A quanto pare, le inversioni non erano una buona idea per la mia funzione. Ho cambiato il mio uso di formatgolf ulteriormente. Spostato ae bdirettamente dentro zipper ulteriore golf (il non golf rimane invariato perché la separazione di ae bc'è utile per evitare disordine nella mia spiegazione)

Modifica: preso in prestito (some number)>>(n)&(2**something-1)da questa risposta da xnor nella sfida Music Solval Solver . Il disordine che zip(*[divmod(et cetera, 2) for i in input()])può essere probabilmente può essere giocato a golf meglio, anche se mi piace l'opportunità che offre dall'uso di due tuple 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

Rubino, 166 163 byte

->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 ... transposeè troppo lungo.

Trucchi usati qui:

• sprintf('%02b',x)Per convertire "0", "1", "2", "3"in "00", "01", "10", e "11", rispettivamente. Sorprendentemente, il secondo argomento non deve essere prima convertito in un numero intero.

• La rotazione avviene tramite a[1].push a[0].pop;a[0].unshift a[1].shift;, che pensavo fosse almeno un po 'intelligente (se non eccessivamente prolisso in Ruby). La simmetria è esteticamente bella, comunque: P

Javascript ES6 125 byte

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

Mappo ogni personaggio a un equivalente binario a due cifre

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

e sto pensando a loro come uno sopra l'altro

3212021 becomes
1101010
1010001

L'ho salvato su n

Per ogni carattere (0-3) di n, controllo i suoi vicini, aggiungendo il bit di ordine più alto del vicino sinistro al bit di ordine più basso del vicino destro. se i == 0 (primo carattere) utilizzo il proprio bit di ordine inferiore anziché il bit di ordine superiore del vicino sinistro.

se n [i + 1]> - 1 significa che abbiamo 0,1,2,3, quindi quando è falso colpiamo l'ultimo elemento.

Quando ciò accade, uso il bit di ordine più alto del personaggio anziché il bit inferiore del vicino di destra

mappalo di nuovo a .':terra e unisciti nuovamente a quell'array

MATL , 40 39 byte

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

Provalo online! La versione collegata è stata vsostituita da &v, a causa di cambiamenti nella lingua dopo che questa risposta è stata pubblicata .

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

Probabilmente può essere migliorato molto:

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 byte

Ringraziamo @Downgoat per aver salvato 16 byte nella revisione a 188 byte

Aggiornamento: ho avuto un'onda cerebrale e ho ridotto la prima operazione sa una singola mapchiamata anziché a due separate

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

Bella stampa e spiegazione

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 byte

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 aggiunto per la -nbandiera.

Praticamente lo stesso algoritmo della mia risposta di Ruby , solo più breve, perché ... 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

Odiosamente, @a=(shift@b,@a)è più corto di unshift@a,shift@b.

Purtroppo, questi hanno la stessa lunghezza:

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

Grazie a Ton Hospel per 5 byte e msh210 per un byte!

Pitone 3, 294 287 283 byte

Waaayyyyyy troppo a lungo, ma proverò a giocare a golf di alcuni byte:

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 byte

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

Uso:

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