코더는 항상 배열을 지루한 1 차원 엔터티로 평면화하려고 노력하며 슬프게 만듭니다.

당신의 임무는 임의의 문자열을 풀어서 아름다운 도시의 하늘을 출력하는 것입니다.

문자열을 고려하십시오. aaabbbbbccqrrssstttttttPPw

다음과 같이 훨씬 나아 보입니다 :

            tt
            tt
  bb        tt
  bb        tt
aabb      sstt
aabbcc  rrssttPP
aabbccqqrrssttPPww

(예, 글자가 복제되어 더 도시-스카이 라인으로 보이게됩니다).

입력 문자열을 가져와 일치하는 문자의 각 하위 섹션을 복제하고 (알파벳 문자 일 필요는 없음) 도시를 건설하십시오!

가장 짧은 코드 바이트가 이깁니다.

실제로 요구 사항이 해결되었다고 생각했지만 몇 가지 질문에 대답했습니다.

• 그것은 지상에 있어야합니다
• 당신이 원한다면 여분의 하늘을 가질 수 있습니다 (빈 공간을 둘러싼 빈 줄)-건물 사이에는 없습니다.
• 문자열 내에서 문자를 재사용 할 수 있음 (동일한 아키텍처, 다른 위치)
• 문자는 ASCII로 가정되지만 추가 인코딩 (UTF8 등)을 지원하는 문자에는 더 많은 감각이 부여됩니다

05AB1E , 6 바이트

γ€DζR»

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

챌린지보다 새로운 버전에서는 다음 ζ과 같은 대체품으로 추가되었습니다..Bø

05AB1E , 8 바이트

γ€D.BøR»

설명:

γ            Convert into a list of consecutive equal elements
 €D          Duplicate each element
   .B        Squarify; pad each element with spaces so that they are the length of the longest element
     ø       Transpose
      R      Reverse (otherwise the city would be upside-down)
       »     Join by newlines

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

CJam , 23 바이트

