Codierer versuchen immer, Arrays in langweilige eindimensionale Entitäten zu verwandeln, und das macht mich traurig.

Ihre Aufgabe ist es, eine beliebige Zeichenfolge zu glätten, um eine schöne Stadt-Himmelslandschaft auszugeben.

Betrachten Sie die Zeichenfolge: aaabbbbbccqrrssstttttttPPw

Es sieht viel besser so aus:

            tt
            tt
  bb        tt
  bb        tt
aabb      sstt
aabbcc  rrssttPP
aabbccqqrrssttPPww

(Ok, ja, die Buchstaben sind dupliziert, damit es mehr nach Skyline aussieht.)

Nimm eine Eingabezeichenfolge, dupliziere jeden Unterabschnitt der übereinstimmenden Zeichen (nicht unbedingt alphabetische Buchstaben) und baue mir eine Stadt!

Kürzeste Code-Bytes gewinnen.

Ich dachte eigentlich, ich hätte die Anforderungen genagelt, aber um einige Fragen zu beantworten:

• es muss auf dem Boden liegen
• Sie können zusätzlichen Himmel haben, wenn Sie möchten (führende Leerzeilen, umgebende Leerzeichen) - aber nicht zwischen den Gebäuden
• Buchstaben können innerhalb des Strings wiederverwendet werden (gleiche Architektur, unterschiedliche Position)
• Es wird angenommen, dass die Buchstaben ASCII sind, aber diejenigen, die zusätzliche Codierungen (UTF8 usw.) unterstützen, erhalten mehr Flair.

05AB1E , 6 Bytes

γ€DζR»

Probieren Sie es online!

In einer neueren Version als die Herausforderung wurde ζals Ersatz für hinzugefügt.Bø

05AB1E , 8 Bytes

γ€D.BøR»

Erläuterung:

γ            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

Probieren Sie es online!

CJam , 23 Bytes

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

Probieren Sie es online!

Erläuterung:

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

Gelee , 9 Bytes

Œgx'2z⁶ṚY

Probieren Sie es online!

Erläuterung:

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

-19 Bytes dank @LeakyNun
-2 Bytes dank @officialaimm
-1 Bytes dank @Wondercricket

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

Probieren Sie es online!

Python 2 , 117 Bytes

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)

Probieren Sie es online!

Java 8, 412 400 330 324 312 319 Bytes

-6 Bytes dank VisualMelon
-12 Bytes dank Kevin Cruijssen,
aber +19 Bytes, weil ich vergessen habe, die Importe in die Byteanzahl einzubeziehen .

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

Probieren Sie es online!

Japt , 19 18 15 13 12 Bytes

Schließt nachfolgende Leerzeichen in jede Zeile ein.

ò¦
íU c ·z w

Probier es aus

Erläuterung

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

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

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

Probieren Sie es online!

Liest von stdin, schreibt nach stdout (mit einem nachgestellten Zeilenumbruch).

Erläuterung:

• rle Ermittelt die Länge der Zeichenstreifen, die Höhe der einzelnen Türme.
• Der subAusdruck ersetzt jedes Zeichen durch das Doppelte (so musste ich mich nicht mit dem Setzen benachbarter Indizes herumschlagen).
• sapply gibt ein Array zurück (in diesem Fall eine Matrix):
  • sum(e$l|1)ist die Anzahl der verschiedenen Zeichen; wir gehen von oben nach unten
  • ifelse( ... )ist eine Vektorisierung, die if...elsees uns ermöglicht, eine Matrix aus Türmen und Doppelräumen zu bauen
  • write Schreibt in die Konsole mit einigen Formatierungsoptionen.

Pyth , 13 Bytes

j_.tsC*2]*Mr8

Probieren Sie es online!

PHP , 138 Bytes

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

Probieren Sie es online!

MATL , 15 Bytes

'(.)\1*'XXtvc!P

Probieren Sie es online!

Erläuterung

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

Kohle , 40 Bytes:

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

Probieren Sie es online! Link ist eine ausführliche Version des Codes. Ursprünglich habe ich eine einfache Schleife über die Eingabezeichenfolge versucht, um bei jeder Änderung des Buchstabens ein Rechteck auszudrucken, aber ich habe auf diese Listenerstellungsmethode umgestellt, da sie 5 Bytes sparte. Erläuterung: Die Variable lenthält eine verschachtelte Liste der eingegebenen Buchstaben. Zeichen, die mit den aktuellen Elementen der letzten Liste übereinstimmen, werden in die letzte Liste verschoben, andernfalls wird eine neue Unterliste für dieses Zeichen erstellt. Anschließend müssen die Buchstaben in jeder Unterliste zusammengefügt werden, damit sie zweimal vertikal gedruckt werden können.

C 259 231 Bytes

Golf Code

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

Ausführlicher Code

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

}

Kompiliert mit GCC, keine speziellen Flags

Bearbeiten

28 Bytes dank adelphus gespart. Seine Änderung erlaubte mir, eine Definition zu erstellen. Und ich habe die while-Schleifen zu for-Schleifen gemacht, um jeweils 2 Bytes zu sparen, indem ich die Schleife neu anordnete. Ich habe auch ein Problem behoben, bei dem der Code unterbrochen wurde, wenn das letzte eingegebene Zeichen kein Singleton war. Der Code schlägt fehl, wenn es nur einen eindeutigen Buchstaben gibt, sollte aber in allen anderen Fällen funktionieren.

Pip , 22 Bytes

21 Byte Code, +1 für -l Flag.

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

Probieren Sie es online!

Erläuterung

                       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 Bytes

+1 Byte für das 1Flag.

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

Probieren Sie es online!

⊖⍵ Nachbearbeitung durch Umdrehen

(.)\1* Läufe mit identischen Zeichen

2/⍪⍵M duplizieren die kolumnifizierten M atch

Das 1Flag bewirkt, dass die Ergebnisse zusammengeführt werden.

Haskell, 144 Bytes

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

Ich bin ziemlich zuversichtlich, dass ich es besser machen kann, aber dies ist das Beste, was ich mir vorerst einfallen lassen kann.

Gestapelt , 42 Bytes

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

Probieren Sie es online!

Ruby , 116 Bytes

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

Probieren Sie es online!

APL (Dyalog) , 37 Bytes

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

Probieren Sie es online!

q / kdb + 53 Bytes

Lösung:

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

Beispiel:

 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"

Erläuterung:

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

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

Probieren Sie es online!