DouKaku?

#!/usr/local/bin/perl
use strict;
use warnings;

sub center{
    my $str = shift;
    my $width = shift || 80;
    my $margin = int(($width - length($str))/2);
    return $str if $margin == 0;
    return " " x int($margin) . $str if $margin > 0;
    substr($str, 0, -$margin, '');
    return substr($str, 0, $width);
}

chomp and print center($_, 72), "\n" for(<>)
__END__
0         1         2         3         4         5         6         7
012345678901234567890123456789012345678901234567890123456789012345678901
This line is intentionally longer than 72 chars to test center() works fine.

class String
  def centered(width)
    width ||= 80
    margin = (width - self.length)/2;
    return self if margin == 0
    return " " * margin + self if margin > 0
    self[-margin..margin-1]
  end
end

ARGF.readlines.each{|l| puts l.centered(72) }
__END__
0         1         2         3         4         5         6         7
012345678901234567890123456789012345678901234567890123456789012345678901
This line is intentionally longer than 72 chars to test String#centered works fine.

#!/usr/bin/python

def center_and_crop(str, width = 80):
    margin = (width - len(str))/2
    if margin >= 0: return str.center(width)
    else:           return str[-margin:width-margin]

if __name__ == '__main__':
  import sys
  for line in sys.stdin:
    print center_and_crop(line[:-1], 72)

#         1         2         3         4         5         6         7
#12345678901234567890123456789012345678901234567890123456789012345678901
#This line is intentionally longer than 72 chars to test center_and_crop works \
fine.

(use srfi-13)

(define (string-pad-both string width)
  (let* ((slen (string-length string))
         (left (string-take string (quotient slen 2)))
         (right (string-drop string (quotient slen 2)))
         (llen (quotient width 2))
         (rlen (- width llen)))
    (string-append
     (string-pad left llen)
     (string-pad-right right rlen))))

(define (center string . args)
  (string-pad-both string (get-optional args 80)))

import std.stdio;
import std.string;
import std.utf;

string cropCenter(string str, uint width){
    auto wstr = toUTF16(str);
    int leftMargin = cast(int)(width - wstr.length) / 2;
    int rightMargin = cast(int)(width - wstr.length) - leftMargin;
    return (rightMargin < 0) ?
           toUTF8(wstr[-leftMargin..($ + rightMargin)]) :
           (repeat(" ", leftMargin) ~ str ~ repeat(" ", rightMargin));
}

void main(){
    writefln(cropCenter("ほげら", 2));  //=> "ほげ"
    writefln(cropCenter("ほげら", 1));  //=> "げ"
    writefln(cropCenter("ほげ",   2));  //=> "ほげ"
    writefln(cropCenter("ほげ",   1));  //=> "ほ"
    writefln(cropCenter("ほげら", 5));  //=> " ほげら "
    writefln(cropCenter("ほげら", 4));  //=> "ほげら "
    writefln(cropCenter("ほげ",   5));  //=> " ほげ  "
    writefln(cropCenter("ほげ",   4));  //=> " ほげ "
}

using System;
static class Program {
    static void Main() {
        string[] texts = {
            "0123456789",
            "abc",
            "abcdefg",
            "abcdefghijklmn",
        };
        foreach(string text in texts) {
            Console.WriteLine(Centering(text, 10));
        }
    }
    static string Centering(string text, int width) {
        int margin = (int)((width - text.Length) / 2);
        if (margin == 0)
            return text;
        if (0 < margin)
            return text.PadLeft(margin + text.Length);
        return text.Substring(-margin, width);
    }
}

def centering(lst,n)
  return lst if (n <= 0 || lst == "")
  c = (lst = " "*n + lst + " "*n).size/2
  lst[c-n/2..-1][0..n-1]
end

if __FILE__ == $0
  p (s = centering("end",4))  != " end" ? s : :ok
  p (s = centering("end",3))  != "end"  ? s : :ok
  p (s = centering("end",2))  != "en"   ? s : :ok
  p (s = centering("end",1))  != "n"    ? s : :ok
  p (s = centering("end",0))  != "end"  ? s : :ok
  p (s = centering("end",-1)) != "end"  ? s : :ok
  p (s = centering("",0))     != ""     ? s : :ok
  p (s = centering("",1))     != ""     ? s : :ok
