text:
Type uniqchars!
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:

Input string:
Type unique chars!

Output string:
Type uniqchars!

Input string
"I think it's dark and it looks like rain", you said

Output string
"I think'sdarloe,yu

Input string
3.1415926535897932384626433832795

Output string
3.14592687

Just to double check: Does the no builtins rule mean that set objects are disallowed?

@Sp3000 Set objects are allowed. Just don't use a function or method (if it exists) that gives you its unique elements. And input/output should be strings, not set tobjects

@Sp3000 Do you think it would make it more interesting to reduce byte count by half if no set functions are used? Or better not change the rules once the challenge has been set?

I think only my answer uses sets currently, and I wouldn't mind if you changed it. However, I'm not really sure a bonus like that would change much, e.g. I doubt CJam would be doable in < 6 bytes without sets. Also, I'm not sure where the line is between a builtin which finds unique elements, and constructing a set from a number of elements...

@Sp3000 Yes, it's a blurred border. I hadn't anticipated set functions. I think I'll leave the challenge as it is now

@ThomasKwa I agree with you. In fact, when an interpreter prints a string to the screen, there's usually an implicit \n printed at the end  even if the string doesn't have it. I've notified J F

Is it allowed for the input data structure to have a different type from the output data structure, if they both are valid representations of strings of characters?

I guess if they both represent strings that's fine. But I'm confused: how can they represent strings without actually being string data type?

@LuisMendo: I mean the easiest example might be JavaScript where "abc".split("") is a data structure which represents a string without actually being one. (Some of the below answers might be able to use this to shave 10 or more bytes off!) The case that I am talking about is a lot more convoluted and appears below in my Haskell answer.

@Sp3000 I totally missed than answer. Thanks for the heads-up!

1-byte cheating Jelly solution: Q.

@EriktheGolfer Doubly cheating

@EriktheGolfer Because the language postdates the challenge and because builtin is not allowed

@LuisMendo Non-competing is not always cheating. Non-competing does not compete at all, so what sort of cheating is it?

Ah, finally a use for the pangram "Cwm fjord bank glyphs vext quiz." Or for my favorite word, Abcdefghijklmnopqrstuvwxyz

-1 Disallowing built-ins serves no purpose other than making interesting answers. This is code-golf, not popularity contests.

GolfScript, 2 bytes
.&

or, alternatively:
.|

I posted this a while ago in the Tips for golfing in GolfScript 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.

CJam, 3 bytes
qL|

Setwise or of the input with an empty list. CJam set operations preserve element order.
Try it online

I'm assuming this is valid since sets are allowed, but I'm not sure...

Very clever! I knew CJam would be one of the best, but I didn't expect just 3 bytes!

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, 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 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.

I honestly wouldn't have expected C# to be this short. Excellent job!

Uhm. I think you should submit a complete program (with static void Main etc.).

@Timwi This challenge states "Either functions or programs are allowed."

C# allows for a shorter approach, also using LINQ. I've posted a competing answer. :)

@hvd Nice one! +1

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.

I was looking for a regex to do this; I didn't realize it was so short! +1

Perl 5 + -p, 19 bytes
Saved 1 byte thanks to @kos and 1 byte thanks to @Xcali!
s/./$&x!$h{$&}++/eg

Try it online!

You could save 1 byte negating $h{$&} and using a logic AND instead of a ternary operator: s/./!$h{$&}++&&$&/eg

@kos if you'd asked me, I'd have told you that I 100% tried this and ended up with 1s in the output, but it doesn't! Thank you, updating!

Upvoted already :) I think you tried s/./$h{$&}++||$&/eg (I fell for that as well at first). Shame because that would have been another saved byte.

Got it down one more byte: Try it online!

@Xcali Nice one! Thanks!

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.

The spaces around for's expression are not necessary and you could make it anonymous function as some other solutions did: s=>[for(c of Set(s))c].join\`. (Pale update: not 100% sure, but the new` keyword seems also unnecessary.)

Wasn't sure of the rules with anon functions, and good catch on the space.

Transpiled code without new resulted in Uncaught TypeError: Constructor Set requires 'new' in Google Chrome.

Please excuse my ignorance but at what point does this filter unique values? It looks like it just converts a string to a set to an array then joins the values resulting in the original string again.

@PatrickRoberts it's the conversion to a set. A set by definition has no dupluicates

But are we sure that the conversion to Set mantains the original order?

Answering myself: yes http://www.2ality.com/2015/01/es6-maps-sets.html. And this can be made even shorter: s=>[...new Set(s)].join" or (tested in Firefox) s=>[...Set(s)].join" (21 bytes)

@edc65 Not sure why I originally went for array comprehension over the spread operator, when I use the latter far more than the former. Good catch.

Macaroni 0.0.2, 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/)

• give the language a funny and appropriate name: check

Beam, 23 18 bytes
v<H
vs)
rS
g@S
>u^

Try it online!

C# 6 - 18+46=64
using System.Linq;

and then
string f(string s)=>string.Concat(s.Union(s));

The Enumerable.Union 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.

Nice one, I was thinking of string u(string s)=>String.Join("",s.Distinct()); but that's a little bit longer.

@germi Thanks. There has been an answer using Distinct() already, but it's deleted because Distinct() is disallowed in this challenge, as it's a method specifically intended to find unique values.

Ah right... overlooked that bit ;)

Is s => string.Concat(s.Union(s)) valid? That would be the delegate passed to a Func<string, string> as an argument.

@TylerStandishMan If that's valid, I would expect more people to make use of it, and I haven't seen it before, so I don't think it is. But maybe it should be valid -- this seems like something worth checking on Meta if you're interested.

Thanks. http://codegolf.stackexchange.com/a/84285/39227 is the one place I recall seeing it, and I asked there too lol. I'll check meta

Python 2, 42 bytes
Uses a couple anonymous functions and reduce.
lambda s:reduce(lambda x,y:x+y[y in x:],s)

Try it online

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>

What does the <i?'':e part do?

It's a ternary operator. If the first instance of a character e is before the current index i, it returns an empty string, thus getting rid of the character. If that is the first instance, it simply returns e and no changes are made.

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 :)

unique not allowed, sorry! It's in the challange definition

Missed that, never mind.

Following Sp3000's answer, may I suggest setdiff with the 'stable' option?

@LuisMendo didn't help. But I found an alternative the unique which with an extra byte achieves the same thing :)

If you don't mind it saying ans= when it prints out, the disp() can also be removed saving another 6 characters.

Nice! And yes, you can remove disp because then you have a function that returns a string , which is allowed

You can also use intersect with 'stable' to achieve the same effect too.  I was going to write that, but given this answer, it's no longer original lol.

><>, 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.

.......this is brilliant. I wish I had thought of this. I'll include a Befunge version of this in my answer, but not as the primary. EDIT: On second thought, this wouldn't work because Befunge doesn't have an infinite code space. Dangit!

@El'endiaStarman I think the Beam answer also does the same thing, so unfortunately I can't say I was first :P

Ahh, yeah, I think you're right. Your explanation is clearer though.

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.

The consensus now seems to be that you can use input in Python 2, so you can make yours a byte shorter.

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

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
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.

Nitpicking: "And input/output should be strings" says Luis. "Unione reduce" returns a nested array, not a string. O:-)

You're right, adding a ∊ at the beginning to correct.

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 joins 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".

I had a similar idea but it wasn't as concise. Nice work!

