Introductions

Une matrice booléenne 2 × n peut être représentée par une chaîne de quatre caractères . ':. La chaîne a une "rangée supérieure" et une "rangée inférieure", avec des points représentant les 1 et des espaces vides représentant les 0. Par exemple, la matrice 2 × 6

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

peut être représenté comme ' '. :. Votre tâche consiste à prendre une matrice sous cette "forme comprimée" et à faire pivoter ses entrées d'un pas dans le sens des aiguilles d'une montre, à la manière d'un tapis roulant.

Contribution

Votre entrée est une chaîne unique sur les caractères . ':. Sa longueur est garantie d'être d'au moins 2.

Sortie

Votre sortie doit être la chaîne d'entrée, mais avec chaque point tourné d'un pas dans le sens des aiguilles d'une montre. Plus explicitement, les points de la rangée supérieure se trouvent à un endroit à droite, sauf le plus à droite, qui se déplace vers le bas. Les points de la rangée inférieure se déplacent d'un pas vers la gauche, sauf le plus à gauche qui monte. En particulier, la chaîne de sortie doit avoir la même longueur que l'original et les espaces sont significatifs.

Exemple

Considérons la chaîne d'entrée :..:'., qui correspond à la matrice 2 × 6

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

La version tournée de cette matrice est

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

qui correspond à la chaîne ::. :'.

Règles et notation

Vous pouvez écrire un programme complet ou une fonction. Le nombre d'octets le plus faible gagne et les failles standard sont interdites. Vous pouvez décider si l’entrée et la sortie sont entre guillemets, et une nouvelle ligne est également acceptable dans les deux cas.

Cas de test

Ces cas de test sont entre guillemets.

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

JavaScript (ES6), 100 97 93 octets

4 octets sauvés grâce à @ edc65

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

Comment ça fonctionne

Cela détermine le caractère que nous devons insérer en effectuant des calculs sur les caractères avant et après le caractère actuel. Nous somme:

• Si c'est le premier caractère et qu'il a un point en bas, 2;
• Sinon, si celui qui le précède a un point en haut, 2.
• Si c'est le dernier caractère et qu'il a un point en haut, 1;
• Sinon, si celui qui suit a un point en bas, 1.

Cela résume bien à 0 pour un espace, 1 pour ', 2 pour .et 3 pour :.

Extrait de test

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 octets

Comprend +2 pour -lp

Exécuter avec la chaîne d'entrée sur STDIN, par exemple

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

rotatedots.pl:

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

Explication

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)

L'espace n'est pas converti dans le code ci-dessus. Pour les calculs /2et *2il se comportera comme et deviendra 0. Dans les autres positions, il fera partie du "ou", mais les 1 bits de l’espace sont un sous-ensemble des 1 bits de 0et auront le même effet que 0s’ils étaient marqués avec un des chiffres. Ce n'est que si le personnage avec lequel il est écrit est un espace qu'il restera un espace au lieu de devenir un 0. Mais ce n'est pas grave, car de toute façon 0, nous aurions été reconvertis dans l'espace.

Rétine , 66

• 2 octets enregistrés grâce à @daavko
• 4 octets enregistrés grâce à @randomra

:
1e
\.
1f
'
0e

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

f1
.

Explication

En commençant par l'entrée:

: ''. :

Les 4 premières étapes construisent la matrice, en utilisant respectivement 1/ epour true et 0/ fpour false pour les lignes du haut et du bas. Les rangées supérieure et inférieure sont entrelacées. Cela donnerait une chaîne comme:

e1f0e0e0f1f0e1

Cependant, ces 4 étapes déplacent également efficacement la rangée inférieure 1 vers la gauche, simplement en inversant l'ordre des lettres et des chiffres:

1e0f0e0e1f0f1e

L' Tétape de ré-écriture inverse les chiffres hexadécimaux pour les premier et dernier caractères uniquement, c'est-à-dire remplace 0-9a-fpar f-a9-0. Cela a pour effet de déplacer le caractère en bas à gauche jusqu'à la rangée supérieure et le personnage en haut à droite vers la rangée inférieure:

ee0f0e0e1f0f11

L'étape suivante remplace ensuite chaque paire de lettres et de chiffres, déplaçant ainsi la rangée supérieure 1 vers la droite. Auparavant (\D)(\d), c'était (.)(\d)suffisant , mais il s'avère que cela est suffisant car les substitutions se font toujours de gauche à droite et les deux derniers chiffres ne seront donc pas identiques, car l'avant dernier caractère aura déjà été substitué. La matrice a maintenant été entièrement pivotée selon les besoins:

e0e0f0e1e0f1f1

Les 4 dernières étapes sont ensuite traduites au format original:

'' :'..

Essayez-le en ligne.

Tous les cas de test, un par ligne , sont majoutés à la Tligne pour permettre un traitement séparé de chaque ligne d'entrée.

Jelly, 32 30 29 octets

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

Notez l'espace de fuite. Essayez-le en ligne! ou vérifier tous les cas de test .

Contexte

Nous commençons par considérer la chaîne d'entrée (par exemple, :..:'.) et son inverse.

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

Pour chaque caractère de la rangée du haut, nous vérifions s'il appartient à ':, et pour chaque caractère de la rangée du bas s'il appartient .:. Cela donne le tableau 2D de booléens

100110
101111

qui est la matrice de la question, avec la ligne inférieure inversée.

Nous supprimons le dernier booléen de chaque ligne, inversons l'ordre des lignes, ajoutons des booléens dans leur ordre d'origine et, enfin, inversons la ligne du haut.

100110    10011    10111    010111    111010
101111    10111    10011    110011    110011

