DouKaku?

import copy
import threading
import time

class calcThread(threading.Thread):
    def __init__(self, cups, result):
        self.cups = cups
        self.result = result
        threading.Thread.__init__(self)
    def run(self):
        count = 0
        cups = self.cups
        while(cups[1]!=0 or cups[2] !=0):
            count+=1

            if cups[1] and cups[2] :
                cups[0] += 2
                cups[1] -= 1
                cups[2] -= 1
                continue

            if cups[1] == 0:
                cups[1] += 2
                cups[0] -= 1
                cups[2] -= 1
                continue

            if cups[2] == 0:
                cups[2] += 2
                cups[0] -= 1
                cups[1] -= 1
                continue
        self.result[0] = count

def water_move(cups):
    count = [[0],[0],[0]]
    threadholder = []
    for x in xrange(3):
        c = copy.copy(cups)
        c[0], c[x] = c[x], c[0]
        threadholder.append(calcThread(c, count[x]))
        threadholder[-1].setDaemon(True)
        threadholder[-1].start()

    while (1):
        for x in range(3):
            if not threadholder[x].isAlive():
                return count[x][0]
        

#print water_move([3,1,12])
print water_move([827392,65536,122880])

#include <stdio.h>
#include <stdint.h>

#define BAKET_SWAP(a,b) { uint32_t *work = *(a); *(a) = *(b); *(b) = work; }

void baket_sort( uint32_t **baket[] )
{
  int is_changed = 1;
  while( is_changed == 1 )
  {
    is_changed = 0;
    if( (*(baket[0])) < (*(baket[2])) ){ BAKET_SWAP(baket[0], baket[2]); is_changed = 1;}
    if( (*(baket[0])) < (*(baket[1])) ){ BAKET_SWAP(baket[0], baket[1]); is_changed = 1;}
    if( (*(baket[1])) < (*(baket[2])) ){ BAKET_SWAP(baket[1], baket[2]); is_changed = 1;}
  }
}

uint64_t play_game(uint32_t A, uint32_t B, uint32_t C)
{
  uint32_t *baket[] = {&A, &B, &C};
  uint64_t count = 0;

  while( 1 )
  {
    /* 水の量が均一になれば終わり */
    if( A == B )
    {
      printf("のこるのは C\n");
      count += A;
      break;
    }
    if( A == C )
    {
      printf("のこるのは B\n");
      count += A;
      break;
    }
    if( B == C )
    {
      printf("のこるのは B\n");
      count += B;
      break;
    }
    /* 昇順にバブルソート */
    baket_sort( &baket );
    (*(baket[0])) --; (*(baket[1])) --;
    (*(baket[2])) += 2;
    count ++;
  }
  return count;
}

int main(int argc, char *argv[])
{
  printf("ans = %lld\n", play_game(4,2,10));
  printf("ans = %lld\n", play_game(3,1,12));
  return 0;
}

