DouKaku?

module Main where

import Control.Applicative
import qualified Data.Set as S
import qualified System.IO.UTF8 as U

main :: IO ()
main = mapM_ (U.putStrLn . snd)
     . S.toAscList . S.map pair
     . foldl ((S.insert <*>) . flip S.delete) S.empty
     . zipWith N [1..] . lines =<< U.getContents
  where pair (N i s) = (i,s)

data NL = N Int String
instance Eq NL where
  N _ s == N _ s' = s == s'
instance Ord NL where
  N _ s `compare` N _ s' = s `compare` s'

#include <list>
#include <string>
#include <iostream>
#include <fstream>
#include <iterator>
#include <algorithm>
using namespace std;

void uniq(const char *fname) {
	ifstream fin(fname);
	if (!fin) return;
	
	list<string> lines;
	string s;
	
	while (getline(fin, s)) {
		lines.remove(s);
		lines.push_back(s);
	}

	copy(lines.begin(), lines.end(), ostream_iterator<string>(cout, "\n"));
}

int main(void) {
	uniq("hoge.txt");
	return 0;
}

| in lines line out |
in := FileStream oldFileNamed: 'in.txt'.
lines := OrderedCollection new.

[(line := in nextLine) notNil] whileTrue: [
	lines remove: line ifAbsent: [].
	lines add: line].
in close.

out := FileStream forceNewFileNamed: 'out.txt'.
lines do: [:each | out nextPutAll: each; cr].
out edit

