DouKaku?

require "mathn"
(5**8).times do |i|
  s=("2".."9").inject("1") do |r,e|
    r+=["","+","-","*","/"][i%5]+e;i/=5;r
  end
  puts s if eval(s)==100
end

(use srfi-1)

(define (atom? x)
  (not (or (null? x) (pair? x))))
(define (atom-list? ls)
  (and (pair? ls) (atom? (car ls))))

(define (my-flatten ls)
  (cond ((null? ls) '())
        ((pair? ls)
         (cond ((atom? (car ls)) (list ls))
               ((atom-list? (car ls))
                (append (list (car ls)) (my-flatten (cdr ls))))
               (else
                (append (my-flatten (car ls)) (my-flatten (cdr ls))))))
        (else (list ls))))

(define (_ a b)
  (cond ((< b 10) (+ (* a 10) b))
        ((< b 100) (+ (* a 100) b))
        ((< b 1000) (+ (* a 1000) b))
        ((< b 10000) (+ (* a 10000) b))
        ((< b 100000) (+ (* a 100000) b))
        ((< b 1000000) (+ (* a 1000000) b))
        ((< b 10000000) (+ (* a 10000000) b))
        ((< b 100000000) (+ (* a 100000000) b))
        ((< b 1000000000) (+ (* a 1000000000) b))
;        (else #f)
        ))

(define ops '(_ + - * /))

(define (apply-op op x y)
  (case op
    ((_) (_ x y))
    ((+) (+ x y))
    ((-) (- x y))
    ((*) (* x y))
    ((/) (/ x y))
    ))

(define (apply-rev-op op x y)
  (case op
;    ((_) (_ x y))
    ((+) (- x y))
    ((-) (+ x y))
    ((*) (/ x y))
    ((/) (* x y))))

(define (komachi n sum)
  (define (append-op-n ls op n) (append ls (list op n)))

  (define (1..k= k p)
; [1..k] = p となる組み合わせ
    (if (= 1 k) ;
      ; 1 = 1   ; p!=1ならアウト
        (if (= p 1) '((1)) '())
    ; [1..k-1] ?? k = p
        (my-flatten (map (lambda (op) (1..k (- k 1) op k p)) ops))
        ))

  (define (eval-exp exp)
    (define (iter rest product)
      (cond ((null? rest) product)
            ((eq? '* (car rest))
             (iter (cddr rest) (* product (cadr rest))))
            ((eq? '/ (car rest))
             (iter (cddr rest) (/ product (cadr rest))))
            ))
    (iter (cdr exp) (car exp)))

  (define (1..k?<..>= k op exp p)
; [1..k] op (exp) = p
    (if (= 1 k)
        (case op
          ((_)
           (let1 exp* (cons (_ 1 (car exp)) (cdr exp))
                 (if (= (eval-exp exp*) p)
                     exp*
                     '())))
          ((+ -) ; 1 +- exp = p
           (if (= (apply-op op 1 (eval-exp exp)) p)
               (append (list 1 op) exp)
               '()))
          ((* /)
           (let1 exp* (append (list 1 op) exp)
                 (if (= (eval-exp exp*) p)
                     exp*
                     '())))
          )
        (case op
          ((_)
           (my-flatten
            (map (lambda (op2) (1..k?<..>= (- k 1) op2 (cons (_ k (car exp)) (cdr exp)) p)) ops)))
          ((+ -)
           (map (lambda (x) (append x (list op) exp))
                (my-flatten (1..k= k (apply-rev-op op p (eval-exp exp))))
                ))
          ((* /)
           (my-flatten
            (map (lambda (op2) (1..k?<..>= (- k 1) op2 (append (list k op) exp) p)) ops)))
          )
        ))

  (define (1..k k op n p)
; [1..k] op n = p となる組み合わせが全部ほしい
    (if (= 1 k)
      ;k=1 : [1] op n = p
        (case op
          ((_)
           (if (= (_ 1 n) p) (list (_ 1 n)) '()))
          ((+ -)
           (if (= (apply-op op 1 n) p) (list 1 op n) '()))
          ((*)
           (if (= n p) (list 1 '* n) '()))
          ((/) '()) ; 1/n (n>1) cannot be p
          )
      ;k>1
        (case op
          ((_); [1..k-1] ?? k_n = p
           (my-flatten (map (lambda (op2) (1..k (- k 1) op2 (_ k n) p)) ops)))
          ((+ -) ; [1..k] ± n = p ;
           (map (lambda (x) (append-op-n x op n))
                (my-flatten (1..k= k (apply-rev-op op p n)))))
          ((* /) ; [1..k] */ n = p :: [1..c] ? ([c+1..k] */ n) = p
           (my-flatten (map (lambda (op2) (1..k?<..>= (- k 1) op2 (list k op n) p)) ops)))
           ; 結合則が加減算とは違う
          )
        ))

  (remove null? (1..k= n sum)))

(map print (komachi 9 100))

def komachi():
    num = range(1,10)
    ope = ["",".0+",".0-",".0*",".0/"]
    c = 1
    for x in xrange(5**8):
        formula = str(num[0])
        for n in range(1,9):
            formula += ope[x%5] + str(num[n])
            x /= 5
        if eval(formula) == 100:
           print formula,c
           c += 1
           

komachi()

using System;
using System.Collections.Generic;
using IronPython;
using IronPython.Hosting;
using IronPython.Runtime;
using IronPython.Runtime.Calls;
class Program {
    static void Main() {
        PythonEngine python = new PythonEngine();
        EngineModule module = python.CreateModule();
        Dictionary<string, object> locals = new Dictionary<string, object>();
        int count = 0;
        locals["komachi"] = new CallTarget2(delegate(object obj, object obj2) {
            if (obj2.Equals(100.0)) {
                count++;
                Console.WriteLine(obj + " = " + obj2);
            }
            return null;
        });
        DateTime before = DateTime.Now;
        foreach (string code in GenPythonCode()) {
            python.Execute(code, module, locals);
        }
        Console.WriteLine("time: {0}", DateTime.Now - before);
        Console.WriteLine("total: {0}", count);
    }
    static IEnumerable<string> GenPythonCode()
    {
        string[] ops = { "", ".0+", ".0-", ".0*", ".0/" };
        for (int i = 0; i < Math.Pow(ops.Length, 8); i++) {
            string code = "1";
            int j = i;
            foreach (char num in "23456789") {
                code += ops[j % ops.Length] + num;
                j /= ops.Length;
            }
            yield return string.Format("komachi(\"{0}\", {0})", code + ".0");
        }
    }
}

import scala.util.parsing.combinator.{Parsers, ImplicitConversions, ~, mkTilde}
import scala.util.parsing.combinator.syntactical.StdTokenParsers
import scala.util.parsing.combinator.lexical.StdLexical

object Komachi extends StdTokenParsers with Application{
  type Tokens = StdLexical ; val lexical = new StdLexical
  lexical.delimiters ++= List("+","-", "*", "/")
  def expr = term*("+" ^^ {(x: double, y: double) => x + y}
                 | "-" ^^ {(x: double, y: double) => x - y})
  def term = factor*("*" ^^ {(x: double, y: double) => x * y}
                   | "/" ^^ {(x: double, y: double) => x / y})
  def factor: Parser[double] = numericLit ^^ (_.toDouble)

  ((List(List[String]())) /: List.make(8, List("+", "-", "*", "/", ""))){
    for(i <-_; j <-_) yield j::i
  }.foreach{fs =>
    val s = (new StringBuilder("1") /: (2 to 9)){(s,i) =>
      s.append(fs(i-2)).append(i)
    }.toString
    if(expr(new lexical.Scanner(s)).get == 100.0) println(s)
  }
}

function komachi() {
  var list = Array.prototype.slice.apply(arguments, [0]);
  var right = list.pop();
  var operator = ["", "+", "-", "*", "/"];
  var n = Math.pow(operator.length,list.length-1);

  for(var i=0; i<n; i++) {
    var exp = [list[0]];
    var o = (n+i).toString(5);
    for(var j=1, ii=i; j<list.length; j++) {
      exp.push(operator[o.slice(j,j+1)]);
      exp.push(list[j]);
      ii = Math.floor(i/5);
    }
    if(eval(exp.join("")) == right) print(exp.join("") + '=' + right);
  }
}
print("begin");
komachi(1,2,3,4,5,6,7,8,9,100);
print("end");

import Numeric

data Item a b = Value a | Op (a->a->a) b [Char]

cat a b = a*10+b

ops :: [Item Double Integer]
ops = [Op cat 2 "", Op (+) 0 "+", Op (-) 0 "-", Op (*) 1 "*", Op (/) 1 "/"]
 
opparse [] _ vs = reverse vs
opparse (op:ops) (i:is) vs = opparse ops is $ push op (Value i) vs

push op@(Op o p _) v (op'@(Op o' p' _):vs)
  | (p <= p') = (op:v:op':vs)
  | otherwise = (op':push op v vs)
push op v vs = op:v:vs

calc [a] [] = a
calc ns ((Value a):vs) = calc (a:ns) vs
calc (a:b:ns) ((Op op _ _):vs) = calc ((op b a):ns) vs
calc _ _ = error "invalid stack state"

showFormula ops = "1" ++ rec [2..] ops where
   rec _ [] = ""
   rec (i:is) ((Op _ _ n):ops) = n ++ (showInt . round) i (rec is ops)

genops 0 = [[]]
genops n = [o:os | o <- map (ops!!) [0..4], os <- genops (n-1)]

komachi n = [ops | ops <- genops n, test 100 ops] where
   test sum ops = abs (sum - (calc [] $ opparse ops [2..] [Value 1])) <= 1.0e-10

main = putStr $ unlines $ map showFormula $ komachi 8

(defun apply-op (op x y)
  (case op
    (#\+ (+ x y))
    (#\- (- x y))
    (#\* (* x y))
    (#\/ (/ x y))
    (#\SPACE (+ (* 10 x) y))
    (t 't)))

(defun precedence (op) (case op ((#\+ #\-) 1) ((#\* #\/) 2) (t 3)))
(defun precedence< (op1 op2) (< (precedence op1) (precedence op2)))

(defun eval-string (s)
  (loop with vstack and opstack
    for c across s
    if (digit-char-p c) do
    (push (parse-integer (string c)) vstack)
    else if #1=(or (null opstack) (precedence< (car opstack) c)) do
    (push c opstack)
    else do
    (loop until #1# do
      #2=(setf vstack
               (cons (apply-op (pop opstack) (cadr vstack) (car vstack))
                     (cddr vstack))))
    (push c opstack)
    finally
    (loop for op in opstack do  #2#)
    (return (car vstack))))

(defun komachi ()
  (let ((s (copy-seq "1 2 3 4 5 6 7 8 9")))
    (dotimes (x (expt 5 8))
      (dotimes (i 8)
        (setf (elt s (+ i i 1)) (elt " +-*/" (rem (floor x (expt 5 i)) 5))))
      (if (= (eval-string s) 100) (write-line s)))))

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

from __future__ import division
import re

E = '1%s2%s3%s4%s5%s6%s7%s8%s9==100'
A = ['', '+', '-', '*', '/']
F = lambda n: [[i] + l for i in A for l in F(n-1)] if n > 1 else [[i] for i in A]
R = lambda s: s.replace('+', u'＋').replace('-', u'－').replace('*', u'×').replace('/', u'÷').replace('==', u'＝')

print '\n'.join([R(E % tuple(l)) for l in F(8) if eval(E % tuple(l))])

import java.util.ArrayList;
import java.util.List;

public class Sample104 {

    public static void komachi(int[] lhs, int rhs) {
        if (lhs.length == 0) return;

        List<Term> expression = new ArrayList<Term>();
        expression.add(new TermValue(lhs[0]));
        for (int index = 1; index < lhs.length; index++) {
            List<Term> work = new ArrayList<Term>(expression);
            expression.clear();
            for (Term term: work) {
                List<Term> list = createTerm(term, lhs[index]);
                expression.addAll(list);
            };
        }

        int counter = 1;
        for (Term term: expression) {
            if (term.getValue() == rhs) {
                System.out.println(counter++ + ": " + term.toString() + " = " + rhs);
            }
        }
    }
    private static List<Term> createTerm(Term lhs, int r) {
        List<Term> result = new ArrayList<Term>();
        Operator[] operators = Operator.values();
        for (int index = 0; index < operators.length; index++) {
            result.add(new TermData(operators[index], lhs, new TermValue(r)));
        }
        return result;
    }


    public enum Operator {
        None {
            public int getPriority() { return 10; }
            public double operate(double lhs, double rhs) { return lhs * 10 + rhs; }
            public String toString() { return ""; }
        },
        Plus {
            public int getPriority() { return 1; }
            public double operate(double lhs, double rhs) { return lhs + rhs; }
            public String toString() { return "+"; }
        },
        Minus {
            public int getPriority() { return 1; }
            public double operate(double lhs, double rhs) { return lhs - rhs; }
            public String toString() { return "-"; }
        },
        Times {
            public int getPriority() { return 2; }
            public double operate(double lhs, double rhs) { return lhs * rhs; }
            public String toString() { return "*"; }
        },
        Divide {
            public int getPriority() { return 2; }
            public double operate(double lhs, double rhs) { return lhs / rhs; }
            public String toString() { return "/"; }
        };

        public abstract int getPriority();
        public abstract double operate(double lhs, double rhs);
    }
    private static interface Term {
        public boolean isOperate();
        public double getValue();
    }
    private static class TermValue implements Term {
        public final int value;

        public TermValue(int val) {
            value = val;
        }
        public boolean isOperate() { return false; }
        public double getValue() {
            return value;
        }
        public String toString() { return String.valueOf(value); }
    }
    private static class TermData implements Term {
        public final Operator op;
        public final Term lhs;
        public final Term rhs;

        /**
         * 右辺は追加分と考えて、演算子の順序に従ってデータを正規化します。
         */
        public TermData(Operator o, Term l, Term r) {
            Operator operator = o;
            Term lterm = l;
            Term rterm = r;

            if (l.isOperate()) {
                TermData data = (TermData) l;
                if (operator.getPriority() > data.op.getPriority()) {
                    rterm = new TermData(operator, data.rhs, rterm);
                    lterm = data.lhs;
                    operator = data.op;
                }
            }
            op = operator;
            lhs = lterm;
            rhs = rterm;
        }
        public boolean isOperate() { return true; }
        public double getValue() {
            return op.operate(lhs.getValue(), rhs.getValue());
        }
        public String toString() {
            return lhs.toString() + op.toString() + rhs.toString();
        }
    }


    public static void main(String[] args) {
        long start = System.currentTimeMillis();
        komachi(new int[] {1, 2, 3, 4, 5, 6, 7, 8, 9}, 100);
        System.out.println();
        long end = System.currentTimeMillis();
        System.out.println("elipse: " + (end - start) + "(ms)");
    }
}

#!/usr/local/bin/perl
use strict;
use warnings;
use B::Deparse;

sub komanechi {
    for my $i ( 1 .. 5**8 ) {
        my $formula = 1;
        for my $n ( 2 .. 9 ) {
            $formula .= ( '', qw{+ - * /} )[ $i % 5 ] . $n;
            $i /= 5;
        }
        next if  100 != eval $formula;
        print "$formula\n";
    }
}

komanechi;

#include <ctype.h>
#i