DouKaku?

pyramid: fun(str) {
    space: [" "].cycle;
    arr: str.split("").to_a;
    n: arr.length;
    n.times.map(|i| i + 1){
        chain(space.take(n - it ),
              arr.slice(n - it, n).zip(space).map(|a,b| a~b)).join("").p;
    }
}

pyramid("hoge");
pyramid("abracadabra");

Sequence splitEvery := method(
    l := list()
    self foreach(v, 
        l append(v asCharacter)
    )   
    return l
)
pyramid := method(str,
    t := str size * 2 - 1 
    for(i, 1, str size,
        str slice(str size - i, str size) splitEvery join(" ") alignCenter(t, " ") println 
    )   
)

String.prototype.repeat = function(n) {
    for(var i=0, str=""; i < n; i++) {
        str += this;
    }
    return str;
}

String.prototype.alignCenter = function(n, str) {
    var r = (n - this.length) / 2;
    return str.repeat(r) + this + str.repeat(r);
}

var pyramid = function(str) {
    var t = str.length * 2 - 1
    var res = ""
    for(var i=1, len=str.length; i<=len; i++) {
        res += str.slice(str.length - i, str.length).split("").join(" ").alignCenter(t, " ") + "\n"
    }
    return res;
}

String.prototype.alignCenter = function(n, str) {
    var r = (n - this.length) / 2
    return str.repeat(Math.floor(r)) + this + str.repeat(Math.ceil(r));
}

