DouKaku?

(use gauche.collection)
(use util.match)

(define (classify lis)
  (match (group-collection lis)
    [((x ...))     `(homo ,(car x))]
    [((x ...) (y)) `(quasi-homo ,(car x) ,y)]
    [((y) (x ...)) `(quasi-homo ,(car x) ,y)]
    [_ 'hetero]))

def check(xs):
    c = {}
    for i in xs:
        if not c.has_key(i):
            c[i] = 0
        c[i] += 1
        if (len(c) == 3):
            return 2

    if len(c) == 1:
        return 0
    if len(c) == 2:
        a = c.items()[0][1]
        b = c.items()[1][1]
        if min(a,b) > 1:
            return 2
        return 1
    else:
        return 2
        

print check((1,1,1,1))
print check((1,1,1,2))
print check((1,1,2,1))
print check((1,1,2,3))
print check((1,2,2,1))
print check((1,2,2,1))

def classify(ary)
  hash = ary.inject(Hash.new(0)){|h,x| h[x]+=1; h }
  first = hash.keys.first
  case hash.keys.length
  when 1; [:homo, first]
  when 2
    second = hash.keys[1]
    hash[first]==1 ? [:quasi_homo, first, second] : [:quasi_homo, second, first]
  end
end

classify [1,1,1,1]              # => [:homo, 1]
classify [1,2,1,1,1]            # => [:quasi_homo, 2, 1]
classify [2,1,1,1,1]            # => [:quasi_homo, 2, 1]
classify [1,2,3,4]              # => nil

def classify(ary)
  hash = ary.inject(Hash.new(0)){|h,x| h[x]+=1; h }
  first = hash.keys.first
  case hash.keys.length
  when 1; [:homo, first]
  when 2
    second = hash.keys[1]
    hash[first]==1 ? [:quasi_homo, first, second] : [:quasi_homo, second, first] if hash.values.include?(1)
  end
end

classify [1,1,1,1]              # => [:homo, 1]
classify [1,2,1,1,1]            # => [:quasi_homo, 2, 1]
classify [2,1,1,1,1]            # => [:quasi_homo, 2, 1]
classify [2,2,1,1,1]            # => nil
classify [2,4,1,1,1]            # => nil
classify [1,2,3,4]              # => nil

(defun classify (list)
  (labels ((rec (list alist)
             (let ((pair (assoc (car list) alist))
                   (len (length alist)))
               (cond ((null list)
                      (if (= len 1)
                          (values :homo (caar alist))
                          (let ((one (position 1 (mapcar #'cdr alist))))
                            (case one
                              (0 (values :quasi-homo (caar alist) (caadr alist)))
                              (1 (values :quasi-homo (caadr alist) (caar alist)))
                              (t nil)))))
                     ((and (>= len 2) (null pair))
                      (return-from classify nil))
                     ((null pair)
                      (rec (cdr list) (cons (cons (car list) 1) alist)))
                     (t
                      (incf (cdr pair))
                      (rec (cdr list) alist))))))
    (rec list ())))
(multiple-value-list (classify '(1 1 1 1)))   ; => (:HOMO 1)
(multiple-value-list (classify '(1 2 1 1 1))) ; => (:QUASI-HOMO 2 1)
(multiple-value-list (classify '(1 1 1 1 2))) ; => (:QUASI-HOMO 2 1)
(multiple-value-list (classify '(2 2 1 1 1))) ; => (NIL)
(multiple-value-list (classify '(2 4 1 1 1))) ; => (NIL)
(multiple-value-list (classify '(1 2 3 4)))   ; => (NIL)
(multiple-value-list (classify '()))          ; => (NIL)

#include <stdio.h>
enum { hetero, homo, quasi_homo };
typedef struct {
    int type;                   /* hetero, homo, quasi_homo */
    int one;
    int other;
} classify_result;

classify_result classify(int *p, int len) {
    int temp[] = {  -1,  0,  -1,    0 };
    /*            key1 val1 key2 val2 */
    int cur, i;
    static classify_result hetero_result = {hetero, -1, -1};
    classify_result res = hetero_result;

    if (len == 0) return hetero_result;
    for (i=0; i<len; i++) {
        cur = p[i];
        if (temp[0] == cur) temp[1]++;
        else if (temp[2] == cur) temp[3]++;
        else if (temp[0] == -1) { temp[0]=cur; temp[1]=1; }
        else if (temp[2] == -1) { temp[2]=cur; temp[3]=1; }
        else return hetero_result;
    }
    if (temp[2] == -1) { res.type = homo; res.one = temp[1]; }
    else if (temp[1] == 1) { res.type = quasi_homo; res.one = temp[0]; res.other = temp[2]; }
    else if (temp[3] == 1) { res.type = quasi_homo; res.one = temp[2]; res.other = temp[0]; }
    else return hetero_result;
    return res;
}
/* コードはここまで。以後テスト。 */

void print_classify_result(classify_result x) {
    switch(x.type) {
    case hetero:
        printf("<hetero>\n");
        break;
    case homo:
        printf("<homo %d>\n", x.one);
        break;
    case quasi_homo:
        printf("<quasi_homo %d %d>\n", x.one, x.other);
        break;
    default:
        printf("BUG!\n");
    }
}
int main() {
    {
        int ary[] = {1,1,1,1};
        print_classify_result(classify(ary, sizeof(ary)/sizeof(int)));
    }
    {
        int ary[] = {1,2,1,1,1};
        print_classify_result(classify(ary, sizeof(ary)/sizeof(int)));
    }
    {
        int ary[] = {1,1,1,1,2};
        print_classify_result(classify(ary, sizeof(ary)/sizeof(int)));
    }
    {
        int ary[] = {2,2,1,1,1,1};
        print_classify_result(classify(ary, sizeof(ary)/sizeof(int)));
    }
    {
        int ary[] = {2,4,1,1,1,1};
        print_classify_result(classify(ary, sizeof(ary)/sizeof(int)));
    }
    {
        int ary[] = {1,2,3,4};
        print_classify_result(classify(ary, sizeof(ary)/sizeof(int)));
    }
    {
        int ary[] = {};
        print_classify_result(classify(ary, sizeof(ary)/sizeof(int)));
    }
}

otherList :: (Eq a) => [a] -> [a]
otherList (x:xs) = [ y |  y<-xs , y /= x ]

quasiHomo1 :: (Eq a) => [a] -> Bool
quasiHomo1     = (== 1) . length . otherList

quasiHomo2 :: (Eq a) => [a] -> Bool
quasiHomo2 xs  = (== 1) $ (length xs ) - (length $ otherList xs)

quasiHomoList :: (Eq a) => [a] -> [a]
quasiHomoList xs = map head $ [xs] ++ [otherList xs]

homo :: (Eq a) => [a] -> Bool
homo (xs) = xs == [ y | y <- xs , y == (head xs)]

classify :: (Eq a) => [a] ->  ([Char],[a])
classify xs | homo xs = ("homo" , [head xs])
            | quasiHomo1 xs = ("quasi-homo", quasiHomoList xs)
            | quasiHomo2 xs = ("quasi-homo", reverse $ quasiHomoList xs)
            | otherwise = ("hetero",[])

{
	delete xs
	for (i=1;i<=NF;i++) xs[i] = $i
	result = nakama(xs)
	if (result ~ /unanimity/) {
		printf("全部の要素が同じ値: %s\n", MAJORITY)  ## %dでなく%s
	} else if (result ~ /left alone/) {
		printf("一つだけ仲間はずれがある: 仲間はずれ(%s),多数派(%s)\n", MINORITY, MAJORITY)  ## %dでなく%s
	} else if (result ~ /(empty|two different values|other)/) {
		printf("その他\n")
	}
}

function nakama(xs,  i,len,x_count,member,m,m1,m2)
{
	len = 0 ; for (i in xs) len++
	if (len == 0) return "empty"
	if (len == 1) {
		MAJORITY = xs[1] ; MINORITY = "" ; return "unanimity"
	}

	delete x_count

	member = ":" xs[1] ":"
	x_count[xs[1]] = 1

	for (i=2; i<=len; i++) {
		x = xs[i]

		if (member !~ ":" x ":") member = member x ":"
		x_count[x]++
	}

	gsub(/(^:|:$)/,"",member)
	member_count = split(member,m,":")
	if (member_count == 1) {
		MAJORITY = m[1] ; MINORITY = "" ; return "unanimity"
	} else if (member_count == 2) {
		m1 = m[1] ; m2 = m[2]
		if (x_count[m1] == 1) {
			if (x_count[m2] == 1) {
				MAJORITY = m1 ; MINORITY = m2 ; return "two different values"
			} else {
				MAJORITY = m2 ; MINORITY = m1 ; return "left alone"
			}
		} else if (x_count[m2] == 1) {
			MAJORITY = m1 ; MINORITY = m2 ; return "left alone"
		} else {
			MAJORITY = MINORITY = "" ; return "other"
		}
	} else {
		MAJORITY = MINORITY = "" ; return "other"
	}
}

data Case a = Zero 
            | One {first :: a}
            | Two {first, second :: a}
            | Homo {homo :: a} 
            | QuasiHomo {homo, strange :: a}
            | Hetero
  deriving Show

classify :: Eq a => [a] -> Case a
classify []     = Zero
classify (x:xs) = judge (One x) xs

judge c [] = c
judge (One x) (y:ys) 
      | x == y    = judge (Homo x) ys
      | otherwise = judge (Two x y) ys
judge (Homo x) (y:ys)
      | x == y    = judge (Homo x) ys
      | otherwise = judge (QuasiHomo x y) ys
judge (Two x y) (z:zs)
      | x == z    = judge (QuasiHomo x y) zs
      | y == z    = judge (QuasiHomo y x) zs
judge (QuasiHomo x y) (z:zs)
      | x == z    = judge (QuasiHomo x y) zs
judge _ _         = Hetero

{-
*Main> classify [1,1,1,1,1]
Homo {homo = 1}
*Main> classify [1,2,1,1,1]
QuasiHomo {homo = 1, strange = 2}
*Main> classify [1,2,1,2,1]
Hetero
-}

type 'a t = H of 'a | Q of 'a * 'a | Other

let classify (x::xs) =
  let rec one a = function
  | [] -> H a
  | x::xs when x = a -> one' a xs
  | x::xs -> two a x xs
  and one' a = function
  | [] -> H a
  | x::xs when x = a -> one' a xs
  | x::xs -> two' a x xs
  and two a b = function
  | [] -> Q (a, b)
  | x::xs when x = a -> two' a b xs
  | x::xs when x = b -> two' b a xs
  | _ -> Other
  and two' a b = function
  | [] -> Q (a, b)
  | x::xs when x = a -> Q (a, b)
  | _ -> Other
  in
  one x xs

def lookfor(target):
    count = {}
    for v in target:
        if not count.has_key(v):
            count[v] = target.count(v)
    #2つ以上要素があって、1回出現の要素がない時はその他
    #要素が2つより多い場合もその他
    if (1 not in count.values() and len(count.keys()) >= 2)\
            or len(count.keys()) > 2:
        print '%s その他' % (target)
    #要素が1つしかない時は全部同じ
    elif len(count.keys()) == 1:
        print '%s 全て同じ' % (target)
    #この時点で1回出現の要素と多数出現の要素の2つが残っている
    else:
        for k, v in count.iteritems():
            if v == 1:
                outofgroup = k
            else:
                group = k
        print '%s 多数派: %s, 仲間外れ: %s' % (target, group, outofgroup)

Array.prototype.classify = function () {
  if(this.length == 0) return [];
  var a , b, ac = 0, bc = 0;
  for(var i=0, n=this.length; i<n; i++) {
    if(ac == 0 || a == this[i]) {a = this[i]; ac++; }
    else if(bc == 0 || ac == 1 && b == this[i]) {b = this[i]; bc++;}
    else return [];
  }
  return a == void 0 ? [b] : 
         b == void 0 ? [a] :
         ac < bc     ? [b, a] : [a, b];
};

alert([2,2,1,2].classify());// => [2, 1]
alert([1,1,1].classify());  // => [1]
alert([2, 1, 1, 1].classify()); // => [1, 2]
alert([2, 1, 0, 1].classify()); // => []
alert([1, 2, 1, 2, 1].classify()); // => []

   }
-  return a == void 0 ? [b] :
-         b == void 0 ? [a] :
-         ac == bc    ? [] :
-         ac < bc     ? [b, a] : [a, b];
+  return ac == 0  ? [b] :
+         bc == 0  ? [a] :
+         ac == bc ? [] :
+         ac < bc  ? [b, a] : [a, b];
 };

def classify_r(xs):
  if len(xs) == 0 :
    return dict()
  else:
    d = classify_r(xs[1:])
    c = d.get(xs[0], 0)
    d.update({xs[0]: c + 1})
    return d

def classify(xs):
  d = classify_r(xs)
  if len(d) == 0:
    return "Empty"
  elif len(d) == 1:
    return d.keys()[0]
  elif len(d) == 2:
    a = d.keys()[0]
    b = d.keys()[1]
    if d[a] >= d[b]:
      return (a, b)
    else:
      return (b, a)
  else:
    return "Mixed"

try: set
except NameError: from sets import Set as set

def dup_check(xs):
	for attr in ['major', 'minor']:
		if hasattr(dup_check, attr): delattr(dup_check, attr)
	L = list(set(xs))
	if len(L) == 1:
		dup_check.major = L[0]
		return 1
	elif len(L) == 2:
		L.sort(key=xs.count)
		dup_check.minor = L[0]
		dup_check.major = L[1]
		return 2
	else:
		return 0

print 'ret =', dup_check([1,1,1,1])
print 'uniq =', dup_check.major
print
print 'ret =', dup_check([1,2,1,1,1])
print 'major =', dup_check.major
print 'minor =', dup_check.minor
print
print 'ret =', dup_check([1,2,3,4])

出力：
ret = 1
uniq = 1

ret = 2
major = 1
minor = 2

ret = 0

def f(xs):
  a = list(set(xs))
  if len(a) == 1: return xs[0], None
  if len(a) == 2 and xs.count(a[0]) == 1: return a[1], a[0]
  if len(a) == 2 and xs.count(a[1]) == 1: return a[0], a[1]
  return None, None

print f([1,1,1,1])
print f([1,2,1,1,1])
print f([1,1,2,2])
print f([1,1,2,3])

(defun hajiki (lst &optional &key (test #'equal))
  (let ((xs (remove (car lst) lst :test-not test))
	(ys (remove (car lst) lst :test test))
	(kind (let ((cnt 0) tem)
		(dolist (item lst cnt)
		  (or (eq tem (pushnew item tem :test test)) (incf cnt))
		  (and (> cnt 2) (return-from hajiki (values nil lst)))))))
    (if (= kind 1)
	(values (car xs) nil)
	(let ((xs-len (length xs))
	      (ys-len (length ys)))
	  (cond ((< xs-len ys-len ) (values (car xs) (car ys)))
		((= xs-len ys-len) (values nil lst))
		('T (values (car ys) (car xs))))))))

Function Classify(ByVal xs() As Integer) As Integer()
    Dim seq = From x In xs Group By x Into Count() Order By Count

    If seq.Count = 1 Then
        Return New Integer() {seq.First.x}
    ElseIf seq.Count = 2 AndAlso seq.First.Count = 1 Then
        Return New Integer() {seq(1).x, seq(0).x}
    End If
    Return New Integer() {}
End Function

import scala.collection.mutable.HashMap

trait Base
case class All[+A](a:A) extends Base
case class One[+A](a:A, b:A) extends Base

def groupTest[A](xs:List[A]):Option[Base] = {
  val map = xs.foldLeft(new HashMap[A,int]){(r,v)=>r(v)=r.getOrElse(v, 0)+1;r}
  val hasone = map.values.exists(1==)

  map.size match {
    case 1 => Some(All(map.keys.toList.head))
    case 2 if hasone => 
      val (a, b) = map.keys.toList.partition(map(_) == 1)
      (map(a(0)), map(b(0))) match {
        case (1, _) => Some(One(b(0), a(0)))
        case (_, 1) => Some(One(a(0), b(0)))
        case _      => None
      }
    case _ => None
  }
}

groupTest(List(1,2,1,1,1)) match {
  case Some(All(a))     => println(a)
  case Some(One(a, one)) => println(a+","+one)
  case None             => println("None")
}