मुझे एक शहर बनाओ

Question

कोडर्स हमेशा बोरिंग 1-आयामी संस्थाओं में सरणियों को समतल करने की कोशिश कर रहे हैं और यह मुझे दुखी करता है।

आपका काम पात्रों के एक मनमाने ढंग से स्ट्रिंग को खोलना है, एक सुंदर शहर स्काईस्केप का उत्पादन करना।

स्ट्रिंग पर विचार करें: aaabbbbbccqrrssstttttttPPw

यह इस तरह दिखता है:

            tt
            tt
  bb        tt
  bb        tt
aabb      sstt
aabbcc  rrssttPP
aabbccqqrrssttPPww

(ठीक है, हाँ, अक्षरों को डुप्लिकेट किया गया है ताकि यह अधिक सिटी-स्काईलाइन-एरी दिख सके)।

एक इनपुट स्ट्रिंग लें, मिलान वर्णों के प्रत्येक उपधारा को डुप्लिकेट करें (जरूरी अक्षर नहीं) और मुझे एक शहर बनाएँ!

सबसे छोटा कोड बाइट्स जीतता है।

मुझे वास्तव में लगा कि मेरे पास आवश्यकताएं हैं, लेकिन कुछ सवालों के जवाब देने के लिए:

• यह जमीन पर होना चाहिए
• आप चाहें तो अतिरिक्त आकाश रख सकते हैं (प्रमुख रिक्त रेखाएँ, रिक्त स्थान के आसपास) - लेकिन इमारतों के बीच नहीं
• पत्र स्ट्रिंग के अंदर पुन: उपयोग किया जा सकता है (एक ही वास्तुकला, विभिन्न स्थान)
• अक्षरों को ASCII माना जाता है, लेकिन अतिरिक्त एन्कोडिंग (UTF8, आदि) का समर्थन करने वालों को अधिक फ्लेयर दिया जाएगा।

Comments

क्या हम सिटीस्केप को 90 डिग्री घुमा सकते हैं?

— ओकेक्स

क्या किरदार फिर से दोहराएंगे यानी aaabbbbaa?

— द लीथल कोडर

@ ओएक्सएक्स क्या आपने कभी किसी शहर को 90 डिग्री घुमाया हुआ देखा है, जो बहुत मूर्खतापूर्ण लगेगा! ;)

— टॉम

@ हो सकता है ..?

— रॉड

साइट पर आपका स्वागत है! भविष्य की चुनौतियों के लिए, मैं उन्हें सैंडबॉक्स में पहले पोस्ट करने की सलाह देता हूं जहां आप इसे चुनौती के रूप में पोस्ट करने से पहले समुदाय से प्रतिक्रिया प्राप्त कर सकते हैं।

— दादा

Answer 1

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

इसे ऑनलाइन आज़माएं!

Comments

दिलचस्प बात यह है जेली है z⁶के लिए .Bø... लेकिन यह भी है Œgx'2के लिए γ€D> _>

— एरिक Outgolfer

γ.BD)ø˜øR»मैं जो बिना देखे था, €Dवह बेहतर है; मुझे लगता है कि हम दोनों 1-बाइट समाधान इनलाइन दोहराव को याद कर रहे हैं।

— मैजिक ऑक्टोपस Urn

@MagicOctopusUrn रुको, आपने इसे देखे बिना भी चुनौती को हल कर दिया?

— 20

@ ओकेएक्स, यह बुद्धिमानी नहीं है कि जवाबों को पहले देखें क्योंकि गोल्फिंग का पूरा मज़ा खुद को काट दिया जा सकता है।

— निकोल आउटफर गोल्फ

@EriktheOutgolfer यह एक मजाक था, और मेरा क्या मतलब था कि उन्होंने इसे चुनौती की सामग्री को देखे बिना हल किया।

— ओकेक्स

Answer 2

सीजेएम , 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

Comments

वाह, एक CJam जवाब> _>

— श्री Xcoder

Answer 3

जेली , 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

Comments

