Les codeurs essaient toujours d’aplanir les tableaux en entités ennuyeuses à une dimension et cela me rend triste.

Votre tâche consiste à aplatir une chaîne arbitraire de caractères pour créer un magnifique paysage urbain.

Considérons la chaîne: aaabbbbbccqrrssstttttttPPw

Ça ressemble beaucoup mieux à ça:

            tt
            tt
  bb        tt
  bb        tt
aabb      sstt
aabbcc  rrssttPP
aabbccqqrrssttPPww

(Ok, oui, les lettres sont dupliquées pour donner un aspect plus urbain à la ville).

Prenez une chaîne de saisie, dupliquez chaque sous-section de caractères correspondants (pas nécessairement des lettres alphabétiques) et construisez-moi une ville!

Les octets de code les plus courts gagnent.

En fait, je pensais avoir les exigences définies, mais pour répondre à quelques questions:

• il doit être sur le terrain
• vous pouvez avoir du ciel en plus si vous le souhaitez (lignes vierges, espace vide environnant) - mais pas entre les bâtiments
• les lettres peuvent être réutilisées à l'intérieur de la chaîne (même architecture, emplacement différent)
• les lettres sont supposées être ASCII, mais plus de talent sera donné à ceux supportant des encodages supplémentaires (UTF8, etc.)

05AB1E , 6 octets

γ€DζR»

Essayez-le en ligne!

Dans une version plus récente que le défi, ζa été ajouté pour remplacer.Bø

05AB1E , 8 octets

γ€D.BøR»

Explication:

γ            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

Essayez-le en ligne!

CJam , 23 octets

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

Essayez-le en ligne!

Explication:

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

Gelée , 9 octets

Œgx'2z⁶ṚY

Essayez-le en ligne!

Explication:

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

-19 octets grâce à @LeakyNun
-2 octets grâce à @officialaimm
-1 octet grâce à @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='')

Essayez-le en ligne!

Python 2 , 117 octets

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)

Essayez-le en ligne!

Java 8, 412 400 330 324 312 319 octets

-6 octets grâce à VisualMelon
-12 octets grâce à Kevin Cruijssen
mais +19 octets car j'ai oublié d'inclure les importations dans le nombre d'octets.

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

Essayez-le en ligne!

Japt , 19 18 15 13 12 octets

Inclut les espaces de fin sur chaque ligne.

ò¦
íU c ·z w

Essaye-le

Explication

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

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

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

Essayez-le en ligne!

lit à partir de stdin, écrit sur stdout (avec une nouvelle ligne).

Explication:

• rle trouve la longueur des traînées de caractères, les hauteurs de chaque tour.
• l' subexpression remplace chaque caractère par son double (donc je n'ai pas eu à me gêner pour définir des index adjacents ensemble)
• sapply retourne un tableau (dans ce cas une matrice):
  • sum(e$l|1)est le nombre de caractères distincts; on va de haut en bas
  • ifelse( ... )est une vectorisée if...elsenous permettant de construire une matrice de tours et de doubles espaces
  • write écrit sur la console, avec quelques options de formatage.

Pyth , 13 octets

j_.tsC*2]*Mr8

Essayez-le en ligne!

PHP , 138 octets

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

Essayez-le en ligne!

MATL , 15 octets

'(.)\1*'XXtvc!P

Essayez-le en ligne!

Explication

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

Charbon de bois , 40 octets:

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

Essayez-le en ligne! Le lien est vers la version verbeuse du code. À l’origine, j’ai essayé une simple boucle sur la chaîne d’entrée pour imprimer une forme oblongue chaque fois que la lettre était modifiée, mais j’ai opté pour cette méthode d’établissement de liste, qui économise 5 octets. Explanation: La variable lcontient une liste imbriquée des lettres saisies. Les personnages qui correspondent aux derniers éléments de la liste en cours sont ajoutés à la dernière liste, sinon une nouvelle sous-liste est créée pour ce personnage. Il reste ensuite à joindre les lettres de chaque sous-liste pour pouvoir les imprimer deux fois verticalement.

C, 259 231 octets

Code de golf

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

Code verbeux

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

}

Compilé avec GCC, pas de drapeaux spéciaux

modifier

Sauvegardé 28 octets grâce à adelphus. Son changement m'a permis de créer une définition. Et j'ai créé les boucles while dans les boucles for afin d'économiser 2 octets chacune en réorganisant la boucle. J'ai également corrigé un problème qui entraînait la rupture du code lorsque le dernier caractère saisi n'était pas singleton. Le code échouera s'il n'y a qu'une seule lettre mais doit fonctionner dans tous les autres cas.

Pépin , 22 octets

21 octets de code, +1 pour le -ldrapeau.

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

Essayez-le en ligne!

Explication

                       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 octets

+1 octet pour le 1drapeau.

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

Essayez-le en ligne!

⊖⍵ post-traitement en retournant à l'envers

(.)\1* des séries de caractères identiques

2/⍪⍵M dupliquer le columnified M atch

Le 1drapeau provoque la fusion des résultats.

Haskell, 144 octets

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

Je suis persuadé que je peux faire mieux que cela, mais c'est le meilleur que je puisse trouver pour le moment.

Empilés , 42 octets

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

Essayez-le en ligne!

Ruby , 116 octets

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

Essayez-le en ligne!

APL (Dyalog) , 37 octets

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

Essayez-le en ligne!

q / kdb +, 53 octets

Solution:

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

Exemple:

 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"

Explication:

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

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

Essayez-le en ligne!