I programmatori cercano sempre di appiattire le matrici in noiose entità monodimensionali e questo mi rende triste.

Il tuo compito è di appiattire una serie arbitraria di personaggi, dando vita a un incantevole skyscape cittadino.

Considera la stringa: aaabbbbbccqrrssstttttttPPw

Sembra molto meglio così:

            tt
            tt
  bb        tt
  bb        tt
aabb      sstt
aabbcc  rrssttPP
aabbccqqrrssttPPww

(Ok, sì, le lettere sono duplicate per far sembrare più lo skyline della città).

Prendi una stringa di input, duplica ogni sottosezione di caratteri corrispondenti (non necessariamente lettere alfabetiche) e costruiscimi una città!

Vincono i byte di codice più brevi.

In realtà pensavo di avere i requisiti inchiodati, ma per rispondere ad alcune domande:

• deve essere a terra
• puoi avere del cielo extra se vuoi (linee vuote iniziali, spazio vuoto circostante) - ma non tra gli edifici
• le lettere possono essere riutilizzate all'interno della stringa (stessa architettura, posizione diversa)
• si presume che le lettere siano ASCII, ma verrà dato più fascino a quelli che supportano codifiche aggiuntive (UTF8, ecc.)

05AB1E , 6 byte

γ€DζR»

Provalo online!

In una versione più recente della sfida, ζè stato aggiunto un sostituto per.Bø

05AB1E , 8 byte

γ€D.BøR»

Spiegazione:

γ            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

Provalo online!

CJam , 23 byte

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

Provalo online!

Spiegazione:

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

Gelatina , 9 byte

Œgx'2z⁶ṚY

Provalo online!

Spiegazione:

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

-19 byte grazie a @LeakyNun
-2 byte grazie a @officialaimm
-1 byte grazie a @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='')

Provalo online!

Python 2 , 117 byte

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)

Provalo online!

Java 8, 412 400 330 324 312 319 byte

-6 byte grazie a VisualMelon
-12 byte grazie a Kevin Cruijssen
ma +19 byte perché ho dimenticato di includere le importazioni nel conteggio dei byte.

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

Provalo online!

Japt , 19 18 15 13 12 byte

Include spazi finali su ogni riga.

ò¦
íU c ·z w

Provalo

Spiegazione

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

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

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

Provalo online!

legge da stdin, scrive su stdout (con una nuova riga finale).

Spiegazione:

• rle trova le lunghezze delle strisce di personaggi, le altezze di ogni torre.
• il sub espressione sostituisce ogni personaggio con il suo doppio (quindi non ho dovuto preoccuparmi di mettere insieme gli indici adiacenti)
• sapply restituisce un array (in questo caso una matrice):
  • sum(e$l|1)è il numero di caratteri distinti; andiamo dall'alto verso il basso
  • ifelse( ... ) è un vettore if...else che ci consente di costruire una matrice di torri e doppi spazi
  • write scrive sulla console, con alcune opzioni per formattare.

Pyth , 13 byte

j_.tsC*2]*Mr8

Provalo online!

PHP , 138 byte

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

Provalo online!

MATL , 15 byte

'(.)\1*'XXtvc!P

Provalo online!

Spiegazione

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

Carbone , 40 byte:

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

Provalo online! Il collegamento è alla versione dettagliata del codice. Inizialmente ho provato un semplice ciclo sopra la stringa di input per stampare oblungamente ogni volta che la lettera veniva cambiata, ma sono passato a questo metodo di creazione di elenchi salvando 5 byte. Spiegazione: La variabile lcontiene un elenco nidificato delle lettere di input. I caratteri che corrispondono agli ultimi elementi dell'elenco corrente vengono inseriti nell'ultimo elenco, altrimenti viene creato un nuovo elenco secondario per quel personaggio. Resta quindi da unire le lettere in ciascun elenco secondario in modo che possano essere stampate verticalmente due volte.

C, 259 231 byte

Codice Golfed

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

Codice dettagliato

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

}

Compilato con GCC, nessuna bandiera speciale

modificare

Risparmiato 28 byte grazie ad adelphus. Il suo cambiamento mi ha permesso di creare una definizione. E ho fatto il ciclo while in loop per salvare 2 byte ciascuno riorganizzando il loop. Ho anche risolto un problema in cui il codice si sarebbe rotto quando l'ultimo carattere in input non era singleton. Il codice fallirà se esiste una sola lettera univoca ma dovrebbe funzionare in tutti gli altri casi.

Pip , 22 byte

21 byte di codice, +1 per la -lbandiera.

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

Provalo online!

Spiegazione

                       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 byte

+1 byte per la 1bandiera.

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

Provalo online!

⊖⍵ post-processo capovolgendo

(.)\1* serie di personaggi identici

2/⍪⍵M duplicare il M atch colonnato

Il 1flag fa sì che i risultati vengano uniti.

Haskell, 144 byte

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

Sono abbastanza fiducioso di poter fare meglio di così, ma questo è il meglio che posso inventare per il momento.

Impilato , 42 byte

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

Provalo online!

Rubino , 116 byte

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

Provalo online!

APL (Dyalog) , 37 byte

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

Provalo online!

q / kdb +, 53 byte

Soluzione:

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

Esempio:

 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"

Spiegazione:

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

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

Provalo online!