Cela donne la matrice tournée de la question.

Enfin, nous considérons chaque colonne de booléens comme un nombre binaire et un index '.:pour obtenir les caractères appropriés.

332031    ::. :'

Comment ça fonctionne

,Ṛ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 octets grâce à Jakube!

Essayez-le ici ou lancez la suite de tests .

Explication:

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 octets

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

Explication

La solution golfée utilise la propriété suivante de zip: peut zip('ABCD', 'xy') --> Ax By donc zip(a[:l],a[l:])être remplacée par zip(a,a[l:])et permet de supprimer la définition 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 

Résultats

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

Pyth, 66 octets

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

Essayez-le ici!

Explication

Cela peut être décomposé en 3 parties:

• Convertissez l’entrée en un tableau plat de uns et de zéros.
• Faites la rotation.
• Reconvertissez-le en ASCII.

Convertir une entrée

C'est assez trivial. Chaque caractère est mappé de la manière suivante:

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

Le premier est un espace blanc.
Nous obtenons une liste de 2-tuples que nous transposons pour obtenir les 2 lignes de la matrice qui est ensuite aplatie.

Code

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

KlQ # enregistrer la largeur de la matrice en K (est utilisé plus tard)
       m Q # mapper chaque caractère d
                        % Cd5 # code ASCII de d modulo 5
        @ [, 1Z, Z1, ZZ, 1 1) # l'utiliser comme index dans une liste de recherche
   J.nC # transpose, aplatit et affecte à J

Tourner

Nous avons la matrice sous forme de tableau à plat dans Jet la largeur de la matrice dans K. La rotation peut être décrite comme suit:

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

Code

s [: JKhKJhK: JtKK) # J = tableau plat, K = largeur de la matrice

s [) # Concatez tous les résultats de cette liste
  : JKhK # J [K]
       JhK # J [K + 1:]
               : JtKK # J [K-1]

Le reconvertir

jkm @ ". ':" id2Cc [) K # [) = liste résultante de l'étape ci-dessus

              c [) K # couper en 2 rangées
             Transposer en C # pour récupérer les 2 tuples
  m # carte chaque 2-tuple d
          id2 # interprète d comme binaire et convertit en décimal
   @ ". ':" # utilisez-le comme index dans une chaîne de recherche pour obtenir le caractère correct
jk # rejoindre dans une chaîne

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

Edit: J'ai emprunté l'utilisation de la réponse Pythonzip d' Erwan à la fin de la fonction. et leur idée d'utiliser des [::-1]inversions, bien que je mette ma propre tournure. En fin de compte, les renversements n'étaient pas une bonne idée pour ma fonction. J'ai changé mon utilisation formatpour continuer à jouer au golf. Déplacé aet bdirectement dans zippour jouer au golf (le non-golf reste inchangé car la séparation de aet bil est utile pour éviter l'encombrement dans mon explication)

Edit: emprunté (some number)>>(n)&(2**something-1)à cette réponse par xnor pour le challenge Music Interval Solver . Le fouillis qui se trouve zip(*[divmod(et cetera, 2) for i in input()])peut probablement être mieux joué au golf, bien que j'aime bien l'opportunité qu'il procure d'utiliser deux n t- uplets et 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

Rubis, 166 163 octets

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

Beurk ... transposec'est trop long.

Astuces utilisées ici:

• sprintf('%02b',x)à convertir "0", "1", "2", "3"en "00", "01", "10"et "11"respectivement. Étonnamment, le deuxième argument ne pas nécessaire de convertir en un entier.

• La rotation se fait via a[1].push a[0].pop;a[0].unshift a[1].shift;, ce qui me paraissait au moins un peu malin (sinon trop bavard en Ruby). La symétrie est esthétique quand même: P

Javascript ES6 125 octets

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

Je mappe chaque caractère à un équivalent binaire à deux chiffres

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

et je pense à eux comme étant l'un sur l'autre

3212021 becomes
1101010
1010001

Je garde ça pour n

Pour chaque caractère (0-3) de n, je vérifie ses voisins, en ajoutant le bit de plus haut ordre du voisin de gauche au bit de plus bas ordre du voisin de droite. si i == 0 (premier caractère), j'utilise son propre bit d'ordre inférieur au lieu du bit d'ordre supérieur du voisin de gauche.

Si n [i + 1]> - 1, cela signifie que nous avons 0,1,2,3. Lorsque c'est faux, nous passons au dernier élément.

Lorsque cela se produit, j'utilise le bit le plus élevé du personnage au lieu du bit inférieur du voisin de droite

carte qui retourne à la .':terre et rejoindre ce tableau en arrière ensemble

MATL , 40 39 octets

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

Essayez-le en ligne! La version liée a été vremplacée par &v, en raison de changements de langue après la publication de cette réponse .

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

Peut probablement être amélioré beaucoup:

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 octets

Crédit à @Downgoat pour la sauvegarde de 16 octets dans la révision de 188 octets

Mise à jour: j'ai eu une onde cérébrale et j'ai réduit la première opération sà un seul mapappel au lieu de deux appels séparés

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

Jolie impression et explication

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 octets

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

Octet ajouté pour le -ndrapeau.

À peu près le même algorithme que ma réponse Ruby , juste plus court, parce que ... 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

Obnoxieusement, @a=(shift@b,@a)c'est plus court que unshift@a,shift@b.

Hélas, ils ont la même longueur:

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

Merci à Ton Hospel pour 5 octets et à msh210 pour un octet!

Python 3, 294 287 283 octets

Waaayyyyyy trop longtemps, mais je vais essayer de jouer au golf de quelques octets:

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 octets

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

Usage:

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