क्या आप एक विवरण जोड़ सकते हैं कृपया मैं समझ नहीं पा रहा हूं कि यहां क्या हो रहा है: ओ

— नाथन

@Nathan pastebin.com/DzaBSjd5

— HyperNeutrino

@ हाइपर न्यूट्रिनो अच्छा स्पष्टीकरण ...

— एरिक आउटगॉल्फ

बस यह सुनिश्चित करने के लिए कि क्या यह सही है? : पी

— हाइपरनेत्रिनो

@HyperNeutrino खैर, यह पूरी तरह से इरादा नहीं था ', जो कि खुद सूचियों को दोहराना था और उनके अंदर की वस्तुओं को नहीं, लेकिन कुल मिलाकर यह अच्छा है। :)

— एरिक आउटगोल्फ

Answer 4

अजगर 3 , 155 136 134 132 बाइट्स

-19 बाइट्स @LeakyNun -2 बाइट्स की बदौलत @officialaimm
को धन्यवाद
@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='')

इसे ऑनलाइन आज़माएं!

Answer 5

पायथन 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)

इसे ऑनलाइन आज़माएं!

Answer 6

जावा 8, 412 400 330 324 312 319 बाइट्स

-6 बाइट्स विजुअलमेल
-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);}}}

इसे ऑनलाइन आज़माएं!

Comments

गोल्फ जावा और सी # (मेरा विभाग) बहुत मजेदार है! बने रहिए! परीक्षण नहीं किया गया है, लेकिन मुझे लगता है कि आप लूप के लिए रिजेगिंग करके कुछ बाइट्स बचा सकते हैं: आप पूर्व-असाइन i=0या बेहतर कर सकते हैं i=l, और नीचे की गिनती कर सकते हैं for(;i-->0;h=d>h?d:h)(और h=वहां थोड़ा सा सामान कर सकते हैं)। वही बैक-काउंटिंग आंतरिक लूप के लिए भी काम करेगा। भीतर को ifभी ब्रेस की कोई जरूरत नहीं है {}। और हमेशा की थके हुए हो <=या >=, आप के साथ चारों ओर त्रिगुट बदल सकते हैं >और एक बाइट बचाने।

— विजुअलमेल

धन्यवाद, मैं एक और 6 बाइट्स दाढ़ी कर सकता हूं आपके सुझावों के लिए कोड धन्यवाद। खैर, मुझे लगता है कि मैं जावा गोल्फिंग के साथ रहने जा रहा हूं क्योंकि मैं वास्तव में इसे पसंद करता हूं;)।

— ट्वोमैन

PPCG में आपका स्वागत है! मुझे डर है कि आप की आवश्यकता के कारण 329 (+19 बाइट्स बाइट-संख्या में वृद्धि करना होगा हूँ import java.util.*;के लिए Mapऔर HashMapआयात बाइट गिनती का हिस्सा हैं, और -1 अनुगामी सेमी-कोलन, जो नहीं है को हटाने के द्वारा बाइट-काउंट का हिस्सा)।

— केविन क्रूज़सेन

ऐसा कहने के बाद, आप अभी भी कुछ हिस्सों को इस तरह से गोल्फ कर सकते हैं: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);}}}

— केविन क्रूज़सेन

परिवर्तनों का सारांश: HashMap<>→ HashMap; Map n=→ ,nऔर n=; m.put(c,d=m.get(c)!=null?d+1:1);ब्रैकेट से छुटकारा पाने के लिए फॉर-लूप के अंदर; अर्ध-बृहदान्त्र और फॉर-लूप ब्रैकेट से छुटकारा पाने k=x.charAt(i)के if(n.get(k)!=null)लिए अंदर । फिर से, आपका स्वागत है और महान जवाब! मुझ से +1। इसके अलावा, अगर आपने इसे अभी तक नहीं देखा है: जावा में गोल्फिंग के लिए टिप्स और <किसी भी भाषा में गोल्फिंग के लिए टिप्स> के माध्यम से पढ़ने के लिए दिलचस्प हो सकता है।

— केविन क्रूज़सेन

Answer 7

जाप , 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.