35 bytes [https://tio.run/##yyrNyUw0rPj/X7HYVsPPVknJOjrzUUenn5qahp@WbaamQlp@kUKmbXGstZ/m/4KizLwSDUWlkMqCVIXSvMzC0lSF5IzEomJFJc3/AA Try it online!]

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 Xth 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.

Pyth, 7 bytes
soxzN{z

Pseudocode:
z = input
sum of order-by index in z of N over set of z.

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

Perl, 54 27 bytes
map{$h{$_}||=print}<>=~/./g
123456789012345678901234567

Test:
$ echo Type unique chars! | perl -e 'map{$h{$_}||=print}<>=~/./g'
Type uniqchars!
$

print exists($h{$_})?"":$_ → $h{$_}||print

Has SO inserted a unicode → char in there rendering it broken?

using a statement modifier would save you some bytes, along with @manatwork's suggestion $h{$_}||=print and using <>=~/./g should help save a few more as well!

No, I inserted it, with the meaning of “change to”.

Changing to map would also improve the saving:  map{$h{$_}||=print}<>=~/./g

@manatwork - many thanks, will revise.

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!

Well, since your code already isn't valid C, just accepted by lenient C compilers: you can declare r as int (and omit the int) to save some bytes: f(s,r)char*s;{...}. But it limits your code to platforms where char* is the same size as int, and of course where compilers are as lenient as yours and mine.

@hvd That's evil!  I was willing to default the return value because I don't use it. But that's a bit more dodgy than I would like to be.  I think I would prefer making it compliant rather than going that far!  Thanks for bringing back to the light side.

You can save one char by replacing if(x)y with x?y:0

Here's a 60 char function that writes to stdout instead of an array parameter:  f(char*s){int a[128]={0};for(;*s;s++)a[*s]++?0:putchar(*s);}

You can unconditionally copy into *q, and only increment q if the character appeared earlier, allowing stuffing a bit more together: void f(char*s,char*r){for(char*q=r;*q=*s;strchr(r,*s++)<q||q++);} (Note that strchr(r,*s++)<q is always well-defined, there's no UB there, because strchr cannot return NULL in this version.) Except for the return type, it's even shorter than @AShelly's version.

@AShelly a[*s]++||putchar(*s) makes it a tie.

And q+=q==strchr(r,*s++) is saving one more byte over strchr(r,*s++)<q||q++.

You guys are amazing.  I am so impressed.  I obviously have lots to learn!

Oh wait -- AShelly's version is valid C90 so can leave the return type out. My version like yours needs C99 for the declaration in the for loop, which doesn't allow omitting the return type, but C99 does allow explicitly specifying the return type as int and then not returning any value. int is shorter than void, so that saves a byte. Alternatively, the declaration in the for loop can be moved out of it, making it valid C90, and then the return type can be omitted. Also, both your version and mine would work if they modify the string in place, allowing one parameter to be removed.

@hvd Thanks for the idea about modifying in place.  I have added that.  I comes out one character shorter - hopefully I didn't miss any golfing opportunities this time..

The code of @AShelly is the shortest because all the others use strchr which requires to add the bytes of #include<string.h> to the count. Here's Ashelly's code golfed a bit more: 51 bytes

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.

<?foreach(str_split($argv[1])as$c)$a[$c]=0;echo join('',array_keys($a)); Shorter and does the same.

Found a shorter loop: while($c=$argv[1][$i++*1]). This replaces the whole foreach. Everything else is the same

I tried something similar first but refrained from it because it would stop on a character that coerces to "false", i.e. "0". Try "abc0def" as input.

You're right about it. Surelly there's a workaround for it that doesn't cost more than 2 bytes.

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[].

Haskell, 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.)

Python 3, 26 bytes
lambda s:[*dict(zip(s,s))]

Try it online!
Reviving an ancient question with a new idea, inspired by Noodle9's solution to "Special String reformatting" and my further refinement.
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.

Great explanation. I could follow it perfectly with my limited Python knowledge. Yes, any sequence of chars is fine, not necessarily a string. By the way, set operations are allowed, and in fact some answers use them. (In retrospect, forbidding builtins was not a great idea anyway. It was my first challenge, and I guess in 2015 we were more permissive with that)

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);
}

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 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!

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;

}

I know it's been about 2.5 years, but you can golf it to s->{String r="";for(String c:s.split(""))r+=r.indexOf(c)<0?c:"";return r;}, or even six bytes shorter when using Java 10 instead of 8, so both String can be var. And I'm not 100% sure it's allowed, but I think you can just input it as a String-array instead so .split("") can be removed. In total: s->{var r="";for(var c:s)r+=r.indexOf(c)<0?c:"";return r;} Try it online 58 bytes. (Or alternatively: s->{var r="";for(var c:s)r=r.indexOf(c)<0?r+c:r;return r;} Also 58 bytes.)

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.

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.

Scala, 118114 bytes
def f(a:String):String=a.zipWithIndex.groupBy(_._1.toLower).map(_._2.head).toList.sortBy(_._2).map(_._1).mkString

87 bytes if you remove the unnecessary def part and use a lambda, with infix+postfix notation.

Or 61 bytes

C, 47 bytes
a[];main(c){for(;read(0,&c,1);write(!a[c]++));}

Simplex v.0.7, 22 10  bytes
s^oR^l^Ryg
s          ~~ string input
 ^o        ~~ convert to tuple
   R       ~~ go right
    ^l     ~~ unicode tuple
      ^R   ~~ take intersection
        yg ~~ convert to string and output

sigh Minkolang is kicking Simplex's butt.
s^[oZ%_Q]n?[^_s^~M^=]]
s                      ~~ string input
 ^[     ]              ~~ postfixes each of the inner with a ^
   o                   ~~ convert to tuple
    Z                ] ~~ fold
     %                 ~~ tuple w/out current character + increment
      _                ~~ current character
       Q               ~~ membership
         n?[        ]  ~~ if current character not in tuple
            ^_s^~M^=   ~~ print that character

What a coup for Simplex!

Vim, 23 keystrokes
qq:s/\v(.).*\zs\1<cr>@qq@q

Explanation:
qq                           " Start recording into register 'q'
  :s/                        " Search and replace:
      \v                     " Enable 'magic', which just makes regexes a littl shorter
        (.)                  " Any symbol, captured in group one
           .*                " Anything
             \zs\1           " Start selection, group one
                             " Replace with nothing
                  <cr>       " Globally
                      @q     " Call macro q. Since we are still recording, this will not do anything the first time, and create a loop the next time
                        q    " Stop recording.
                         @q  " Start the loop. This will run until there is no match.

Since V is backwards compatible, you can Try it online!

05AB1E, 5 4 bytes
ʒkNQ

Try it online or verify all test cases.
Slightly more interesting previous 5 bytes version:
SkāαÏ

Try it online or verify all test cases.
Explanation:
ʒ     # Filter the characters in the (implicit) input-string by:
 k    #  Get the first index of the current character in the (implicit) input-string
  NQ  #  Check if it's equal to the filter-index
      # (after which the result is output implicitly)

S     # Convert the (implicit) input-string to a list of characters
 k    # Get the first 0-based index of each character in the (implicit) input-string
  ā   # Push a list in the range [1, list-length] (without popping)
   α  # Get the absolute difference between the values at the same positions in the lists
    Ï # Keep the characters of the (implicit) input-string at the truthy (==1) indices
      # (after which the result is output implicitly)

With builtins allowed, this would of course be a single byte: Ù
Try it online or verify all test cases.

