编码人员一直在尝试将数组平整为无聊的一维实体，这让我很难过。

您的任务是展开任意字符串，输出漂亮的城市天空景观。

考虑以下字符串： 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

Python 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='')

在线尝试！

Python 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);}}}

在线尝试！

贾普特，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 复制columnified 中号 ATCH

该1标志使结果合并在一起。

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

在线尝试！