Answer 8

मैथेमेटिका, 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}]])&

Answer 9

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

इसे ऑनलाइन आज़माएं!

स्टडिन से पढ़ता है, stdout को लिखता है (अनुगामी न्यूलाइन के साथ)।

स्पष्टीकरण:

• rle पात्रों की लकीरों की लंबाई, प्रत्येक टॉवर की ऊंचाइयों को पाता है।
• subअभिव्यक्ति अपने डबल के साथ प्रत्येक चरित्र को बदल देता है (तो मैं आसन्न सूचकांक एक साथ स्थापित करने के साथ के बारे में गंदगी के लिए नहीं था)
• sapply एक सरणी देता है (इस मामले में एक मैट्रिक्स):
  • sum(e$l|1)विभिन्न वर्णों की संख्या है; हम ऊपर से नीचे तक जाते हैं
  • ifelse( ... )एक वेक्टरकृत है if...elseजो हमें टावरों और दोहरे स्थानों के मैट्रिक्स का निर्माण करने की अनुमति देता है
  • write कंसोल के लिए लिखते हैं, प्रारूप के लिए कुछ विकल्प के साथ।

Answer 10

पायथ , 13 बाइट्स

j_.tsC*2]*Mr8

इसे ऑनलाइन आज़माएं!

Comments

49 मिनट ... रास्ता बहुत धीमा है

— ओकेक्स

Answer 11

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

इसे ऑनलाइन आज़माएं!

Answer 12

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

Answer 13

चारकोल , 40 बाइट्स:

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

इसे ऑनलाइन आज़माएं! लिंक कोड के वर्बोज़ संस्करण के लिए है। मैंने मूल रूप से इनपुट स्ट्रिंग पर एक साधारण लूप की कोशिश की, जो हर बार पत्र बदल जाने पर एक आयताकार प्रिंट करता था, लेकिन मैंने इस सूची-निर्माण पद्धति पर स्विच कर दिया क्योंकि यह 5 बाइट्स बचाता था। स्पष्टीकरण: चर lमें इनपुट अक्षरों की एक नेस्टेड सूची होती है। वर्तमान अंतिम सूची तत्वों से मेल खाने वाले वर्ण अंतिम सूची में धकेल दिए जाते हैं अन्यथा उस चरित्र के लिए एक नया सबलिस्ट बनाया जाता है। यह तब प्रत्येक सबलिस्ट में अक्षरों को जोड़ने के लिए रहता है ताकि उन्हें दो बार लंबवत मुद्रित किया जा सके।

Answer 14

सी, 259 231 बाइट्स

गोल्फ कोड

#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

}

जीसीसी के साथ संकलित, कोई विशेष झंडे नहीं

संपादित करें

सहेजे गए 28 बाइट्स एडेल्फस के लिए धन्यवाद। उनके बदलाव ने मुझे एक परिभाषित बनाने की अनुमति दी। और मैंने लूप में फेरबदल करके प्रत्येक को 2 बाइट्स बचाने के लिए छोरों के लिए छोरों को बनाया। मैंने यह भी एक मुद्दा तय किया कि इनपुट में अंतिम वर्ण सिंगलटन नहीं होने पर कोड कहां टूट जाएगा। केवल एक अनूठा पत्र होने पर कोड विफल हो जाएगा, लेकिन अन्य सभी मामलों में काम करना चाहिए।

Comments

अच्छा! लेकिन गोल्फ संस्करण किसी कारण से मनमाने इनपुट के साथ काम नहीं करता है। नमूना इनपुट से अंतिम "डब्ल्यू" को हटाने से क की कमी और स्ट्रिंग को दोहराता प्रतीत होता है। यकीन है कि यह कुछ छोटा है ...

— एडलफस

यह भी while (i < strlen(argv[1]))छोटा किया जा सकता है while (argv[1][i])- अशक्त चरित्र तक पाश

— एडेल्फ़स

@adelphus दिलचस्प है, मैं मौका मिलने पर कल इसे आज़माऊंगा। मैंने दिए गए परीक्षण मामले (आलसी मुझे पता है) के अलावा कुछ भी परीक्षण नहीं किया।