qe`::*:__:,:e>f{Se[}zN*

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

설명:

qe`::*:__:,:e>f{Se[}zN* Accepts (multi-line?) input
q                       Take all input
 e`::*                  Split into groups of equal elements
      :_                Duplicate each
        _:,:e>          Push maximal length without popping
              f{Se[}    Left-pad each to that length with space strings (NOT space chars, although not a problem here)
                    z   Zip
                     N* Join with newlines

젤리 , 9 바이트

Œgx'2z⁶ṚY

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

설명:

Œgx'2z⁶ṚY  Main Link
Œg         Group runs of equal elements
  x        Repeat
   '              the lists
    2                       twice without wrapping
     z⁶    Zip (transpose), filling in blanks with spaces
       Ṛ   Reverse the whole thing so it's upside-down
        Y  Join by newlines

파이썬 (3) , 155 (136) 134 132 바이트

@LeakyNun 덕분에 -19 바이트, @officialaimm 덕분에
-2 바이트 @Wondercricket 덕분에
-1 바이트

s=input()+'+'
k=' '*len(s)
a=[]
c=b=''
while s:
 while c in b:b+=c;c,*s=s
 a+=b+k,b+k;b=c
for r in[*zip(*a)][:0:-1]:print(*r,sep='')

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

파이썬 2 , 117 바이트

import re
s=input()
for l in zip(*[x+S*len(s)for x,_ in re.findall(r'((.)\2*)',s)for S in'  '])[::-1]:print''.join(l)

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

자바 (8) 412 400 330 324 312 319 바이트

VisualMelon 덕분에 -6 바이트
Kevin Cruijssen 덕분에 -12 바이트
지만 바이트 수에 가져 오기를 포함하는 것을 잊었 기 때문에 +19 바이트.

import java.util.*;x->{Map m=new HashMap(),n;int l=x.length(),i=l,v,y,h=0,d=1;char c,k;for(;i-->0;m.put(c,d=m.get(c)!=null?d+1:1),h=d>h?d:h)c=x.charAt(i);for(y=h;y>0;y--){n=new HashMap(m);for(i=0;i<l;i++)if(n.get(k=x.charAt(i))!=null){v=(int)m.get(k);System.out.print((y>v?"  ":k+""+k)+(i==l-1?"\n":""));n.remove(k);}}}

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

Japt , 19 18 15 13 12 바이트

각 줄에 후행 공백을 포함합니다.

ò¦
íU c ·z w

그것을 테스트

설명

         :Implicit input of string U
ò        :Split U to an array by ...
¦        :   checking for inequality between characters.
í        :Pair each item in U with...
U        :   The corresponding item in U (i.e, duplicate each string)
c        :Flatten the array (í creates an array of arrays).
·        :Join to a string with newlines.
z        :Rotate 90 degrees.
w        :Reverse.
         :Implicit output of resulting string.

Mathematica, 150 바이트

(z=Characters[v=#];f=CharacterCounts[v][#]&/@(d=Union@z);Row[Column/@Map[PadLeft[#,Max@f,""]&,Table[Table[d[[i]]<>d[[i]],f[[i]]],{i,Length@d}],{1}]])&

R 135 바이트

e=rle(sub('(.)','\\1\\1',strsplit(scan(,''),'')[[1]]));write(sapply(sum(e$l|1):1,function(x)ifelse(e$l>=x,e$v,'  ')),'',sum(e$l|1),,'')

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

stdin에서 읽고 stdout에 씁니다 (후행 줄 바꿈).

설명:

• rle 문자의 줄 길이, 각 탑의 높이를 찾습니다.
• 이 sub표현은 각 문자를 이중으로 대체합니다 (따라서 인접한 색인을 함께 설정하는 것에 대해 고민 할 필요가 없습니다)
• sapply 배열 (이 경우 행렬)을 반환합니다.
  • sum(e$l|1)고유 문자 수입니다. 우리는 위에서 아래로 간다
  • ifelse( ... )if...else우리는 타워와 이중 공간의 행렬을 만들 수 있도록 벡터화 된 것입니다.
  • write 몇 가지 옵션을 지정하여 콘솔에 씁니다.

Pyth , 13 바이트

j_.tsC*2]*Mr8

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

PHP , 138 바이트

for(;~$s=&$argn;$s=substr($s,$r++%2*$i))for($i=0;$i<strspn($s,$c=$s[0]);$f[$i++][$r]=$c)a&$f[$i]?:$f[$i]=" ";krsort($f);echo join("
",$f);

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

MATL , 15 바이트

'(.)\1*'XXtvc!P

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

설명

'(.)\1*' % Push string to be used as regexp pattern
XX       % Implicit input. Regexp matching. Pushes row cell array of matching substrings
t        % Duplicate
v        % Concatenate vertically
c        % Convert to char. This reads cells in column-major order (down, then across)
         % and produces a 2D char array, right-padding with spaces
!        % Transpose
P        % Flip vertically. Implicitly display

숯 , 40 바이트 :

Ａ⟦⟦ω⟧⟧λＦθ¿⁼ι§§λ±¹¦⁰⊞§λ±¹ι⊞λ⟦ι⟧ＦλＦ²↑⁺⪫ιω¶

온라인으로 사용해보십시오! 링크는 자세한 버전의 코드입니다. 원래 문자가 변경 될 때마다 직사각형을 인쇄하기 위해 입력 문자열에 간단한 루프를 시도했지만 5 바이트를 절약 하면서이 목록 작성 방법으로 전환했습니다. 설명 : 변수 l에 입력 문자의 중첩 된 목록이 있습니다. 현재 마지막 목록 요소와 일치하는 문자가 마지막 목록으로 푸시됩니다. 그렇지 않으면 해당 문자에 대한 새 하위 목록이 작성됩니다. 그런 다음 각 하위 목록의 문자를 결합하여 세로로 두 번 인쇄 할 수 있습니다.

C, 259231 바이트

골프 코드

#define v a[1][i
i,k,l,x,h,w;main(char*s,char**a){for(;v];w+=2*!x,s=v++],h=x>h?x:h)x=(s==v])*(x+1);h++;s=malloc((x=h++*++w+1)+w);memset(s,32,h*w);for(i=k;v];s[x+1]=s[x]=k=v++],x=k==v]?x-w:(h-1)*w+l++*2+3)s[i*w]=10;printf("%s",s);}

자세한 코드

//Variable Explanations:
//i - increment through argument string, must beinitialized to 0
//k - increment through argument string, must be initialized to 0
//l - record x coordinate in return value, must be initialized to 0
//x - record the actual character position within the return string
//arrheight - the height of the return string
//arrwidth - the width of the return string
//arr - the return string
//argv - the string containing the arguments
#define v argv[1][i

i,k,l,x,arrheight,arrwidth;

main(char*arr,char**argv){
  for(;v];                                 //For Length of input
    arrwidth+=2*!x,                        //increment width by 2 if this char is not the same as the last
    arr=v++],                              //set arr to current char
    arrheight=x>arrheight?x:arrheight      //see if x is greater than the largest recorded height
  )x=(arr==v])*(x+1);                     //if this character is the same as the last, increment x (using arr to store previous char)
  arrheight++;                             //increment height by one since its 0 indexed
  arr=malloc((x=arrheight++*++arrwidth+1)+arrwidth); //create a flattened array widthxheight and set x to be the bottom left position
  memset(arr,32,arrheight*arrwidth);       //fill array with spaces
  for(i=k;v];                              //For Length of input
    arr[x+1]=arr[x]=k=v++],                //set x and x+1 positions to the current character, store current character in i
    x=k==v]?x-arrwidth:(arrheight-1)*arrwidth+l++*2+3 //if next char is same as current move vertically, else set x to bottom of next column
  )arr[i*arrwidth]=10;                     //Add new lines to string at end of width

  printf("%s",arr);                        //output string

}

특수 플래그없이 GCC로 컴파일

편집하다

adelphus 덕분에 28 바이트를 절약했습니다. 그의 변화로 정의를 만들 수있었습니다. 그리고 루프를 재정렬하여 while 루프를 for 루프로 만들어 각각 2 바이트를 절약했습니다. 또한 입력의 마지막 문자가 싱글 톤이 아닌 경우 코드가 중단되는 문제를 수정했습니다. 고유 한 문자가 하나만 있지만 다른 모든 경우에는 작동해야합니다.

핍 , 22 바이트

21 바이트 코드, -l플래그는 +1

Ya@`(.)\1*`RV:yWVyZDs

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

설명

                       a is 1st cmdline arg; s is space (implicit)
 a@`(.)\1*`            Using regex, create list of runs of same character in a
Y                      Yank that into y variable
              yWVy     Weave (interleave) y with itself to duplicate each item
                  ZDs  Zip to transpose, with a default character of space filling gaps
           RV:         Reverse the resulting list (with the compute-and-assign
                        meta-operator : being abused to lower the precedence)
                       Auto-print, one sublist per line (implicit, -l flag)

QuadS , 15 + 1 = 16 바이트

1플래그의 경우 +1 바이트

⊖⍵
(.)\1*
2/⍪⍵M

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

⊖⍵ 뒤집어서 후 처리

(.)\1* 동일한 문자로 실행

2/⍪⍵M 컬럼 화 된 M atch를 복제하십시오

1플래그는 결과를 함께 병합됩니다.

하스켈, 144 바이트

f s=let x=groupBy(==)s;l=length;m=maximum(map l x)in concatMap(++"\n")$reverse$transpose$concat[[z,z]|z<-(map(\y->y++(replicate(m-(l y))' '))x)]

나는 이것보다 더 잘할 수 있다고 확신하지만, 당분간 내가 할 수있는 최선입니다.

스택 , 42 바이트

[rle toarr[...*chars]map FIX 2*tr rev out]

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

루비 , 116 바이트

->s{a=s.scan(/(.)(\1*)/).map{|x,y|[x,y.size+1]}.to_h
m=a.values.max
m.times{|i|puts a.map{|k,v|v+i<m ?'  ':k*2}*''}}

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

APL (Dyalog) , 37 바이트

{⊃,/⍵↑⍨¨-⌈/≢¨⍵}'(.)\1*'⎕S{2/⍪⍵.Match}

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

q / kdb +, 53 바이트

해결책:

{(|)(+)(,/)(max(#:)each c)$(+)2#(,)c:((&)differ x)_x}

예:

 q){(|)(+)(,/)(max(#:)each c)$(+)2#(,)c:((&)differ x)_x}"BBPPPPxxGGGGKKKKKKKkkkkEEeeEEEeeEEEEEOOO8####xxXXX"
 "        KK                      "
 "        KK                      "
 "        KK          EE          "
 "  PP  GGKKkk        EE    ##    "
 "  PP  GGKKkk    EE  EEOO  ##  XX"
 "BBPPxxGGKKkkEEeeEEeeEEOO  ##xxXX"
 "BBPPxxGGKKkkEEeeEEeeEEOO88##xxXX"

설명:

{reverse flip raze (max count each c)$flip 2#enlist c:(where differ x)_x} / ungolfed function
{                                                                       } / lambda function
                                                      (where differ x)    / indices where x differs
                                                                      _   / cut at these points aabbbc -> "aa","bbb","c"
                                                    c:                    / save in variable c
                                             enlist                       / put this list in another list
                                           2#                             / take two from this list (duplicate)
                                      flip                                / rotate columns/rows
                   (max count each c)                                     / find the longest run of characters
                                     $                                    / whitespace pad lists to this length
              raze                                                        / reduce down lists
         flip                                                             / rotate columns/rows
 reverse                                                                  / invert so buildings are on the ground

Perl 5 , 92 + 1 (-p) = 93 바이트

while(s/(.)\1*//){$a[$_].=($"x($i-length$a[$_])).$1x2for 1..length$&;$i+=2}say while$_=pop@a

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