(defun water-puzzle (a b c)
  (loop for (x y) in `((,a ,b) (,b ,c) (,c ,a))
    if (zerop (mod (- x y) 3)) minimize (max x y)))

function doukaku73_bad(a, b, c){
  var f = function(x, y){ return x - y }, v = [a, b, c].sort(f), i = 0, d;
  for(; v[0] < v[1] && v[1] < v[2]; i++){
    v[0] += 2, v[1]--, v[2]--;
    if(v[0] > v[1]) v.sort(f);
  }
  return i + v[1];
}
/// ↓ ///

function doukaku73(a, b, c){
  for(var v = arguments, r = [], i = 3, j; i--;)
    r[i] = (v[i] - v[j = (i + 1) % 3]) % 3 ? Infinity : Math.max(v[i], v[j]);
  return Math.min.apply(null, r);
}

| start result |
start := #(827392 65536 122880).
result := start max.
start combinations: 2 atATimeDo: [:pair |
    (pair first - pair second isDivisibleBy: 3) ifTrue: [result := result min: pair max]].
^result

public class Sample {
    private static int[] volume = {4, 2, 10};
    private static boolean[] dFlag = new boolean[3];
    private static int minStep = Integer.MAX_VALUE;
    public static void move(int dest, int step) {
        boolean so = dFlag[dest];
        try {
            volume[dest] += 2;
            volume[(dest + 1) % 3]--;
            volume[(dest + 2) % 3]--;
            dFlag[dest] = true;
            int emptyCount = 0;
            int destCount = 0;
            for (int i = 0; i < 3; i++) {
                if (volume[i] < 0) {
                    return;
                } else if (volume[i] == 0) {
                    emptyCount++;
                }
                if (dFlag[i]) destCount++;
            }
            if (destCount == 3) return;
            if (emptyCount == 2) {
                if (minStep > step + 1)
                    minStep = step + 1;
            } else {
                move(0, step + 1);
                move(1, step + 1);
                move(2, step + 1);
            }
        } finally {
            dFlag[dest] = so;
            volume[dest] -= 2;
            volume[(dest + 1) % 3]++;
            volume[(dest + 2) % 3]++;
        }

    }
    public static void main(String[] args) {
        move(0, 0);
        move(1, 0);
        move(2, 0);
        System.out.println(minStep);
    }
}

(define (wp n . l)
  (let1 sl (sort l)
    (cond ((= (caddr sl) (cadr sl)) (+ n (cadr sl)))
          (else (wp (+ 1 n) (+ (car sl) 2) (- (cadr sl) 1) (- (caddr sl) 1))))))

(print (wp 0 4 2 10))
(print (wp 0 827392 65536 122880))

module Main(main) where

import List(any, findIndex)

type Youki = (Int, Int, Int)

main :: IO ()
main = print $ shallowestLeafDepth (4, 2, 10)

shallowestLeafDepth :: Youki -> Int
shallowestLeafDepth y = maybe 0 id $ findIndex (any isLeaf) $ bfs branch [y]

isLeaf :: Youki  -> Bool
isLeaf (_, 0, 0) = True
isLeaf (0, _, 0) = True
isLeaf (0, 0, _) = True
isLeaf _ = False

branch :: Youki -> [Youki]
branch (w1, 0, 0) = []
branch (0, w2, 0) = []
branch (0, 0, w3) = []
branch (0, w2, w3) = [(2, w2-1, w3-1)]
branch (w1, 0, w3) = [(w1-1, 2, w3-1)]
branch (w1, w2, 0) = [(w1-1, w2-1, 2)]
branch (w1, w2, w3) = [(w1+2, w2-1, w3-1), (w1-1, w2+2, w3-1), (w1-1, w2-1, w3+2)]

bfs :: (a -> [a]) -> [a] -> [[a]]
bfs f [] = []
bfs f xs = xs : bfs f (concatMap f xs)

use Data::Dumper;

my %hash = (
    1 => 827392,
    2 => 65536,
    3 => 122880,
);

my $calc_cnt = 0;

until ( any_eqv( \%hash ) ) {

    ++$calc_cnt;

    my $mini_key = get_mini_key( \%hash );
    $hash{$mini_key} += 2;

    @other_key = get_other_key($mini_key);
    for (@other_key) {
        $hash{$_} -= 1;
    }
}

print Dumper( \%hash );

$nokori = get_same_val( \%hash );
print "The answer is " . ( $calc_cnt + $nokori );

sub any_eqv {
    my $hash_ref = shift;
    my %hash     = %{$hash_ref};

    if (   $hash{1} == $hash{2}
        or $hash{2} == $hash{3}
        or $hash{3} == $hash{1} )
    {
        return 1;
    }
    else {
        return 0;
    }
}

sub get_mini_key {
    my $hash_ref = shift;
    my %hash     = %{$hash_ref};
    my $mini     = $hash{1};
    my $mini_key;
    for ( 1 .. 3 ) {
        $mini = $hash{$_} xor $mini_key = $_
            if ( $mini >= $hash{$_} );

    }
    return $mini_key;
}

sub get_other_key {

    my $target = shift;
    my $list   = '123';
    $list =~ s/$target//;
    return split( //, $list );
}

sub get_same_val {

    my $hash_ref = shift;
    my %hash     = %{$hash_ref};

    if ( $hash{1} == $hash{2} ) {
        return $hash{1};
    }
    elsif ( $hash{2} == $hash{3} ) {
        return $hash{2};
    }
    elsif ( $hash{3} == $hash{1} ) {
        return $hash{3};
    }
}

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

long water_move(long a,long b,long c){
    long ret=-1;
    
    if((a-b)%3==0)
        ret=max(a,b);
    if((a-c)%3==0)
        if(ret==-1) ret=max(a,c);
        else ret=min(ret,max(a,c));
    if((b-c)%3==0)
        if(ret==-1) ret=max(b,c);
        else ret=min(ret,max(b,c));
    
    return ret;
}

void put_water_move(long a,long b, long c){
    int ret;
    
    ret=water_move(a,b,c);
    printf("A=%ld B=%ld C=%ld : ");
    if (ret==-1)
        printf("出来ません\n");
    else
        printf("%ld\n",ret);
}

int main(){
    put_water_move(4,2,10);
    put_water_move(827392,65536,122880);
    put_water_move(4,2,6);
    put_water_move(4,1,10);
    
    return 0;
}

@list = sort { $b <=> $a } qw(827392 65536 122880);
die "むりぽ"
    if (!( map { $sum += $_; $sum } @list ) % 3
    and !grep { $_ ne $x xor( $x = $_ ) } @list );

@list = sort { $a <=> $b } @list
    if ( grep { $_ ne $x xor( $x = $_ ) } @list );
print my ($min) = @list;

(eval-when-compile (require 'cl))

(defun water-puzzle (a b c)
  (let ((cups (list a b c)))
    (destructuring-bind ((i p) (j q) (k r))
        (sort `((0 ,a) (1 ,b) (2 ,c))
              (lambda (x y) (< (cadr x) (cadr y))))
      (cond ((zerop (mod (- p q) 3)) (show-strategy cups i j k))
            ((zerop (mod (- p r) 3)) (show-strategy cups i k j))
            ((zerop (mod (- q r) 3)) (show-strategy cups j k i))
            (t (message "Cannot solve!"))))))

