DouKaku?

xs.uniq

Array.prototype.uniq = function () {
  for (var i = 0, r = [], s = {}; i < this.length; i++) {
    if (!s[this[i]]) r.push(this[i]);
    s[this[i]] = true;
  }
  return r;
};

require 'pseudohash' # http://www.notwork.org/~gotoken/ruby/p/pseudohash/

xs = [3, 1, 4, 1, 5, 9, 2, 6, 5, 3, 5, 8, 9, 7, 9]

h = PseudoHash.new
xs.each{|i|
  h[i, true] = nil
}
xs_out = h.map{|k, v| k}

p xs_out

>>> [ xs[i] for i in xrange(0, len(xs)) if xs[i] not in xs[:i] ]
[3, 1, 4, 5, 9, 2, 6, 8, 7]

xs = [3, 1, 4, 1, 5, 9, 2, 6, 5, 3, 5, 8, 9, 7, 9]

h = {}
xs_out = []
xs.each {|i|
  xs_out << i unless h.key?(i)
  h[i] = nil
}

p xs_out

let uniq xs =
  let rec uniq' acc = function
  | [] -> acc
  | y::ys when (List.mem y acc) -> uniq' acc ys
  | y::ys -> uniq' (y::acc) ys
  in
  List.rev (uniq' [] xs)

(define xs #(3 1 4 1 5 9 2 6 5 3 5 8 9 7 9))

(define (vector-uniq vec)
  (let ((ls (vector->list vec)))
    (do ((ls ls (cdr ls))
         (acc '() (if (memv (car ls) acc) acc (cons (car ls) acc))))
        ((null? ls) (list->vector (reverse! acc))))))

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

public class Unique {
	
	public static Object[] toUniqueArray(Object[] array) {
		List unique = new ArrayList();
		for (Object o : array) {
			if (!unique.contains(o)) {
				unique.add(o);
			}
		}
		return unique.toArray();
	}

}

| xs uniq |
xs := #(3 1 4 1 5 9 2 6 5 3 5 8 9 7 9).
uniq := OrderedCollection new.
xs do: [:each | uniq addIfNotPresent: each].
^uniq asArray

"=> #(3 1 4 5 9 2 6 8 7) "

def iter_uniq(it):
    s = set()
    for x in it:
        if x not in s:
            yield x
            s.add(x)

def uniq(a):
    return list(iter_uniq(a))

print uniq([3, 1, 4, 1, 5, 9, 2, 6, 5, 3, 5, 8, 9, 7, 9])

(use gauche.sequence)
(define (uniq a)
  (let1 h (make-hash-table 'equal?)
    (define (p x) (or (hash-table-exists? h x)
                      (begin (hash-table-put! h x #t) #f)))
    (remove-to (class-of a) p a)))

<?php
$xs = array(3,1,4,1,5,9,2,6,5,3,5,8,9,7,9);
var_dump(array_unique($xs));
?>

(define (uniq lst)
  (fold
   (lambda (e l)
     (cond ((null? l) (cons e l))
           ((member e l) l)
           (else (append l (list e)))))
   '()
   lst))

nub xs

xs = [3, 1, 4, 1, 5, 9, 2, 6, 5, 3, 5, 8, 9, 7, 9]
xs.inject([]){|a, e| a.member?(e) ? a : a << e }

using System;
using System.Collections.Generic;
class Program
{
  static void Main()
  {
    int[] xs ={ 3, 1, 4, 1, 5, 9, 2, 6, 5, 3, 5, 8, 9, 7, 9 };
    foreach(int i in Uniq(xs))
      Console.WriteLine(i);
  }
  static List<T> Uniq<T>(T[] xs)
  {
    List<T> lst = new List<T>();
    Dictionary<T, object> dic = new Dictionary<T, object>();
    foreach (T t in xs) if (!dic.ContainsKey(t))
      { lst.Add(t); dic.Add(t, null); }
    return lst;
  }
}

#include <stdio.h>

int main()
{
  int xs[] = {3, 1, 4, 1, 5, 9, 2, 6, 5, 3, 5, 8, 9, 7, 9};
  int array_size;
  int i, j, k;
  int save;

  array_size = (sizeof(xs) / sizeof(xs[0]));
  for (i = 0; i < array_size; i++) {
    save = xs[i];
    for (j = i+1; j < array_size; j++) {
      if (save == xs[j]) {
        /* 配列を詰める作業 */
        for (k = j; k < array_size-1; k++) {
          xs[k] = xs[k+1];
        }
        array_size--;
      }
    }
  }

  for (i = 0; i < array_size; i++) {
    printf("%d ", xs[i]);
  }
  printf("\n");

  return 0;
}

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

namespace ArrayUniq
{
    class Program
    {
        static void Main(string[] args)
        {
            object[] source = { 3, 1, 4, 1, 5, 9, 2, 6, 5, 3, 5, 8, 9, 7, 9 };
            object[] results = Uniq(source);
            foreach (object value in results)
            {
                System.Console.WriteLine(value);
            }
        }

        static object[] Uniq(object[] array)
        {
            List<object> uniqList = new List<object>();
            foreach (object value in array)
            {
                if (! uniqList.Contains(value))
                {
                    uniqList.Add(value);
                }
            }
            return uniqList.ToArray();
        }
    }
}

(let ((xs (list 3 1 4 1 5 9 2 6 5 3 5 8 9 7 9)))
  (delete-duplicates xs :from-end t))