점을 회전


46

소개

2xn 부울 행렬은 4 개의 문자로 구성된 문자열로 표현 될 수 있습니다 . ':. 문자열에는 "상단 행"과 "하단 행"이 있으며 점은 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

이것은 문자열에 해당합니다 ::. :'.

규칙과 득점

전체 프로그램이나 함수를 작성할 수 있습니다. 바이트 수가 가장 적고 표준 허점이 허용되지 않습니다. 입력과 출력을 따옴표로 묶을 지 여부를 결정할 수 있으며, 마지막 줄 바꿈도 둘 다 허용됩니다.

테스트 사례

이 테스트 사례는 큰 따옴표로 묶습니다.

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

답변:


11

자바 스크립트 (ES6), 100 97 93 바이트

@ edc65 덕분에 4 바이트 절약

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의 경우가 :좋습니다.

테스트 스 니펫


잘 했어. 저장 4 : s=>s.replace(/./g,(c,i)=>" '.:"[(i?q>' '&q!=".":c>"'")+(q=c,s[++i]?s[i]>"'":c>' '&c!=".")*2])(2 부분을 뒤집어 i를 증가시키고 정규 표현식을 줄이고 더 간단한 테스트를 수행하고 q에 prev c를 저장하십시오)
edc65

@ edc65 팁 주셔서 감사합니다!
ETHproductions

9

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 비트는 1 비트의 부분 집합이며 임의의 숫자와 00거나 같은 효과를 갖습니다 . 문자가 공백 인 경우에만 문자가 아닌 공백이됩니다 0. 그러나 0어쨌든 우주로 다시 변환되었으므로 괜찮습니다 .


8

망막 , 66

  • @daavko 덕분에 2 바이트 절약
  • @randomra 덕분에 4 바이트 절약
:
1e
\.
1f
'
0e

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

f1
.

설명

입력으로 시작 :

: ''. :

처음 4 단계 는 맨 위 / 아래 행에 각각 /에 대해 1/ e를 사용하여 매트릭스를 구성합니다 . 상단 및 하단 행이 함께 인터레이스됩니다. 다음과 같은 문자열이 생성됩니다.0f

e1f0e0e0f1f0e1

그러나이 4 단계는 문자와 숫자의 순서를 반대로하여 아래쪽 행 1을 왼쪽으로 효과적으로 이동합니다.

1e0f0e0e1f0f1e

T첫 번째와 마지막 문자 ransliteration 무대 반전의 16 진수는, 즉 대체 0-9a-f와 함께 f-a9-0. 이는 왼쪽 아래 문자를 맨 위 행으로, 오른쪽 위 문자를 맨 아래 행으로 이동시키는 효과가 있습니다.

ee0f0e0e1f0f11

그런 다음 다음 단계는 모든 문자-숫자 쌍을 교체하여 상단 행 1을 오른쪽으로 이동합니다. 이전에는 이것이 (\D)(\d)였지만 (.)(\d)대체는 항상 왼쪽에서 오른쪽으로 발생하므로 마지막 두 자리가 잘못 일치하지 않기 때문에 충분합니다. 두 번째 문자는 이미 대체 되었기 때문입니다. 매트릭스는 이제 필요에 따라 완전히 회전되었습니다.

e0e0f0e1e0f1f1

마지막 4 단계는 원래 형식으로 다시 변환됩니다.

'' :'..

온라인으로 사용해보십시오.

각 입력 라인을 개별적으로 처리 할 수 ​​있도록 모든 테스트 케이스 (라인 당 하나씩)를 라인m추가했습니다 T.


7

젤리, 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.

5

피스, 38 36

L,hb_ebsXCyc2.>syCXzJ" .':"K.DR2T1KJ

Jakube 덕분에 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

너무 복잡해서 ^^ 설명을 추가 하시겠습니까?
Denker

1
@DenkerAffe 하나를 추가하는 중간에 :) 추가!
FryAmTheEggman

당신과 같은 접근법을 했어. 내가 알았던 두 가지 :이 람다 L,hb_eb는 1 바이트 더 짧 .DR2T으며 데카르트 곱과 몇 쌍을 더 만들지 만 숫자가 아니고 공간을 절약하는 데 도움이됩니다.
Jakube

@Jakube 감사합니다, 그 .D트릭은 정말 멋지다!
FryAmTheEggman

5

파이썬 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]))

설명

다음 golfed 솔루션은 우편의 다음과 같은 속성을 사용 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(".....''''''")
":...  '''':"

세미콜론으로 구분하여 마지막 세 줄을 한 줄에 넣어 몇 바이트를 절약 할 수 있습니다.
mbomb007

4

Pyth, 66 바이트

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

여기 사용해보십시오!

설명

이것은 세 부분으로 나눌 수 있습니다.

  • 입력을 1과 0으로 구성된 평면 배열로 변환하십시오.
  • 회전하십시오.
  • 다시 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 # d 모듈로의 ASCII 코드 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 행으로 자르기
             2 튜플을 다시 얻기 위해 C # 조옮김
  m # 각 2 튜플 d를 매핑
          id2 # d를 이진수로 해석하고 십진수로 변환
   @ ". ':"# 올바른 문자를 얻기 위해 조회 문자열의 색인으로 사용하십시오.
jk # 하나의 문자열로 결합


3