— dj0wns

कि वास्तव में एक टन की मदद की, मैं समस्या को ठीक करने और लगभग 30 बाइट्स को कम करने में सक्षम था!

— dj0wns

Answer 15

पिप , 22 बाइट्स

-lध्वज के लिए कोड के 21 बाइट्स, +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)

Answer 16

क्वाड्स , 15 + 1 = 16 बाइट्स

1ध्वज के लिए +1 बाइट ।

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

इसे ऑनलाइन आज़माएं!

⊖⍵ उल्टा-पुल्टा करके पोस्ट-प्रोसेस

(.)\1* समान चरित्रों के रन

2/⍪⍵M स्तंभित M atch को डुप्लिकेट करें

1झंडा परिणाम एक साथ मर्ज करने का कारण बनता है।

Answer 17

हास्केल, 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)]

मुझे पूरा विश्वास है कि मैं इससे बेहतर कर सकता हूं, लेकिन यही सबसे अच्छा समय है।

Comments

पहले बुरी खबर: आप उन कार्यों का उपयोग करते हैं, Data.Listजो डिफ़ॉल्ट रूप से दायरे में नहीं हैं। आप या तो जोड़ने के लिए import Data.List(जैसे से भाषा बदल बाइट गिनती करने के लिए या एक हास्केल वातावरण जो डिफ़ॉल्ट रूप से यह शामिल नहीं है निर्दिष्ट Haskellकरने के लिए Haskell (lambdabot)उपयोग की पद्धति के बजाय बाँध चर के गार्ड: - एक। कुछ टिप्स) letऔर / या घोषणा सहायक कार्यों सीधे: l=length;f s|x<-groupBy(==)s,m<-... =concatMap। b) map l xहै l<$>x, c) concatMap("++\n"है unlines। d) groupBy(==)बस है group। ई) concatहै id=<<। आप mकेवल एक बार उपयोग करते हैं, इसलिए इसे इनलाइन करें

— nami

... च) ()आसपास के लिए कोई ज़रूरत नहीं है l y, replicate ... ' 'और map ... x। सभी में सभी import Data.List;l=length;f s|x<-group s=unlines$reverse$transpose$id=<<[[z,z]|z<-map(\y->y++replicate(maximum(l<$>x)-l y)' ')x]:।

— नमि

groupBy(==)= group, बिल्कुल मुझे यकीन नहीं है कि एक प्रस्तावना में है और दूसरा नहीं है। concatMapलिखा जा सकता है >>=, और mapके रूप में infixed किया जा सकता है <$>, और concat[[z,z]|z<-…]हो सकता है (replicate 2)=<<…या(\z->[z,z])=<<…

— Bergi

: आप @ Bergi उत्तम सिरे से एक और बाइट बंद दाढ़ी कर सकते (\z->[z,z])है (:)<*>pure, यानी...transpose$(:)<*>pure=<<map(\y...)x

— nimi

Answer 18

स्टैक किया गया , 42 बाइट्स

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

इसे ऑनलाइन आज़माएं!

Answer 19

रूबी , 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}*''}}

इसे ऑनलाइन आज़माएं!

Comments

puts a.map{...}के साथ प्रतिस्थापित किया जा सकता हैp(a.map{})

— फ़िलिप बार्टुज़ी

pउत्पादन पात्रों का उद्धरण करेगा, इसलिए यह यहां फिट नहीं है

— एलेक्स

ओह, वाह, धन्यवाद। आप रोज सीखते हैं - stackoverflow.com/a/1255362/2047418

— फिलिप बार्टूज़ी

Answer 20

APL (Dyalog) , 37 बाइट्स

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

इसे ऑनलाइन आज़माएं!

Answer 21

क्यू / केडीबी +, ५३ बाइट्स

समाधान:

{(|)(+)(,/)(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

Answer 22

पर्ल 5 , 92 + 1 (-पी) = 93 बाइट्स

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

इसे ऑनलाइन आज़माएं!