Kodlayıcılar her zaman dizileri sıkıcı 1 boyutlu varlıklara düzleştirmeye çalışıyorlar ve bu beni üzüyor.

Göreviniz, hoş bir şehir manzarası yaratan, rastgele bir karakter dizisini çözmektir.

Dizeyi düşünün: aaabbbbbccqrrssstttttttPPw

Böyle daha iyi görünüyor:

            tt
            tt
  bb        tt
  bb        tt
aabb      sstt
aabbcc  rrssttPP
aabbccqqrrssttPPww

(Tamam, evet, harfler daha çok şehir manzarası görünümünde görünmesi için çoğaltılmıştır).

Bir giriş dizesi alın, eşleşen karakterlerin alt bölümlerini çoğaltın (zorunlu alfabetik harflerle değil) ve bana bir şehir kurun!

En kısa kod baytı kazanır.

Gerçekte çivilenmiş şartlara sahip olduğumu sanıyordum ama bazı soruları cevaplamak için:

• yerde olmalı
• İsterseniz ekstra gökyüzü olabilir (baştaki boş satırlar, etrafı boş alan) - ancak binalar arasında
• harfler dizginin içinde tekrar kullanılabilir (aynı mimari, farklı konum)
• Harflerin ASCII olduğu kabul edilir, ancak ek kodlamaları destekleyenlere daha fazla bilgi verilecektir (UTF8, vb.)

05AB1E , 6 bayt

γ€DζR»

Çevrimiçi deneyin!

Mücadeleden daha yeni bir sürümünde, ζyerine fo olarak eklendi.Bø

05AB1E , 8 bayt

γ€D.BøR»

Açıklama:

γ            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

Çevrimiçi deneyin!

CJam , 23 bayt

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

Çevrimiçi deneyin!

Açıklama:

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

Jöle , 9 bayt

Œgx'2z⁶ṚY

Çevrimiçi deneyin!

Açıklama:

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

@LeakyNun
-2 bayt sayesinde -19 bayt @officialaimm
-1 bayt sayesinde @Wondercricket sayesinde

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

Çevrimiçi deneyin!

Python 2 , 117 bayt

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)

Çevrimiçi deneyin!

Java 8, 412 400 330 324 312 319 bayt

VisualMelon sayesinde -6 bayt Kevin Cruijssen sayesinde -12 bayt
ama +19 bayt çünkü ithalatı bayt sayımına dahil etmeyi unuttum.

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

Çevrimiçi deneyin!

Japt , 19 18 15 13 12 bayt

Her satırdaki sondaki boşlukları içerir.

ò¦
íU c ·z w

Dene

açıklama

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

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

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),,'')

Çevrimiçi deneyin!

stdin'den okur, stdout'a yazar (takip eden bir yeni satırla).

Açıklama:

• rle Her bir kulenin yüksekliğini, karakter çizgilerinin uzunluğunu bulur.
• sub(I bitişik endeksleri ayar sürtmek yoktu öylesine) sentezleme de çift ile her bir karakteri yerine
• sapply bir dizi döndürür (bu durumda bir matris):
  • sum(e$l|1)farklı karakterlerin sayısıdır; yukarıdan aşağıya gideriz
  • ifelse( ... )if...elsebir matris kulesi ve çift boşluk oluşturmamıza izin veren bir vectorized
  • write biçimlendirmek için birkaç seçenek ile, konsola yazar.

Pyth , 13 bayt

j_.tsC*2]*Mr8

Çevrimiçi deneyin!

PHP , 138 bayt

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

Çevrimiçi deneyin!

MATL , 15 bayt

'(.)\1*'XXtvc!P

Çevrimiçi deneyin!

açıklama

'(.)\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

Kömür , 40 bayt:

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

Çevrimiçi deneyin! Bağlantı, kodun ayrıntılı bir versiyonudur. Başlangıçta, mektubun her değiştirişinde bir dikdörtgen yazdırmak için giriş dizgisi üzerinde basit bir döngü denedim, ancak 5 byte kaydettiğinde bu liste oluşturma yöntemine geçtim. Açıklama: Değişken l, giriş harflerinin iç içe geçmiş bir listesini içerir. Geçerli son liste öğelerine uyan karakterler son listeye itilir, aksi takdirde bu karakter için yeni bir alt liste oluşturulur. Daha sonra her bir alt listedeki harfleri birleştirmeye devam eder, böylece iki kez dikey olarak basılabilirler.

C, 259 231 Bayt

Golf Kodu

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

Ayrıntılı Kod

//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 ile derlenmiş, özel Bayrak yok

Düzenle

Adelphus sayesinde 28 byte kurtarıldı. Değişimi bir tanım oluşturmamı sağladı. Ve döngüleri yeniden düzenleyerek 2 bayttan tasarruf etmek için süre döngülerine girdim. Ayrıca girdideki son karakter singleton olmadığı zaman kodun kırılacağı problemini de düzelttim. Yalnızca bir benzersiz harf varsa kod başarısız olur, ancak diğer tüm durumlarda da çalışması gerekir.

Pip , 22 bayt

21 bayt kod, -lbayrak için +1 .

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

Çevrimiçi deneyin!

açıklama

                       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)

Dörtlü , 15 + 1 = 16 bayt

1Bayrak için +1 bayt .

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

Çevrimiçi deneyin!

⊖⍵ ters çevirerek işlem sonrası

(.)\1* aynı karakterlerin çalışması

2/⍪⍵M sütunlu M atch çoğaltmak

1Bayrak sonuçları birleştirilmiş neden olur.

Haskell, 144 bayt

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

Bundan daha iyisini yapabileceğimden eminim ama şu an için en iyi bulabildiğim bu.

Yığılmış , 42 bayt

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

Çevrimiçi deneyin!

Ruby , 116 bayt

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

Çevrimiçi deneyin!

APL (Dyalog) , 37 bayt

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

Çevrimiçi deneyin!

q / kdb +, 53 bayt

Çözüm:

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

Örnek:

 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"

Açıklama:

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

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

Çevrimiçi deneyin!