(defun show-strategy (cups i j k)
  (let ((buf (get-buffer-create "*water puzzle*"))
        (mover (lambda (di dj dk)
                 (incf (nth i cups) di) (redraw-cup i di)
                 (incf (nth j cups) dj) (redraw-cup j dj)
                 (incf (nth k cups) dk) (redraw-cup k dk)))
        (counter 0))
    (switch-to-buffer buf)
    (show-init-state cups)
    (while (> (nth j cups) 0)
      (sit-for 1)
      (apply mover (if (zerop (nth i cups)) '(2 -1 -1) '(-1 -1 2)))
      (incf counter))
    (message "Solved in %d step%s."
             counter (if (= counter 1) "" "s"))))

(defun show-init-state (cups)
  (delete-region (point-min) (point-max))
  (redraw-cup 0 (car cups))   (insert ?\n)
  (redraw-cup 1 (cadr cups))  (insert ?\n)
  (redraw-cup 2 (caddr cups)) (insert ?\n))

(defun redraw-cup (i d)
  (goto-line (1+ i))
  (if (plusp d) (dotimes (x d) (insert ?|)) (delete-char (- d))))

;;; test
(water-puzzle 4 2 10)

{
    # A, B, C を cups[0], cups[1], cups[2] とする
    cups[0] = $1
    cups[1] = $2
    cups[2] = $3

    # A <= B <= C にそろえる
    sort(cups)

    total = 0
    # A と B からとり、C に移す。A が空になるまで
    count = cups[0]
    cups[0] = 0
    cups[1] -= count
    cups[2] += count * 2
    total += count

    # B が空になるまで、以下を繰り返す。
    # B と C から取って A に移し、A と B からとって C に移す。
    count = cups[1]
    cups[0] = count % 2
    cups[1] -= count
    cups[2] += count * 2
    total += count

    if(cups[0] != 0) {
        print "N/A"