(defpackage #:doukaku-66 (:use #:cl #:pg))

(in-package #:doukaku-66)

(defun no-dup (file &optional (output t))
  (with-open-file (input file :direction :input)
    (flet ((rl () (read-line input nil 'eof)))
      (do ((line (rl) (rl))
	   result)
	  ((eql 'eof line)
	   (mapc (lambda (l) (format output "~&~A~%" l))
		 (delete nil (nreverse result))))
	(aif (member line result :test #'string=)
	     (setf (car it) nil))
	(push line result)))))

fun uniq file =
let
  open TextIO

  val fs = openIn file

  fun f a =
    case inputLine fs of
        NONE => app print a
      | SOME s => f ((List.filter (fn x => x <> s) a) @ [s])
in
  f []
end;

uniq "hoge.txt"

(use srfi-1)
(use srfi-42)
(define (uniq-file file)
  (call-with-input-file file
    (lambda (p)
      (let1 ls (fold-ec '() (:port ln p read-line)
                        ln (lambda (x r) (append (delete! x r) (list x))))
        (do-ec (: ln ls) (print ln))))))

import sys

l = []
for s in file(sys.argv[1], 'r') if len(sys.argv) > 1 else sys.stdin:
  try:
    l.remove(s)
  except:
    pass
  l.append(s)

for s in l:
  sys.stdout.write(s)

(loop for s = (read-line nil nil) while s collect s into lines
  finally (mapc #'write-line (delete-duplicates lines :test #'string=)))

import java.io.*;
import java.util.*;

public class Sample {
    public static void main(String[] args) throws IOException {
        BufferedReader r=new BufferedReader(new InputStreamReader(System.in));
        LinkedHashSet<String> uniqLines = new LinkedHashSet<String>();
        String str;
        while ((str = r.readLine()) != null) {
            if (uniqLines.contains(str)) {
                uniqLines.remove(str);
            }
            uniqLines.add(str);
        }
        for (String s : uniqLines) {
            System.out.println(s);
        }
    }
}

(define (argl proc) (lambda arg (proc arg)))

(let ((h (make-hash-table 'string=?))
      (c 0))
  (port-for-each (cut hash-table-put! h <> (inc! c)) read-line)
  (for-each (compose print car)
            (sort (hash-table-map h cons)
                  (compose (apply$ <) (argl (map$ cdr))))))

import scala.collection.mutable.LinkedHashSet
import scala.io.Source.fromFile

(new LinkedHashSet[String] /: fromFile("test.txt").getLines){(set,line) =>
  set -= line; set += line; set
}.foreach(print)

$c=0;
while(<>){$b{$_}ne''?$r[$b{$_}]='':0;$b{$_}=$c++;push@r,$_}
print grep{$_}@r;

<?php
$a=array();
for($i=0;($str=fgets(STDIN))!==false;)
	$a[$str]=$i++;
asort($a);
echo implode("",array_keys($a));
?>

a = []

while line = ARGF.gets
  a.delete(line)
  a << line
end

a.each{|line|
  print line
}

my $file_name = $ARGV[0];

open IN , '<' , $file_name or die "Can't open $file_name";
open CMP, '<' , $file_name or die "Can't open $file_name";

my $hash = {};
my $index= {};

for (my $n=0; my $line = <IN>; $n++ )
{
    next if (exists $hash->{$n});

    my @array = ();
    for ( my $i=0; my $cmp = <CMP> ; $i++ )
    {
        if ( $line eq $cmp )
        {
            $hash->{$i} = undef ;
            push @array , $i;
        }
    }
    seek CMP , 0 , 0 ;

    my $tmp = (sort {$b <=> $a} ( @array ))[0];
    $index->{$tmp} = undef ;
}

for (my $i=0; my $line = <CMP>; $i++)
{
    print $line if (exists $index->{$i});
}

close IN ;
close CMP;

import System (getArgs)
import System.IO
import System.IO.UTF8 as U
import Data.List ((\\))
import Control.Exception (bracket)

main = do
  (file:_) <- getArgs
  bracket (openFile file ReadMode) hClose exec

exec :: Handle -> IO ()
exec = loop []
  where loop ret h = do
          eof <- hIsEOF h
          if eof then U.print ret
                 else U.hGetLine h >>= return . (\l -> (ret \\ [l]) ++ [l]) >>= flip loop h

var o = [], l = 0;
with(WSH.stdIn) while(!atEndOfStream) o[readLine() +'\n'] = l++;
for(l in o) o[o[l]] = l;
WSH.stdOut.write(o.join(''));

perl -ne '$h{$_}=++$i; END { print "$_" foreach ( sort { $h{$a} <=> $h{$b};} keys(%h));}'

mysql -uroot -p -N test << EOF

DROP TABLE IF EXISTS tmp;
CREATE TABLE tmp (
  id INT PRIMARY KEY AUTO_INCREMENT,
  line LONGTEXT NOT NULL
) CHARACTER SET UTF8;

LOAD DATA LOCAL INFILE "$1" INTO TABLE tmp FIELDS TERMINATED BY '\n' (line);

SELECT line FROM tmp GROUP BY line ORDER BY MAX(id);

EOF

h = {}

while line = ARGF.gets
  print line if not h[line]
  h[line] = 0
end

Dictionary<string, long> table = new Dictionary<string, long>();
long number = 0L;
TextReader reader = args.Length > 0 ? new StreamReader(args[0], Encoding.Default) : Console.In;
string line = null;
while ((line = reader.ReadLine()) != null)
  table[line] = number++;
SortedDictionary<long, string> list = new SortedDictionary<long, string>();
foreach (KeyValuePair<string, long> pair in table)
  list.Add(pair.Value, pair.Key);
foreach (KeyValuePair<long, string> pair in list)
  Console.WriteLine(pair.Value);

'print reverse do{grep {1>$s{$_}++} reverse <>}' ~/.bash_history

#include <stdio.h>
#include <stdlib.h>
#include <string.h>
#define BLOCK_SIZE 1024

void read_line(char **out){
    int cnt = 1;
    *out = (char *)malloc(1);
    *out[0] = '\0';
    do{
        *out = (char *)realloc(*out, BLOCK_SIZE * cnt);
        fgets((*out) + strlen(*out), BLOCK_SIZE, stdin);
        cnt++;
    }while((*out)[strlen(*out)-1] != '\n' && !feof(stdin));
    *out = (char *)realloc(*out, strlen(*out) + 1);
}

int main(){
    int i;
    int size = 0;
    char **list = NULL;
    char *line;
    while(!feof(stdin)){
        read_line(&line);
        for(i=0; i<size; i++){
            if(list[i]