end

(defun center (str &optional (width 80))
  (let ((margin (- (length str) width)))
    (if (> margin 0)
        (format t "~a" (subseq str (floor (/ margin 2)) (+ width (floor (/ margin 2)))))
      (format t (format nil "~~~a:@<~~a~~>" width) str))))

| centeredOf |
centeredOf := [:line :width |
    | size offset centered start end delta |
    size := line size.
    delta := (width - size + 1) // 2.
    offset := (delta min: 0) negated + 1.
    start := (delta max: 0) + 1.
    end := delta + size min: width.
    centered := String new: width withAll: Character space.
    centered replaceFrom: start to: end with: line startingAt: offset].

centeredOf value: '123456789' value: 15.  "=> '   123456789   ' "
centeredOf value: '123456789' value: 5.   "=> '34567' "

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

char *center( char *str, int width, char *out ){
   int len,margin,i=0;
   char *p = out;
   if( !out ){
      return NULL;
   }
   len = strlen(str);
   margin = (abs(width-len)+1)/2;
   if( margin == 0 || len > width ){
      strncpy( p, &str[margin], width );
   }
   else{
      while( i++ < margin ) *p++ = ' ';
      strcpy( p, str );
      p += len;
      while( i++ < width - len + 1 ) *p++ = ' ';
   }
   return out;
}

int main ( int argc, char *argv[] ){
   int n;
   char *out;
   if( argc < 3 ){
      fprintf(stderr, "usage: %s str num\n", argv[0]);
      return EXIT_FAILURE;
   }

   n = atoi( argv[2] );
   if( n <= 0 || (out = malloc( sizeof(char)*n )) == NULL ){
      return EXIT_FAILURE;
   }
   printf("%s#\n", center( argv[1], n, out ) );
   free(out);
   return EXIT_SUCCESS;
}