파이썬 3 166 154 153 150 146 138 137 135 132 127 바이트

편집 : 나는의 사용을 차용 한 zip에서 유안의 파이썬 답을 함수의 끝에서. 나는 내 자신의 비틀기를 넣었지만 반전 을 사용하려는 그들의 아이디어 [::-1]. 결과적으로 반전은 내 기능에 좋지 않은 아이디어였습니다. format추가 골프 사용을 변경했습니다 . 이동 ab직접적으로 zip상기 골프 용 (분리 때문에 그대로 남아 ungolfingab내 설명에 혼란을 피하는 데 유용있다)

편집 : Music Interval Solver challenge에 대한 xnor 의이 답변(some number)>>(n)&(2**something-1) 에서 차용 했습니다 . 되는 혼란 zip(*[divmod(et cetera, 2) for i in input()])나는 그것이 두 개의 튜플을 사용 부여 편의를 좋아한다지만 아마, 더 나은 golfed 할 수 tv.

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

2

루비, 166163 바이트

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


골프를 조금 제안해도 될까요? ->s{a=s.tr(f=" .':",'001').chars;b=s.tr(f,'0101').chars;b<<a.pop;([b.shift]+a).zip(b).map{|x|x.join.to_i 2}.join.tr'0-3',f}
manatwork

마침내 ☕이 효과를 냈습니다. 아침 내내 이것을 찾고 있었다 : .map{|x|x.join.to_i 2}.join.tr'0-3',f.map{|x|f[x.join.to_i 2]}*''
manatwork 9

2

자바 스크립트 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``

각 문자를 2 자리 이진수로 매핑합니다.

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

그리고 나는 그것들이 다른 하나의 위에 있다고 생각합니다.

3212021 becomes
1101010
1010001

나는 n에 저장

n의 각 문자 (0-3)에 대해 이웃을 확인하여 왼쪽 이웃의 최상위 비트를 오른쪽 이웃의 가장 낮은 비트에 추가합니다. i = = 0 (첫 번째 문자)이면 왼쪽 이웃의 상위 비트 대신 자체 하위 비트를 사용합니다.

n [i + 1]>-1이면 0,1,2,3을 얻었으므로 거짓이면 마지막 요소에 부딪칩니다.

그런 일이 발생하면 오른쪽 이웃의 하위 비트 대신 캐릭터 자체의 최상위 비트를 사용합니다.

다시 .':토지에 매핑하고 해당 어레이에 다시 합류


2

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

1

자바 스크립트, 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]=="'"?".":" ")

어쩌면 뭔가를 설정 s[i-1]하시겠습니까? 바이트를 절약 할 수 있습니다.
Rɪᴋᴇʀ

와 동일합니다 s[i+1].
Rɪᴋᴇʀ

1
ES6 화살표 기능과 조회를 사용해보십시오. <대신에 사용 ==하면 꽤 많은 바이트를 절약 할 수 있습니다. JS에서 골프를 위한 팁
Downgoat

1
@Downgoat <대신 사용하는 방법==
Jens Renders

1

자바 스크립트 (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``
)

1
수행합니다 s=>(r=" .':",a=[],s=[...s].map(c=>('00'+r.indexOf(c).toString(2)).slice(-2)).map(n=>(a.push(n[0]),n[1]),a.splice(0,0,s.shift()),s.push(a.pop()),a.map((v,i)=>r[parseInt(v+s[i],2)]).join``)작업을?
Downgoat

이전에 답장을 보내지 않아서 죄송합니다. 알림을받지 못했습니다. 개발자 도구에서 "잘못된 문자"예외가 발생했습니다
RevanProdigalKnight

당신이 그것을 넣을 때 작동하도록했습니다-분명히 복사했을 때 브라우저 개발자 도구에 표시되지 않는 추가 문자가 있습니다.
RevanProdigalKnight

1

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플래그에 바이트가 추가되었습니다 .

내 루비 답변 과 거의 동일한 알고리즘 입니다.

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;

덕분에 톤 Hospel 5 바이트에 대한 msh210 바이트에!


..@a대신 사용할 수 있습니까 ..$#a? (아마도 oct죽거나 0 또는 무언가를 돌려줍니다. 시도하지 않았습니다.)
msh210

공간을 0으로 변환 할 필요가 없습니다. 어쨌든 sprintf의 경우 0으로 평가됩니다. 또한 정규식에서 괄호를 제거하십시오. 캡처가 없으면 전체 경기가 다음과 같이 반환됩니다 ://g
Ton Hospel

@ msh210 그것은 실제로 작동합니다; 감사!
Doorknob

@TonHospel Thanks, 답변에 포함 시켰습니다 (물론 여전히 당신의 물을 완전히 내뿜습니다).
Doorknob

sprintfsoooo를 깁니다. map$_%2,/./g그리고 map$_/2|0,//g거의 짧은 (안된)이어야한다
톤 Hospel

0

파이썬 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)

0

루아, 139 바이트

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

용법:

$ lua conveyor.lua ".'  '.::  :.'. . ::.'  '. . .::'  :.'."
' ' .:.''..'.'. ..:' ' .'. ...'''..'.'
당사 사이트를 사용함과 동시에 당사의 쿠키 정책개인정보 보호정책을 읽고 이해하였음을 인정하는 것으로 간주합니다.
Licensed under cc by-sa 3.0 with attribution required.