DouKaku?

module Main where
import Data.List
import qualified System.IO.UTF8 as U

partitionNum n = sortBy cmp $ pttn n n
  where cmp a b | length a < length b  = LT
                | length a == length b = EQ
                | otherwise            = GT
        pttn 0 _ = [[]]
        pttn n k = [(n-x):xs | x <- [max (n-k) 0..n-1], xs <- pttn x (n-x)]

main = U.putStr $ unlines $ foldr chunk [] $ partitionNum 50
  where chunk ns r = map (\n -> replicate n '□') ns ++ [""] ++ r

using System;
using System.Collections.Generic;
using System.Linq;
using System.Text;

namespace 自然数
{
    class Program
    {
        static void Main(string[] args)
        {
            DateTime prev = DateTime.Now;
            young(50);
            Console.WriteLine((DateTime.Now - prev).TotalSeconds);
        }

        static void young(int n)
        {
            List<int[]> youngList = new List<int[]>();
            Stack<int> stack = new Stack<int>();

            for( int i = n ; i > 0 ; --i )
                subYoung( youngList, stack, i, n-i );

            var x = from y in youngList
                    orderby y.Count() ascending
                    select y;

            foreach (int[] list in x)
            {
                foreach (int i in list)
                    Console.WriteLine( new string( '□', i ) );

                Console.WriteLine();
            }

            Console.WriteLine(youngList.Count());
        }

        static void subYoung( List<int[]> youngList, Stack<int> stack, int num, int zan )
        {
            stack.Push(num);

            if (zan == 0)
            {
                youngList.Add(stack.Reverse().ToArray());
            }
            else
            {
                for (int i = zan >= num ? num : zan; i > 0; --i)
                {
                    subYoung(youngList, stack, i, zan - i);
                }
            }

            stack.Pop();
        }
    }
}

import java.util.*;

public class Yang{

  ArrayList[] table;

  public Yang(int a){
    table = new ArrayList[a+1];
  }

  public ArrayList partitions(int value){
    ArrayList list = new ArrayList();
    ArrayList l0;
    l0 = new ArrayList();
    l0.add(new Integer(value));
    list.add(l0);
    for(int i = 1; i < value; i++){
      int v = value  - i;
      ArrayList l;
      if(table[i] != null){
     l = table[i];
      }else{
     l = partitions(i);
    table[i] = l;
      }
      Iterator it = l.iterator();
      while(it.hasNext()){
    l0 = (ArrayList)(it.next());
    if(((Integer)(l0.get(0))).intValue() <= v){
      ArrayList l1 = new ArrayList();
      l1.addAll(l0);
      l1.add(0, new Integer(v));
      list.add(l1);
    }
      }
    }
    return list;
  }

  public static void output(ArrayList list){
    Iterator it = list.iterator();
    while(it.hasNext()){
      int v = ((Integer)(it.next())).intValue();
      for(int i = 0; i < v; i++){
    System.out.print("□");
      }
      System.out.println();
    }
  }

  public static void main(String[] args){
    int a = Integer.parseInt(args[0]);
    Yang yang = new Yang(a);
    ArrayList l = yang.partitions(a);
    //System.err.println(l.size());
    Iterator it = l.iterator();
    while(it.hasNext()){
      output((ArrayList)(it.next()));
      System.out.println();
    }
  }

}

# -*- coding: utf-8 -*-

import sys

def m_partitions(n, m, l):
    if m == 1:
        if n <= l:
            yield [n]
    else:
        for i in xrange(min(n - m + 1, l), 0, - 1):
            for p in m_partitions(n - i, m - 1, min(i, l)):
                yield [i] + p

def partitions(n):
    for i in xrange(1, 1 + n):
        for p in m_partitions(n, i, n - i + 1):
            yield p

def young(n):
    for pattern in partitions(n):
        for m in pattern:
            print 'â–¡' * m
        print

def main(args):
    if len(args) == 1:
        n = int(args[0])
    else:
        n = 5

    young(n)

if __name__ == '__main__':
    main(sys.argv[1:])

#include <time.h>
#include <iostream>
#include <vector>

int young_sub(int n, int d, std::vector<int>& stack)
{
    if (n <= 0)
    {
        for (std::vector<int>::iterator li = stack.begin(); li != stack.end(); li++)
        {
            int n = *li;
            while (n--) { std::cout << "□"; }
            std::cout << std::endl;
        }
        std::cout << std::endl;
        return 1;
    }

    int count = 0;
    for (int i = ((n < d) ? n: d); i > 0; i--)
    {
        stack.push_back(i);
        count += young_sub(n - i, i, stack);
        stack.pop_back();
    }
    return count;
}