str="abracadabra"; (str.length-1).downto(0) {|i| print(" "*i, str[i..-1].split(//).join(" "),"\n") }

sub pyramid {
    my $i = my @py = split //, $_[0];
    print ' ' x $i . "@py[$i..$#py]\n" while $i--;
}

pyramid('hoge');
pyramid('abracadabra');

function pyramid(str)
  len = string.len(str)
  for i=len, 1, -1 do
    io.stdout:write(string.rep(" ",i-1))
    for j=i, len, 1 do io.stdout:write(string.sub(str,j,j), " ") end
    io.stdout:write("\n")
  end
end
pyramid("abracadabra")

(use srfi-1)
(define (pyramid str)
  (map
   (lambda (i)
     (format #t "~a~a~%" (make-string i)
             (string-join (map string (string->list str i (string-length str))) " ")))
   (iota (- (string-length str) 0) (- (string-length str) 1) -1)))
(pyramid "abracadabra")

(defun pyramid (str)
  (loop for i from (1- (length str)) downto 0 do
       (format t "~a~a~%"
               (make-string i :initial-element #\Space)
               (apply #'concatenate 'string
                      (loop for c across str
                         for j from 0
                         when (<= i j)
                         collect (format nil "~c~a" c " "))))))
(pyramid "abracadabra")

#include <stdio.h>

void pyramid(char *str) {
    int i,j,len;
    len = strlen(str);
    for (i=len-1; i>=0; i--) {
        for(j=0; j<i; j++) printf(" ");
        for(j=i; j<len; j++) printf("%c%c", str[j], ' ');
        printf("\n");
    }
}

int main() {
    pyramid("abracadabra");
    return 0;
}

private import std.stdio;

void pyramid(char[] str) {
    int i,j;
    for (i=str.length-1; i>=0; i--) {
        for(j=0; j<i; j++) writef(" ");
        for(j=i; j<str.length; j++) writef("%s%s", str[j], " ");
        writef("\n");
    }
}

int main() {
    pyramid("abracadabra");
    return 0;
}

(require 'cl)
(defun pyramid (str)
  (interactive "sPyramid string: ")
  (with-output-to-temp-buffer "*Pyramid*"
    (loop for i from (1- (length str)) downto 0 do
          (princ (make-string i ? ))
          (princ (mapconcat 'identity (split-string (substring str i) "") " "))
          (terpri))))

function pyramid () {
    str=$1
    len=`expr length $str`
    for ((i=$len; i>=1; i--)); do
        for ((j=0; j<$i; j++)); do echo -n ' '; done
        for ((j=$i; j<=$len; j++)); do
            echo -n `expr substr $str $j 1`' '
        done
        echo
    done
}
pyramid "abracadabra"

(use util.list)
(define (pyramid s)
  (let r ((s (string->list s)) (p '()))
    (unless (null? s)
      (r (cdr s) (cons #\ p))
      (apply print (append p (intersperse #\  s))))))

import Data.List

binapp o f g x = f x `o` g x
pyramid = binapp (zipWith (++)) (map (map (const ' ')) . tail . tails)
                                (map (intersperse ' ') . tail . inits)
printPyramid = putStr . unlines . pyramid

{-
*Main> printPyramid "abracadabra"
          a
         a b
        a b r
       a b r a
      a b r a c
     a b r a c a
    a b r a c a d
   a b r a c a d a
  a b r a c a d a b
 a b r a c a d a b r
a b r a c a d a b r a
-}

BEGIN {
	if (length(ARGV[1]) > 0) printf pyramid(ARGV[1])
}

function pyramid(str,  N,moji,i,j)
{
	N = split(str,moji,"")

	s = ""
	a = moji[1]; for (i=2; i<=N; i++) a = a " " moji[i]  ## a = moji.join(' ')
	for (i=N; i>=1; i--) {
		s = a "\n" s
		sub(/[a-z]/,"",a)  ## 先頭から１文字ずつ消していく
	}
	return s
}

def pyramid(s):
	for i in range(len(s)):
		print ' '.join(s[~i:]).center(len(s)*2-1)

pyramid('hoge')
pyramid('abracadabra')

import Data.List

binapp o f g x = f x `o` g x
pyramid = binapp (zipWith (++)) (map (map (const ' ')) . tail)
                                (map (intersperse ' ') . tail . reverse)
        . tails
printPyramid = putStr . unlines . pyramid

{-
*Main> printPyramid "abracadabra"
          a
         r a
        b r a
       a b r a
      d a b r a
     a d a b r a
    c a d a b r a
   a c a d a b r a
  r a c a d a b r a
 b r a c a d a b r a
a b r a c a d a b r a
-}

<?php
function pyramid($data) {
	$stclm = strlen($data);
	for ( $i = strlen($data) - 1; $i > -1; $i-- ) {
		$stclm--;
		echo str_pad("",$stclm," ",STR_PAD_LEFT);
		for ( $j = $i; $j < strlen($data); $j++ ) {
			echo substr($data,$j,1)." ";
		}
		echo "\n";
	}
}

pyramid("hoge");
pyramid("abracadabra");
?>

def pyramid(s:String) = {
  val (len, cs) = (s.size-1, s.toList)
  len.until(-1,-1).map(cs.splitAt).foreach{p =>
    println((p._1.map(x=>""):::p._2).mkString(" "))
  }
}

#include <iostream>
#include <string>
#include <iterator>
#include <algorithm>

void pyramid(const std::string& s)
{
    for (std::string::const_iterator it = s.end(); it != s.begin(); --it)
    {
        const size_t n = std::distance(s.begin(), it - 1);

        std::fill_n(std::ostream_iterator<char>(std::cout), n, ' ');

        std::copy(it - 1, s.end() - 1, std::ostream_iterator<char>(std::cout, " "));

        std::cout << *(s.end() - 1);

        std::fill_n(std::ostream_iterator<char>(std::cout), n, ' ');

        std::cout << std::endl;
    }
}

int main()
{
    pyramid("hoge");
    pyramid("abracadabra");
}

def pyramid(s):
  print '\n'.join([' '*i + ' '.join(s[i:]) for i in range(len(s)-1, -1, -1)]),

pyramid('hoge')
pyramid('abracadabra')

function pyramid($str) {
    $splt;
    for ($i = 0; $i < strlen($str); $i++) {
        $s = str_split(substr($str,$i,strlen($str)));
        $splt[] = str_repeat(" ", $i) .join(" ",$s);
    }
    krsort($splt);
    return join("\n",$splt);
}
echo pyramid("abracadabra");

function pyramid(s){
  s = s.split('');
  for(var r = [], i = s.length, j = 0; i--; s[j++] = "") r[i] = s.join(' ');
  return r.join('\n');
}

| input |
input := 'abracadabra'.
World findATranscript: nil.
1 to: input size do: [:len |
	Transcript cr; show: (String new: input size - len withAll: $ ).
	(input last: len) do: [:each | Transcript show: each] separatedBy: [Transcript space]]

s="abracadabra";n=len(s);print"\n".join(" ".join(s[~i:]).center(n*2-1)for i in range(n))

public class Pyramid {
	public static void main(String[] args) {
		String data = args.length > 0 ? args[0] : "abracatabra";
		char[] spaceChars = new char[data.length()-1];
		java.util.Arrays.fill(spaceChars, ' ');
		String space = new String(spaceChars);
		
		for(int i=0;i<data.length();i++) {
			System.out.println(space.substring(i)
					+ data.substring(data.length()-1-i).replaceAll("(.)(?=.)","$1 "));
		}
	}
}

<?php
function pyramid($str)
{
    $len=strlen($str);
    $str=implode(" ",str_split($str));
    for($i=1;$i<=$len;++$i)
    	echo str_repeat(" ", $len-$i),substr($str,-($i*2-1)),"\n";
}
echo pyramid("abracadabra");
?>

<?php
function pyramid($str)
{
	$i=strlen($str);
	$a=array_fill( 0, $i, "");
	while(--$i>=0)
	{	$a[$i]=$str[$i];
		echo implode(" ",$a),"\n";
	}
}

pyramid("abracadabra");
?>

Sub pyramid(ByVal block As String)
    For i As Integer = 0 To block.Length - 1
        Dim line As String = Space(block.Length - i - 1)
        For j As Integer = 0 To i
            line &= " " & block.Substring(block.Length - i - 1 + j, 1)
        Next
        Console.WriteLine(line.Substring(1))
    Next
End Sub

#include <stdio.h>
#include <string.h>

void put_s(int n)
{
	int i;
	for (i = 0; i < n; i++) putchar(' ');
}

void put_c(const char *s)
{
	putchar(*s);
	
	while (*++s) {
		putchar(' ');
		putchar(*s);
	}
}
void pyramid(const char *s)
{
	int n;

	n = strlen(s);
	
	while (--n >= 0) {
		put_s(n);
		put_c(s + n);
		put_s(n);
		putchar('\n');
	}
}

int main()
{
	pyramid("hoge");
	pyramid("abracadabra");
	return 0;
}

(defun pyramid (str)
  (let ((base (coerce (cdr (reduce (lambda (r x) `(,@r #\Space ,x))
				   (coerce str 'list)
				   :initial-value '())) 'string)))
    (do ((idx 2 (+ idx 2))
	 (len (length base))
	 (result base (concatenate 'string spacer (subseq base idx) "~%" result))
	 (spacer " " (concatenate 'string " " spacer)))
	((> idx len) (format t result)))))

<?php

$p_mess="hoge";
echo "<textarea cols=100 rows=20>";
echo pyramid($p_mess);
echo "</textarea>";


$p_mess="abracadabra";
echo "<textarea cols=100 rows=20>";
echo pyramid($p_mess);
echo "</textarea>";

function pyramid($p_mess)
{
	$p_len=strlen($p_mess);
	for($i=1;$i<=$p_len;$i++)	//縦方向ループ
	{
		$w="";
		for($j=$p_len-$i;$j<=$p_len;$j++)	//横方向ループ、x行目=後ろからx文字分をループ
		{
			$w.=substr($p_mess,$j,1)." ";	//切り出し+空白文字をwに入れ込む
		}
		
		$w=str_pad($w,$p_len*2+1," ",STR_PAD_BOTH);	//左右に[ ]を埋める
		$ret.=rtrim($w)."\n";	//右側の空白ははずす
	}
	return $ret;
}

?>

(defun pyramid (string)
  (let ((chars (coerce string 'list)) (floors nil))
	(labels
		((make-floors (list n-space)
		   (unless (null list)
			 (push (format nil "~{~A~}~{~A~^ ~}~%"
						   (make-list n-space :initial-element #\Space) list)
				   floors)
			 (make-floors (cdr list) (1+ n-space)))))
	  (make-floors chars 0))
	(mapcan #'(lambda (string)
				(format t "~A" string))
			floors)))

<?php
function pyramid($str){
	for($i=$j=$n=strlen($str); $i>0; $i--, $n=$j*2-$i)
		printf("% {$n}s\n", trim(join(" ", preg_split("//", substr($str, $i-1, $j)))));
}

pyramid("abracadabra");
?>

import Control.Arrow
import Data.List (tails,intersperse)

pyramid = id &&& length >>> first (tails >>> reverse >>> tail >>> map (id &&& length)) >>> uncurry f
    where f xs len = mapM_ (\(x,y) -> putStrLn $ (++) (replicate (len - y) ' ') $ intersperse ' ' x) xs

(defun pyramid (string)
  (loop for x on (coerce string 'list) for i from 0 with tmp
     collect (format nil "~VT,0~{~A~^ ~}" i x) into tmp
     finally (mapc #'write-line (nreverse tmp))))

(defun pyramid (string)
  (loop for x on (coerce string 'list) for i from 0
    collect (format nil "~V,0T~{~A~^ ~}" i x) into tmp
    finally (mapc #'write-line (nreverse tmp))))

pyramid <- function(s, n=nchar(s), s2=unlist(strsplit(s, ''))){
   for(i in n:1) cat(c(character(i-1), s2[i:n]), fill=TRUE)
}

function pyramid( $str, $_=''){
   echo strlen($str)? pyramid( substr($str,1), "$_ ")."\n$_"
      : null, join( ' ', preg_split('//',$str));
}
pyramid('abracadabra');

import Data.List
import Data.Traversable

pyramid str = do 
    for (reverse $ p str) putStrLn 
    return ()
  where
    p (x:xs) = (intersperse ' ' (x:xs)) : map (' ':) (p xs)
    p [] = []

<?php
function pyramid($str){
	for($i=$n=strlen($str); $i>=0; $i--, $n=strlen($str)*2-$i+1)
		printf("% {$n}s\n", join(" ", preg_split("//", substr($str, $i))));
}

pyramid("abracadabra");
?>

import Data.List

pyramid :: String -> [String]
pyramid xs
 = map bar                     -- 片リストから行リストへ
 $ reverse                     -- リストを反転，上片から下片へ
 $ zipWith (flip const) xs     -- xs の長さ分切り取る
 $ iterate foo ("",xs)         -- 下片から上片へのリスト

foo :: (String, String) -> (String, String)
foo (indent,str) = (' ':indent, tail str)         -- 下片から１つ上片を求める
bar :: (String,String) -> String
bar (indent,str) = indent ++ intersperse ' ' str  -- 片から行へ変換

{-
*Main> putStr $ unlines $ pyramid "hoge"
   e
  g e
 o g e
h o g e
-}

import Data.List

starling f g x = f x (g x)
binapp' o f g x y = f x `o` g y

pyramid' = map (uncurry bar') . reverse . starling (zipWith (flip const)) (iterate (uncurry foo') . ((,) ""))

foo' = binapp' (,) (' ':) tail
bar' = binapp' (++) id (intersperse ' ')

{-
*Main> putStr $ unlines $ pyramid' "hage"
   e
  g e
 a g e
h a g e
-}

import Data.List

pyramid :: String -> [String]
pyramid = reverse . unfoldr phi . (,) ""
  where 
     phi (_ ,"")         = Nothing
     phi (xs,yys@(_:ys)) = Just (xs ++ intersperse ' ' yys,(' ':xs,ys))

{-
*Main> putStr $ unlines $ pyramid "hoge"
   e
  g e
 o g e
h o g e
-}

"""
>>> pyramid("hoge")
   e
  g e
 o g e
h o g e

>>> pyramid("abracadabra")
          a
         r a
        b r a
       a b r a
      d a b r a
     a d a b r a
    c a d a b r a
   a c a d a b r a
  r a c a d a b r a
 b r a c a d a b r a
a b r a c a d a b r a
"""
def pyramid(s, padding=None):
  assert(len(s) > 0)
  if padding is None:
    padding = ' '
  if len(s) == 1:
    return s[0]
  else:
    p = pyramid(s[1:], padding + ' ')
    print padding + p
    if padding == ' ':
      print s[0] + ' ' + p
    else:
      return s[0] + ' ' + p

import doctest
doctest.testmod()

(defun pyramid (s &optional p)
  (unless (string= s "")
    (pyramid (substring s 1) (cons ? p))
    (insert (concat p) (mapconcat #'string s " ") "\n")))

def strPyramid(s="abracadabra"):
    s      = " ".join(s)
    length = len(s)        
    
    for i in range(length)[::-2]:
        print s[i:].center(length,' ')

let pyramid str =
  let rec letters = function
    | "" -> []
    | s  -> (String.sub s 0 1) :: (letters (String.sub s 1 (String.length s - 1)))
  in
  fst (List.fold_right (fun s t -> let x = s ^ snd t in (x :: (fst t), " " ^ x))
                       (letters str) ([], ""))
  |> List.mapi (fun i s -> (String.make i ' ') ^ s) |> List.rev |> String.concat "\n";;

let _ = pyramid "abracadabra" |> printf "%s\n";;

#!/bin/sed -f
s/ //g
s/./ &/g
s/^ /\n/

:loop
s/^\n[^\n]*/&&/
s/^\(\n *\)[^ ] /\1 /
s/\n/ \n/2
/^\n *\n/!b loop

s/^\n *\n//

function pyramid($s = "abracadabra") {
     for ($i = 1; $i -le $s.length; $i++) {
          $p = $s[-$i..-1]
          $len = $s.length - $p.length
          " " * $len + $p
     }
}

 #include <stdio.h>
#include <stdlib.h>

void pyramid(char* p)
{
    int i, j, n = strlen(p);
    char* buff = (char*)_alloca(n * n * 2);
    memset(buff, ' ', n * n * 2);
    for (i = 0; i < n; i++)
    {
        for (j = n * 2 * i + n - i - 1; j < n * n * 2; j += n * 2 + 1)
        {
            *(buff + j) = *(p + n - i - 1);
        }
        printf("%.*s\n", n * 2, buff + i * n * 2);
    }
}

int main(int argc, char* argv[])
{
    pyramid(argv[1]);
}

using System;
using System.Text.RegularExpressions;

class Program {
    static void pyramid(string s) {
        int len = s.Length;
        s = Regex.Replace(s, "(.)(?=.)", @"$1 ");
        for (int n = len - 1; n >= 0; n--)
            Console.WriteLine(s.Substring(n * 2).PadLeft(len * 2 - n).PadRight(len * 2));
    }
    static void Main(string[] args) {
        pyramid("hoge");
        pyramid("abracadabra");
    }
}

#include <iostream>
#include <string>

void pyramid(const std::string& src)
{
    const int   strLength = src.size();
    const int   lineLength = strLength * 2 - 1;
    std::string line(strLength, ' ');
    for(int i = strLength - 1; i >= 0; --i)
    {
        line[i] = src[i];
        std::cout << line.substr(0, lineLength) << std::endl;
        line = ' ' + line;
    }
}

def pyramid str
str.chomp.reverse.gsub(/./){([" "*$'.size]*2)*(($`+$&).reverse.scan(/./)*" ")+$/}
end

def pyramid(str)
  n = str.length
  1.upto(n) do |i|
    result_str = str.split('').last(i).join
    spaces = " " * (n - i)
    puts result_str.split('').join(' ').insert(0, spaces)
  end
end
pyramid("piyohoge")

def pyramid(str)
  n = str.length
  reversed_str_ary = str.reverse.split('')
  n.times do |i|
    result_str = reversed_str_ary[0..i].join
    spaces = " " * (n - i)
    puts result_str.split('').join(' ').insert(0, spaces)
  end
end
pyramid("piyohoge")

def pyramid(str = '')
  n = str.length
  1.upto(n) do |i|
    result_str = str.split('').last(i).join
    spaces = " " * (n - i)
    puts result_str.split('').join(' ').insert(0, spaces)
  end
end

def pyramid(str, space = "")
  if str == ""
    ""
  else
    pyramid(str[1, str.size-1], space+" ") +
      space+str.split(//).join(" ")+"\n"
  end
end

print pyramid("hoge")
print pyramid("abracadabra")

pyramid_sub([], _, []).
pyramid_sub([C|S], W, [32, C|S1]) :- pyramid_sub(S, W, S1),
	format('~t~s~t~*|~n', [[C|S1], W]).

pyramid(S) :- length(S, N), W is (N * 2) - 1, pyramid_sub(S, W, _).

:- pyramid("hoge").
:- pyramid("abracadabra").

def pyramid(s):
    row=s[-1]
    print ' '*(len(s)-1)+row
    for i in range(2,len(s)+1):
        row=s[-i]+' '+row
        print ' '*(len(s)-i)+row

if __name__=='__main__':
    pyramid('abracadabra')

    call pyramid "hoge";
    call pyramid "abracadabra";
    endmacro;

pyramid:
    ##len = strlen( $$1 );
    ##i = ##len - 1;
    while( ##i >= 0 ) {
        ##j = ##i;
        while( ##j > 0 ) {
            insert " ";
            ##j = ##j - 1;
        }
        ##j = ##i;
        while( ##j < ##len ) {
            insert midstr( $$1, ##j, 1 );
            insert " ";
            ##j = ##j + 1;
        }
        insert "\n";
        ##i = ##i - 1;
    }
    return;

「abracadabra」のピラミッドを表示
●ピラミッド(sの)
    tとは配列
    ケタ数=(2*バイト数(s)-1)
    (バイト数(s))回
        tに(文字列センタリング(文字列注入(RIGHT(s,回数)," "),ケタ数))を配列追加
    tで戻る
●文字列注入(sにlを)
    sを文字列分解してlで配列結合で戻る

#include <stdio.h>
#include <string.h>

void print_pyramid(const char* s)
{
  int i, j;
  int n = strlen(s);
  
  for (i=0; i<n; i++) {
    for (j=n-i-2; j>=0; j--) putchar(' ');
    for (j=n-i-1; j<n-1; j++) {
      putchar(s[j]);
      putchar(' ');
    }
    putchar(s[j]);
    puts("");
  }
}

int main(int argc, char** argv)
{
  print_pyramid("hoge");
  print_pyramid("abracadabra");
  return 0;
}

def pyramid(s):
  for i in range(len(s)-1, -1, -1):
    print " "*i + " ".join(s[i:])

pyramid("hoge")
pyramid("abracadabra")

pyramid2=.3 :'(,&a:<\.(<:#y)#'' ''),&;/"0([,'' '',])/&.>|.<\.y'

fun pyramid s =
let
  fun loop s' NONE = []
    | loop s' (SOME c) =
    let
      val ns = subst (str c) "" s'
    in
      loop ns (CharVector.find Char.isGraph ns) @ [s']
    end

  val ss = (String.concatWith " " o global_slice ".") s
in
  (app println o loop ss o SOME o sub) (ss, 0)
end

val _ = pyramid "hoge"
val _ = pyramid "abracadabra"

-module(string_pyramid).
-import(lists, [flatmap/2, foreach/2, nthtail/2, seq/2]).
-import(string, [centre/2, len/1, strip/3]).
-export([string_pyramid/1]).

string_pyramid(Str) ->
    L1 = [nthtail(len(Str) - X, Str) || X <- seq(1, len(Str))],
    L2 = [flatmap(fun(Y) -> [Y, " "] end, X) || X <- L1],
    L3 = [centre(strip(X, both, " "), len(Str) * 2 - 1) || X <- L2],
    foreach(fun(X) -> io:format("~s~n", [X]) end, L3).

def pyramid(str)
  def recurs(str, i, spc = ' ')
    puts "#{spc*i}#{str[i..-1].split('').join(spc)}"
    recurs(str, i-1) if i >= 1
  end
  recurs(str, str.size-1)
end
pyramid("abracadabra")

let pyramid s =
  let len = String.length s in
  for spc = (len-1) downto 0 do
    print_string (String.make spc ' ');
    String.iter (Printf.printf "%c ") (String.sub s (spc) (len-spc));
    print_newline ();
  done;;

#include <stdio.h>
#include <string.h>

void pyramid(char* p) {

    int i, j, len;

    len = strlen(p);

    for(i=0; i<len; i++) {
        printf("%*c ", len-i, p[len-i-1]);
        for(j=len-i; j<=len; j++) printf("%c ",p[j]);
        printf("\r\n");
    }
}

int main(int argc, char **argv) {

    argc > 1 ? pyramid(argv[1]) : 　;
    pyramid("hoge");
    pyramid("abracadabra");
    return 0;
}

:: pyramid.bat
@echo off
  setlocal enabledelayedexpansion
    set l=0
    set n=0
    set s=
    set t=

    if "%1" == "" (echo %~n0 [STRING] & goto :EOF)

    call :length %1 l

    for /l %%i in (1,1,%l%) do (
      set s=
      set /a n=%l%-%%i
      for /l %%j in (!n!,-1,1) do set s=!s! 
      for /l %%j in (%%i,-1,1) do (
        set /a n=%l%-%%j
        call :substr %1 !n! 1 t
        set s=!s!!t!
        if %%j gtr 0 set s=!s! 
      )
      echo !s!
    )
  endlocal
goto :EOF

:length
  setlocal
    set i=0
    set t=%1
    set t=%t:"=%

    :loop
      set t=%t:~1%
      set /a i+=1
    if not "%t%" == "" goto loop
  endlocal & set %2=%i%
goto :EOF

:substr
  setlocal enabledelayedexpansion
    set t=%1
    set t=!t:~%2,%3!
  endlocal & set %4=%t%
goto :EOF

%!PS

/pyramid { % (string) pyramid -
    dup length 1 sub dup -1 0 {
        dup { ( ) print } repeat
        1 2 index {
            2 index exch 1 getinterval print ( ) print
        } for
        ( ) =
    } for
} def

% ------- Test Code -------- 
(hoge) pyramid
(abracadabra) pyramid

#include <stdio.h>
#include <stdlib.h>
#include <string.h>

int main(int argc, char **argv){
    int i, len;
    char *srcstr, *cpstr, *s, *d, format[15];
    
    if(argc < 2) exit(1);
    srcstr = argv[1];
    len = strlen(srcstr);

    cpstr = malloc(len * 2);
    if(!cpstr) exit(1);

    s = srcstr + len - 1;
    d = cpstr + len * 2;
    *d-- = '\0';
    while(s != srcstr){
        *d-- = *s--;
        *d-- = ' ';
    }
    *d = *s;

    d = cpstr + len * 2 - 1;
    for(i = 0; i < len; i++, d -= 2){
        sprintf(format, "%%%ds\n", len + i);
        printf(format, d);
    }

    free(cpstr);
    return 0;
}

<xsl:stylesheet version="2.0"
  xmlns:xsl="http://www.w3.org/1999/XSL/Transform"
  xmlns:xs="http://www.w3.org/2001/XMLSchema"
  xmlns:fn="http://www.w3.org/2005/xpath-functions"
  >

  <xsl:param name="txt" as="xs:string" />

  <xsl:output method="text" />

  <xsl:template match="/" >
    <xsl:variable name="chars" as="xs:string*">
      <xsl:for-each select="fn:string-to-codepoints($txt)">
        <xsl:sequence select="fn:codepoints-to-string((.))" />
      </xsl:for-each>
    </xsl:variable>

    <xsl:for-each select="1 to fn:count($chars)">
      <xsl:variable name="wscount" as="xs:integer"
        select="fn:count($chars)-." />
      <xsl:for-each select="1 to $wscount" >
        <xsl:text> </xsl:text>
      </xsl:for-each>
      <xsl:value-of select="fn:subsequence($chars, $wscount+1)" />
      <xsl:text>&#xA;</xsl:text>
    </xsl:for-each>
  </xsl:template>

</xsl:stylesheet>

pyramid s =
  take ln $ [(replicate (ln - l) ' ') ++ (drop ((ln - l) * 2) ss) | l <- [1..]]
    where
      ln = length s
      ss = concat [[x,' '] | x <- s]

main = do
  mapM_ putStrLn $ pyramid "hoge"
  mapM_ putStrLn $ pyramid "abracadabra"

                   
    
                           
    
                     
    
                           
    
                        
    
              
    
                           
    
                        
    
                        
    
                        
    
                           
    
                           
    
                       
    
              
    
      

   
 
  
     
                              
          
         
       
       
 
 

      
 
     
         
           
       
           
 
                 
 
 
          
 
 
              

 
         

           




       
 
              
 
           
    
  
          
       
        
              
 
           
            
    
      
  
 
        

        
             
    
   

 


    

              
 
 
            
            
    
         
          
 
            

         
 


    
.

WITH
  Input(id, str) AS (
    SELECT 1, 'hoge'
    UNION ALL SELECT 2, 'abracadabra'
  )
, ExpandsSrc(id, str, input_str) AS (
    SELECT
        id
      , CAST(LEFT(str, 1) + ' ' AS varchar(max))
      , SUBSTRING(str, 2, LEN(str))
    FROM
        Input
    UNION ALL
    SELECT
        id
      , str + LEFT(input_str, 1) + ' '
      , SUBSTRING(input_str, 2, LEN(input_str))
    FROM
        ExpandsSrc
    WHERE
        input_str <> ''
  )
, Expands(id, str) AS (
    SELECT id, str FROM ExpandsSrc WHERE input_str = ''
  )
, Pyramid(id, i, str, input_str) AS (
    SELECT
        id
      , 1
      , str
      , SUBSTRING(str, 3, LEN(str))
    FROM
        Expands
    UNION ALL
    SELECT
        id
      , i + 1
      , SPACE(i) + input_str
      , SUBSTRING(input_str, 3, LEN(input_str))
    FROM
        Pyramid
    WHERE
        input_str <> ''
  )
SELECT str FROM Pyramid
ORDER BY id, i DESC

object MojiPira {
  def main(args : Array[String]) : Unit = {
    val moji = args(0)
    val m    = moji.length
    
    val fn = (m:Int,x:String) => println( x+" "*( 2*m - 1 - x.length ) )
    mojiPira(m).foreach(fn(m,_))
    
    def mojiPira(n:Int) :List[String] = {
      if( n==1 ){
        return List(moji(0).toString)
      }else{
        val tail = moji(n-1)
        val prev = mojiPira(n-1)
        var now = List(" "*prev.length + tail)
        for(a<-prev) now = now ::: (a + " " + tail)::Nil
        return now
      }
      Nil
    }
    
    ()
  }
}

object MojiPira {
  def main(args : Array[String]) : Unit = {
    pyramid(args(0))
  }
  def pyramid(moji:String) = {
    val m    = moji.length
    mojiPira(" "*(m-1),"",moji.reverse){print _}
  }
  def mojiPira(mergin:String,prevPrn:String,s:String)(prn:String=>Unit) : Unit = {
      val prnStr = if (prevPrn=="") ""+s(0) else s(0) + " " + prevPrn
      prn(mergin + prnStr + mergin + "\n")
      if( mergin!="" )
        mojiPira(mergin.substring(1),prnStr,s.substring(1))(prn)
  }
}

"abracadabra".inject([]){r,i->[' '*r.size()+i]+r.collect{it+' '+i}}.each{println it}

using System;
using System.Linq;

namespace Sample {
    class Program {
        static void Main(string[] args) {
            Pyramid("hoge");
            Pyramid("abracadabra");
            Console.ReadLine();
        }

        static void Pyramid(string s) {
            int length = s.Length;
            for (int n = 0; n < length; n++) {
                // 左側の空白を表示
                int spCount = length - n - 1;
                Console.Write(new string(' ', spCount));
                // 右側の文字部分を表示
                var ls = s.Skip(spCount);
                foreach (var c in ls)
                    Console.Write(c + " ");
                Console.WriteLine();
            }
        }
    }
}