[Question]
  [
Given a string consisting of **printable ASCII chars**, produce an output consisting of its **unique chars in the original order**. In other words, the output is the same as the input except that a char is removed if it has appeared previously.
**No built-ins** for finding unique elements in an array can be used (for example, MATLAB has a `unique` function that does that). The idea is to do it manually.
Further details:
* Either **functions or programs** are allowed.
* Input and output can be in the form of **function arguments, stdin/stdout** (even for functions), or a mix of those.
* If stdin or stdout are used, a string is understood as just the **sequence of chars**. If function arguments are used, the sequence of chars may need to be **enclosed** in quotation marks or equivalent symbols that the programming language of choice uses for defining strings.
* The output should be a string **containing only** the unique characters of the input. So no extra linebreaks, spaces etc. The only exception is: if the output is displayed in stdout, most displaying functions add a trailing `\n` (to separate the string from what will come next). So **one trailing `\n` is acceptable in stdout**.
* If possible, post a link to an **online** interpreter/compiler so that others can try your code.
This is **code golf**, so shortest code in bytes wins.
Some **examples**, assuming stdin and stdout:
1. Input string:
```
Type unique chars!
```
Output string:
```
Type uniqchars!
```
2. Input string
```
"I think it's dark and it looks like rain", you said
```
Output string
```
"I think'sdarloe,yu
```
3. Input string
```
3.1415926535897932384626433832795
```
Output string
```
3.14592687
```
  
[Answer]
# CJam, 3 bytes
```
qL|
```
Setwise or of the input with an empty list. CJam set operations preserve element order.
[Try it online](http://cjam.aditsu.net/#code=qL%7C&input=%22I%20think%20it's%20dark%20and%20it%20looks%20like%20rain%22%2C%20you%20said)
[Answer]
# C# 6, 18 + 67 = 85 bytes
Requires this `using` statement:
```
using System.Linq;
```
The actual method:
```
string U(string s)=>string.Concat(s.Where((x,i)=>s.IndexOf(x)==i));
```
This method saves some chars by [defining the function as a lambda](https://codegolf.stackexchange.com/a/44315/9275), which is supported in C# 6. This is how it would look in C# pre-6 (but ungolfed):
```
string Unique(string input)
{
    return string.Concat(input.Where((x, i) => input.IndexOf(x) == i));
}
```
How it works: I call the [`Where` method](https://msdn.microsoft.com/en-us/library/vstudio/bb534803%28v=vs.100%29.aspx) on the string with a lambda with two arguments: `x` representing the current element, `i` representing the index of that element. `IndexOf` always returns the first index of the char passed to it, so if `i` is not equal to the first index of `x`, it's a duplicate char and mustn't be included.
[Answer]
# GolfScript, 2 bytes
```
.&
```
or, alternatively:
```
.|
```
I posted this a while ago in the [Tips for golfing in GolfScript](https://codegolf.stackexchange.com/questions/5264/tips-for-golfing-in-golfscript/17839#17839) thread. It works by duplicating the input string (which is put on the stack automatically by the GolfScript interpreter, and which behaves in most ways like an array of characters) and then taking the set intersection (`&`) or union (`|`) of it with itself. Applying a set operator to an array (or string) collapses any duplicates, but preserves the order of the elements.
[Answer]
# [Retina](https://github.com/mbuettner/retina), 14 bytes
```
+`((.).*)\2
$1
```
Each line should go in its own separate file, or you can use the `-s` flag to read from one file.
To explain it, we'll use this longer but simpler version:
```
+`(.)(.*)\1
$1$2
```
The first line is the regex to match with (`+`` is the configuration string that keeps running until all replacements have been made). The regex looks for a character (we'll call it C), followed by zero or more arbitrary characters, followed by C. The parentheses denote capturing groups, so we replace the match with C (`$1`) and the characters in between (`$2`), removing the duplicate of C.
For example, if the input string was `unique`, the first run would match `uniqu`, with `u` and `niq` as `$1` and `$2`, respectively. It would then replace the matched substring in the original input with `uniq`, giving `uniqe`.
[Answer]
# [Perl 5](https://www.perl.org/) + `-p`, 19 bytes
Saved 1 byte thanks to [@kos](https://codegolf.stackexchange.com/users/45846/kos) and 1 byte thanks to [@Xcali](https://codegolf.stackexchange.com/users/72767/xcali)!
```
s/./$&x!$h{$&}++/eg
```
[Try it online!](https://tio.run/##K0gtyjH9/79YX09fRa1CUSWjWkWtVltbPzX9//@QyoJUhdK8zMLSVIXkjMSiYsV/@QUlmfl5xf91CwA "Perl 5 – Try It Online")
[Answer]
# JavaScript ES7, ~~37~~ ~~33~~ 25 bytes
Pretty simple approach using ES6 `Set` and ES7 ~~Array comprehensions~~ spread operator:
```
s=>[...new Set(s)].join``
```
22 bytes less than the `indexOf` approach. Worked on a handful of test cases.
[Answer]
## [Macaroni 0.0.2](https://github.com/KeyboardFire/macaroni-lang/releases/tag/v0.0.2-alpha), 233 bytes
```
set i read set f "" print map index i k v return label k set x _ set _ slice " " length index f e 1 1 set f concat f wrap x return label e set _ slice " " add _ multiply -1 x 1 1 return label v set _ unwrap slice i _ add 1 _ 1 return
```
* create "anti-golfing" language: check
* golf it anyway: check
This is a full program, which inputs from STDIN and outputs on STDOUT.
Wrapped version, for aesthetic value:
```
set i read set f "" print map index i k v return label k set x _ set _ slice "
" length index f e 1 1 set f concat f wrap x return label e set _ slice " " add
_ multiply -1 x 1 1 return label v set _ unwrap slice i _ add 1 _ 1 return
```
And a heavily "commented" and ungolfed version (there are no comments in Macaroni, so I just use bare string literals):
```
set input read                  "read line from STDIN, store in 'input' var"
set found ""                    "we need this for 'keep' below"
print map index input keep val  "find indeces to 'keep', map to values, print"
return
label keep
    "we're trying to determine which indeces in the string to keep. the special
     '_' variable is the current element in question, and it's also the value
     to be 'returned' (if the '_' variable is '0' or empty array after this
     label returns, the index of the element is *not* included in the output
     array; otherwise, it is"
    set x _ set _ slice
        " "
        length index found exists
        1
        1
    "now we're using 'index' again to determine whether our '_' value exists in
     the 'found' array, which is the list of letters already found. then we
     have to apply a boolean NOT, because we only want to keep values that do
     NOT exist in the 'found' array. we can 'invert' a boolean stored as an
     integer number 'b' (hence, 'length') with 'slice(' ', b, 1, 1)'--this is
     equivalent to ' '[0:1], i.e. a single-character string which is truthy, if
     'b' was falsy; otherwise, it results in an empty string if 'b' was truthy,
     which is falsy"
    set found concat found wrap x  "add the letter to the 'found' array"
return
label exists
    set _ slice
        " "
        add _ multiply -1 x
        1
        1
    "commentary on how this works: since 0 is falsy and every other number is
     truthy, we can simply subtract two values to determine whether they are
     *un*equal. then we apply a boolean NOT with the method described above"
return
label val
    set _ unwrap slice input _ add 1 _ 1  "basically 'input[_]'"
return
```
(This is the first real Macaroni program (that actually does something)! \o/)
[Answer]
# Python 2, 42 bytes
Uses a couple anonymous functions and [`reduce`](https://docs.python.org/2/library/functions.html#reduce).
```
lambda s:reduce(lambda x,y:x+y[y in x:],s)
```
[**Try it online**](http://ideone.com/3tgQUX)
[Answer]
# C# 6 - 18+46=64
```
using System.Linq;
```
and then
```
string f(string s)=>string.Concat(s.Union(s));
```
The [`Enumerable.Union`](https://msdn.microsoft.com/en-us/library/vstudio/bb341731(v=vs.100).aspx) extension method specifies that elements are returned in the original order:
> 
> When the object returned by this method is enumerated, Union enumerates *first* and *second* in that order and yields each element that has not already been yielded.
> 
> 
> 
Set operations that aren't specifically intended to find unique values appear to be allowed judging by the other answers.
[Answer]
# [Beam](http://esolangs.org/wiki/Beam), ~~23~~ 18 bytes
```
v<H
vs)
rS
g@S
>u^
```
[![enter image description here](https://i.stack.imgur.com/A6X8i.png)](https://i.stack.imgur.com/A6X8i.png)
[Try it online!](https://tio.run/nexus/beam#@19m48FVVqzJVRTMle4QzGVXGvf/v5KnQklGZl62QmaJerFCSmJRtkJiXgqQp5CTn59drJCTmZ2qUJSYmaeko1CZX6pQnJiZAgA "Beam – TIO Nexus")
[Answer]
# JavaScript ES6, 47 bytes
```
f=s=>s.replace(/./g,(e,i)=>s.indexOf(e)<i?'':e)
```
The test below works on all browsers.
```
f=function(s){
  return s.replace(/./g,function(e,i){
    return s.indexOf(e)<i?'':e
  })
}
run=function(){document.getElementById('output').innerHTML=f(document.getElementById('input').value)};document.getElementById('run').onclick=run;run()
```
```
<input type="text" id="input" value="Type unique chars!" /><button id="run">Run</button><br />
<pre id="output"></pre>
```
[Answer]
# MATLAB, 23
```
 @(n)union(n,n,'stable')
```
Does the "set union" of the input string with itself, using the 'stable' method which does not sort, and then prints.
This works because `union` returns only non-duplicate values after the merge. So essentially if you `union` the string with itself, it first produces a string like `Type unique chars!Type unique chars!`, and then removes all duplicates without sorting.
No need for `unique` :)
[Answer]
# [><>](https://esolangs.org/wiki/Fish), 16 bytes
```
i:0(?;:::1g?!o1p
```
 ><> doesn't have strings, so we make use of the codebox. Due to the toroidal nature of ><>, the following runs in a loop:
```
i         Read a char
:0(?;     Halt if EOF
:::       Push three copies of the char
1g        Get the value at (char, 1), which is 0 by default
?!o       Print the char if the value was nonzero
1p        Set the value at (char, 1) to char
```
Note that this uses the fact that the input only contains printable ASCII, as this would not work if ASCII 0 was present.
[Answer]
## Python 3, 44
```
r=''
for c in input():r+=c[c in r:]
print(r)
```
Builds the output string `r` character by character, including the character `c` from the input only if we haven't seen it already.
Python 2 would be 47, losing 4 chars with `raw_input` and saving 1 on not needing parers for `print`.
[Answer]
# [Element](https://github.com/PhiNotPi/Element), ~~22~~ ~~19~~ 18 bytes
```
_'{"(3:~'![2:`];'}
```
Example input/output: `hello world` -> `helo wrd`
This works by simply processing the string one character at a time and keeping track which ones it has seen before.
```
_'{"(3:~'![2:`];'}
_                        input line
 '                       use as conditional
  {              }       WHILE loop
   "                     retrieve string back from control (c-) stack
    (                    split to get the first character of (remaining) string
     3:                  a total of three copies of that character
       ~                 retrieve character's hash value
        '                put on c-stack
         !               negate, gives true if undef/empty string
          [   ]          FOR loop
           2:`           duplicate and output
               ;         store character into itself
                '        put remaining string on c-stack as looping condition
```
[Answer]
## APL, 3
```
∊∪/
```
This applies union (∪) between each element of the vector, obtaining an iteration that has the effect of removing duplicates.
Test it on [tryapl.org](http://tryapl.org/?a=%u220A%u222A/%27Type%20unique%20chars%21%27&run)
Old One:
```
~⍨\
```
This uses ~ (with reversed arguments, using ⍨) applied between each element of the argument.
The result is that for each element, if it's already in the list, it gets erased.
[Answer]
# TI-BASIC, 49 bytes
```
Input Str1
"sub(Str1,X,1→Y₁
Y₁(1
For(X,2,length(Str1
If not(inString(Ans,Y₁
Ans+Y₁
End
Ans
```
The equation variables are rarely useful since they take 5 bytes to store to, but `Y₁` comes in handy here as the `X`th character of the string, saving 3 bytes. Since we can't add to empty strings in TI-BASIC, we start the string off with the first character of Str1, then loop through the rest of the string, adding all characters not already encountered.
```
prgmQ
?Why no empty st
rings? Because T
I...
Why noemptysrig?Bcau.
```
[Answer]
# Pyth, 7 bytes
```
soxzN{z
```
Pseudocode:
z = input
sum of order-by index in z of N over set of z.
[Answer]
# Julia, ~~45~~ 42 bytes
```
s->(N="";[i∈N?N:N=join([N,i])for i=s];N)
```
Old version:
```
s->(N={};for i=s i∈N||(N=[N,i])end;join(N))
```
Code builds the new string by appending new characters onto it, then `join`s them together to a proper string at the end. New version saves some characters by iterating via array comprehension. Also saves a byte by using `?:` rather than `||` (as it removes the need for brackets around the assignment).
Alternate solution, 45 bytes, using recursion and regex:
```
f=s->s!=(s=replace(s,r"(.).*\K\1",""))?f(s):s
```
### Julia, 17 bytes
(Alternate version)
```
s->join(union(s))
```
This uses `union` as basically a substitute for `unique` - I don't consider this the "real" answer, as I interpret "don't use `unique`" to mean "don't use a single built-in function that has the effect of returning the unique elements".
[Answer]
# Ruby, ~~30~~ 24 characters
(23 characters code + 1 character command line option.)
```
gsub(/./){$`[$&]?"":$&}
```
Sample run:
```
bash-4.3$ ruby -pe 'gsub(/./){$`[$&]?"":$&}' <<< 'hello world'
helo wrd
```
[Answer]
## Perl, 54 27 bytes
```
map{$h{$_}||=print}<>=~/./g
123456789012345678901234567
```
Test:
```
$ echo Type unique chars! | perl -e 'map{$h{$_}||=print}<>=~/./g'
Type uniqchars!
$
```
[Answer]
# PHP, 72 Bytes ~~84 Bytes~~
```
<?foreach(str_split($argv[1])as$c)$a[$c]=0;echo join('',array_keys($a));
```
Uses the characters as keys for an associative array, then prints the keys. Order of array elements is always the order of insertion.
Thanks Ismael Miguel for the `str_split` suggestion.
[Answer]
# Java, 78 bytes
```
String f(char[]s){String t="";for(char c:s)t+=t.contains(c+"")?"":c;return t;}
```
A simple loop while checking the output for characters already present. Accepts input as a `char[]`.
[Answer]
# [Haskell](http://ghc.io/), 29 bytes
Nestable, no-variable-name one-liner:
```
foldr(\x->(x:).filter(x/=))[]
```
Same count, saved into a function named `f` as a top-level declaration:
```
f(x:t)=x:f[y|y<-t,x/=y];f_=[]
```
Note that there is a slightly-cheating optimization which I haven't made in the spirit of niceness: it is technically still allowed by the rules of this challenge to use a different input and output encoding for a string. By representing any `string` by its partially-applied Church encoding `\f -> foldr f [] string :: (a -> [b] -> [b]) -> [b]` (with the other side of the bijection provided by the function `($ (:))`) this gets golfed down to `($ \x->(x:).filter(x/=))`, only 24 characters. 
I avoided posting the 24-character response as my official one because the above solution could be tried on the above interpreter as `foldr(\x->(x:).filter(x/=))[]"Type unique chars!"`whereas the golfed solution would be written instead:
```
($ \x->(x:).filter(x/=))$ foldr (\x fn f->f x (fn f)) (const []) "Type unique chars!"
```
as a shorthand for the literal declaration which would be the more-insane:
```
($ \x->(x:).filter(x/=))$ \f->f 'T'.($f)$ \f->f 'y'.($f)$ \f->f 'p'.($f)$ \f->f 'e'.($f)$ \f->f ' '.($f)$ \f->f 'u'.($f)$ \f->f 'n'.($f)$ \f->f 'i'.($f)$ \f->f 'q'.($f)$ \f->f 'u'.($f)$ \f->f 'e'.($f)$ \f->f ' '.($f)$ \f->f 'c'.($f)$ \f->f 'h'.($f)$ \f->f 'a'.($f)$ \f->f 'r'.($f)$ \f->f 's'.($f)$ \f->f '!'.($f)$ const[]
```
But it's a perfectly valid version of the data structure represented as pure functions. (Of course, you can use `\f -> foldr f [] "Type unique chars!"` too, but that is presumably illegitimate since it uses lists to actually store the data, so its foldr part should then presumably be composed into the "answer" function, leading to more than 24 characters.)
[Answer]
# C - 58
Thanks to @hvd and @AShelly for saving a bunch of characters.
There were multiple ways suggested of making it much shorter than the original:
```
// @hvd     - always copy to q but only increment q if not found
g(char*s,char*r){char*q=r;for(;*q=*s;q+=q==strchr(r,*s++));}
// @AShelly - keep a histogram of the usage of each character
h(char*s){int a[128]={0};for(;*s;s++)a[*s]++||putchar(*s);}
// @hvd     - modify in place
i(char*s){char*q=s,*p=s;for(;*q=*p;q+=q==strchr(s,*p++));}
// original version - requires -std=c99
void f(char*s,char*r){for(char*q=r;*s;s++)if(!strchr(r,*s))*q++=*s;}
```
As you can see modifying in place seems to be the shortest (so far!) The test program compiles without warnings using `gcc test.c`
```
#include <stdlib.h> // calloc
#include <string.h> // strchr
#include <stdio.h>  // puts, putchar
// 000000111111111122222222223333333333444444444455555555556666666666
// 456789012345678901234567890123456789012345678901234567890123456789
// @hvd     - always copy to q but only increment q if not found
g(char*s,char*r){char*q=r;for(;*q=*s;q+=q==strchr(r,*s++));}
// @AShelly - keep a histogram of the usage of each character
h(char*s){int a[128]={0};for(;*s;s++)a[*s]++||putchar(*s);}
// @hvd     - modify in place
i(char*s){char*q=s,*p=s;for(;*q=*p;q+=q==strchr(s,*p++));}
/* original version - commented out because it requires -std=c99
void f(char*s,char*r){for(char*q=r;*s;s++)if(!strchr(r,*s))*q++=*s;}
*/
// The test program:
int main(int argc,char*argv[]){
  char *r=calloc(strlen(argv[1]),1); // make a variable to store the result
  g(argv[1],r);                      // call the function
  puts(r);                           // print the result
  h(argv[1]);                        // call the function which prints result
  puts("");                          // print a newline
  i(argv[1]);                        // call the function (modifies in place)
  puts(argv[1]);                     // print the result
}
```
Thanks for all the help. I appreciate all the advice given to shorten so much!
[Answer]
# [Python 3](https://docs.python.org/3/), 26 bytes
```
lambda s:[*dict(zip(s,s))]
```
[Try it online!](https://tio.run/##K6gsycjPM/6fZhvzPycxNyklUaHYKlorJTO5RKMqs0CjWKdYUzP2f0FRZl6JRppGZl5BaYmGpqbm/5DKglSF0rzMwtJUheSMxKJiRQA "Python 3 – Try It Online")
Reviving an ancient question with a new idea, inspired by [Noodle9's solution to "Special String reformatting"](https://codegolf.stackexchange.com/a/205837/20260) and my [further refinement](https://codegolf.stackexchange.com/a/205855/20260).
Because Python 3's dictionaries automatically remove duplicate keys beyond the first appearance while keeping them in order, we convert the the input string to a dictionary as keys. We then convert the dictionary back to a list with iterable unpacking, which extracts its keys. (The challenge seems to be fine with a list of characters in lieu of a string, asking for a "sequence of chars".)
While we could make the dictionary via a comprehension like `{c:1for c in s}`, it's one byte shorter to use the `dict` constructor as `dict(zip(s,s))`, which each character is both the key and the values. A same-length alternative is `{}.fromkeys(s)`.
Note that while `set` does also remove duplicates, it fails to keep them in order, and is also disallowed by the challenge. 
[Answer]
# Java, 79 bytes
It's java, and it may be a little bit shorter than some of the more wordy esoteric languages.
But still, java.
```
s->{String r="";for(char c:s.toCharArray())r+=(r.indexOf(c)>-1)?"":c;return r;}
```
Explanation:
```
s->{ //Lambda expression opening, note that java can infer the type of s
    String r=""; //Initializes String r
    for(char c:s.toCharArray()) //Iterates through the string
        r+=(r.indexOf(c)>-1)?"":c; //indexOf(c) returns -1 if there are no occurrences
    return r;
}
```
[Answer]
## [Befunge](http://www.esolangs.org/wiki/Befunge)-93, 124 bytes
```
v
<v1p02-1
0_v#`g00: <0_@#+1::~p
 1>:1+10p2+0g-!#v_v
g `#v_10g0^       >:10g00
 ^0g 00$        <
 ^  >:,00g1+:00p1+:1+01-\0p
```
Test it in [this online interpreter](http://www.quirkster.com/iano/js/befunge.html).
---
This was more difficult than I expected. I'll post a fuller explanation tomorrow if anyone wants me to, but here's an overview of what my code does.
* Unique characters seen so far are stored on the first row, starting from `2,0` and extending to the right. This is checked against to see if the current character is a duplicate.
* The number of unique characters seen so far is stored in `0,0` and the check-for-duplicate loop counter is stored in `1,0`.
* When a unique character is seen, it is stored on the first row, printed out, and the counter in `0,0` is incremented.
* To avoid problems with reading in the spaces present (ASCII 32), I put the character corresponding to -1 (really, 65536) in the next slot for the next unique character.
[Answer]
## C, 96 bytes
```
#include<stdio.h> 
int c,a[128];main(){while((c=getchar())-'\n')if(!a[c])a[c]=1,putchar(c);}
```
This uses an array of integers, indexed by ASCII character number. The characters are only printed if that place in the array is set to FALSE. After each new character is found that place in the array is set to TRUE. This takes a line of text from standard input, terminated by a newline. It ignores non-ASCII characters.
---
Ungolfed:
```
#include<stdio.h>
#include<stdbool.h>
int main(void)
{
  int i, c;
  int ascii[128];
  for (i = 0; i < 128; ++i) {
    ascii[i] = false;
  }
  while ((c = getchar()) != '\n') {
    if (ascii[c] == false) {
      ascii[c] = true;
      putchar(c);
    }
  }
  puts("\n");
  return(0);
}
```
[Answer]
# PHP, ~~56~~ 54
```
// 56 bytes
<?=join('',array_flip(array_flip(str_split($argv[1]))));
// 54 bytes
<?=join(!$a='array_flip',$a($a(str_split($argv[1]))));
```
Edging out @fschmengler's [answer](https://codegolf.stackexchange.com/a/59656/16410) using `array_flip` twice - second version uses variable method and relies on casting the string to true, negating it to false, then casting it back to the empty string in the first argument to save a couple of bytes in the second. Cheap!
]