(define (centering s w)
  (let* ((p (make-string (quotient w 2) #\ ))
         (ss (string-append p s p))
         (sw (string-length ss))
         (mg (quotient (- sw w) 2)))
    (substring ss mg (- sw mg))))

(print "1234567890")
(print (centering "abc" 10))
(print (centering "abcdef" 10))
(print (centering "abcdefg" 10))
(print (centering "abcdefghijkl" 10))

def center(s, n):
  return (' ' * n + a + ' ' * n)[(len(a)+n)/2:][:n]

print center('abc', 9)
print center('abc', 1)

function center(s, w) {
    var r=[], d=w-s.length;
    if (d < 0) { s=s.substring(d/2*-1, s.length+d/2); }
    for (var i=0; i<=d/2-1; i++) { r.push(" "); }
    r.push(s);
    for (var i=0; i<=d/2-1+d%2; i++) { r.push(" "); }
    return r.join("");
}
console.log("[" + center("test", 0) + "]");    // => []
console.log("[" + center("test", 5) + "]");    // => [test ]
console.log("[" + center("test", 6) + "]");    // => [ test ]
console.log("[" + center("test", 10) + "]");    // => [   test   ]
console.log("[" + center("testtest", 10) + "]");    // => [ testtest ]

center <- function(s, n){
    format(substring(s, (i<-(nchar(s)-n)/2+1), i+n-1), width=n, justify="centre")
}

public class Answer87 {
    public static String formatCenter(String str, int length) {
        if (length <= 0) return str;
        StringBuilder builder = new StringBuilder(str);
        for (int index = 0; index < length; index++) {
            builder.insert(0, ' ');
            builder.append(' ');
        }
        int start = (builder.length() - length) / 2;
        return builder.substring(start, start + length);
    }

    public static void main(String[] args) {
        System.out.println(formatCenter("abcde", 5));    // "abcde"
        System.out.println(formatCenter("abcde", 7));    // " abcde "
        System.out.println(formatCenter("abcde", 8));    // "  abcde "
        System.out.println(formatCenter("abcde", 1));    // "c"
        System.out.println(formatCenter("abcde", 2));    // "bc"
        System.out.println(formatCenter("abcde", 0));    // "abcde"
    }
}

var src = '123456789'
say( '[' + centering(src,100)  + ']' );
say( '[' + centering(src,5)    + ']' );
function centering( s , w ){
  if( s.length < w ) return space( ( w / 2 - s.length / 2 ) ) + s + space( ( w / 2 - s.length / 2 ) );
  else               return s.substring( ( s.length - w ) / 2, s.length - ( ( s.length - w ) / 2 ) );
  function space (l){ var r = ''; while( r.length < l ) r += ' '; return r; }
}

#include <cstdlib>
#include <iostream>
#include <sstream>
#include "boost/format.hpp"

using namespace std;
using namespace boost;

string &center( string &str, int width ){
   int len = str.length();
   if( len > width ){
      str = str.substr( (len-width+1)/2, width );
   }
   ostringstream oss;
   oss << "%1$=" << width << "s";
   str = ( format(oss.str()) % str ).str();
   return str;
}

int main ( int argc, char *argv[] ){
   int width( atoi(argv[2]) );
   string str( argv[1] );
   cout << center( str, width ) << endl;
   return EXIT_SUCCESS;
}

center :: Int -> [Char] -> [Char]
center n str | slen < n  = center'
             | slen > n  = clop
             | otherwise = str
  where
    slen = length str
    center' = lmargin ++ str ++ rmargin
    (lmargin, rmargin) = splitAt ((n-slen) `div` 2) $ replicate (n-slen) ' '
    clop = take n $ drop ((slen-n) `div` 2) str

String.prototype.center = function(width){ var d, s;
  return (d = (width |= 0) - this.length) > 0
    ? (s = Array((d >> 1) + 1).join(' ')) + this + (d & 1 ? s + ' ' : s)
    : this.substr(-d >> 1, width);
};

(typeof alert != 'undefined' ? alert :
 typeof print != 'undefined' ? print :
 function($){ typeof WSH == 'object' && WSH.echo($) })((function(s, f, t){
   for(var r = []; f <= t;) r.push(s.center(f++));
   return '['+ r.join(']\n[') +']' })('hoge', -1, 8));

    begingroupundo;
    if ( getconfig( "AutoAdjustOrikaeshi" ) == 2 ) {
        #width = windowwidth;
    } else {
        #width = getconfig( "Orikaeshi" );
    }
    if ( !selecting ) {
        selectall;
    } else {
        #l1 = seltoplineno;
        #l2 = selendlineno;
        movetolineno 1, #l1;
        beginsel;
        movetolineno 1, #l2;
        movetolineno linelen2 + 1, #l2;
        endsel;
    }
    $text = gettext( seltopx, seltopy, selendx, selendy, 1 );
    delete;
    call center $text, #width;
    insert $$return;
    endgroupundo;
    endmacro;

center:
    $$result = "";
    while( $$1 != "" ) {
        ##lineLen = strstr( $$1, "\x0d\x0a" );
        ##isLastLine = ##lineLen == -1;
        if ( ##isLastLine ) {
            ##lineLen = strlen( $$1 );
        }
        $$line = leftstr( $$1, ##lineLen );
        call center_line $$line, ##2;
        $$result = $$result + $$return;
        $$1 = rightstr( $$1, strlen( $$1 ) - ##lineLen );
        if ( !##isLastLine ) {
            $$1 = rightstr( $$1, strlen( $$1 ) - strlen( "\x0d\x0a" ) );
            $$result = $$result + "\n";
        }
    }
    return $$result;

center_line:
    ##margin = ##2 - strlen( $$1 );
    if ( ##margin >= 0 ) {
        $$result = "";
        ##i = ##margin / 2;
        while( ##i > 0 ) {
            $$result = $$result + " ";
            ##i = ##i - 1;
        }
        $$result = $$result + $$1;
    } else {
        ##idx = -##margin / 2;
        call midstr2, $$1, ##idx, ##2;
        $$result = $$return;
        // ±1バイトとる範囲をずらして、その中から一番長いテキストをとる
        if ( strlen( $$result ) < ##2 ) {
            call midstr2, $$1, ##idx + 1, ##2;
            if ( strlen( $$return ) > strlen( $$result ) ) {
                $$result = $$return;
            }
            if ( strlen( $$result ) < ##2 ) {
                call midstr2, $$1, ##idx - 1, ##2;
                if ( strlen( $$return ) > strlen( $$result ) ) {
                    $$result = $$return;
                }
            }
        }
    }
    return $$result;

midstr2: // マルチバイトを考慮した midstr
    $$src = $$1;
    ##idx = ##2;
    ##len = ##3;
    if ( ##idx < 0 ) {
        ##idx = 0;
    }
    if ( ##idx > strlen( $$src ) ) {
        ##idx = strlen( $$src );
    }
    if ( ##len < 0 ) {
        ##len = 0;
    }
    if ( ##len > strlen( $$src ) - ##idx ) {
        ##len = strlen( $$src ) - ##idx ;
    }
    
    ##end = ##idx + ##len;
    ##i = 0;
    $$dest = "";
    while( ##i < ##end ) {
        ##char = ascii( rightstr( $$src, strlen( $$src ) - ##i ) );
        ##byte = strlen( char( ##char ) );
        if ( ( ##i >= ##idx ) && ( ##i + ##byte <= ##end ) ) {
            $$dest = $$dest + char( ##char );
        }
        ##i = ##i + ##byte;
    }
    return $$dest;

(defun string-centering (s c)
  (let ((p (lambda (k) (make-string k ? )))
        (d (- c (length s))))
    (let ((n (/ d 2))
          (m (% d 2)))
      (if (>= d 0)
          (concat (funcall p n) s (funcall p (+ n m)))
        (substring s (abs n) (- (length s) (abs (+ n m))))))))

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

#define SPACE ' '
//#define SPACE '*'

char *centering(char *out, const char *str, int width){
    int i, len, offset;
    len = strlen(str);
    memset(out, SPACE, width);
    out[width] = '\0';
    offset = (width - len) / 2;
    for(i=0; i<len; i++){
        int ind = offset + i;
        if(ind >= 0 && ind <width)
            out[ind] = str[i];
    }
    return out;
}

int main(){
    char buf[256];
    int i;
    for(i=1; i<20; i++)
        puts(centering(buf, "abcde", i));
    return 0;
}

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

// dest のサイズは w + 1 以上とする事
char *centering(char *dest, const char *s, size_t w) {
    size_t len;

    len = strlen(s);
    sprintf(dest, "%*s", w, "");
    
    if (len >= w) strncpy(dest, s + (len - w) / 2, w);
    else          strncpy(dest + (w - len) / 2, s, len);

    return dest;
}

int main(void) {
    char buff[256];
    printf("|%s|\n", centering(buff, "123456789", 15));
    printf("|%s|\n", centering(buff, "123456789",  5));
}

class String
    def neko_center (w)
        if (d = self.size - w) > 0
            #self.gsub(/\A.{#{d/2}}|.{#{(d+1)/2}}\Z/, '')
            self[d/2..-d/2-1]
        else
            self.center(w)
        end
    end
end

let center str width =
  let len = String.length str in
  if width>len then
    let res = String.make width ' ' in
    (String.blit str 0 res ((width-len)/2) len; res)
  else
    String.sub str ((len-width)/2) width ;;

center width str = take width . adjust lmargin $ str ++ repeat ' '
    where 
    lmargin = (width - length str) `div` 2
    adjust n | n > 0      = (replicate n ' ' ++)
             | otherwise  = drop (-n)

    begingroupundo;
    if ( getconfig( "AutoAdjustOrikaeshi" ) == 2 ) {
        #width = windowwidth;
    } else {
        #width = getconfig( "Orikaeshi" );
    }
    if ( !selecting ) {
        #top = 1;
        #end = linecount2;
    } else {
        #top = seltoplineno;
        #end = selendlineno;
        escape;
    }
    #i = #top;
    while( #i <= #end ) {
        movetolineno 1, #i;
        #margin = #width - linelen2;
        if ( #margin >= 0 ) {
            #j = #margin / 2;
            $margin = "";
            while( #j > 0 ) {
                $margin = $margin + " ";
                #j = #j - 1;
            }
            insert $margin;
        } else {
            beginsel;
            movetolineno linelen2 + 1, #i;
            $text = gettext( seltopx, seltopy, selendx, selendy, 1 );
            delete;
            call cutstr, $text, #width;
            insert $$return;
        }
        #i = #i + 1;
    }
    endgroupundo;
    endmacro;

cutstr:
    $$src = $$1;
    ##width = ##2;
    if ( ##width < 0 ) {
        ##width = 0;
    }
    if ( ##width > strlen( $$src ) ) {
        ##width = strlen( $$src );
    }
    ##start = strlen( $$src ) - ##width;
    ##end = strlen( $$src ) + ##width;
    ##i = 0;
    $$dest = "";
    $$left = "";
    $$right = "";
    while( ##i * 2 < ##end ) {
        ##char = ascii( $$src );
        ##bytes = strlen( char( ##char ) );
        if ( ##i * 2 < ##start ) {
            $$left = char( ##char );
        }
        if ( ( ( ##i + ##bytes ) * 2 > ##end ) && ( $$right == "" ) ) {
            $$right = char( ##char );
        }
        if ( ( ##i * 2 >= ##start ) && ( ( ##i + ##bytes ) * 2 <= ##end ) ) {
            $$dest = $$dest + char( ##char );
        }
        $$src = rightstr( $$src, strlen( $$src ) - ##bytes );
        ##i = ##i + ##bytes;
    }
    if ( $$right == "" ) {
        $$right = char( ascii( $$src ) );
    }
    if ( strlen( $$dest ) >= ##width ) {
        return $$dest;
    }
    if ( ( strlen( $$left + $$dest ) <= ##width ) && ( $$left != "" ) ) {
        return $$left + $$dest;
    }
    if ( ( strlen( $$dest + $$right ) <= ##width ) && ( $$right != "" ) ) {
        return $$dest + $$right;
    }
    return $$dest;

import Control.Monad.Fix

center :: Int -> String -> String
center n = fix (\f x -> g f x)
  where g f x | length x1 == n = x1
              | length x2 == n = x2
              | length x2 > n = f x2
              | otherwise = f $ head $ zipWith3 (\x y z -> x ++ y ++ z) [" "] [x] [" "]
          where x1 = tail x
                x2 = init x1

    if ( getconfig( "AutoAdjustOrikaeshi" ) == 2 ) {
        #width = windowwidth;
    } else {
        #width = getconfig( "Orikaeshi" );
    }
    disabledraw;
    begingroupundo;
    if ( !selecting ) {
        selectall;
    }
    #i = seltoplineno;
    #end = selendlineno;
    escape;
    while( #i <= #end ) {
        movetolineno 1, #i;
        #margin = #width - linelen2;
        if ( #margin >= 0 ) {
            #j = #margin / 2;
            while( #j > 0 ) {
                insert " ";
                #j = #j - 1;
            }
        } else {
            while( linelen2 > #width ) {
                golineend2;
                backspace;
                if ( !linelen2 > #width ) {
                    break;
                }
                golinetop2
                delete;
            }
        }
        #i = #i + 1;
    }
    endgroupundo;
    enabledraw;

center n s = uncurry (c n []) $ halve s
  where c 0 a p q = take n (a ++ q)
        c i a p q = d (pred i) (head p:a) (tail p) q
        d 0 a p q = take n (a ++ q)
        d i a p q = c (pred i) a p q

halve s = e (repeat ' ') (s++repeat ' ') s
  where e a b [] = (a,b)
        e a b c  = o (head b:a) (tail b) (tail c)
        o a b [] = (a,b)
        o a b c  = e a b (tail c)

def center(s:String, n:int) = {
  val pad = List.make(n," ").mkString("")
  (pad + s + pad).toList.drop((s.size+n)/2).take(n).mkString("")
}

Sequence centered := method(width,
    margin := (width - self size) / 2
    if (margin < 0,
        self slice(-margin, self size + margin)
    ,
        self alignCenter(width)
    )
)


# なんか手元のだと定義されていないので
Number to := method(i,
    Range clone setRange(self, i)
)

0 to(7) foreach(i,
    "proto" asMutable centered(i) justSerialized
    "" println
)

/* output

""
"o"
"ro"
"rot"
"prot"
"proto"
"proto "
" proto "

*/

"abcdefg"を3でセンタリングして表示
●センタリング(SをNで)
    もし(文字数(S)<=N)ならば
        文字列センタリング(S,N)で戻る
    1の間
        Sから1文字右端削除
        もし(文字数(S)<=N)ならば,Sで戻る
        Sの1から1文字削除
        もし(文字数(S)<=N)ならば,Sで戻る

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

void centering( char *buffer, int col_num, char* string );

int main( int argc, char *argv[] )
{
    char buf[256];
    
    memset( buf, 0, sizeof(buf) );
    
    centering( buf, 10, "abcdefg" );
    printf( "%s\n", buf );
    
    centering( buf, 8, "0123456789" );
    printf( "%s\n", buf );
    
    centering( buf, 7, "0123456789" );
    printf( "%s\n", buf );
    return 0;
}

void centering( char *buffer, int col_num, char* string )
{
    int copy_len = 0;
    int source_index = 0;
    int target_index = 0;
    
    /* output initialize (using '@' instead of SPACE for check) */
    memset( buffer, '@', col_num );
    buffer[col_num] = '\0';
    
    /* length of string for output */
    copy_len = strlen( string );
    
    /* check which is longer */
    if( copy_len < col_num )
    {
        int diff = col_num - copy_len;
        target_index = diff / 2;
    }
    else
    {
        int diff = copy_len - col_num;
        source_index = diff / 2;
        copy_len = col_num;
    }
    
    memcpy( &buffer[target_index], &string[source_index], copy_len );
    return;
}

-module(center).
-export([center/2]).

center(Str, Len) -> string:centre(Str, Len).

center=.4 :'x{.((<.@-:@#)|.])(x#'' ''),y'

;; ------------------------------------------------
;; strcenter.s for Mac OS X (PowerPC 32bit)
;; % as -o strcenter.o strcenter.s
;; ------------------------------------------------

        .machine ppc
        .globl  _strcenter

;; char *strcenter(char *dest, const char *s, size_t width)
;;
;; r3: char *dest
;; r4: const char *s
;; r5: size_t width
;;
;; r7:  文字列 s のサイズ
;; r8:  文字列の前のスペースのサイズ
;; r9:  文字列の後のスペースのサイズ
;; r10: スペースのASCIIコード
;; r11: r3 のコピー
;; r12: r4 のコピー
;; 
_strcenter:
        ;; 初期化
        li      r7, 0
        li      r10, 32         ; ' '
        mr      r11, r3
        mr      r12, r4
        b       _strlen

_init_sizes:
        ;; 基準となるスペースのサイズ
        sub     r2, r5, r7      ; r2 = width - strlen(s)
        li      r0, 2
        divw    r2, r2, r0      ; r2 = r2 / 2

        ;; 余り
        sub     r0, r5, r7      ; r0 = width - strlen(s)
        andi.   r0, r0, 1

        ;; 前後のスペースのサイズを決定、コピー
        add     r8, r2, r0      ; 余りがあれば前のスペースに追加
        addi    r9, r2, 0

        ;; 基準のスペースのサイズが負の場合
        cmpi    cr7, r2, 0
        blt     cr7, _shorten_strcenter

;; 前のスペースをコピー
_copy_former_spaces:
        stb     r10, 0(r11)
        addi    r11, r11, 1
        subi    r8, r8, 1
        cmpli   cr7, r8, 0
        bgt     cr7, _copy_former_spaces

;; 文字列をコピー
_copy_str:
        lbz     r0, 0(r12)
        stb     r0, 0(r11)
        addi    r11, r11, 1
        addi    r12, r12, 1
        subi    r7, r7, 1
        cmpli   cr7, r7, 0
        bgt     cr7, _copy_str

;; 後のスペースをコピー
_copy_latter_spaces:
        stb     r10, 0(r11)
        addi    r11, r11, 1
        subi    r9, r9, 1
        cmpli   cr7, r9, 0
        bgt     cr7, _copy_latter_spaces

;; 終端をコピーして終了
_end_strcenter:
        li      r0, 0
        stb     r0, 0(r11)
        blr                     ; 関数を終了

;; 文字列の前後をカットしてコピー
_shorten_strcenter:
        sub     r12, r12, r8    ; 文字列の前半をカット
        add     r7, r7, r8
        add     r7, r7, r9      ; 文字列の後半をカット

_copy_shorten_str:
        lbz     r0, 0(r12)
        stb     r0, 0(r11)
        addi    r11, r11, 1
        addi    r12, r12, 1
        subi    r7, r7, 1
        cmpli   cr7, r7, 0
        bgt     cr7, _copy_shorten_str
        b       _end_strcenter

_strlen:
        mr      r2, r4
        li      r7, 0
        
__strlen:
        lbz     r0, 0(r2)       ; 1文字レジスタに移す
        cmpli   cr7, r0, 0
        beq     cr7, _init_sizes
        addi    r2, r2, 1
        addi    r7, r7, 1
        b       __strlen

fun center s width =
  let
    open StringCvt

    val len = size s
    val m = abs (width - len)
    val (left, right) = (m div 2, m div 2 + m mod 2)
  in
    if width < len then substring (s, left, len - left - right)
    else (padLeft #" " (left + right + len) o padRight #" " (right + len)) s
  end

<?php
function Centering($str, $width)
{
    $slen = strlen($str);
    if ($slen < $width) {
        $str = str_pad($str, $width, ' ', STR_PAD_BOTH);
    } else {
        $str = substr($str, (int)(($slen - $width)/2), $width);
    }
    return $str;
}
?>

:: center.bat

@echo off
  setlocal enabledelayedexpansion
    set l=0
    set m=0
    set n=0
    set t=%1
    set t=%t:"=%

    call :length "%t%" l

    if %2 gtr %l% (
      set /a m=%2-%l%
      set /a n=!m!/2
      :: パディング
      for /l %%i in (1,1,!n!) do set t= !t!
      for /l %%i in (1,1,!n!) do set t=!t! 
      set /a n=!m!%%2
      if !n! equ 1 set t=!t! 
    )

    if %l% gtr %2 (
      set /a m=%l%-%2
      set /a n=!m!/2
      :: トリミング
      for /l %%i in (1,1,!n!) do set t=!t:~1!
      for /l %%i in (1,1,!n!) do set t=!t:~0,-1!
      set /a n=!m!%%2
      if !n! equ 1 set t=!t:~0,-1!
    )

  endlocal & echo [%t%]
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

#runtime "hsp3cl"
#module
#defcfunc spaces int len
    if len <= 0 : return ""

    sdim s, len + 1
    repeat len
        poke s, cnt, ' '
    loop
    return s

#defcfunc centered_text str target, int len
    if len <= 0 : return ""

    target_length = strlen(target)
    result = target
    if target_length < len {
        result = spaces((len - target_length)/2) + target + spaces((len - target_length + 1)/2)
    } else : if target_length > len {
        result = strmid(result, (target_length - len)/2, len)
    }
    return result
#global

    s = "*"
    repeat 10
        mes centered_text(s, 15)
        s += " *"
    loop
    stop

(def mklist (n (o fill nil)) (map (fn (x) fill) (range 1 n)))

(def centering (str length)
  (withs (plen (- length (len str)) tlen (abs plen) l (trunc (/ tlen 2)) r (- tlen l))
    (if (positive plen)
        (string (mklist l #\space) str (mklist r #\space))
        (cut str l (- (len str) r)))))

%!PS

/FillSpace { % (String) FillSpace (String')
    dup length 1 sub 0 1 3 -1 roll {
        1 index exch 32 put
    } for
} bind def

/Centering { % (String) length Centering (NewString)
    dup string FillSpace dup
    3 index length 4 -1 roll
    2 copy le {
        sub neg 2 idiv 4 -1 roll putinterval
    } {
        2 copy sub 2 idiv 
        exch 6 -1 roll 3 1 roll getinterval
        exch pop 0 exch putinterval
    } ifelse
} bind def

% -------------------- Test Code ------------------
(ABC) 10 Centering ==
(ABCDEF) 10 Centering ==
(ABCDEF) 3 Centering ==
(ABCDEF) 6 Centering ==

// 例（Stringクラスのメソッド）
"Japanese".center(20)

center n str = let s = (n - length str)
                   s1 = div s 2
                   s2 = s - s1
               in reverse.format s2.reverse.format s1 $ str
  where format n 
          | n >= 0   =(replicate n ' '++)
          |otherwise = drop (-n)