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

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"

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

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

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

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