Function to print a diamond shape

[monarch_dodra]

On Tuesday, 25 March 2014 at 02:25:57 UTC, Jay Norwood wrote:
> not through yet with the diamond.  This one is a little faster.
>  Appending the newline to the stars and calculating the slice 
> backward from the end would save a w.put for the newlines ... 
> probably faster.  I keep looking for a way to create a dynamic 
> array of a specific size, filled with the init value I provide. 
> Does it exist?
>
> D:\diamond\diamond\diamond\Release>diamond 1>nul
> brad: time: 19370[ms]
> printDiamond1: time: 1140[ms]
> printDiamond2: time: 1631[ms]
> printDiamond3: time: 633[ms]
> jay1: time: 459[ms]
> sergei: time: 11886[ms]
> jay2: time: 415[ms]
> diamondShape: time: 4553[ms]
> printDiamond: time: 187[ms]
> printDiamonde2a: time: 139[ms]
>
>
> void printDiamonde2a(in uint N)
> {
>     size_t N2 = N/2;
>     char pSpace[] = uninitializedArray!(char[])(N2);
>     pSpace[] = ' ';
>
>     char pStars[] = uninitializedArray!(char[])(N);
>     pStars[] = '*';
>
>     char pNewLine[]=uninitializedArray!(char[])(2);
>     pNewLine[] = '\n';
>
>     auto w = appender!(char[])();
>     w.reserve(N*4);
>
>     foreach (n ; 0 .. N2 + 1){
>         w.put(pSpace[0 .. N2 - n]);
>         w.put(pStars[0 .. 2*n+1]);
>         w.put(pNewLine[1]);
>     }
>
>     foreach_reverse (n ; 0 .. N2){
>         w.put(pSpace[0 .. N2 - n]);
>         w.put(pStars[0 .. 2*n+1]);
>         w.put(pNewLine[1]);
>     }
>     write(w.data);
> }

Interesting. I'd have thought the "extra copy" would be an 
overall slowdown, but I guess that's not the case.

I also tried your strategy of adding '\n' to the buffer, but I 
was getting some bad output on windows. I'm not sure why "\n\n" 
works though. On *nix, I'd have also expected a double line feed. 
Did you check the actual output?

Appender is better than "~=", but it's not actually that good 
either. Try this:

//----
void printDiamond3(size_t N)
{
     import core.memory;
     char* p = cast(char*)GC.malloc(N*N+16);
     p[0..N*N+16]='*';

     auto pp = p;
     N/=2;
     enum code = q{
         pp[0 .. N - n] = ' ';
         pp+=(1+N+n);
         version(Windows)
         {
             pp[0 .. 2] = "\r\n";
             pp+=2;
         }
         else
         {
             pp[0] = '\n';
             ++pp;
         }
     };
     foreach        (n; 0 .. N + 1) {mixin(code);}
     foreach_reverse(n; 0 .. N    ) {mixin(code);}
     write(p[0 .. pp-p]);
}
//----

This makes just 1 allocation of roughly the right size. It also 
eagerly fills the entire array with '*', since I *figure* that's 
faster than a lot of different writes.

I could be mistaken about that though, but I imagine the 
pre-allocation and not using Appender is definitely a boost.