int young(int n)
{
    if (n < 1)
        return 0;
    std::vector<int> stack;
    stack.reserve(n);
    return young_sub(n, n, stack);
}

int main(int argc, char* argv[])
{
    if (argc < 2)
        return -1;
    int v = atoi(argv[1]);

    clock_t s = clock();
    int count = young(v);
    clock_t e = clock();

    std::cout << "count:"   << count << std::endl;
    std::cout << "time[s]:" << ((double)(e-s)/CLOCKS_PER_SEC) << std::endl;
    return count;
}

using System;
using System.Collections.Generic;

class Program {
    static IEnumerable<string> Young2(int n, int m) {
        if (n <= m) yield return new string('□', n) + '\n';

        for (int i = Math.Min(n - 1, m); i > 0; i--)
            foreach (string s in Young2(n - i, i))
                yield return new string('□', i) + '\n' + s;
    }
    static IEnumerable<string> Young(int n) {
        return (n <= 0) ? new string[] {} : Young2(n, n);
    }
    static void Main(string[] args) {
        foreach (string s in Young(50))
            Console.WriteLine(s);
    }   
}

main = putStr $ unlines $ map (unlines . map (bou!!))
  $ partitions 50 where
  bou = iterate ("[]"++) ""

partitions n = f n n where
  f 0 _ = [[]]
  f n m = [m',m'-1..1] >>= (\x -> map (x:) (f (n-x) x)) where m' = min m n

;; -*- coding: utf-8 -*-
(use srfi-43)

(define (partition-num n)
  (define bins (make-vector n '()))
  (define (rec n k r)
    (if (= n 0)
      (let1 k (- (length r) 1)
        (vector-set! bins k (cons (reverse r) (vector-ref bins k))))
      (let loop ((x (clamp (- n k) 0)))
        (unless (= x n)
          (rec x (- n x) (cons (- n x) r))
          (loop (+ x 1))))))
  (rec n n '())
  bins)

(define (show bins)
  (define bars
    (vector-map (lambda (i _) (string-append (make-string (+ i 1) #\□) "\n"))
                bins))
  (vector-for-each (lambda (i bss)
                     (dolist (bs (reverse bss))
                       (dolist (b bs)
                         (display (vector-ref bars (- b 1))))
                       (newline)))
                   bins))
                   
(define (main args)
  (set! (port-buffering (current-output-port)) :full)
  (with-port-locking (current-output-port)
    (cut show (partition-num (x->integer (cadr args)))))
  0)

def part(n, mx, a, i)
  if n == 0
    i.times {|j| puts '□'*a[j] }
    puts
  else
    [n, mx].min.downto(1) do |k|
      a[i] = k
      part(n-k, k, a, i+1)
    end
  end
end

def young(n)
  part(n, n, Array.new(n), 0)
end

let young n =
  let makeO x acc = ((String.make x 'O') ^ "\n") :: acc in
  let rec out = function [] -> print_char '\n' | hd :: tl -> let _ = out tl in print_string hd in
  let rec loop r c acc =
    if c <> 0 then match r - c with
      | 0            -> let _ = out      (makeO c acc) in loop r (c-1) acc
      | x when x > 0 -> let _ = loop x c (makeO c acc) in loop r (c-1) acc
      | _            -> loop r r acc in
    loop n n []

let _ = young (int_of_string Sys.argv.(1))

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

sub young {
    my $n = shift;
    die 'young($n); # where $n is an integer' unless $n;
    return [1] if $n == 1;
    my @result = ( [$n] );
    for my $k ( reverse 1 .. $n - 1 ) {
        push @result,
          map { [ $k, @$_ ] } grep { $k >= $_->[0] } young( $n - $k );
    }
    @result;
}

memoize 'young';

sub print_young{
    my $n = shift;
    local $\ = "\n";
    for my $a (young($n)){
        print '#' x $_ for @$a;
        print "=" x $n;
    }
}

my ($n, $quiet) = @ARGV;
$quiet ? young($n) : print_young($n);
__END__
% perl young.pl 5
#####
=====
####
#
=====
###
##
=====
###
#
#
=====
##
##
#
=====
##
#
#
#
=====
#
#
#
#
#
=====
% time perl young.pl 50 1
9.390u 0.783s 0:10.29 98.8%     0+0k 0+1io 0pf+0w
% time sh -c 'perl young.pl 50 | grep = | wc'
  204226  204226 10415526
10.903u 0.894s 0:11.82 99.7%    0+0k 0+3io 0pf+0w