K (ngn/k), 14 bytes
{x@&(!#x)=x?x}

Try it online!
A ngn/k implementation of the classic APL idiom for unique-ifying a list.

x?x find the indices of the first time each character appears in the input
(!#x) generate 0..n, where n is the length of the input
(...)=... build boolean list storing whether or not the first index of each character in the input is the same as the index of each character
x@& filter input to the indices where the above is true

GNU AWK, 35 34 bytes
BEGIN{RS=".|";ORS=e}!a[RT]++,$0=RT

Try it online!
This is a major edit of my first version. In fact, it changed entirely. Only works in GNU AWK, due to the RT variable.
BEGIN{RS=".|";ORS=e}

RS=".|" works like the /./ regex, so every character of the input is considered a record separator. The practical use is that RT returns each character at a time. ORS=e prevents newlines from appearing.
!a[RT]++,$0=RT

A simple AND gate. This is a range pattern. The left part: current RT element of the a array is incremented by 1, but it is evaluated by the NOT gate before the increment. Returns TRUE only the first time a character appears. The right part: assigns the current character (RT) to the input/output $0; only happens when beginning pattern is true, i.e., the first time a character appears.
AWK, 48 bytes (former answer)
split($0,a,e){for(i in a)printf a[j=a[i]]++?e:j}

Try it online!
{
split($0,a,e); # Splits the input into the _a_ array, one char for each element.
               # _e_ variable is not assigned, and returns "".

for(i in a)            # For each element _i_ of the array _a_,
  printf
         a[j=a[i]]++?  # if the element a[i] (AKA j) is positive (i.e, true),
                  ^--- (This also increments this element by 1 after evaluating it)
                   e:  # prints _e_ (AKA "")
                   j   # if it's zero (AKA not assigned, AKA false), prints a[i].
}

You can shave off one ; by moving the split($0,a,e) to the left of the {.

@cnamejj - you're right! Thanks for the tip.

i386 machine code, 22 21 bytes
Machine code:
00000034  6a 20 59 6a ff e2 fc 91  ac d0 2c 04 71 01 aa e2  |j Yj......,.q...|
00000044  f7 83 ec 80 c3                                    |.....|
00000049

Commented assembly:
        .intel_syntax noprefix
        .globl .type_uniqchars
        // dst: EDI: output buffer (must be big enough)
        // src: ESI: input string
        // len: EAX: length of string
.type_uniqchars:
        // Set ECX to 32
        push    32
        pop     ecx
        // Create a 128 byte buffer on the stack of all 1 bits
        // by pushing -1 32 times.
        // We only need 128 bytes because we know that
        // we are only dealing with ASCII.
.Lpush_loop:
        push    -1
        loop    .Lpush_loop
.Lpush_loop.end:
        // ECX = len
        // EAX = 0 (because of the loop)
        xchg    ecx, eax
.Lloop:
        // AL = *src++;
        lodsb   al, byte ptr [esi]
        // This is taking advantage of this quirk with SHR:
        //
        //   The OF flag is affected only on 1-bit shifts [...]
        //   For the SHR instruction, the OF flag is set to the
        //   most-significant bit of the original operand.
        //
        // So basically, we do this:
        //
        //     unique     duplicate
        //   0b11111111  0b01111111
        //     |\\\\\\\    |\\\\\\\
        //  OF:1||||||| OF:0|||||||
        //   0b01111111  0b00111111
        //
        // I chose this over INC+JNZ because this will never
        // overflow: it will just stay at zero.
        shr     byte ptr [esp + eax]
        // No overflow means duplicate
        jno     .Lloop.duplicate
.Lloop.unique:
        // *dst++ = AL
        stosb   byte ptr [edi], al
.Lloop.duplicate:
        // Loop while there is still data
        loop    .Lloop
.Lloop.end:
        // Clean up the stack and return.
        // Note that sub esp, -128 is smaller than add esp, 128.
        sub     esp, -128
        ret

Try it online!
char *.type_uniqchars(char *dst {edi}, const char *src {esi}, size_t len {eax})

src is a pointer to the input string
dst is a pointer to an output buffer, it must be large enough
len is the length of src in bytes.

A pointer one byte past the end of the output string will be returned in edi. However, in the test code, I just null terminate because it is easier to print that way.
Doesn't follow standard calling convention, hence the leading dot.
Explanation (see comments for more)
This uses a lookup table on the stack, which is set to -1. It is 128 bytes because we are only dealing with ASCII.
Then, this magic is used:
        shr     byte ptr [esp + eax]
        jno     .Lloop.duplicate

This uses the fact that a one bit shr will put the most significant bit in the overflow flag. The first time, the overflow flag will be set since all bits are set, but then that most significant bit will be shifted out.
Unlike something like this:
        inc     byte ptr [esp + eax]
        jnz     .Lloop.duplicate

You could run this 1, 10, 100000 times, and it will never fail. That inc solution will fail after 256 duplicates as it wraps around to zero. Shifting right will just end up at zero and stay there indefinitely.
Other than that, it is a pretty straightforward string copy routine.

C - 88 Bytes
r[99];b;a;main(i){for(;read(i=0,&b,1);99-i?b=0:putchar(r[a++]=b))for(;i<99&&b-r[i++];);}

Thanks to @ceilingcat because I saved 20 bytes with his modification.
Ungolfed
r[99]; b; a;

main(i) {
    for(; read(0, &b, 1); 99 - i?b = 0: putchar(r[a++] = b))
       for(i = 0; i < 99 && b - r[i++]; ); }

Explanation
Characters are read from the console, which are searched for within a list containing all the repeated characters found so far, as the characters are read, the list is updated, with new characters being added at the end of the list. If a character is repeated it is not printed.
This code was tested on GCC and it generates some warnings but it compiles and works fine (although it is not the most optimized code).

Vyxal, 2 bytes
ƒ∪

Try it Online!
Reduce by set union. Port of caird's answer.
Vyxal, 3 bytes
ÞU*

Try it Online!
Multiply by uniquify mask.

ngn/k (2 bytes)
!=

= produces a dict that shows where each element is located, ! takes the keys.

Matlab, 46 bytes
It uses an anonymous function, with function arguments as input and output:
@(s)eval('s(~any(triu(bsxfun(@eq,s,s''),1)))')

(I couldn't get this to work in an Octave online interpreter.)
Example use:
>> @(s)eval('s(~any(triu(bsxfun(@eq,s,s''),1)))')
ans =
    @(s)eval('s(~any(triu(bsxfun(@eq,s,s''),1)))')

>> ans('Type unique chars!')
ans =
Type uniqchars!

that would have been my idea as well :) - you don't need the ,1 with any, btw.

@Jonas Thanks! Alrhough it's hard to see through that mess of parentheses, the 1 is for triu  (I need to remove the diagonal), not for any

AutoIt, 107
Func _($0)
$1=''
For $2 In StringSplit($0,'',3)
$1&=StringInStr($1,$2,1)?'':$2
Next
Return $1
EndFunc

Call it like any function:
ConsoleWrite(_("Type unique chars!"))

CJam, 9
Lq{1$-+}/

This doesn't convert a string to a set, but it performs a kind of set difference to determine whether a character is found in a string. Try it online
Explanation:
L       push an empty array/string
q       read the input
{…}/    for each character in the input
  1$    copy the previous string
  -     subtract from the character (set difference),
         resulting in the character or empty string
  +     append the result to the string

Another version, 13 bytes:
Lq{_2$#)!*+}/

This doesn't do anything related to sets. Try it online
Explanation:
L       push an empty array/string
q       read the input
{…}/    for each character in the input
  _     duplicate the character
  2$    copy the previous string
  #)    find the index of the character in the string and increment it
  !     negate, resulting in 0 if the character was in the string and 1 if not
  *     repeat the character that many times
  +     append the result to the string

Powershell, 30
$args-replace'(.)(?<=\1.+)',''

I feel there's likely to be a better regex than this, and I can't work out what it is

-creplace of course. Try it online!

SED, 61 bytes
s/^/\a/
:
s/\a\(\(.\).*\)\2/\a\1/
t
s/\a\(.\)/\1\a/
t
s/\a//

2 characters shorter: s/\a\(.\)\(.*\)\1/\a\1\2/ → s/\a\(\(.\).*\)\2/\a\1/. If you have GNU sed you can remove the parenthesis escaping at the price of +1 for the -r switch.

@manatwork: Nice, changed. (I could also shrink all \a sequences into a single unprintable BEL character, though I'm not sure it's really worth it)

Haskell, 50
f=concat.(tail>>=zipWith(\x y->[last x]\\y)).inits

inits is in Data.List, so you need an import, which is usually added to the byte count.

Delphi, 111 bytes
procedure u(var s:string);var i:word;begin for i:=length(s) downto 1 do if pos(s[i],s)[...s].map(c=>s[c]?'':s[c]=c,s=[]).join``

Unexpectedly, this time the flag array is one byte shorter than the indexOf approach.

.map(c=>s[c]?'':s[c]=c,s=[]) => .map(s=c=>s[c]?'':s[c]=c)

Haskell, 33 bytes
foldl(\r c->r++[c|notElem c r])[]

Uses foldl to iterate through the string appending characters that are not in the current result, starting with the empty string (list).

Perl 5.10+, 21 bytes
perl -pe '1while s/(.).*\K\1//'

20 bytes + 1 byte for -p. Note that Perl 5.10 or above is required for \K.
Takes input from stdin:
$ echo 'Type unique chars!' | perl -pe '1while s/(.).*\K\1//'
Type uniqchars!

$ echo \"I think it\'s dark and it looks like rain\", you said | perl -pe '1while s/(.).*\K\1//'
"I think'sdarloe,yu

$ echo 3.1415926535897932384626433832795 | perl -pe '1while s/(.).*\K\1//'
3.14592687

Online demo

Inspired by NinjaBearMonkey's Retina answer. Perl may not have a compact way to re-run a substitution until nothing changes, but it does have \K, which causes the regex engine to "keep" everything to its left. This allows you to drop a set of parentheses on the LHS and a capture variable on the RHS:
s/(.).*\K\1//   # 13 bytes

vs.
s/((.).*)\2/$1/ # 15 bytes

Save 1 byte using s/(.).*\K\1//&&redo

Minkolang 0.10, 13 bytes
This language was made after this challenge but not for this challenge.
Much thanks to Sp3000 for pointing me the way to this much shorter solution.
od?.dd0q?Od0p

Try it here.
Explanation
od               Read character from input and duplicate it (for the conditional)
  ?.             Stop if 0 (i.e., input is empty)
    dd           Duplicate twice (for q and for possible output)
      0q         Gets value stored in (character,0) in the codebox (0 if empty)
        ?O       Outputs character if it's unique (i.e. the previous value was 0)
          d0p    Puts the value of the character at (value,0) in the codebox

AppleScript, 143 142 Bytes
set x to(display dialog""default answer"")'s text returned's characters
set o to""
repeat with i in x
if not i is in o then set o to o&i
end
o
Not a language for golfing, but it's very readable.

Octave, 25 bytes
@(s)s(sum(triu(s'==s))<2)

Javascript (ES6), 47 bytes
a=>[...a].filter((b,c)=>a.indexOf(b)==c).join``

Test it here
Some code is added to have a better input and to write to the console the result.

d=document,g=d.getElementById.bind(d);g("s").onclick=e=>console.log((a=>[...a].filter((b,c)=>a.indexOf(b)==c).join``)(g("t").value))
<input id="t"><button id="s">Convert</button>

Ruby, 19 + 1 = 20 bytes
Uses the -p flag. Uses set operations like the GolfScript answer, which is totally not a built-in like uniq. (Performing set or on a list and an empty list purges the list of duplicates, just like calling and against a copy of itself.)
$_=($_.chars|[])*""

Jelly, 3 bytes
œ|/

Try it online!
Simply reduces by set union
Slightly more creative, but relies on "unique sieve" functions not being banned:
xŒQ

Try it online!
How it works
xŒQ - Main link. Takes a string S on the left
 ŒQ - Unique sieve; For each character in S, replace it with 1 if it hasn't occurred yet, else 0
x   - Repeat each character in S according to the corresponding value in the sieve
    - Implicitly print, mashing empty strings into the output

Pyth, 8 bytes
s.gxQk.|

Try it online!

Bitwise Or the input
Group the input by:
It's index in the original input
Join list and print.

MUMPS, 54 bytes
f(s) f i=1:1:$L(s) s c=$E(s,i) s:t'[c o=o_c,t=t_c
    q o

Not terribly exciting - it just keeps a running list of already-viewed characters and only appends to the output string if the current character isn't in that list.

Ceylon, 98 bytes (stdio) / 69 bytes (function)
This version is using stdio and a HashSet, 98 bytes:
import ceylon.collection{H=HashSet}shared void u(){print(String(H{*(process.readLine()else"")}));}

This is just a function String → String (also using a HashSet), 69 bytes:
import ceylon.collection{H=HashSet}String n(String i)=>String(H{*i});

Ungolfed version:
import ceylon.collection {
    HashSet
}
void uniq() {
    value input = process.readLine() else "";
    value set = HashSet { elements = input; };
    print(String(set));
}

A Ceylon HashSet by default is linked (i.e. conserves the insertion order as iteration order). We use here the named-argument syntax to pass the elements argument to the HashSet constructor.
A string is also an iterable of characters, and as such can be passed to the elements parameter. A string can also be constructed from such a sequence, which is what we do in the last command.
The golfed version again:
import ceylon.collection{H=HashSet}shared void u(){print(String(H{*(process.readLine()else"")}));}
Some used tricks:

Variable inlining
If we have to import HashSet anyways, give it a shorter name.
The named-argument syntax accepts also a "normal" argument list. Any arguments in that list will be, if they don't fit the other arguments, be wrapped in an Iterable and passed to an Iterable argument (if there is one). To spread our existing iterable (the input string) into such an argument list, we use the "spread operator *".

If we don't have to handle standard-input and output and just need a function, this is shorter:
import ceylon.collection{HashSet}
String n(String i) => String(HashSet{*i});

The explanations from above are still valid.

Ceylon, 98 bytes (stdio) / 68 bytes (function)
Here is a version without using Set or similar stuff, as a function (68 bytes):
String i(String s)=>String{for(x->c in s.indexed)if(!c in s[0:x])c};

The same with stdio (reading just one line) (98 bytes):
void q(){value s=process.readLine()else"";print(String{for(x->c in s.indexed)if(!c in s[0:x])c});}

The first one ungolfed (117 bytes):
String i(String s) => String{
        for (x->c in s.indexed)
            if (!c in s[0:x])
                c
    };

This uses the feature to build a string from an iterable of characters, but this time the iterable is build from a comprehension, which is passed to the string-constructor using the named-argument-list syntax. (This could also have been written as String({...});, using a positional argument list and an iterable-constructor, but that would have been two bytes more).
The comprehension consists of a for-clause (which iterates over an indexed version of the input string, i.e. x is the index corresponding to the character c) and an if-clause (which filters the character by checking if it appears in the substring up to the index).
We see here two different uses of the keyword in – once as part of the syntax of the for clause of comprehensions, and once as the in operator, which maps to s[0:x].contains(c).
The "thin arrow" in x->c is the syntax for an Entry made of x and c (as key and value). As an expression one can build an entry this way from its constituents, but here it is a part of the comprehension syntax (and also the syntax of the for-loop), and deconstructs the entry which is returned by the iterator of the iterable s.indexed.
The "fat arrow" => is a shorthand for defining a function whose body consists of just one expression (which is evaluated and returned) – that saves us the return and a pair of braces.
The variant which uses stdio:
void q() {
    value s = process.readLine() else "";
    print(String { for (x->c in s.indexed)
                if (!c in s[0:x])
                    c });
}

Unfortunately we need a variable here to store the string, because we need to access it twice (in the loop and in the filter).

Instead of using an Iterable comprehension, we can also use the stream-manipulating method filter together with the spread attribute operator *. and a lambda expression (e)=>!e.item in s[0:e.key] inbetween:
String j(String s)=>String(s.indexed.filter((e)=>!e.item in s[0:e.key])*.item);

This is even longer with 79 bytes.

Rust, 318 Bytes
not really a competitor, but rust needs a bit more love. As always, comments and advice welcome.
use std::io;fn main(){let mut s=io::stdin();let mut b=String::new();s.read_line(&mut b).unwrap();let mut n: Vec<char>=b.chars().collect();for i in 0..n.len()-2{let mut j=i+1;let mut p = true;while j<n.len(){if j<n.len(){if n[i]==n[j]{n.remove(j);p=false;}}if p{j+=1;}p=true;}}for i in 0..n.len()-2{print!("{}",n[i]);}}

Try it online here (first compile, then execute, then click into the proper area to enter user input)
ungolfed:
use std::io;
fn main() {
let mut s = io::stdin();
let mut b=String::new();
s.read_line(&mut b).unwrap();
let mut chars: Vec<char> = b.chars().collect();
for i in 0..chars.len()-2 {
    let mut j=i+1;
    let mut inc = true;
    while j<chars.len() {
        if j<chars.len()
        {
            if chars[i]==chars[j] {
                chars.remove(j);
                inc = false;
            }
        }
        if inc {
            j+=1;
        }
        inc = true;
    }
}
for i in 0..chars.len()-2 {
    print!("{}",chars[i]);
}
}

Python 2, 62 bytes
s=set();print filter(lambda i:not(i in s or s.add(i)),input())

Python, 62 bytes
lambda s:''.join([c for i,c in enumerate(s)if c not in s[:i]])

It's scored by size in bytes, I'll just edit it so its right... Also, you can move the space between the : ''.join so it's like :''.join

I don't think you need the outer square brackets.

Python 3, 132 109 105 bytes
u=[]
def t(l):
 if l in u:return''
 else:
  u.append(l);return l
print(''.join([t(l)for l in input()]))

Ungolfed:
used_chars = []
def test(letter):
    if letter in used_chars:
        return '' # skip
    else:
        used_chars.append(letter)
        return letter
print(''.join([test(letter) for letter in input()]))

Shouldn't the r(l) in the last line be t(l)?

Also, you can use print if you end the line with a comma: print ('%s') % (''.join([r(l)for l in i])), then import sys won't be necessary.

Following Thomas Kwa's suggestion, one trailing \n is acceptable in stdout (in fact it's implicit in many functions used for displaying into stdout). I've made this explicit in the challenge rules. You may perhaps use that to reduce your code length

Python 2, 79
def S(s):
 s=s[::-1]
 for c in s:s=s.replace(c,'',s.count(c)-1)
 return s[::-1]

It reverses the input string, cycles through it, replaces any extra characters with null ones and returns the reverse of that. The reverse is so the last characters are removed, not the first.
>>> S('''"I think it's dark and it looks like rain", you said''')
'"I think\'sdarloe,yu'
>>> S("3.1415926535897932384626433832795")
'3.14592687'
>>> S("Type unique chars!")
'Type uniqchars!'

68 bytes

Scala, 79, 66 bytes
Inspired by the Haskell version using foldLeft
def f(s:String)=s.foldLeft("")((a,c)=>if(a.contains(c))a else a+c)

Previous version using zipWithIndex and collect
def f(s:String)=s.zipWithIndex.collect{case(c,i)if s.indexOf(c)==i=>c}.mkString

Perl 6, 32 bytes
The way you would normally write this would be:
$*IN.comb.unique.print # it would have been 22

Which would have had the benefit of being obviously correct.

Instead I have to write something like the following
print $*IN.comb.grep:{!.{$^a}++} # 32

Gema, 18 characters
?=${?;$0}@set{$0;}

Sample run:
bash-4.3$ gema '?=${?;$0}@set{$0;}' <<< 'hello world'
helo wrd

R, 52 bytes
cat(union(a<-strsplit(readline(),"")[[1]],a),sep="")

Test examples:
Type uniqchars!
"I think'sdarloe,yu
3.14592687

RProgN, 85 Bytes
S i 'a' = s 'n' = a L while a pop 'b' = n b hasvalue ! if n b push end a L end n i ++

Explanation
S i                     # Take the implicit string input, convert it to a stack such that the first letter is at the bottom, invert the stack such that the first letter is at the top.
'a' =                   # Associate it with 'a'
s 'n' =                 # Create a new stack, associate it with 'n'
a L                     # Push the size of a
while                   # While the top of the stack contains a truthy value
    a pop 'b' =         # Pop the top of a, associate it with 'b'
    n b hasvalue !      # Push if the stack 'n' does not contain b
    if                  # If the top of the stack is truthy
        n b push        # Push b to the stack n
    end                 #
    a L                 # Push the length of a
end                     # loop
n i ++                  # Push the n, inverts it, sums it, which acts to concatenate it, implicitly print the result.

REXX, 79 bytes
a=arg(1)
o=
do while a>''
  parse var a b+1 a
  if pos(b,o)=0 then o=o||b
  end
say o

Python, 61 59 bytes
lambda s:''.join(i for c,i in enumerate(s)if s.index(i)==c)

str.index always returns the first occurrence, so only output the character if the current occurrence is the first occurrence.
Edit: The square brackets were unnecessary.

PHP, 47 Bytes
for(;a&$c=$argn[$i++];)$r[$c]=$c;echo join($r);

Try it online!

sed -E, 21 bytes
:L;s/((.).*)\2/\1/;tL

Try it online!

Stax, 5 bytes
╤•╗jP

Run and debug it

Red, 23 bytes
func[s][union/case s s]

Try it online!
Using a map!, 58 bytes
func[s][m: copy #()foreach c s[put m c c]rejoin keys-of m]

Try it online!
A naive  implementation, 69 bytes
func[s][rejoin collect[foreach c s[unless find collected c[keep c]]]]

Try it online!

Lexurgy, 30 bytes
Due to how Lexurgy handles whitespace, it expects whitespace to be replaced with some other character, such as _.
a propagate:
[]$1=>*/$1 []* _

Explanation
a propagate:        # rule a: while the current string changed last run...
[]$1                # match anything...
    =>              # and replace with...
      *             # empty string
       /            # when the input...
        $1          # starts with the captured char
          []*       # followed by any number of anything
             _      # then a captured char

Lua, 70 bytes
l={}print(((...):gsub('.',function(c)c=l[c]or c;l[c]=''return c end)))

Attempt This Online! Stores the characters in the table after gsub walks through the whole string. Strings are truthy values in Lua so when list[character] is nil, the character is returned the first time then it is replaced with an empty string after the assignment.

nanoMIPS machine code, 34 bytes
00000000: 80 1c a0 d3 fc 90 a7 23 87 04 80 bb c0 5f 89 90  .......#....._..
00000010: a7 23 07 30 00 bb a7 23 87 38 d4 5f a9 90 80 bb  .#.0...#.8._....
00000020: 80 1d                                            ..

Commented assembly:
    .globl uniqchars
    # Type uniqchars! for nanoMIPS, Yet Another Weird MIPS Extension
    # Follows C calling convention
    #    void uniqchars(const char *input, char *output);
    # Input:
    #    a0: pointer to a null terminated ASCII string
    #    a1: pointer to an adequately sized buffer
    # Output:
    #    Null terminated ASCII string stored to a1
uniqchars:
    # Create a 128 byte stack buffer for a lookup table
    # Equivalent normieMIPS:
    #  addiu $sp, -128
    save     128
    # Clear the buffer
    li       $a3, 128 / 4
.Lclear:
    # Decrement index
    addiu    $a3, -4
    # Behold! MIPS finally added register-register addressing!
    # And only like 31 years late!
    #  addiu $at, $sp, $a3
    #  sw    $zero, ($at)
    swx      $zero, $a3($sp)
    # Loop if not zero
    bnez     $a3, .Lclear
    # Loop through the string
.Lloop:
    # Load byte from a0
    lb       $a3, ($a0)
    # Increment pointer
    addiu    $a0, 1
    # Load byte from lookup table
    lbx      $a2, $a3($sp)
    # If it is nonzero, this char is not unique. Try the next one.
    bnez     $a2, .Lloop
    # Store the char itself to the lookup table
    sbx      $a3, $a3($sp)
    # Store the char to the output string
    sb       $a3, ($a1)
    addiu    $a1, 1
    # Loop if it was not a null terminator
    bnez     $a3, .Lloop
    # Clean up the stack and return
    #  addiu $sp, 128
    #  jr    $ra
    restore.jrc 128

This uses the new nanoMIPS calling convention, and can be called from C with the following prototype:
void uniqchars(const char *input, char *output);

Yes. This is the third compressed variant of the MIPS instruction set. All three of which are incompatible.

 At least it golfs decently.

Aside from a few "hybrid instructions" added, it is just normal MIPS in shorthand.
A GCC toolchain, QEMU port, and documentation links are in the link above. Note that for some reason the Windows port lacks qemu-nanomips and both Linux and Windows versions crash on my system unless I run it in qemu-x86_64 itself.

Thunno 2 J, 1 byte
ċ

Attempt This Online!
Takes the set union with itself (set operations were allowed by OP).
Thunno 2 J, 11 bytes
{DȤsƇ¬?ȥ;}Ȥ

Attempt This Online!
A different answer that doesn't use sets.
Explanation
{DȤsƇ¬?ȥ;}Ȥ  # Implicit input
{        }   # For each character in the input:
 D           #  Duplicate it
  Ȥs         #  Push the global array and swap
    Ƈ¬?      #  If it's not in the global array:
       ȥ;    #   Add it to the global array
          Ȥ  # After the loop, push the global array
             # Implicit output, joined

Rockstar, 126 bytes
Listen to I
Cut I
O's ""
While I
Roll I in C
X's 0
P's 1
While O at X
If C's O at X
P's 0

Build X up

If P
Let O be+C

Say O

Try it (Code will need to be pasted in)
Or, if we can output each character individually, on a separate line ...
124 bytes
Listen to I
Cut I
O's ""
While I
Roll I in C
X's 0
P's 1
While O at X
If C's O at X
P's 0

Build X up

If P
Let O be+C
Say C

Z80Golf, 13 bytes
00000000: cd 03 80 38 04 26 ff 6f cb 76 74 c5 c0           ...8.&.o.vt..

Try it online!
Commented assembly:
start:
.loop:
    call  0x8003         ; CD 0380  Read from stdin to A, C is success
    jr    c, .end + 1    ; 38 04    Jump to the 76 in the middle of the bit opcode to halt
    ld    h, 0xFF        ; 26 FF    HL = 0xFFxx
    ld    l, a           ; 6F       HL = 0xFF00+A, address + offset of LUT
.end:
    bit   6, (hl)        ; CB 76    Test bit 6 of the table
    ; halt               ;   (76)      Exit the program with halt (overlaps)
    ld    (hl), h        ; 74       Mark the LUT to 0xFF
    push  bc             ; C5       Push address of .loop for ret (BC is 0x0000)
    ret   nz             ; C0       If bit 6 was set (not unique), ret to .loop
                         ;          otherwise fall through to putchar

This uses the LUT method in my other answers. However it is much easier on Z80Golf because I know the full state of the machine and can optimize for it.
Specifically, I know that the 128 bytes at 0xFF00-0xFF7F will be 0, so I can use that by setting the high byte of HL and the low byte of A.
There are some weird optimizations to make this smaller. I could get 0xFF in h in one byte by dec h, but that introduces a state I have to check. Instead, I suck up the byte for ld h, 0xFF in favor of the entire program being stateless outside of the table. Then, I can use push bc followed by ret nz to loop if nonzero or fall through the nop sled to putchar otherwise.


text:
A Bit of a Pickle
Python's pickle module is used for serialisation, allowing one to dump an object in a way such that it can be later reconstructed. For this, pickle uses a simple stack-based language.
To keep things simple, we will be dealing with a small subset of this language:
(              Push a mark to the stack
S'abc'\n       Push a string to the stack (here with contents 'abc')
l              Pop everything up to the last mark, wrapping all but the mark in a list
t              Pop everything up to the last mark, wrapping all but the mark in a tuple
.              Terminate the virtual machine

Your task is to implement this subset of the language. Note that \n is a literal newline here, and newlines are actually important to the language.
For those familiar with GolfScript or CJam-like languages, ( and l/t operate similarly to [ and ] respectively.
Input
To keep things simple, the input will always be valid. In particular, you may assume the following about the input:

Strings will only consist of lowercase letters and spaces [a-z ], and will always use single quotes.
There will be no extraneous characters, with all instructions being as specified above. For example, this means that newlines will only ever occur after strings.
Every l/t has a matching ( before it and every ( has a matching l/t after it. There will also be at least one (.
There will be exactly one ., and it will always be the final character.

You may take input via command line, STDIN or function argument. You may use a single newline-escaped string instead of a multiline string if you wish, but please specify this in your answer.
Output
Output should be a representation of the final object, printed to STDOUT or returned as a string. Specifically:

Strings are represented by opening and closing single quotes with content in between, e.g. S'abc' -> 'abc'. You may not use double quotes for this challenge, even though they are allowed in Python.
Lists are represented by comma-separated elements surrounded by [] (e.g. ['a','b','c']), while tuples are repsented by comma-separated elements surrounded by () (e.g. ('a','b','c')).
Spaces don't matter, e.g. ('a', 'b',  'c' ) is okay.
You cannot have a comma before the closing bracket. Note that this is intentionally different from Python syntax rules to make things easier for most languages, and also to make it harder to simply build the list/tuple in Python then output it, due to how the single-element tuple is represented (for this challenge, we need ('a') as opposed to ('a',)).

Examples
The above text might seem daunting, but the following examples should make things a bit clearer.
(l.

Possible output: []
(t.

Possible output: ()
(S'hello world'
l.

Possible output: ['hello world']
(S'string one'
S'string two'
S'string three'
t.

Possible output: ('string one', 'string two', 'string three')
(S'a'
(S'b'
S'c'
lt.

Possible output: ('a',['b','c'])
((S'a'
S'b'
(lS'c'
t(S'd'
tl.

Possible output: [('a', 'b', [], 'c'), ('d')]
((S'a'
((S'b'
t(S'c'
lS'd'
(((ltlS'e'
S'f'
lS'g'
tl.

Possible output: [('a',[('b'),['c'],'d',[([])],'e','f'],'g')]
Rules

This is code-golf, so the code in the fewest bytes wins.
Any functionality that is designed to work with Python pickles is not allowed.

Security note: In real code, only unpickle from sources you trust, or else you might get a nasty cos\nsystem\n(S'rm -rf'\ntR. surprise

Does S'abc'\n push abc or 'abc'?

CJam, 63
q{"Slt 1:T;L ]',*'[\+']+ ]',*'(\+')+ [
 0:T; C+"35/T=S/(C#=~}fC

Try it online
Explanation:
q        read the input
{…}fC    for each character C in the input
  "…"    push that long string, containing code to handle various cases
  35/    split it into (two) parts of length 35
  T=     get the T'th part; T is 1 when parsing a string and 0 otherwise
          (T is initially 0 by default)
  S/     split by space into an array of strings
  (      take out the first item (containing special characters to check)
  C#     find the index of C in that string
  =      get the corresponding string from the array
          (when C is not found, # returns -1 which gets the last array item)
  ~      execute that string

Now the long string with various pieces of code. Each part has a few characters to check and then a block for handling each one, and the default case.
First part: Slt 1:T;L ]',*'[\+']+ ]',*'(\+')+ [
Slt      special characters to check
######## first block, corresponding to character 'S'
1:T;     set T=1, causing the next characters to be processed with the 2nd part
L        push an empty string/array, which will be used to collect the string
######## second block, corresponding to character 'l'
]        end array
',*      join with commas
'[\+     prepend a '['
']+      append a ']'
######## third block, corresponding to character 't'
]        end array
',*      join with commas
'(\+     prepend a '('
')+      append a ')'
######## last block, corresponding to other characters (practically, '(' and '.')
[        start array

Second part: (newline) 0:T; C+
newline  special characters to check (only one)
######## first block, corresponding to newline
0:T;     set T=0, switching back to the first part
######## last block, corresponding to any other character (including apostrophe)
C+       append the character to the collecting string

Perl, 149 bytes
I have a bad feeling that this is a poor attempt, but here goes:
$/=$,;$"=",";@s=[];/^\(/?$s[@s]=[]:{$p=/S(.*')/?$1:/l|t/?($l="@{pop@s}")|/l/?"[$l]":"($l)":0,push@{$s[-1]},$p}for<>=~/([(lt]|S.*?\n)/g;print$s[0][0];

The script has to be saved in a file and it takes input from STDIN.
Explanation:
# Set the input record separator to undef so that <> reads all lines at
# once
$/=$,;
# Ensure that elements of lists printed in quotes are separated by commas
$"=",";

# The stack. Initialise the bottom element with an empty array
@s=[];

# Tokens are extracted in the for loop a few lines below. Copied here for
# clarity: Read the entire input and iterate over all valid tokens of the
# pickle language
# for <>=~/([(lt]|S.*?\n)/g;
# the token is a mark - push an empty array to the stack
/^\(/ ? $s[@s]=[]
      # token is a string, push it inside the stack top
      : {$p=/S(.*')/ ? $1
                     # otherwise, remove the top and create list or tuple
                     # from it and push it inside the top element
                     : /l|t/ ? ($l="@{pop@s}") | /l/ ? "[$l]"
                                                     : "($l)"
                             : 0 # dummy value
                             # pushing of the string/list/tuple actually
                             # happens here
                             , push@{$s[-1]},$p}
# read the entire input at once and iterate over all valid tokens
for <>=~/([(lt]|S.*?\n)/g;

# in the end, the bottom element of the stack will be an array with just one
# element which is the string representation of the object
print$s[0][0];

><>, 88 bytes
^"][">}r]
~rl?!;o11.
^0\!\
 &</\?[1&~?=1l","
 1/\ii:"'"=?v44.
>i9%0$.     >r]i~

 ")("\

Fun with jumps! Uses the fact that the ASCII codes for the 5 main commands involved, mod 9, are:
S -> 2
l -> 0
t -> 8
( -> 4
. -> 1

This allows each operation to be handled on its own line, which will be jumped to directly. Also uses the stack of stacks to construct each string and nested list/tuple separately before wrapping them in the required characters.

Nice work, but unfortunately I don't seem to be getting the right output for most of the test cases (the brackets seem to be the wrong way around, for one thing)

Julia + ParserCombinator.jl 306 240
With my latest set of revisions I no longer think a pure julia solution would be shorter.
using ParserCombinator
v=join
j(t)=v(t,",")
a=Delayed()
s=E"S'"+Star(p".")+Drop(Equal("'\n"))|>x->"'$(v(x))'"
i=Star(a)|E""
l=E"("+i+E"l"|>x->"[$(j(x))]"
t=E"("+i+E"t"|>x->"($(j(x)))"
a.matcher=s|l|t
f(x)=parse_one(x,a+E".")|>first

That was interesting.
I think the coded is fairly eloquent.

Output formatting is done at generation
a l, i, t, and s are basically CFG rules
f is the function that is called it brings it all together.
the Drop(Equal("'\n")) is annoying -- that would ideally be written as E"\n" but the E string macro does not handle escape sequences.
Interestingly this can trivially be converted to returning julia data-structures, it is basically removing the transforms on the RHS of |>s and adding tuple for the t rule

Unfortunately, per the rules in our help center, golfing is a requirement for posting solutions to code golf challenges.

I'm not 100% I can do an a shorter one, however. This is golfed to the exent that any solution using this langauge/library combination "Julia + ParserCombinator.jl" can be golfed.
But on the other hand, there is solid change that there is a shorter pure julia solution.... now I have to write it.

You don't have to write an entirely different solution; getting the most out of your approach is enough. At least the comments should be removed though.

I didn't count the comments (or blank lines) towards the byte-count.
I figured that was convention, I guess I figured wrongly

Yes, the code is scored as posted. You can always add an ungolfed/annotated version though.

Neat solution. As far as golfing it goes, I think you can at least save four bytes by using b inline rather than defining it. The same can probably be done with s, l, and t, at the cost of parentheses.

@JulianWolf  The b for sure. the s l  and t I guess so yes, it might save a couple of bytes. Depends how many based on how tightly | binds. I'd need to check.
I just worked out how to save 66. So I'll be back maybe to play with this later.

JavaScript (ES6), 199 bytes
s=>(q=x=>(o=[],x.slice(0,-1).map(v=>o=[...o,v.map?q(v):`'${v}'`]),x.pop()<"m"?`[${o}]`:`(${o})`),q(eval(s[r="replace"](/\(/g,"[")[r](/[tl](?![\w ]+'\n)/g,"'$&'],")[r](/S('.+')/g,"$1,").slice(0,-2))))

Runs several regex replaces on the input to turn it into valid JS code, then parses that.
Test Snippet

f=
s=>(q=x=>(o=[],x.slice(0,-1).map(v=>o=[...o,v.map?q(v):`'${v}'`]),x.pop()<"m"?`[${o}]`:`(${o})`),q(eval(s[r="replace"](/\(/g,"[")[r](/[tl](?![\w ]*'\n)/g,"'$&'],")[r](/S('.+')/g,"$1,").slice(0,-2))))
<select oninput="I.value=this.selectedIndex?this.value.replace(/\\n/g,'\n'):'';O.innerHTML=this.selectedIndex?f(I.value):''"><option>---Tests---<option>(l.<option>(t.</option><option>(S'hello world'\nl.<option>(S'string one'\nS'string two'\nS'string three'\nt.<option>(S'a'\n(S'b'\nS'c'\nlt.<option>((S'a'\nS'b'\n(lS'c'\nt(S'd'\ntl.<option>((S'a'\n((S'b'\nt(S'c'\nlS'd'\n(((ltlS'e'\nS'f'\nlS'g'\ntl.</select>

<textarea rows=10 cols=20 id=I></textarea>
<button onclick="O.innerHTML=f(I.value)">Run</button>

source: Stack Exchange

license: Creative Commons - Attribution Share-Alike - https://creativecommons.org/licenses/by-sa/3.0/

sort: votes


text:
Theme of my birthday: up in flames
I need to light some candles. In fact, I need to light an arbitrary amount of candles. But only the good ones.
OBJECTIVE Given a block of text (containing lit, valid, and invalid candles) and a number N as input, write a program or function that lights an amount exactly equal to N, minus the number of already-lit candles. If N is greater than the number of valid candles, the program should print the number of missing, valid candles. If no candles are present, the output should be :(.
Here are some valid candles:
.
|   .       .
|   |   .   \
|   |   |   /

(ending with a ., containing only | or balanced, not necessarily adjacent \ and /, can be of any length.)
Here are some invalid candles:
.       .   .   .
\       |   |   |
|           |   |
\   .   |   !

(unbalanced \, no candle stick, disconnected, non-| characters, not planted on the ground.)
A lit candle will replace the . on a valid candle with any of the following characters (your choice):
@ ^ & " ~

You must use at least one, and you get a -10% bonus for each character used in your program, in such a way that each character can appear on a lit candle. If you use the  emoji, you get a -15 byte bonus, which is applied before the percentage bonuses, if used. THE BYTE COUNT IS ROUNDED DOWN!
This is a code-golf, so the shortest code in bytes wins.
Example IOs
input: 8,
.         .
| . ! . . |.  . . .
| | | | | | | | | |
output:
@         @
| @ ! @ @ |.  @ @ @
| | | | | | | | | |
input: 14,
   // nothing
output: :(
input: 15,
.   ..  . .  ". .
| . ||  | |  || !
output: 9 // more candles required; 15 - (6 unlit) = 9 (thanks to @AndersKaseorg for catching my mistakes (plural)!)
input: 7,
.
/        ~
|        \  .
/  &   " /  |
\  | @ | | . . . . .
\  | | | | | 1 l I |
output:
&
/        ~
|        \  .
/  &   " /  |
\  | @ | | ^ . . .
\  | | | | | 1 l I |
input: 5,
. .             |
i Q no candl es . |3-.
output: :(

Leaderboards
Here is a Stack Snippet to generate both a regular leaderboard and an overview of winners by language.
To make sure that your answer shows up, please start your answer with a headline, using the following Markdown template:
# Language Name, N bytes

where N is the size of your submission. If you improve your score, you can keep old scores in the headline, by striking them through. For instance:
# Ruby, <s>104</s> <s>101</s> 96 bytes

If there you want to include multiple numbers in your header (e.g. because your score is the sum of two files or you want to list interpreter flag penalties separately), make sure that the actual score is the last number in the header:
# Perl, 43 + 2 (-p flag) = 45 bytes

You can also make the language name a link which will then show up in the leaderboard snippet:
# [><>](http://esolangs.org/wiki/Fish), 121 bytes

var QUESTION_ID=59664,OVERRIDE_USER=8478;function answersUrl(e){return"http://api.stackexchange.com/2.2/questions/"+QUESTION_ID+"/answers?page="+e+"&pagesize=100&order=desc&sort=creation&site=codegolf&filter="+ANSWER_FILTER}function commentUrl(e,s){return"http://api.stackexchange.com/2.2/answers/"+s.join(";")+"/comments?page="+e+"&pagesize=100&order=desc&sort=creation&site=codegolf&filter="+COMMENT_FILTER}function getAnswers(){jQuery.ajax({url:answersUrl(answer_page++),method:"get",dataType:"jsonp",crossDomain:!0,success:function(e){answers.push.apply(answers,e.items),answers_hash=[],answer_ids=[],e.items.forEach(function(e){e.comments=[];var s=+e.share_link.match(/\d+/);answer_ids.push(s),answers_hash[s]=e}),e.has_more||(more_answers=!1),comment_page=1,getComments()}})}function getComments(){jQuery.ajax({url:commentUrl(comment_page++,answer_ids),method:"get",dataType:"jsonp",crossDomain:!0,success:function(e){e.items.forEach(function(e){e.owner.user_id===OVERRIDE_USER&&answers_hash[e.post_id].comments.push(e)}),e.has_more?getComments():more_answers?getAnswers():process()}})}function getAuthorName(e){return e.owner.display_name}function process(){var e=[];answers.forEach(function(s){var r=s.body;s.comments.forEach(function(e){OVERRIDE_REG.test(e.body)&&(r="
"+e.body.replace(OVERRIDE_REG,"")+"
")});var a=r.match(SCORE_REG);a&&e.push({user:getAuthorName(s),size:+a[2],language:a[1],link:s.share_link})}),e.sort(function(e,s){var r=e.size,a=s.size;return r-a});var s={},r=1,a=null,n=1;e.forEach(function(e){e.size!=a&&(n=r),a=e.size,++r;var t=jQuery("#answer-template").html();t=t.replace("{{PLACE}}",n+".").replace("{{NAME}}",e.user).replace("{{LANGUAGE}}",e.language).replace("{{SIZE}}",e.size).replace("{{LINK}}",e.link),t=jQuery(t),jQuery("#answers").append(t);var o=e.language;/s.lang?1:e.lang<s.lang?-1:0});for(var c=0;c<t.length;++c){var i=jQuery("#language-template").html(),o=t[c];i=i.replace("{{LANGUAGE}}",o.lang).replace("{{NAME}}",o.user).replace("{{SIZE}}",o.size).replace("{{LINK}}",o.link),i=jQuery(i),jQuery("#languages").append(i)}}var ANSWER_FILTER="!t)IWYnsLAZle2tQ3KqrVveCRJfxcRLe",COMMENT_FILTER="!)Q2B_A2kjfAiU78X(md6BoYk",answers=[],answers_hash,answer_ids,answer_page=1,more_answers=!0,comment_page;getAnswers();var SCORE_REG=/<h\d>\s*([^\n,]*[^\s,]),.*?([\d.]+)(?=[^\n\d<>]*(?:<(?:s>[^\n<>]*<\/s>|[^\n<>]+>)[^\n\d<>]*)*<\/h\d>)/,OVERRIDE_REG=/^Override\s*header:\s*/i;
body{text-align:left!important}#answer-list,#language-list{padding:10px;width:290px;float:left}table thead{font-weight:700}table td{padding:5px}
 <link rel="stylesheet" type="text/css" href="//cdn.sstatic.net/codegolf/all.css?v=83c949450c8b">

Leaderboard

	Author	Language	Size

Winners by Language

Language	User	Score

{{PLACE}}	{{NAME}}	{{LANGUAGE}}	{{SIZE}}	Link

{{LANGUAGE}}	{{NAME}}	{{SIZE}}	Link

Oh, and it's my Birthday.

Happy Birthday!

@steveverrill Thanks ^_^

Can we assume the input is padded with spaces to form a rectangle?

@vihan Like this?

@CᴏɴᴏʀO'Bʀɪᴇɴ yeah, that's what I mean

@vihan Go ahead. Just say that it has been assumed that the input is like that.

Ambiguities: (1) "lights up to X valid candles" (where X is said to be N minus the number of already-lit valid candles) sounds like we can light fewer than X candles (verb = lights, modifier = up to), possibly zero,did you mean "lights exactly X valid candles" (verb = lights up, modifier = exactly) instead? (2) Why does your second example have X = 3 when N is plainly 3 and the number of already-lit candles appears to also be 3, forcing X = 0?

@ChrisDrost Just some mistakes ^_^ Thanks for catching them.

Furthermore: it looks like we have to handle all of the @^&"~ options on inputs for counting already-lit candles: do we also have to handle the emoji? Or is it an output that cannot be an input?

@ChrisDrost You only have to handle one, but you get bonuses for each one you handle (as said). The examples were for a program that ideally goes for the bonuses. The emoji is just an output bonus; it will never appear as an input.

@CᴏɴᴏʀO'Bʀɪᴇɴ Thanks, one last question: is it permitted to change an already-lit valid candle's symbol to a different symbol than the one it started out as?

@ChrisDrost Yes, it is.

Haskell, ⌊(269 bytes − 15) · 0.9⁵⌋ = 149
h('.',0)(e:f,c,o)=(f,2:c,e:o)
h(k,b)(f,c,o)|Just x<-lookup k$zip"\\|/"[4,0..]=(f,x+2*div b 2:c,k:o)|0<1=(f,2:c,k:o)
g l(f,c,o)=foldr h(f,[],'\n':o)$zip l c
d("",_,o)=o
d('@':_,_,_)=":("
d(f,_,_)=show$length f
f n=d.foldr g(take n$'@':cycle"^&\"~",repeat 1,"").lines

Example run:
*Main> putStr s
.
/        ~
|        \  .
/  &   " /  |
\  | @ | | . . . . .
\  | | | | | 1 l I |
*Main> putStr (f 3 s)
^
/        ~
|        \  .
/  &   " /  |
\  | @ | |  . . . @
\  | | | | | 1 l I |

Assumes that each input line is at least as long as the previous line, as allowed by one of the author’s comments.

Looks like we have a new 1st place!

Python 2, 529 bytes with bonus, 303

Assumes that the first line has an integer on it.
Doesn't assume consistent spacing. Doesn't assume candles' column is empty.

Strategy:

Get input as list.
Reverse it and map it to a list of columns.
Test and operate.
Map it back into rows, reverse it, join the lines.

import re;R=raw_input;C=str.count;G=lambda x:[y if y else' 'for y in x];H=lambda x:[''.join(G(v))for v in map(None,*x)];F=re.findall;t,r,i,g,d=0,u"~\"&^@",[],r'^[|/\\]+[%s](?=\s|$)',R()
while d:i+=[d];d=R()
c=int(F('\d+',i.pop(0))[0]);i=i[::-1];m=H(i)
t+=sum(1 for x in m if F(g%r,x))
for p,n in enumerate(m):
 try:b=F(g%'\.',n)[0]
 except:continue
 if C(b,'/')==C(b,'\\')and t<c:t+=1;m[p]=re.sub('\.',r[0],n,1)
 if len(r)>1:r=r[1:]
m='\n'.join(H(m)[::-1])
d=":("if t<1 else`c-t`+" more candles required"if t<c else m;print d

Tests:
5,
*      *               *
  *        *
*
                 *
@     @       @     @
|     |   .   |     |
|     |   |   |     |

*      *               *
  *        *
*
                 *
@     @       @     @
|     |     |     |
|     |   |   |     |

3,
. . .
| \ |

1 more candles required

3,
. . .

. .      .
| |      |

. . .

 ~      "
| |      |

Could you edit to clarify the score before and after bonuses, and whether or not the byte-count is with or without comments?

I'm attempting to golf further. And I want to try a Pyth version.

Cool! Thanks. Good luck with Pyth! ^_^

Why don't you get rid of all the comments, newlines, etc.?

You can get rid of the  more candles required bit; a numeric output is assumed to be thus.

JavaScript (ES6), 328 bytes (score: 184)
I tried to beat the Haskell solution but that's actually a pretty competitive entry given all of the logic that needs to happen.
Score calculated as:Math.floor((328-15)*Math.pow(0.9,5)), bytes counted in a file with UTF-8 encoding, tested and confirmed with io.js --harmony_arrow_functions.
Solution:
eval("(n,s)=>{q=x=>x[0].map((_,c)=>x#[c]));h='Q';c=5;t=n;m=q(s.split('\\n')X#.match(/^ *[Q][\\\\//|]+$/)&&xR\\L==xR/L&&t-->0?xR./,c>1?h[c--]:'@'):x);return t==n?':(':t>0?1+t:q(mX.join('\\n')R@/,'')}"[k='replace'](/[A-Z]/g,x=>({X:"#.split('')))#.join(''))",R:"[k](/\\",Q:'.@^&"~',L:"/g,'').length"}[x]))[k](/#/g,'.map(x=>x'))

Requirements: the array must be space-padded to be rectangular.
Explanation: all of the eval insanity sets one variable (the variable k to the string replace to save some bytes) and shaves 11 bytes off of a 339-byte string, which I can un-golf as:
(num_candles_desired, string) => {
    transpose = array => array[0].map((_, index) => array.map(row => row[index]));
    candle_tips = '.@^&"~';
    c = 5; // decrementing index into candle_tips when > 1.
    candles_left = num_candles_desired;
    transposed_normal_output = transpose(
            string.split('\n').map(line => line.split(''))
        ).map(col_array => col_array.join(''))
         // the next map does the actual logic: finds possible candles with
         // a regex, checks that the \ chars match the / chars in number,
         // then decrements the candles_left index while changing the . to a
         // lit flame.
         .map(col => col.match(/^ *[.@^&"~][\\//|]+$/)
                   && col.replace(/\\/g,'').length == col.replace(/\//g,'').length
                   && candles_left-- > 0 ? x.replace(/\./, c > 1 ? candle_tips[c--]
                                                                 : '~')
                                         : x);
    return candles_left == num_candles_desired ? ':('
                  : candles_left > 0 ? 1 + candles_left
                  : transpose(
                        transposed_normal_output.map(col => col.split(''))
                    ).map(row_array => row_array.join('')).join('\n')
                     // as promised, we include the emoji at least once if we can.
                     // the leading backslash is unnecessary and comes from the
                     // above metaprogramming-compression with eval().
                     .replace(/\@/,'')
}

Since example I/Os were requested, here was the test suite I ran,
Reference example #1, lighting 8 candles...
Input:
.         .
| . ! . . |.  . . .
| | | | | | | | | |
Output:
~
| " ! & ^ |.  @ @ @
| | | | | | | | | |
Reference example #2, lighting 14 candles...
Input:

Output:
:(
Reference example #3, lighting 15 candles...
Input:
.   ..  . .  ". .
| . ||  | |  || !
Output:
9
Reference example #4, lighting 7 candles...
Input:
.
/        ~
|        \  .
/  &   " /  |
\  | @ | | . . . . .
\  | | | | | 1 l I |
Output:
~
/        ~
|        \  .
/  &   " /  |
\  |  | | @ . . . @
\  | | | | | 1 l I |
Reference example #5, lighting 5 candles...
Input:
. .             |
i Q no candl es . |3-.
Output:
:(

Some example I/OS?

@CᴏɴᴏʀO'Bʀɪᴇɴ added.

all_licenses: Creative Commons - Attribution Share-Alike - https://creativecommons.org/licenses/by-sa/3.0/