text:
"Stair-ify" a string
You must write a program or function that creates a "stair-ified" string. Here is how you "stair-ify" a string:
For each character in the string:

If the character is an upper or lowercase vowel, not including 'y', output it then move the rest of the string up a column.

If the character is a space or a tab, output it then move the rest of the string down a colum.

If the character is neither, output it normally.

IO can be in any reasonable format. The input will not contain any newlines. If you want, you can remove any trailing whitespace.
If you choose to return the string, rather than printing it, please also include a short program that will print your string so that it can be visualized. This is not mandatory, nor will it go towards your byte-count. This is just a convenience for users who don't understand golf or esolangs (like me) to be able to verify output or tinker with the code.
Sample IO:
Output for "bcdef ghijkl":
    f    jkl
bcde  ghi

Output for "Programming Puzzles And Code-Golf":
                               lf
                            -Go
                  s  nd   de
         ng   zzle  A   Co
      mmi   Pu
   gra
Pro

Output for "Abcdefghijklmnopqrstuvwxyz":
                     vwxyz
               pqrstu
         jklmno
     fghi
 bcde
A

As usual, this is code-golf, so shortest answer in bytes wins.

Related: http://codegolf.stackexchange.com/q/55593/31716

May we strip any leading/trailing whitespace?

@orlp Since it won't change the visual representation at all, I don't see why not.

If we choose to return the string, is the program for printing it included in the byte count?

@PeterPeter See my last edit.

Your second sample output is incorrect after the word "And".

Closely related

Abcde in the last example should be split

MATL, 38 37 bytes
Oj33<G13Y2m-IL)hYstX<-"@Z"GX@)h]Xh!c!

Try it online!
Explanation
For each char, the code computes its vertical position, measured from above (0 is highest). It then builds the output string transposed: each char is on a line with as many leading spaces as its vertical position indicates. Then all lines are contatenated into a 2D char array, which is finally transposed and displayed.
O       % push a 0
j       % input a string
33<     % array of the same length as the input that contains true for spaces or tabs
G       % push input again
11Y2    % string 'aeiouAEIOU'
m       % array of the same length as the input that contains true for vowels
-       % subtract
IL)     % remove last element
h       % prepend the 0 that is at the bottom of the stack
Ys      % cumulative sum. This gives the vertical position of each char
tX<     % duplicate. Compute minimum
-       % subtract. This sets minimum vertical position to 0
"       % for each vertical position
  @     %   push vertical position of current character
  Z"    %   string with that many spaces
  G     %   push input again
  X@)   %   get the character corresponding to the current iteration index
  h     %   concatenate horizontally
]       % end for each
Xh      % concatenate all lines into a row cell array
!       % transpose into a column cell array
c       % convert into 2D array, padding with spaces if needed
!       % transpose. Implicitly display

Pyth, 63 bytes
V_Q aY?}rN0"aeiou"=hZ?}N"     "=tZZ;Jh.mbYKh.MZYjC.b++*d+JNY*dK_YQ
                         ^^^^^
                         |||||
                         |tabs
                        space

The spaces in the middle is actually a single tab character, but StackExchange renders it as four spaces.
Try it online!

I count 64 bytes.

Because of the tab being shown as four spaces here.

Definitely 64 bytes. https://mothereff.in/byte-counter#V%5fQ%20aY%3F%7DN%22aeiou%22%3DhZ%3F%7DN%22%20%20%20%20%20%22%3DtZZ%3BJh.mbYKh.MZYjC.b%2B%2B%2ad%2BJNY%2adK%5fYQ

No, @KennyLau meant that the tab character should be placed instead of the four spaces. Look at the try it online link.

@MamaFunRoll StackExchange automatically replaces tabs by 4 spaces.

I know, I'm just saying that Kenny meant that.

Your answer isn't valid. Look at the "And" in your Try It Online link, it Is displayed as And, instead of A and nd

Python 2, 141 137 bytes
def S(s,l=[0]):
 for c in s:l+=[l[-1]-(c in"aeiouAEIOU")+(c<"!")]
 for h in sorted(set(l)):print"".join([" ",c][i==h]for i,c in zip(l,s))

This one doesn't seem to descend on spaces

@Score_Under It works fine on my machine. Are you testing on Python 2?

It's working. I don't entirely know how but I must have made a mistake when pasting it the first time.

JavaScript (Firefox 30-57), 151 bytes
s=>[...s].map((c,i)=>r[c<'!'?n++:/[AEIOU]/i.test(c)?n--:n][i]=c,n=s.length,r=[for(_ of s+s)[]])&&[for(a of r)if(s=[for(c of a)c||' '].join``)s].join`\n`

Where \n represents the literal newline character.

With template strings you can put a newline in a string, so you can replace /n with

@GenericUser The byte count is adjusted assuming that you have already done that; I just didn't want to use a literal newline in my post.

Perl, 110 bytes (108 bytes script + 2 bytes flags)
$h=0;map{$h{$h}.=' 'x($p-$p{$h}).$_;$p{$h}=++$p;$h+=/[aeiou]/i-/\s/}split//;print for@h{sort{$b<=>$a}keys%h}

Run with perl -nl script.pl, input is on stdin, output is on stdout.
Deobfuscated
I've renamed the variables more sensibly, made the code use strict and use warnings compliant, and made explicit a lot of the magic perl does automatically.
This is just run as perl script.pl, because it replicates the effects of the -nl flags inside the script.
use strict;
use warnings;
use English;

# The effect of -l in perl's flags
$INPUT_RECORD_SEPARATOR = "\n";
$OUTPUT_RECORD_SEPARATOR = "\n";

# These variables are magicked into existence
our $column = 0;
our %line_col = ();
our %lines = ();

# The implicit while-loop is the effect of -n in perl's flags
while (defined(my $line = <>)) {
    # The "chomp" is part of perl's -l flag too
    chomp $line;

    # Here starts the actual script. "$h=0" turns into...
    our $height = 0;
    for my $char (split '', $line) {
        if (!exists $line_col{$height}) {
            # Setting it to 0 is a bit of a white lie, but it might as well be 0.
            # Perl would otherwise have called the value "undef", which is
            # similar to 0 in numeric contexts.
            $line_col{$height} = 0;
        }

        $lines{$height} .= ' ' x ($column - $line_col{$height});
        $lines{$height} .= $char;

        $column++;
        $line_col{$height} = $column;

        $height++ if $char =~ /[aeiou]/i;
        $height-- if $char =~ /\s/;
    }

    # Sort line heights numerically descending (so the greatest is printed first)
    my @heights = sort { $b<=>$a } keys %lines;

    for my $line (@lines{ @heights }) {
        print $line;
    }
}

C, 180 bytes
char s[99];i,j,p[99],m,M;main(c){for(gets(s);c=s[i];j+=strchr("aeiou",c|32)!=0,j-=c<33,m>j?m=j:M<j?M=j:0)p[i++]=j;for(;m<=M;putchar(10),M--)for(i=0;c=s[i];)putchar(M^p[i++]?32:c);}

Ungolfed:
char s[99];i,j,p[99],m,M;
main(c){for(gets(s);c=s[i];
j+=strchr("aeiou",c|32)!=0,j-=c<33,m>j?m=j:M<j?M=j:0)
  //move current height up or down, adjust minimum and maximum height
p[i++]=j;  //record height of character
for(;m<=M;putchar(10),M--)  //from maximum to minimum height
for(i=0;c=s[i];)putchar(M^p[i++]?32:c);}  //print only characters on this height

JavaScript (ES6), 133
s=>s.replace(/[^aeiou ]*(.?)/gi,(z,x,c)=>(q=o[r]||'',o[r]=q+=' '.repeat(c-q.length)+z,x<'!'?++r:r?--r:o=[,...o]),o=[],r=0)&&o.join`
`

Less golfed
s=>(
  s.replace(/[^aeiou ]*(.?)/gi,(z,x,c)=>(
    q = o[r] || '',
    o[r] = q += ' '.repeat(c - q.length) + z,
    x == ' ' ? ++r : r ? --r : o = [,...o]
  ), o = [], r = 0),
  o.join`\n`
)

Test

f=s=>s.replace(/[^aeiou ]*(.?)/gi,(z,x,c)=>(q=o[r]||'',o[r]=q+=' '.repeat(c-q.length)+z,x<'!'?++r:r?--r:o=[,...o]),o=[],r=0)&&o.join`
`

function test() {
  i=I.value
  O.textContent=f(i)
}

test()
#I { width:90%}
<input id=I oninput='test()' value='Programming Puzzles And Code-Golf'>
<pre id=O>

C,  173   160   156  155 bytes
Edit: Borrowed idea of using strchr from @mIllIbyte to shave off 13 bytes
Edit2: Streamlined the min/max comparisons, -4 bytes
Edit3: c can have any value to begin with -> into main(c) instead, -1 byte
Edit4: Added ungolf/explanation
p,l,j,m;main(c){char b[99],*s=gets(b);for(;j<m+2;p?putchar(c?l?32:c:10):l<j?j=l:l>m?m=l:0,l-=c?(c&=223)&&c-9?!!strchr("AEIOU",c):-1:(p=s=b,l+j++))c=*s++;}

Ungolfed and explained:
/* declare and initialize these variables to int and 0 */
p,l,j,m;

/* declares main, but also int c */
main(c)
{

  /* we can handle strings of length 98 (+1 for string-terminating 0) */
  /* we declare and initialize s to point to the beginning of the input
     string for the first pass through the for loop */
  char b[99],*s=gets(b);

  /* the for-loop actually contains nested loops, where the inner loops
     behave differently depending on the outer loop parameter p as follows:
     p attains the values false (0) and true (non-null pointer), in this order.

     p == false:
      the inner loop has the parameter s and passes through all the characters
      in the string until the string is exhausted (*s == 0). l is the vertical
      position of the current character relative to the first character
      (l = 0), smaller number = higher up. The purpose here is simply to find
      the range of vertical positions [j, m] present in the string. The
      commands in execution order are:

      -- loop over s --

      // test does not do anything since j <= m by design
      1. j < m+2

      // puts current char in c and increments string counter
      2. c = *s++

      // ensures that j (m) equals the min (max) of the vertical positions (l)
         encountered so far. At first step j = l = m = 0.
      3. l<j?j=l:l>m?m=l:0

      // c != 0, this updates the vertical position for the next character
      // c = SPC or C = TAB -> lower (l increases by 1)
      // c = "aeiouAEIOU" -> higher (l decreases by 1)
      4a. l-=(c&=223)&&c-9?!!strchr("AEIOU",c):-1

      -- loop over s ends --

      // c == 0, this resets the string pointer s and puts p = true, and
      //         thereby initiates the next phase of the algorithm
      //         see rest of the explanation at p == true)
      4b. p=s=b

    p == true:
     now there are two inner loops. The outer of these has the parameter j,
     which ranges from the smallest vertical position+1 (the value of j after
     the p == false pass) to the largest vertical position+1 (m+2 after the
     p == true pass). The innermost loop has the parameter s and passes through
     all characters in the string until the string is exhausted (*s == 0) just
     as in the p == false inner loop. Here l is now the vertical position
     relative to the current position j-1, so that l == 0 when a character is
     at the current level. Such characters are printed as is, whereas
     characters at other levels are replaced by space. The end-of-string
     marker 0 outputs a newline. The commands in execution order are:

      -- loop over j --

      // at first step increments j to point to be one more than the
      // current vertical position. At other steps moves the current position
      // (j-1) one vertical position downwards. Also, at all steps, this
      // biases the vertical position counter l to be zero at the current
      // vertical position (j-1)
      1. l=-j++

      // compare j to stopping criteria, exit if j > m+1
      2. j < m+2

       -- loop over s --

       // puts current char in c and increments string counter
       3. c = *s++

       // outputs character as follows:
       // c == 0 (end of string), output newline
       // c != 0 (middle of string)
       //  l == 0 (character at current vertcial position), output c
       //  l != 0 (character not at current vertical position), output space
       4. putchar(c?l?32:c:10)

       // c != 0, this updates the vertical position for the next character
       // c = SPC or C = TAB -> lower (l increases by 1)
       // c = "aeiouAEIOU" -> higher (l decreases by 1)
       5a. l-=(c&=223)&&c-9?!!strchr("AEIOU",c):-1

       -- loop over s ends --

      // c == 0, this resets the string pointer s for next loop over s
      //         algorithm (see rest of the explanation at p == true)
      5b. p=s=b

     -- loop over j ends --
  */

  for(;
      j<m+2;
      p?putchar(c?l?32:c:10):
    l<j?j=l:l>m?m=l:0,
      l-=c?(c&=223)&&c-9?!!strchr("AEIOU",c):-1:
       (p=s=b,l+j++))
    c=*s++;
}

Haskell (within ANSI terminal), 75 bytes
("\27[2J"++).(h=<<)
h ' '="\27[B "
h c|elem c"aeiouAEIOU"=c:"\27[A"
h c=[c]

Usage example: putStr $ ("\27[2J"++).(h=<<) $ "bcdef ghijkl"
This uses ANSI escape codes to move the cursor up and down.


text:
Find the program that prints this integer sequence (Cops' thread)
This is the cops' thread. The robbers' thread goes here.
The last cops-and-robbers thread was already 4 months ago.
The cop's task

The cop's task is to write a program/function that takes a positive (or non-negative) integer and outputs/returns another integer.
The cop must state it if the program is intolerant towards zero.
The cop will provide at least 2 sample inputs/outputs.
For example, if I have decided to write the Fibonacci sequence, I would write this in my answer:

a(0) returns 0
a(3) returns 2

The number of examples is up to the cop's discretion.
However, the sequence must actually exist in the On-Line Encyclopedia of Integer Sequences®, so no pseudo-random number generator for you. :(
The cop can hide as many characters as is so wished.
For example, if my program is:

function a(n)
    if n>2 then
        return n
    else
        return a(n-1) + a(n-2)
    end
end

Then I would hide these characters as I want:

function a(n)
    if ### then
        ########
    else
        ######################
    end
end

The robber's task

is obviously to find the original source code.
However, any proposed source code that produces the same set of output also counts as valid, as long as it is also found in OEIS.

Tips for the cops

The search function in the OEIS only works for consecutive terms, so if you want to hide your sequence, then just leave a hole anywhere.
Apparently there is no way to hide the sequence. Put this in mind when you choose the sequence.

Your score is the number of bytes in your code.
The winner will be the submission with the lowest score that hasn't been cracked in 7 days.
Only submissions that are posted in 2016 April are eligible for the win. Submissions that are posted later than this are welcome, but cannot win.
In order to claim the win you need to reveal the full code and the OEIS sequence (after 7 days).
Your post should be formatted like this (NN is the number of characters):

Lua, 98 bytes
Output:
a(0) returns 0
a(3) returns 2

Code (# marks unrevealed characters):
function a(n)
    if ### then
        ########
    else
        ######################
    end
end

If the code is cracked, insert [Cracked](link to cracker) in the header.
If the submission is safe, insert "Safe" in the header and reveal the full code in your answer. Only answers that have revealed the full code will be eligible for the win.

Just to clarify: if I post a cop which specifies a(0) = 1, a(1)= 1 with the Fibonacci sequence in mind, and a robber posts a crack which outputs the constant 1 sequence (i.e. not what I had in mind), then does this count as cracked?

Also, OEIS search can have blanks with _, fyi

Also "the parts of the code not related to the number generation must be revealed" seems a bit confusing to me. Suppose I posted an answer in Brainfuck - which parts would that be?

In your example you choose to reveal the spaces. Does that mean that you could just add as many spaces as you need in your submission to not reveal anything important?

@Sp3000 Re "OEIS search can have blanks": Then how would I hide the sequence?

@user81655 Yes, but that would count towards the byte count.

@Sp3000 Re "a robber posts a crack which outputs the constant 1 sequence": "However, any proposed source code that produces the same set of output also counts as valid (you are encouraged to reproduce an actual sequence in the OEIS)."

@Sp3000 Re "a(0) = 1, a(1)= 1 with the Fibonacci sequence in mind": a(0)=0.

So if I have, say, 31 characters, do I have to show six or seven of them?

It may be too late to change, but allowing sequences that are multiples of an OEIS sequence, and/or only include every nth term would have made this challenge much better.  sandbox, hint, hint

I don't think that is necessary.

Can I, for example, pick the Fibonacci sequence and provide only a(1000)? (which is part of the sequence, but too large to be searchable on OEIS)

I'd say the values have to actually be searchable on OEIS, so that it can easily be verified that the values are correct for the chosen sequence.

"Intolerant towards zero" makes no sense. What is that supposed to mean?

@feersum I would believe it means whether or not the program outputs the sequence starting with 0 or 1, but I'd also like clarification.

In your example program I think you meant n<2

Can cops post more than one answer?

I don't understand... What is a "Safe" answer ?

@FliiFe An answer that doesn't get cracked in a week.

@KennyLau After a week, an answer cannot be cracked anymore, can it ?

Nope, it cannot.

Vim, 36 keystrokes -- Safe!
i****<esc>:let @q="^*i****$**@***"<cr><n>@qbD

(Note: <n> is where you type your input)
Here is the code unrelated to number generation:
          :let @q="              "<cr><n>@qbD

Meaning I am revealing 5 out of 19 characters.
<n> is the input. Here are some sample outputs:
1@q:    1
2@q:    3
6@q:    18

Answer
This code prints The Lucas Numbers (A000032), which are just like The Fibonnaci Sequence, except that it starts on 2, 1 instead of 1, 1. Here are the first 15 numbers:
2, 1, 3, 4, 7, 11, 18, 29, 47, 76, 123, 199, 322, 521, 843

Here's the revealed code:
i2 1 <esc>:let @q="^diwwyw$pb@-<c-v><c-a>"<cr><n>@qbD

Explanation:
i2 1 <esc>                          "Insert the starting numbers
          :let @q="....."<cr>       "Define the macro 'Q'

Explanation of the macro:
^                      "Move to the first non-whitespace character on the line.
 diw                   "(d)elete (i)nner (w)ord. This is different then 'dw' because it doesn't grab the space.
                      "It also throws people off since 'i' is usually used for inserting text.
    wyw$               "Move to the next number, yank it then move to the end of the line
        pb             "(p)aste the yanked text and move (b)ack
          @-     <c-a> "@- is the register holding the word we deleted. Increment the current number that many times.
            <c-v>      "Since we're adding <c-a> this from the command line, we need to type it as a literal.

Now, we just need to remove the second number, since the first number is the lucas number we want. So we do
b   "move (b)ack
 D  "(D)elete to the end of the line.

Also, if I'm not mistaken, this is the first safe submission! That's kinda cool.

I know the sequence, I think. I just don't know how to turn it into Vim keystrokes.

Is the output just the number or the entire line?

@ASCIIThenANSI After hitting bD at the end, the output is just the one number and some extra whitespace.

I got the sequence right!

05AB1E, 5 bytes, safe
Last one for today :p. Output:
a(0) = 9
a(5) = 4
a(10) = 89

Code:
___m_

Obfuscated characters are indicated with _. Try it online!-link. Uses CP-1252 encoding.

Solution:
žhžm‡

Explanation:
žh       # Short for [0-9].
  žm     # Short for [9-0].
    ‡    # Translate.

Try it online! or Try for all test cases!.

I know the sequence, just not how to generate it in so few bytes...

@LegionMammal978 Yes, I think that is going to be the hardest part of this one.

I can get it in 5 bytes with g°<¹- but I can't figure out any way to use m at this size! D:

@user81655 Yes, that was the alternative solution :).

Element, 7 bytes, cracked
Output:
a(3) = 111
a(7) = 1111111

The # are hidden characters, and they are all printable ASCII.  I think this one is actually reasonably difficult (for only having 5 missing characters).
###,##}

For convenience, here's the Try It Online and Esolang wiki pages.

My original program was:

 _'[,$`}

The trick is that

] and } are functionally identical (both translate to } in Perl).  Also, I used ,$ to produce a 1 as an additional layer of confusion, although it is possible to ignore the , completely by doing ,1 instead.

(I know I shouldn't ask this, but) are you sure that it is correct? In particular, } instead of ]?

@KennyLau The } is correct, and my program (as far as I know) works in every version of Element.

Cracked.

I think the formatting is wrong in your original code?

@EasterlyIrk It is.  If you know how to fix it, be my guest.

@PhiNotPi fixedish.

Jolf, 5 bytes, cracked
Output:
a(2) = 8
a(10) = 4738245926336

All of it is crucial, and I have shown 1 of 5.
####x

Original code:
mPm$x
mP     cube
  m$   catalan number
    x  input

Try it online!

Cracked!

For anyone interested, it's this sequence: https://oeis.org/A033536

JavaScript (ES7), 10 bytes, Cracked
Output
f(0) -> 1
f(1) -> -1

Code
t=>~t##**#

Test it in Firefox nightly. The code is an anonymous function. This will probably be easy since there's only three characters hidden, but at least it's short! :P

My original code was:

 t=>~top**t

but after brute-forcing my own code for a solution, I soon realised

 t=>~t.x**t (where x can be any variable name character)

could also be used. This works because

 in the original ES7 exponentiation operator spec, the operator had lower precedence than unary operators (unlike conventional mathematics and most other languages). ~ performs a bitwise NOT on t.x (undefined) or top (Object) which casts them to a 32-bit signed integer (uncastables like these become 0) before doing the NOT (so 0 becomes -1). I looked into further into this, and very recently, the spec has changed to disallow ambiguous references like this (not good for future golfing D: ), however most ES7 engines haven't updated to the latest version of the spec yet.

@insertusernamehere It seems to think it contains an illegal expression. It does work in Firefox nightly though. I guess they implement the ES7 spec differently.

I just got Firefox nightly, and I must complain that this does not work there. 32-bit windows from here

Assuming ** is equivalent to Math.pow, I have done some of my own testing, and even run a brute force. This is quite hard to crack!

@CᴏɴᴏʀO'Bʀɪᴇɴ My Firefox nightly is up to date as of yesterday. I'm using OS X but I'm quite sure it will work in Windows also. Traceur with appropriate ES7 options enabled transpiles it correctly too.

@CᴏɴᴏʀO'Bʀɪᴇɴ Just tried it in 32-bit Windows from your link and it works also. I'm surprised your brute force search couldn't crack it. I actually just realised there's many solutions to this! D:

@user81655 Weird. I've been assuming the problem is of the form t=>~t<op><data>**<data>, where <op> is any unary operator and <data> is any of 0123456789t.

@CᴏɴᴏʀO'Bʀɪᴇɴ Well who knows, anything could be under the hashes... :P

Cracked?

In my cellphone appear above, some yellow (giallo) rectangles voids

05AB1E, 4 bytes (Cracked)
Sample output :
a(5) = 51
a(8) = 257

And for the code :
###^

I revealed the last one. Should be easy enough though, I had quite a hard time finding a sequence :(
All hidden characters are printable.

Cracked! :)

Ruby, 46 bytes, safe
Edit to add disclaimer/apology: This sequence starts with f[0], while the OEIS entry starts with f[1]. The values are the same.
Obfuscated code (# is any character):
->####or x##1###(#..##0#);x*=3;end;#.###ect:+}

Call like
->####or x##1###(#..##0#);x*=3;end;#.###ect:+}[3] (returns 39)

Output:
f[0] = 0
f[1] = 3
f[2] = 12
f[3] = 39
f[4] = 120
f[5] = 363
f[6] = 1092
f[7] = 3279
f[8] = 9840
f[9] = 29523

Solution:

 f=->*x{for x[-1]in(0..x[0]);x*=3;end;x.inject:+}

Sequence:

 http://oeis.org/A029858

Explanation:

 The minor trick here is that we declare the parameter as *x rather than x. This means that if you pass in 2, x is set to [2]...at first. The major trick exploits bizarre, and justly obscure, Ruby syntax where you can set the iterator in a for loop to any valid left hand side of an assignment expression, instead of an iterator variable like i. So this loops through from 0 to (in this example) 2, assigning each number to x[-1], meaning it overwrites the last value of x. Then the loop body x*=3, further mutates x by concatenating it to itself 3 times. So first x becomes [0], then [0,0,0]. On the next loop it becomes [0,0,1], then [0,0,1,0,0,1,0,0,1]. Finally we pass in 2 and it becomes [0,0,1,0,0,1,0,0,2], then [0, 0, 1, 0, 0, 1, 0, 0, 2, 0, 0, 1, 0, 0, 1, 0, 0, 2, 0, 0, 1, 0, 0, 1, 0, 0, 2]. We then sum the result using the inject method, which reduces the array by applying + (the passed in method) to each element in turn. If we consider how each iteration changes the sum, we see that we effectively add 1 (by overwriting the last element with an element one higher), then multiply by 3. Since 3*(n+1) = 3*n + 3, this implements Alexandre Wajnberg's recurrence relation for the sequence as described on the page.

I really like your cops here, this one particularly.  Well done.

MATL, 5 bytes, cracked
Hidden characters are indicated by %.
%5%*%

Output:
a(1) = 3
a(2) = 6
a(4) = 12

Input 0 is valid.

Original code:
35B*s

that is,
35    % push number 35
B     % convert to binary: array [1 0 0 0 1 1]
*     % multiply element-wise by implicit input n: gives [n 0 0 0 n n]
s     % sum of array: gives 3*n

Hmmm, the five in code is very annoying!

Technically this could be brute-forced by a program... but I won't do that.

cracked

SWIFT, 55 bytes, Cracked
func M(n:Int)->Int{
return(n*****) ?M(**n****):n***;
}

* marks a hidden character
Output:
M(30) -> 91
M(60) -> 91
M(90) -> 91
M(120)-> 110
M(150)-> 140

Function accepts 0

Cracked

Lua, 45 Bytes, Cracked
A small hint:
a(0) will make the program crash :)

Output
a(1)=>0
a(2)=>1

Code
Uses # to hide the code :).
a=function(n)#####n###### and #or ########end

I was using the OEIS A007814, with the following code:
a=function(n)return n%2>0 and 0or 1+a(n/2)end

Cracked.

@KennyLau Well done, I've added the OEIS I was thinking to and the intended code, I should have added at least one more output to prevent this to happen :p

C, 82 bytes, safe
####=############
main(i){scanf("%d",##);
for(i=1;i++/4<#;)##=2;
printf("%d",##);}

Works with gcc, and it is a full program, which reads its input from stdin and prints its output to stdout. Here the sequence is A004526, floor(n/2).
a(0) = 0    a(1) = 0    a(2) = 1
a(3) = 1    a(4) = 2    a(5) = 2
a(6) = 3    a(7) = 3    a(8) = 4

Solution:
a;*b=(char*)&a+1;
main(i){scanf("%d",&a);
for(i=1;i++/4<2;)a*=2;
printf("%d",*b);}

This works only on little endian machines, and only if the size of char is 1 byte.
And only if the byte higher than the highest order byte of a has value 0. I think this is true for gcc since by default uninitialized global variables go into the bss segment, and initialized global variables go into the data segment (see https://stackoverflow.com/questions/8721475/if-a-global-variable-is-initialized-to-0-will-it-go-to-bss). So only a goes into bss (the only other global variable b is initialized and thus goes into the data segment). If a is not at the end of bss, then the byte higher than the highest order byte of a is also in bss and thus has value 0.

Try making function calls now :)

I don't think you had to specify the sequence...

@FliiFe - Fixed :)

Ruby, 38 bytes, cracked
Obfuscated code (# can be any character):
->#{(s=#########).sum==#3333&&eval(s)}

Output:
Multiplies the input by 10 (A008592). Works for any integer, including 0. e.g.
->#{(s=#########).sum==#3333&&eval(s)}[3]  => 30
->#{(s=#########).sum==#3333&&eval(s)}[10] => 100

Cracked.

05AB1E, 5 bytes, cracked
Output:
a(0) = 0
a(1) = 0
a(2) = 1
a(3) = 1
a(4) = 1
a(5) = 1
a(6) = 1
a(7) = 1
a(8) = 1
a(9) = 1
a(10) = 0
a(11) = 0

Obfuscated code:
_____

Try it online!-link.

Cracked.

05AB1E, 3 bytes, cracked
Output:
a(9) = 165
a(10) = 220

Hidden code:
##O

Try it online might come in handy.

Cracked.

Hexagony, 7 bytes, cracked
Output:
a(1) = 2
a(2) = 4

Hidden code:
?#####@

Or alternatively:
 ? #
# # #
 # @

Try it online might come in handy.

Cracked.

Uhhh wait, does your code work for input 0?

@MartinBüttner Oh, it doesn't, my bad. Your solution was the right one though.

05AB1E, 4 bytes, cracked
Well then, I  think I'm addicted to CnR's... Obfuscated code (_ indicates a wild card):
____

Sequence:
a(1) = 2
a(4) = 6720

The sequence in OEIS starts at a(1) = 2.
Try it online!-link

Cracked

PHP, 41 bytes, cracked
Yeah, finally another Cops and Robbers challenge. Hope I didn't make it to easy.
Output
a(5)   = 0
a(15)  = 1
a(35)  = 0
a(36)  = 1
a(45)  = 1

Source
____________________$argv[1]____________;
####################        ############

Notes

It's a full program, not a function.
Reads the input from command line (obviously).
Does not contain any PHP opening tag.

Cracked
I obviously made it to easy and provided not enough examples. The sequence I had in mind was A010054:

a(n) = 1 if n is a triangular number else 0.

Here's my original source code:

 echo(int)($r=sqrt(8*$argv[1]+1))==$r?1:0;

It tests whether the input is a triangular number and outputs 1 or 0 accordingly.

Cracked.

Pyke, 15 bytes, SAFE
Output
a(2) = 21
a(15) = 17

Revealed code:
#R#D######+##)#

Solution:

 OEIS A038822

wR}DSR_Q*L+#P)l

 I used a couple of red herrings here by using wR} to generate the number 100 and revealing the character R which is normally used to rotate the stack. I also used #P)l instead of the more simple mPs to count the number of primes in the sequence.

The sequence in question starts from n=1 not n=0 by the way

I thought it was that sequence, except it starts at n=0 and not n=1 as you've stated.

C, 71 bytes cracked
############
#####
main(){
 scanf("%d",##);
 ###6#;
 printf("%d",##);
}

Output:
a(1) = 0   a(2) = 0   a(5) = 1
a(6) = 1   a(7) = 1   a(9) = 2

This works with gcc, and is a full program. It accepts 0 as input.

Cracked.

Well, I should've revealed more characters. I posted a different one, and I tried to avoid function calls. http://codegolf.stackexchange.com/a/77583/52554

Jolf, 11 bytes, Cracked , A011551
c*______x__

c*mf^+91x~P

Original code:
c*^c"10"x~P

Examples:
0 -> 1

12 -> 1618033988749

Cracked.

@Adnan Good job, though different from mine. And you couldn't figure out first op. :P

Yeah, I couldn't figure out what it does :p

@Adnan it was a cast to int function, misused as a floor one.

Java, 479 bytes, Cracked
Outputs:
a(10) = 81
a(20) = 35890

(Inputs are provided via command line arguments)
Code (# marks hidden characters):
import java.util.*;
public class A{

    public static int#########
    public boolean###########

    static A a = new A();

    public static void main(String[] args){
        int input = Integer.parseInt(args[0]);

        LinkedList<Integer> l = new LinkedList<>();
        l.add(1);
        l.add(0);
        l.add(0);

        for(int ix = 0; ################if(##>##{
            ###########d#
            #######+##p##########+##########(#######
        }

        System.out.println(#########################
            ###(A.#############(#5#####)));
    }
}

The program starts at index 0.
(Note that SE replaces all of the \t indents with 4 spaces, bringing the byte total to 569. Click here to see the program with \t indents instead of space indents.)
Original code:
import java.util.*;
public class A{
    public static interface B{
    public boolean C(int i);}

    static A a = new A();

    public static void main(String[] args){
        int input = Integer.parseInt(args[0]);

        LinkedList<Integer> l = new LinkedList<>();
        l.add(1);
        l.add(0);
        l.add(0);

        for(int ix = 0; ix<input; ix++)cif(i->  {
            return l.add(
            l.pop()+l.peekFirst()+l.peekLast());});{
        }

        System.out.println(l.get(1));}static boolean
            cif(A.B b5){return (b5.C((0)));
    }
}

(Same code, but formatted normally):
import java.util.*;

public class A {
    public static interface B { //functional interface for lambda expression
        public boolean C(int i); //void would have given it away
    }

    static A a = new A(); //distraction

    public static void main(String[] args) {
        int input = Integer.parseInt(args[0]);//Input

        LinkedList<Integer> l = new LinkedList<>();
        l.add(1);//Set up list
        l.add(0);
        l.add(0);

        for (int ix = 0; ix < input; ix++)
            cif(i -> { //Fake if statement is really a lambda expression
                return l.add(l.pop() + l.peekFirst() + l.peekLast());
            });
        { //Distraction
        }

        System.out.println(l.get(1));//Output
    }

    static boolean cif(A.B b5) { //Used to pass in lambda expression.
                  //The A. and b5 were both distractions
        return (b5.C((0)));
    }
}

Hm, how do you come to a byte count of 488? I count 545 from i to }?
And please specify 0-tolerance.

Aren't your examples a(9) and a(19) or a(8) and a(18), according to which version of it on OEIS you took?

@BjörnKautler I'll post a link to the byte counter when I get home. What do you mean by 0-tolerance? The first value is a(1) = 0

From the OP:
"The cop's task is to write a program/function that takes a positive (or non-negative) integer and outputs/returns another integer.
The cop must state it if the program is intolerant towards zero." So I guess you take the input 1 as 0 and this also explains the shift in position, according to the OEIS sequence.

@BjörnKautler OK, thanks. The program doesn't crash if 0 is entered but the sequence starts at index 1, so I guess it's zero-intolerant.

Are you sure? The only matching sequences I found on OEIS that match your samples start at 0 and for one the results would be a(9) and a(19), for the other a(8) and a(18)

@BjörnKautler OEIS is 0-indexed? I'll change it then (in about an hour). Thanks

Depends on the sequence. The one you most probably used says with a(0)=a(1)=0, a(2)=1 and also specifies the offset to be 0, which means the first value in the shown numbers is the 0-value. You can also click on the list link after the numbers and you get a list with n-to-a(n) mapping.

@BjörnKautler I'm not all that familiar with OEIS so that's good to know. I need to test it before I change this post, but to make the code 0-indexed, "int ix = 1" should become "int ix = 0"

Me neither. Just learned about OEIS some minutes ago when I recognized this challenge :-)

@BjörnKautler It seems that SE replaces all tab indents with space indents, upping the byte count. I added a note to clarify the byte situation. Also, I fixed the 0-indexing. Have fun :)

Ah, tabs-vs-4spaces makes sense. And the newlines are also counted as 1 just as in the example, I see. :-) Thanks for clarification. One more question. I almost have it cracked, just a(0) and a(1) are wrong for me, all others are correct. You are sure the first two are calculated correctly by your code, aren't you? :-)

@BjörnKautler I double checked, and they are. Mind if I move the discussion to chat?

No need, it is cracked. :-)

@BjörnKautler Was not expecting that so quickly (or so differently), given that the original had no if statement, and had a second method.

Or a ternary operator. :-D Yeah, I was pretty sure the original code is differently, but also didn't imagine that much. I didn't really expect an interface, an additional method or a lambda here. But the better for me, there was so much room, that I was able to fit in my code and comment out your revealed characters. :-D Though yours will not get an OutOfMemoryError, mine will if you give it a big enough n, as I continuously build up the ArrayList. :-)

That was pretty funny, I should more often solve those :-D

Octave, 34 bytes, cracked
@(m)(m###m#####m##)&isprime(#)####

Outputs:
ans(1) = 0
ans(6) = 5
ans(7) = 10
ans(8) = 15

The sequence starts at ans(1) in OEIS.

Cracked.

MATL, 9 bytes, Cracked
Code:
3#2###*##

Output:
a(1)  = 3
a(2)  = 6
a(4)  = 12
a(12) = 37

a(0) is valid.

Cracked
Original sequence:
A059563
Original code:
3L2^Ze*sk
3L          % Push [1 -1j] from the clipboard
  2^        % square
    Ze      % exp
      *     % times input
       s    % sum
        k   % floor

Cracked.

Pyth, 70 bytes, Cracked
DhbI|qb"#"qb"#"R!1Iqb"#"#####+""s####2###;##lY+Q1Ih+""Z#####)=Z+Z1;@YQ

# are the hidden characters
Has been cracked, so here is the versionn without hidden chars :
DhbI|qb"4"qb"0"R!1Iqb"1"R!0Rh+""sm^sd2cb1;W<lY+Q1Ih+""Z=Y+YZ)=Z+Z1;@YQ

Sample outputs :
a(2) -> 10
a(4) -> 19

Good luck to find this on OEIS, I personally failed to find it from those examples (even tho the sequence is quite easy to spot.)

Cracked.

05AB1E, 1 byte, Cracked
_

_ denotes hidden code.
f(1) == 1
f(18) == 6

Cracked

Reng v.3.3, 36 bytes. Cracked, A005449
Output:
a(1) = 2
a(3) = 15

# denotes a gone character. There are no other #s in the program.
i#:#+##-##)####¡#~
##########!</div>

Alright this is the last one for a while. Other people need to answer >_>. A description of each character can be found in the source code, where all the ops are defined. A comment proceeds each operator.
Original code:
i>:1+(1-?v)v/a+¡n~
~^<$:$:$:>!</div>

Cracked.

What is the original sequence?

+1 for </div>, an HTML tag that strangely appeared in this code. I like finding out secrets like this. :-P

@zyabin101 XD Thanks! I put it there as a red herring.

Jolf, 11 bytes, Cracked.
Output:
a(10) = 4
a(20) = 6
a(30) = 8

And the partially hidden code:
####xd###x#

Hint:

 When I looked through the sequences in order, I didn't go very far before finding this one.

The cracked version isn't quite the same as my original code. I'm not currently at my computer, so I don't have it exactly, but it was something like this:

 l fzxd!m%xH

(The only part I'm unsure about is the !m. It's whatever checks if a variable is zero.)

I found the sequence... Pity I don't know Jolf or javascript very well :(

@muddyfish, Same here...

Well, I guess it's time for the master to do it... may I?

@CᴏɴᴏʀO'Bʀɪᴇɴ If everyone else is stumped – and it looks like they are – feel free.

Cracked.

Interesting approach!

Element, 10 bytes, cracked
Output:
a(3) = 6561
a(4) = 4294967296

There's probably only a few ways to compute this sequence in Element.  I found a 9-char solution, but I figured this 10-char solution is actually more difficult.  The # are hidden characters.
#_####@^#`

For convenience, here's the Try It Online and Esolang wiki pages.

The original was
2_3:~2@^^`

Show one more byte.

@KennyLau I thought it was 1 out of 5?  It's 10 bytes and I'm showing 3.

Inputs and outputs don't count, so you have 8 bytes and you showed 1.

@KennyLau done.

Cracked.

@KennyLau nice.  (and slightly different than original)

Pyth, 18 bytes
# marks unrevealed characters.
L?Jtb##5#m##S#2 #y

Outputs (starts from 1):
1 -> 2
2 -> 3
3 -> 5
4 -> 7

Online interpreter

Primes, no? If not...

If not... what?

then I have no idea

05AB1E, 5 bytes, cracked
I hope that this submission isn't as easy as my other ones :p. Outputs:
a(0) = 0
a(1) = 1
a(2) = 6
a(3) = 24
a(4) = 80
a(5) = 240

Obfuscated code:
####O

Contains some non-ASCII characters though, uses CP-1252 encoding.
Try it online! might come in handy :p.

Cracked.

Why do I feel like I've seen it before?

@KennyLau ¯\(ツ)/¯

JavaScript ES6, 119 bytes, Cracked.
Output:
a(0) = 0
a(5) = 10000

Code:
x=>##=#=>[[[##x####r(###f#n###;#####n####h.##w###<1##].c####t.##pl##[####nc#######y([###(###(#]###)######`#######h####`

Returns an anonymous function.
Original sequence: A016744.
Original code:
x=>{f=n=>[[[1,x] for(x of n)]];return Math.pow(x<<1,[].concat.apply([].concat.apply([],f(f(f([]))))).join``.length)}//`

I need to show more characters of obsfucated code next time :P

Cracked. I wasn't sure which sequence you were going for though, so I had to just choose the easiest one then ignore the rest of the characters. :(

Jolf, 13 bytes, safe!
Outputs:
a(5) = 40
a(8) = 128

Code:
#+~##~####xx#

Interpreter.
Revealed:

 OEIS A003600γ+~iu~iZCzxxγγ              γ =          zx    range 1..x (input)       ZC      cumulutive sum     ~i        identity    u          sum of  ~i           identity +         x   plus x            γ  out γ

Ooh, Jolf. I'm gonna have a crack at this one. Please don't steal it, Kenny.

@QPaysTaxes Any luck? :3

I might've had some of you didn't have undocumented functions everywhere :P. As it is, I've got two candidates for the sequence, and some idea of how to make them, but it's a pain in the butt :P

@QPaysTaxes I don't think this code uses any undocumented features.

But they still make reading the source hard. Anyway, I'm just complaining. Feel free to ignore me.

@QPaysTaxes Consider yourself ignored ;)

Pyke, 6 bytes, Cracked
###X#s

Output:
a(2) = 8
a(8) = 80
a(10) = 120

This doesn't work with N<1
Original solution:

 hSmX$s

Welp, I found an easier alternate to what I had

Cracked.

Jolf, 16 bytes, safe!
Outputs:
a(0) = 0
a(4) = -2
a(51) = 26

Code:
#.‘###4#x##32#mA

Revealed:

 Sequence: A001057, the canonical enumeration of integers.*.‘01m4zx’m32xmA  ‘      ’        an array   0               0: 0    1              1: 1     m4zx          antisum of range 1..x (1 - 2 - 3 - 4 - ... - x) .        m32x    get min(2, x) of that array*             mA  multiply that entry by the sign of x (implicit input); is zero when zero

05AB1E, 5 bytes, cracked
##s##

# indicates a hidden character.
Output:
a(4) = 8
a(6) = 144

The sequence starts at a(1).

The original code was exactly as in @Adnan's answer to robbers' thread.

My first 05AB1E submission!

Wow! I'm glad to see this :)

Cracked.

@Adnan I thought it would last longer :-) Can sequences in OEIS be searched for specific terms?

@Adnan, Oh, there is. _ is used for missing terms

Yes, although OEIS searches for the terms regardless of the starting position of a sequence. I made a script which also searches for the same starting index, so it would rule out other sequences.

@Adnan Could you share it ?

@FliiFe Probably gonna violate the copyright law, but here you go.

@Adnan I think you could avoid copyright law infringement by first making a first search on oeis (preformated), and then let the script choose which one respects the indexes

@FliiFe Oh, that might be a better idea

J, 8 bytes, cracked
# marks unrevealed characters
(##-#)#.

(Online interpreter here.)
Output:
No, I'm not hiding anything by using a long sample. If the input is 0, it outputs 0, if the input is between 1 and 29, it outputs 1.
The outputs for the negative inputs do not match with the actual sequence.
   (##-#)#.0
0
   (##-#)#.1
1
   (##-#)#.2
1
   (##-#)#.3
1
   (##-#)#.4
1
   (##-#)#.5
1
   (##-#)#.6
1
   (##-#)#.7
1
   (##-#)#.8
1
   (##-#)#.9
1
   (##-#)#.10
1
   (##-#)#.11
1
   (##-#)#.12
1
   (##-#)#.13
1
   (##-#)#.14
1
   (##-#)#.15
1
   (##-#)#.16
1
   (##-#)#.17
1
   (##-#)#.18
1
   (##-#)#.19
1
   (##-#)#.20
1
   (##-#)#.21
1
   (##-#)#.22
1
   (##-#)#.23
1
   (##-#)#.24
1
   (##-#)#.25
1
   (##-#)#.26
1
   (##-#)#.27
1
   (##-#)#.28
1
   (##-#)#.29
1

Cracked.

05AB1E, 28  bytes (Cracked)
#D>D>D>D>*##*#D<*#+*#n#n#**#

a(1) = 1
a(2) = 8
a(3) = 42
Behaviour for zero is unspecified.
Cracked:
 DD>D>D>D>****rD<*6+*6n2n5**/

There is no need for an explanation I think as the crack was almost 100% spot on. The only difference is I used r to reverse stack instead of swapping top two elements.

Cracked

05AB1E, 10 bytes, Cracked
##3##1+*1+

0-indexed.
0 ==> 1
4 ==> 61
5 ==> 91
9 ==> 271

Original Program:

 UX3*X1+*1+

Cracked

S.I.L.O.S, 37 bytes (Cracked.)
Code:
readIO
#=#
#+#
#*#
#*#
#+#
printInt i

#s are the hidden characters.
Output:
a(0) = 1
a(4) = 41
a(9) = 181

Cracked

MATL, 10 bytes, safe!
2*##n##qn-

Starts at 1, # are hidden characters. Sample input/output:
a(3)=1
a(8)=2

Revealed

The sequence is the number of primes between n and 2*n. The code used was 2*ZqnGZqn-. This takes implicit input, doubles it, and finds the number of primes less than that number, pushes the input again and finds the number of primes less than that, and then subtracts the two lengths from each other.

I was close with 2*_VnGYqn- (number of decimal figures in 2*input). But that doesn't seem to be an OEIS sequence

I'm really surprised you haven't got it! I wan't thinking of anything like that sequence though. The G is correct though.....

Seriously, 14 bytes (Safe)
,???D*≈@??D*≈-

The ?s denote the hidden code. This sequence starts at a(0).
Output:
a(0) = 1
a(1) = 0
a(3) = 1

Solution:
The sequence is:

 A005614 (the infinite Fibonacci word)

My solution:

 ,;uφD*≈@⌐φD*≈-

The solution is a straightforward implementation of the formula found on the OEIS page (with an error corrected so that the sequence starts at n=0 like the page shows, rather than n=1).

I'm assuming your sequence starts at 0.

@QPaysTaxes Given that the first sample output is a(0), that's a safe assumption :)

No, I mean that either a(-1) is undefined or not listed on OEIS.

@QPaysTaxes You are correct.

Pyth, 51 bytes, Safe
# denote hidden characters:
K"#"D#d=#:d"#|#"1Rs#?qd"#"####"##"b#W<#K+#1=KhK;@KQ
K"0"Dhd=b:d"0|1"1Rsm?qd"0""01""10"b;W<lK+Q1=KhK;@KQ

Outputs
a(0) -> 0
a(1) -> 1
a(2) -> 1
a(4) -> 0

This is a fair one.
Thue-morse sequence, A010060.

C++, 55 bytes (Safe)
This one should be easy...
source:
bool f(int###########;##r#;r###&1#####+######r######r;}

Output:
f(1)=>0
f(2)=>1
f(3)=>1
f(4)=>0
f(5)=>1
f(6)=>0
f(7)=>1
f(8)=>0
f(9)=>0
f(10)=>0
f(11)=>1

answer
Sequence:

 A010051 (Characteristic function of primes: 1 if n is prime else 0.)

code:

 bool f(int r){int i=2;for(;r%i&&1-r;i++);return i ==r;}

I am curious, what is the solution?

@mIllIbyte my solution is posted

No obscure language features at all, it's just optimized. Neat!

Haskell, 51 bytes (Cracked)
Outputs:
f 0 -> 0
f 1 -> 1
f 2 -> 1
f 3 -> 0
f 4 -> 0
f 5 -> 3
f 6 -> 5

Code:
f e=sum[#########$#####(f######=#####e####)#######]

This defines a function named f, with # as the wildcard character.
Shouldn't bee too hard to crack.

my guess

@nimi That is exactly identical to my reference answer. I'll edit it here later.

Ruby, 11 bytes, cracked
Code:
->i{######}

Output:
f(0) = 0
f(1) = 0
f(2) = 0
f(3) = 1
f(4) = 0
f(5) = 0
f(6) = 0
f(7) = 1
f(8) = 0
f(9) = 0
f(10) = 0
f(11) = 1
f(12) = 0
f(13) = 0
f(14) = 0
f(15) = 1

And so on, forming A011765. Curious to see if there's more than one way to do this in 6 bytes.

Cracked?

What was the intended solution then? :)

Was being cagey since there might be a way to salvage the trick, but I've added it to the solution thread.

Here it is in 6 bytes in bc: !++x%4

Python, 123 bytes, Cracked
Probably not winning any prizes, but fun nonetheless.
# marks a hidden character, it is not used anywhere in the code.
def #(#):
 if n<2:
  return n
 else:
  return #(n-1)+#(n-2)

def g(n):
 ######:
  return n
 else:
  return (#(n##)+#(##2))###

Sample cases:
g(1) -> 1
g(6) -> 8
g(10) -> 7

My sequence was A089911, Fibonacci Numbers mod 12.
Original code:
def f(n):
 if n<2:
  return n
 else:
  return f(n-1)+f(n-2)

def g(n):
 if n<2:
  return n
 else:
  return (f(n-1)+f(n-2))%12

Cracked.

Javascript, 30 bytes, Cracked
# marks unrevealed characters.
n=>M###.##w(n#!#[#+!#[#)-(n##)
Examples:
0 -> 1
1 -> 1
7 -> 43
18 -> 307

Original Code:
n=>Math.pow(n,!+[]+!+[])-(n-1)

Cracked

J, 7 bytes, cracked
Output:
a(0) = 6
a(2) = 27

Code (I have shown more for added difficulty):
#+#:###

Is a tacit verb.

Cracked.

Python, 17 bytes, Cracked
####a(n):########

Test cases:
a(1) -> 1
a(2) -> 2

Cracked

Python, 60 bytes, Cracked
def a(n):
 if n<#:
  return #
 else:
  return a(n-#)+a(n-#)

Test cases:
a(0) -> 1
a(1) -> 1
a(3) -> 2
a(6) -> 6

Cracked

Seriously, 16 bytes (safe)
???"Xi"?≈$?,?R??

Examples:
a(3) = 1
a(40) = 4

This sequence starts at a(1).

Sequence:

 http://oeis.org/A001222 (prime divisors of n with multiplicity)

Code:

 ΣM£"Xi"w≈$X,QR£ƒ

Explanation:

 The neat thing about this code (and the reason why it's difficult to crack) is that the actual divisor-counting part is reversed. Going through the code, everything up until the , doesn't actually do anything when executed left-to-right (except for pushing "Xi" and then subsequently popping it). ,QR£ƒ reads in the input (n) and executes the code reversed (Q pushes the source code, R reverses it, and £ƒ calls it). Now, the stack contains n and the code is ƒ£RQ,X$≈w"iX"£MΣ. The first 3 commands (ƒ£R) do nothing with an integer on the stack. Q pushes the source code (again), , does nothing because the input is exhausted, and X gets rid of the Q result. $≈ converts the input to a string and back to an int (necessary in the reversed code to prevent unwanted stack items). w pushes a list of [prime, exponent] pairs for all the prime factors of n, and iX"£MΣ sums up all of the exponents.

R 64 bytes
Code
##########################
a=function(x)sum(x*3,1,a(x-2):a(x-1))

Output
a(1) =1
a(2) =1
a(3) =2
a(4) =3
a(5) =5
a(6) =8
a(7) =13
a(8) =21
a(9) =34
a(10)=55
a(11)=89
a(12)=144
a(13)=233
a(14)=377
a(15)=610
a(16)=987
a(17)=1597
a(18)=2584
a(19)=4181
a(20)=6765

Simply, Fibonnaci sequence.
Hope it's fun enough.

Python 2, 87 bytes, cracked
n=input()
#####################################################################
print _

Output:
a(5) = 2
a(10) = 2
a(15) = 1
a(20) = 1
a(25) = 1

I really should have checked for other sequences before I posted, here's another  one that works (A014709):
n=input()
g=lambda n:~n%2*(n/2%2+1)or g(n/2);_=g(n)############################
print _

Cracked.

Jolf, 3 bytes Cracked, A001477
___

Examples:
0 -> 0

1 -> 1

4 -> 4

9 -> 9

Original Code:
 "%"

Cracked.

PHP, 18 bytes, cracked
Here's a very short one, at least in terms of PHP. I wonder if it survives this Sunday the next thirty minutes.
Output
a(0) = -1
a(1) =  0

Source
____$____[1]+_+_0;
#### ####    # #

Notes

It's a full program, not a function.
Reads the input from command line.
Does not contain any PHP opening tag.

Cracked
The sequence was A023443:

a(n) = n - 1

Here's my original source code, which is slightly different to the robber's:

 echo$argv[1]+-+!0;

Cracked.

J, 8 bytes (Cracked)
# marks unrevealed characters
(#1-#)#.

The output:
No, I'm not hiding anything by using a long sample. If the input is 0, it outputs 0, if the input is between 1 and 29, it outputs 1.
The outputs for the negative inputs do not match with the actual sequence.
   (#1-#)#.0
0
   (#1-#)#.1
1
   (#1-#)#.2
1
   (#1-#)#.3
1
   (#1-#)#.4
1
   (#1-#)#.5
1
   (#1-#)#.6
1
   (#1-#)#.7
1
   (#1-#)#.8
1
   (#1-#)#.9
1
   (#1-#)#.10
1
   (#1-#)#.11
1
   (#1-#)#.12
1
   (#1-#)#.13
1
   (#1-#)#.14
1
   (#1-#)#.15
1
   (#1-#)#.16
1
   (#1-#)#.17
1
   (#1-#)#.18
1
   (#1-#)#.19
1
   (#1-#)#.20
1
   (#1-#)#.21
1
   (#1-#)#.22
1
   (#1-#)#.23
1
   (#1-#)#.24
1
   (#1-#)#.25
1
   (#1-#)#.26
1
   (#1-#)#.27
1
   (#1-#)#.28
1
   (#1-#)#.29
1

Are you sure it's a function, so ((#1-#)#.)1 also works?

((#1-#)#.)1 works.

Cracked.

PHP, 137 bytes, cracked
This is my final sequence. You should be feeling lucky when trying this one.
Output
a(3)  =   7
a(7)  =  21
a(23) =  99

Source
for(___range___303_______________________array_merge____)for(__________________________________________)unset________;echo___$argv[1]-1_;
    ###     ###   #######################           ####     ##########################################      ########     ###          #

Notes

This sequence starts at 1.
The program works up to the last number given bei OEIS, but can easily be adjusted to go to any other value as well.
It's a full program, not a function.
Reads the input from command line (obviously).
Does not contain any PHP opening tag.

Cracked
The wording "feeling lucky" and the value 303 in the source were hints to the sequence A000959:

Lucky numbers

This is my original source, which is slightly different to the robber's:

 for($n=range(1,303);$j<count($n);++$j,$n=array_merge($n))for($i=($x=$j?$n[$j]:2)-1;isset($n[$i]);$i+=$x)unset($n[$i]);echo$n[$argv[1]-1];

Cracked.

Jolf, 3 bytes, cracked
Output:
a(0)  =      0
a(4)  =    260
a(10) =  10010
a(23) = 279864

Code:
###

All these features are documented. Yeah, you don't get any parts of the code :P The sequence is off-by-one.
Original:
+ΤQ

Cracked.

Ah, I thought you might be using T because you added it to the docs just before you posted the answer, but I didn't consider combining it with Q.

@MartinBüttner Was it that obvious? XD Nice job, anyhow! Thanks for using Jolf! :D

05AB1E, 4 bytes, cracked
Outputs:
a(0) = 1
a(2) = 4
a(10) = 4444

Code:
____

_ indicates an obfuscated character. Try it online!.

Easy to find. Easy to implement. Hard to optimize to 4 bytes (stuck at 6 atm). Nice challenge!

@Emigna Yeah, that's probably going to be the hardest part. I think I know what your current 6 byte solution is, so my tip is that there are 1 byte commands which can replace 2-byte combinations in your code (and there are two of them). Good luck though :)

Cracked I never understood was Â did when I read the spec. Should have just looked at the code. Pretty sure I tried F earlier, but I must have done something wrong. My favorite cop this far :)

@Emigna Yeah, I might have to make the docs a bit more specific. Great job in cracking though :).

05AB1E, 3 bytes, Cracked
Output:
a(4) = 4
a(6) = 7

Code:
___

_ (underscore) indicates an obfuscated character
Try it online

Cracked :)

@Adnan: Oh come on! Not even 1h :)

Hahaha, sorry. I always get excited when I see someone else post in 05AB1E :).

05AB1E, 8 bytes, Cracked
Output:
a(3) = 2
a(4) = 7

Code:
___s_r__

_ (underscore) indicates an obfuscated character
Try it online
Original Code:
ÑDgs`rG^

Which is the sequence A178910 (Binary XOR of divisors of n.)

Cracked.

05AB1E, 3 bytes, Cracked
Output:
a(3) = 2
a(4) = 6

Code:
___

_ (underscore) indicates an obfuscated character
Try it online
Original Code:
D;^

Which is the sequence A003188 (Decimal equivalent of Gray code for n)

Cracked. That was a nice puzzle! :)

Python, 37 bytes, cracked
def a(n):
    return ______!______n____*_

a(2)==4
a(4)==16

Cracked

Python 3, 58 Bytes, Cracked
# marks unrevealed chars.
import math;x=int(input());print(int(x/math.####(#)*#**#))

If x < 1, it will not work.
in    out
1     0
4     457
7     2578097
10    44721359549
13    1760848250285208
16    131994155879539032064
19    16810747184697114703691776

Cracked.

LiveCode, 35 bytes, cracked
_un_t_on oeis _
    ___u___n__
En__oeis

oeis (2)==2
oeis (0)==0

Cracked

Jelly, 5 bytes (safe)
Code
??Œ??

Each ? denotes a missing character.
Output
n a(n)

0    1
1    3
2    9
3   21
4   45
5   93
6  189
7  381
8  765
9 1533

This is OEIS entry A068156.
Solution
Ḷ¡ŒṘL

Try it online!
How it works
As noted on the OEIS page, this sequence obeys the recursive formula a(n + 1) = 2a(n) + 3, with base cases a(0) = 1, a(1) = 3.
The code begins with the integer n and applies Ḷ (unlength) n times, which convert all integers k in the previous array into the range [0, ... k - 1]. The output after all n steps is similar to the set-theoretic definition of n.
For n = 0, 1, 2, 3, 4, the outputs of Ḷ¡ŒṘ (unlength n times, then generate Python's string representation) is as follows.
0: 0
1: [0]
2: [[], [0]]
3: [[], [[]], [[], [0]]]
4: [[], [[]], [[], [[]]], [[], [[]], [[], [0]]]]

If we examine the outputs for 3 and 4 closely, we can note the following pattern.
[[], [[]], [[], [0]]]XX[[], [[]], [[], [0]]]X
[[], [[]], [[], [[]]], [[], [[]], [[], [0]]]]

The output for 4 consists of two copies of the output for 3 (the actual characters differ, but we're only interested in the length), and three additional characters (X marks the spots). Thus, if we take the length with L, our program follows the desired recursive formula.

Python 3, 50 bytes (Cracked)
Another one, because I like this sequence
>>> a(1)
0
>>> a(10)
2303

The first number from the sequence is a(0). # used to obfuscate characters.
from #### import ####
a=lambda n:####(###########)

Cracked

Python 3, 58 bytes (Cracked)
One last series
>>> a(0)
0
>>> a(4)
8
>>> a(5)
17

Sequence starts with a(0).
a=lambda n:###(###(###)## if ###### else #####(#######)##)

Original was different than the cracked, because I can't golf Python :P
a=lambda n:int(3**(n/2)-1 if n%2==0 else 2*3**(n/2-1/2)-1)

Cracked.

Python 2, 72 bytes, cracked
print####((#y##########.####c###6#####16#.######)#131963###input()#3###)

Outputs:
a(1) = 1
a(2) = 2
a(3) = 3
a(4) = 6
a(5) = 9
a(6) = 18

a(1) is the first element of the sequence. Tested on my personal computer, on repl.it and on ideone (which have versions 2.7.11, 2.7.2 and 2.7.10 respectively).

The sequence is finite, and all terms are listed - it's just the divisors of 18. However, I overlooked the idea that #s could be substituted for newlines...
The original one-liner was:

 print len((BytesWarning.__doc__*6)[8::16].split()[1319648>>input()*3&7])

Cracked.

Pyth, 4 bytes, Cracked
# denote hidden characters:
###Q

Output
a(1) -> 1
a(2) -> 2
a(3) -> 3
a(10) -> 42

Is this offset at all?

@muddyfish ... I posted this answer without double-checking. I updated the examples.

@muddyfish To answer your question, a(0) is the first term of the sequence. I'm not sure if that's what you wanted to know, but at least you know that.

Cracked.

Pyth, 29 bytes
W##YQ#t^#Z=#h#I#_#=#+Y##;@#tQ

Probably not an easy one. Begins at 1.
a(1) -> 2
a(2) -> 3
a(3) -> 5
a(4) -> 7
a(5) -> 13

Python 3, 108 bytes (Cracked)
Warning (and hint): my implementation is dreadfully slow...
>>> a(0)
0
>>> a(4)
2
>>> a(16)
8
>>> a(20)
42

a(0) is the first element of the series exactly as defined in OEIS.
# is used to hide chars.
def a(n):
 ###n####0######n#0
 f=a#######
 return f #f#####a###### f ####a(##f###i#i###a####n##else a#######

Cracked

Molecule (v5.5), 25 bytes (UTF-8)
"ᘰᜟᘄఄሳÝ̲"C`n

No characters are hidden here ;)
An input of 0 is allowed.
Output of 1: 16
Output of 2: 21

You need to hide some characters to make it a valid submission

The worst thing: It's safe xD

Python, 42 bytes Cracked
def f(x):return # if x<#else ######+######

Where
f(0) -> 0
f(1) -> 1
f(7) -> 13
f(15) -> 610

Cracked.

PHP, 118 Bytes, Safe
I hope that I'm understand the rules right
function f($n){for($a=[],$i=0,$n++;$n!=@@@@@@($a);$i++)if(@@@@@@@)if(@@@@@@@@(@@@@@@@@@@@@@@))$a[]=$i;return end($a);}

echo f(6); # 16
echo f(13);# 32
echo f(0); #2
echo f(1); #4
echo f(54); #128

Original code
function f($n){
  for($a=[],$i=0,$n++;$n!=sizeof($a);$i++){
      if($t=$i%7)if(in_array($t,array(2,4,6)))$a[]=$i;
  }
  return end($a);
}

generates this sequence

source: Stack Exchange

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

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

sort: votes


text:
Find the program that prints this integer sequence (Robbers' thread)
This is the robbers' thread. The cops' thread goes here.
In the cops thread, the task was to write a program/function that takes a positive (or non-negative) integer and outputs/returns another number (not necessarily integer). The robbers task is to unscramble the code the cops used to produce this output.
The cracked code doesn't have to be identical, as long as it has the same length and any revealed characters are in the correct positions. The language must also be the same (version numbers can be different). The output must of course be identical.
No-ops can be used in robber's solution.
The winner of the robbers thread will be the user who has cracked the
most submissions by May 7th 2016. If there's a tie, the user who has cracked submissions with the longest combined code will win.
The submission should be formatted like this:
Language, nn characters (including link to answer), Cop's username
Code:
function a(n)
    if n<2 then
        return n
    else
        return a(n-1) + a(n-2)
    end
end

Output
a(0) returns 0
a(3) returns 2

Optional explanation and comments.

These rules here are different from the cops thred, where it says: However, any proposed source code that produces the same set of output also counts as valid, as long as it is also found in OEIS.

What happens if the examples match multiple OEIS series ? This Just happened with Adnan and me

@FliiFe Under the current rules, any code which matches the cop's code and outputs an OEIS sequence whose values coincide with the cop's examples is a valid crack.

Has this finished? Is there a winner?

MATL, 5 bytes, Luis Mendo
H5-*|

This code calculates abs((2-5)*input) which is just a(n)=3*n for positive numbers, which is http://oeis.org/A008585

Well done! My original code was 35B*s :-)

Hexagony, 7 bytes, Adnan, A005843
?{2'*!@

or
 ? {
2 ' *
 ! @

Try it online!
Simply doubles the input (and assumes positive input). The code is (for once) simply executed in reading order. The code uses three memory edges A, B, C with the memory pointer starting out as shown:

?    Read integer from STDIN into edge A.
{    Move memory pointer forwards to edge B.
2    Set edge B to 2.
'    Move memory pointers backwards to edge C.
*    Multiply edges A and B and store result in C.
!    Print result to STDOUT.
@    Terminate program.

The exact same with what I had! :)

@KennyLau I think the solution is unique up to swapping the roles of B and C.

J, 7 bytes, Cᴏɴᴏʀ O'Bʀɪᴇɴ
Code
2+*:@p:

Output
   f =: 2+*:@p:
   f 0
6
   f 2
27

Try it with J.js.
How it works
Sequence A061725 is defined as a(n) := pn² + 2, where pn is the (n + 1)th prime number.
2+*:@p:  Monadic verb. Argument: n

    @    Atop; combine the verbs to the right and to the left, applying one after
         the other.
     p:  Compute the (n+1)th prime number.
  *:     Square it.
2+       Add 2 to the result.

Nice job! You understand the code more than I did XD

JavaScript, 10 bytes, user81655, A033999
I think I got it. Yeah. This one was really hard. I like the submission because it relies heavily on precedences.

It's the sequence A033999:

a(n) = (-1)^n.

Source
t=>~t.z**t

Explanation
If you split this code according to the JavaScript operator precedences you get:

. (precedence 18) gets evaluated first and t.z will return undefined.
~ (precedence 15) tries to cast undefined, resulting in 0, and returns -1 after bitwise not.
** (precedence 14) will return -1 ^ t, where t is odd or even, resulting in -1 or 1.

Demo
console.log(
    (t=>~t.z**t)(0),
    (t=>~t.z**t)(1),
);

Try before buy

I will award a 100 rep bounty on this cool Cop submission.

You are correct, congratulations! :)

I consider myself well-versed in javascript, but I have no idea how this works.

@CᴏɴᴏʀO'Bʀɪᴇɴ I've added an explanation. Hopefully it explains it well enough.

That's why the brute-force didn't find it. I used a transpiler with wrong op precedence >_<

05AB1E, 5 bytes, Adnan, A001788
Læ€OO

Try it online! This uses an alternative definition given on the page. Explanation:
Læ€OO
L     range;      [1..n]
 æ    powerset;   [[], [1], ..., [1..n]]
  €O  mapped sum; [0, 1, ..., T(n)]
    O sum;        [a(n)]

Ruby, 38 bytes, histocrat, A008592
->o{(s="+o++o"*5).sum==03333&&eval(s)}

Could be different from the intended solution as I found this by hand.

Nicely done! Intended solution was similar: "+f+=f"*5.

Element, 7 bytes, PhiNotPi, A000042
_'[,1`}

Notes: I was misled by the } for soooooo long. So it also matches [.
Try it online!

How it works:
_'[,1`}
_        main_stack.push(input());
 '       control_stack.push(main_stack.pop());
  [      Object temp = control_stack.pop();
         for(int i=0;i<temp;i++){
   ,         Object a = main_stack.pop(); //is actually zero
             main_stack.push(a.toChars()[0]);
             main_stack.push(a);
    1        main_stack.push(1);
     `       System.out.println(main_stack.pop());
      }  }

Nice! I was trying this, but I couldn't figure out how to get the , to stop breaking things.

My trick was to do ,$ to produce a 1, which gave me an excuse to put the really confusing , operator in my program.

I was stuck at the } for tooooo long :(

05AB1E, 4 bytes, Paul Picard, A001317
Code:
$Fx^

Try it online!
Explanation:
$      # Pushes 1 and input
 F     # Pops x, creates a for-loop in range(0, x)
  x    # Pops x, pushes x and 2x
   ^   # Bitwise XOR on the last two elements
       # Implicit, ends the for-loop
       # Implicit, nothing has printed so the last element is printed automatically

The sequence basically is a binary Sierpinski triangle:
f(0)=      1                    =1
f(1)=     1 1                   =3
f(2)=    1 0 1                  =5
f(3)=   1 1 1 1                 =15
f(4)=  1 0 0 0 1                =17

And translates to the formula a(n) = a(n - 1) XOR (2 × a(n - 1))
Luckily, I remembered this one :)

And it is the exact same one, indeed :D

PHP, 41 bytes, insertusernamehere, A079978
echo/* does n%3=0 */$argv[1]%3<1?1:0    ;

Returns 1 if its argument is a multiple of 3, and 0 otherwise. Not much beyond that.

Kudos! I had something completely different in mind. :)

Jolf, 3 bytes, Easterly Irk, A001477
axx

Consists of a simple cat (ax) followed by a no-op. Not sure what the cop was going for here.

That is most definitely not the identity function. It's alert the input. There are actual identity functions :P

MATL, 9 bytes, beaker, A022844
Code (with a whitespace at the end):
3x2xYP*k

Try it online!
Found the following three matches with a script I wrote:
Found match: A022844
info: "name": "Floor(n*Pi).",

Found match: A073934
info: "name": "Sum of terms in n-th row of triangle in A073932.",

Found match: A120068
info: "name": "Numbers n such that n-th prime + 1 is squarefree.",

I tried to do the first one, which is basically done with YP*k:
3x2x       # Push 3, delete it, push 2 and delete that too
    YP     # Push pi
      *    # Multiply by implicit input
       k   # Floor function

Java, 479 bytes, Daniel M., A000073
Code:
import java.util.*;
public class A{

    public static int i=0;
    public boolean b;

    static A a = new A();

    public static void main(String[] args){
        int input = Integer.parseInt(args[0]);

        LinkedList<Integer> l = new LinkedList<>();
        l.add(1);
        l.add(0);
        l.add(0);

        for(int ix = 0; ix<=input; ix++)if(ix>2){
            l.add(0,l//d
            .get(1)+l.peekFirst()+     l.get(2));
        }

        System.out.println(input<2?0:l.pop()
              +(A.i        +(/*( 5*/ 0 )));
    }
}

If you miss non-revealed characters, they are replaced with spaces.

Very different from the original code, but still, congrats!

S.I.L.O.S, betseg, A001844
readIO
a=i
a+1
i*2
i*a
i+1
printInt i

Try it online!

goddamnit you ninjad me

Jolf, 5 characters, Cᴏɴᴏʀ O'Bʀɪᴇɴ, A033536
Code:
!K!8x

Output:
a(2) = 8
a(10) = 4738245926336

This was the exact same answer I had. I was about to post it. :(

Neither answer is the original, but they are functionally the same.

@QPaysTaxes Sorry :(

Reng v3.3, 36 bytes, Cᴏɴᴏʀ O'Bʀɪᴇɴ, A005449
iv:#+##->>)2%æ~¡#~
#>:3*1+*^##</div>

Output
a(1) = 2
a(3) = 15

Explanation
I completely ignored the prespecified commands, except the ) because I did not have enough space.
The actually useful commands are here:
iv      >>)2%æ~
 >:3*1+*^

Stretched to a straight line:
i:3*1+*)2%æ~

With explanation:
i:3*1+*)2%æ~ stack
i            [1]      takes input
 :           [1,1]    duplicates
  3          [1,1,3]  pushes 3
   *         [1,3]    multiplies
    1        [1,3,1]  pushes 1
     +       [1,4]    adds
      *      [4]      multiplies
       )     [4]      shifts (does nothing)
        2    [4,2]    pushes 2
         %   [2]      divides
          æ  []       prints
           ~ []       halts

The formula is a(n) = n(3n+1)/2.

+1 for </div>, an HTML closing tag that somehow appeared in Reng code.

@zyabin101 Wrong place?

Nope. I just like finding hidden secrets in code. :-P

Well this is in the cop's code, so...

05AB1E, 3 bytes, Adnan, A000292
LLO

Output
a(9) = 165
a(10) = 220

How it works
LLO Stack
L   [1,2,3,4,5,6,7,8,9]                         range
 L  [1,1,2,1,2,3,1,2,3,4,...,1,2,3,4,5,6,7,8,9] range of range
  O sum all of them

The mathematical equivalent is sum(sum(n)), where sum is summation.

Nice job, that was the exact same solution :)

Python 2, 87 bytes, Sp3000, A083054
n=input()
_=int(3**.5*n)-3*int(n/3**.5)########################################
print _

Not that hard, actually. Just searched for sequences that met the constraints until I found one that could be generated in the given space.

Jolf, 11 bytes, QPaysTaxes, A000005
aσ0xxdxxxxx

Simple enough: alert the σ0 (number of divisors of) x, then put useless stuff at the end.
Try it online! The test suite button's a bit broke, but still shows proper results.
(You could've golfed it down to two bytes! Just σ0 would've done nicely.)

Wow! Le builtins minuscules! +1

This is nothing like what I had, but it sure works. Mine was so long because you didn't have any mention of finding divisors in the docs.

@QPaysTaxes I guess I need to update the docs :P But seriously, just Ctrl+F the source code ;)

I put my original code in my question if you wanna see it. In retrospect, I should have showed different characters :P

Jolf, 11 bytes, RikerW, A011551
Code:
c*mf^+91x~P

Explanation:
     +91     # add(9, 1) = 10
    ^   x    # 10 ** input
  mf         # floor function (no-op)
 *       ~P  # multiply by phi
c            # ¯\_(ツ)_/¯

Try it here.

c is "cast to integer"

JavaScript (ES6), 119 bytes, Cᴏɴᴏʀ O'Bʀɪᴇɴ, A178501
x=>(n="=>[[["|x|"##r(###f#n###;##")|n?Math.pow("#<1##].c####t.##pl##[####nc#"|10,"y([###(###(#]###)"|x-1|``):0|`#h####`

I'm sure the actual code generates a trickier sequence than this, but with just the two outputs, this OEIS sequence is simple and matches them.
Without all the ignored characters, the algorithm is just x=>x?Math.pow(10,x-1):0.

05AB1E, 5 bytes, Luis Mendo, A051696
Code:
Ðms!¿

Explanation:
Ð      # Triplicate input.
 m     # Power function, which calculates input ** input.
  s    # Swap two top elements of the stack.
   !   # Calculate the factorial of input.
    ¿  # Compute the greatest common divisor of the top two elements.

So, basically this calculates gcd(n!, nn), which is A051696.
Try it online!.

PHP, 18 bytes, insertusernamehere, A023443
Code:
echo$argv[1]+0+~0;

Output:
a(0) = -1
a(1) = 0

Very nice approach. My source was slightly different: echo$argv[1]+-+!0;. :)

Octave (34 bytes) by Stewie Griffin
The sequence is A066911.
@(m)(mod(m,u=1:m  )&isprime(u))*u'

Nice =) For the record, I had u=0:m-1. The same sequence.

PHP, 137 bytes, insertusernamehere, A000959
Code:
for($s=range(1,303);$i<($t=count($s));$s=array_merge($s))for($j=($k=++$i==1?2:$s[$i-1])-1;$j<$t;$j+=$k )unset($s[$j]);echo$s[$argv[1]-1];

Output:
a(3)  =   7
a(7)  =  21
a(23) =  99

Nicely done. Your source is slightly different and you even saved one byte. :)

05AB1E, 10 bytes, George Gibson, A003215
Code:
Ds3*s1+*1+

Explanation:
Computes 3*n*(n+1)+1 which is the oeis sequence A003215.

Python 3 (58 bytes) by CAD97
The sequence is A062318. There were a lot of unnecessary characters in this one, so I commented some out.
a=lambda n: ~-( -~(n%2)
# if ###### else
*3**(n//2))#)##)

The original was the slightly more literal a=lambda n:int(3**(n/2)-1 if n%2==0 else 2*3**(n/2-1/2)-1), but this works as well and is golfier. GG

Ruby, 11 bytes, histocrat, A011765
It only needs 5...
->i{i%4/3 }

I'd like to note though that the sequence is off-by-one compared to OEIS (which specifies that the first term corresponds to A(1)).

Argh, could've sworn I checked for solutions of that form. Also, sorry, yes, didn't notice the offset on the sequence entry.

Intended solution: i[i%2] (the (i mod 2)th least significant bit of i)

@histocrat neat, I didn't even know bits could be indexed like that. :)

Haskell, 51 bytes, Zgarb, A063866
f e=sum[1|1<-sum<$>mapM(flip(:)=<<pure.(0-))[1..e]]

Output: map f [0..6]: [0,1,1,0,0,3,5].

Element, 10 bytes, PhiNotPi, A097547
2_4:/2@^^`

Try it online!
Output
a(3) = 6561
a(4) = 4294967296

05AB1E, 5 bytes, Adnan, A102669
Code:
TA«-g

Output:
a(0) = 0
a(1) = 0
a(2) = 1
a(3) = 1
a(4) = 1
a(5) = 1
a(6) = 1
a(7) = 1
a(8) = 1
a(9) = 1
a(10) = 0
a(11) = 0

Too bad you have designed the language in this inconvenient way.

Wow, I did not see that coming haha. The original code was 0K1Kg.

Python, 17 bytes, ASCIIThenANSI, A000027
def a(n):return n

Trivial?

Python, 60 bytes, ASCIIThenANSI A000930
def a(n):
 if n<3:
  return 1
 else:
  return a(n-1)+a(n-3)

Still trivial

05AB1E, (4 bytes) by Adnan
The sequence is A126804, and the code to produce it is
D·ŸP

Try it online
I've never even looked at a program in 05AB1E before, it looks like a pretty cool language!

Very nice! That was the exact same solution :)

Lua, 45 bytes, Katenkyo, A001477
a=function(n)return n-1<1 and 0or 1+a(n-1)end

Swift, 55 bytes, Nefrin, A103847
The sequence is McCarthy's 91 Function.
It takes the value 91 for any n up to 101 and then continues with 92,93,94 ...
I wonder what it's actually useful for.
func M(n:Int)->Int{
return(n<=100) ?M(M(n+11)):n-10;
}

05AB1E, 28 bytes, Lause, A256861
Code:
DD>D>D>D>****sD<*6+*6n2n5**/

Explanation:
              # implicit n on stack
DD>D>D>D>     # save n,n+1,n+2,n+3,n+4 on the stack
****          # multiply top 5 on stack together
              #     new stack: n,n(n+1)(n+2)(n+3)(n+4)
sD<*          # rotate, duplicate, decrease, multiply
              #     new stack: n(n+1)(n+2)(n+3)(n+4),n(n-1)
6+*           # add 6 to stack, add top 2, multiply top 2
              #     new stack: n(n+1)(n+2)(n+3)(n+4)(n(n-1)*6)
6n2n5**       # add 720 to stack
/             # divide
              # implicitly print n(n+1)(n+2)(n+3)(n+4)(n(n-1)*6)/720

Pyke, 6 bytes, muddyfish, A005563
0QhXts

Yay hacks! The 0Qh and s are no-ops. hXt just computes (n + 1) ^ 2 - 1.

J, 8 bytes, Kenny Lau, A057427
Code:
(-%- )\.

Output:
a(0) = 0
a(1..29) = 1

I don't think this is intended. And I don't know why J had this behavior. But it works.

Gonna add one more restriction xd

Pyth, 70 bytes, FliiFe, A070650
Code (with obfuscated version below):
DhbI|qb"#"qb"#"R!1Iqb"#";=^Q6+""s ]%Q27  ;.qlY+Q1Ih+""Z##;.q)=Z+Z1;@YQ
DhbI|qb"#"qb"#"R!1Iqb"#"#####+""s####2###;##lY+Q1Ih+""Z#####)=Z+Z1;@YQ (obfuscated)

This basically does:
=^Q6%Q27

It calculates a(n) = n6 % 27, which is A070650. Explanation:
=^Q6       # Assign Q to Q ** 6
    %Q27   # Compute Q % 27
           # Implicit output

Try it here

Oops, that's not the one. I updated my answer with another one

From the rules, this is valid. Congrats !

I guess I can tell you the sequence now, It's A007770 (0-indexed)

@FliiFe Oh, I would never have guessed that :p

Actually, if you know the sequence, it's easily spottable, but if you don't, it becomes really hard

Python, 108, CAD97, A005132
def a(n):
 if n == 0: return 0
 f=a(n-1)-n
 return f if f>0 and not f in(a(i)for i in range(n))else a(n-1)+n

Obfuscated code :
def a(n):
 ###n####0######n#0
 f=a#######
 return f #f#####a###### f ####a(##f###i#i###a####n##else a#######

Outputs:
>>> a(0)
0
>>> a(4)
2
>>> a(16)
8
>>> a(20)
42

Exactly what I had. Expected it to be easy, honestly.

C (71 bytes) by mIllIbyte
The sequence is floor(n/4).
x;f(_){x/=4;
    }
main(){
 scanf("%d",&x);
 f( 6);
 printf("%d", x);
}

Jolf, 3 bytes, Cᴏɴᴏʀ O'Bʀɪᴇɴ, A091940
+QQ

Test it here.
Since the output is off-by-one, the second formula on OEIS reduces to n + n^4. Where we implement n^4 by squaring the input twice.

Oh, this wasn't it. What does off-by-one mean? I think I messed it up

@CᴏɴᴏʀO'Bʀɪᴇɴ It means that the number you get for a(23) is actually A091940(24). But this code matches all 4 test cases in your cop post, so whether or not this was your original code, I think it's a valid crack.

Okay then. Nice job!

05AB1A, 4 bytes, Adnan, A001127
Code:
$FÂ+

Explained:
$          # push 1 and input
 F         # input number of times, do:
  Â        # duplicate and reverse
   +       # add

The sequence starts at 1 and continues by adding the current number to its reverse.
0: 1
1: 1+1 = 2
2: 2+2 = 4
3: 4+4 = 8
4: 8+8 = 16
5: 16+61 = 77
6: 77+77 = 154
7: 154+451= 605
and so on...

05AB1E, 3 bytes, Emigna, A022559
Code:
!ÓO

Explanation:
!    # Compute the factorial of the implicit input.
 Ó   # Compute the exponents of the prime factors.
  O  # Sum that up together.

Resulting into A022559. Try it online!

Python, 37 bytes, mnbvc, A000290
I/O:
a(2) = 4
a(4) = 16

Code:
def a(n):
    return n*n#__!______n____*_

Sequence return square of input

05AB1E, 1 byte, mnbvc, A004085
Code:
Õ

Sequence is the sum of digits of Euler totient function of n.

LiveCode, 35 bytes, mnbvc, A001477
I/O:
oeis (0) = 0
oeis (2) = 2

Code:
function oeis n
    return n*1
End oeis

Sequence returns the non-negative integers.

05AB1E, 3 bytes, Emigna, A002994
Code:
3m¬

Explanation:
3m   # Compute input ** 3
  ¬  # Take the first digit

This gives us the initial digits of the cubes, which is A002994.
Uses CP-1252 encoding. Try it online!.

05AB1E, 8 bytes, Emigna, A088666
Code (with obfuscated version below):
4m1s+rT%
___s_r__

Explanation:
4m         # Compute input ** 4
  1        # Add one to the stack
   s       # Swap the top two elements
    +      # Add the two numbers (result = input ** 4 + 1)
     r     # Reverse the stack
      T    # Add 10
       %   # Modulo

This comes down to the formula a(n) = (n4 + 1) % 10, which is A088666. I'm excited to see what the original code was.
Try it online!.

Python 3, 50 bytes, CAD97, A004242
from math import    *
a=lambda n:ceil(1000*log(n))

Try it online
Output:
a(1) => 0
a(10) => 2303

That was fast (though I honestly did not make it very difficult)

@CAD97 I got tripped up slightly because originally I was only importing ceil from math, because I forgot log was in math and not __builtins__. I liked that trick. :)

Python 2 (72 bytes) by Sp3000
There's an unbelievable amount of sequences starting with 1,2,3,6,9,18 from the 1 element. I was fortunate to find one on the 3rd page where these are the only 6 terms: Divisors of 18.
print[1,#((#y
2,3,6,9,#.####c###6#####16#.
18][#)#131963
~-input()#3
]#)

Hmm... I have to say that is the right sequence, but I overlooked the idea  that some of the characters could be replaced by newlines (probably got confused due to the rule changes early on). In any case, a crack is a crack.

Pyth, 4 bytes, FliiFe, A000041
Code:
l./Q

Explanation:
 ./Q  # Calculate the paritions of Q (input)
l     # Take the length, which counts the number of partitions.

Try it here.

Now that I think of it, I could have written l./ with implicit imput.

JavaScript, 30 bytes, Aplet123, A002061
It's the sequence A002061:

Central polygonal numbers: n^2 - n + 1.

n=>Math.pow(n,!![]+!![])-(n-1)

See it in action on JSFiddle.

Python, 123 bytes, ASCIIThenANSI, A089911
Code:
def f(n):
 if n<2:
  return n
 else:
  return f(n-1)+f(n-2)

def g(n):
 if n<2:
  return n
 else:
  return (f(n-1)+f(n-2))%12

The formula for this sequence is g(n) = f(n) % 12, whereas f(n) is the nth Fibonacci number.
This was actually a really nice puzzle! :)

J, 8 bytes, Kenny Lau, A057427
Code:
(>1-*)<.

Output:
a(0) = 0
a(i) = 1 for 0 < i < 30

The sequence is simply signum(n).
The program computes floor(n) > 1 - signum(floor(n)), which is signum(n) for non-negative integers n.

Python 3, 58 bytes, Mega Man
import math;x=int(input());print(int(x/math.sqrt(5)*x**x))

The sequence is:
(x/√5)*(x**x)

Python, 42 bytes, TùxCräftîñg
def f(x):return x if x<2else f(x-1)+f(x-2)

This is the Fibonacci sequence.

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


text:
Switching Gravity
Challenge
You are given an ASCII-art representation of characters on a plane as input by any reasonable method. This will only contain:

[a-z] representing moveable characters. Every letter will appear on the board at most once.
# representing immovable walls
. representing empty space

For example:
abcdef.gh#..
.......ij.#.
#..#.......#
...#.#...###
.#.......#q#
.........###

You are also given a string representing the changes in gravity. This will only contain:

> representing a change to rightward gravity
< representing a change to leftward gravity
^ representing a change to upward gravity
v representing a change to downward gravity

For example:
v>^

Your program must simulate the each change in gravity sequentially until all characters stop moving (they hit a wall, or another character). Characters that "fall off the edge of the map" are permanently removed, and characters can "stack" on top of each other.
In this example, at the start there is downward gravity (v), so c, e, g, h, i, and j fall off the bottom of the map. All other characters slide downwards until hitting a wall, leaving the map like this:
.........#..
a..d......#.
#..#.f.....#
.b.#.#...###
.#.......#q#
.........###

Then, we move on to rightward gravity (>), which leaves us with this:
Note how the a stacks next to the d.
.........#..
........ad#.
#..#......f#
..b#.#...###
.#.......#q#
.........###

Finally, we simulate upward gravity (^), during which the a and the b fall off the map.
.........#..
.........d#.
#..#......f#
...#.#...###
.#.......#q#
.........###

Your task is to output the remaining characters after the gravitational shifts. They can be given in any order. For this example, you could output any permutation of dfq.
Testcases
For the following map:
abcde
.....
##.##

v   =  abde
v>  =  <nothing>

For the following map:
######
#....#
abcdef
#.gh..
######

>   = <nothing>
<   = gh
^>  = bcde
v<  = bghef

How is the input given? List of strings? Function argument? STDIN?

@KennyLau All of those options are fine. Input and output can be anything reasonable for your language.

Somewhat related.

JavaScript (ES6), 251 233 bytes
(m,d,r=`replace`)=>[...d].map(c=>[...`<^>v`].map(d=>m=[...(m=(c==d?m[r](/[.\w]+/g,s=>s[r](/\./g,``)+s[r](/\w/g,``))[r](/^\w+/gm,s=>s[r](/./g,`.`)):m).split`
`)[0]].map((_,i)=>m.map(s=>s[i]).join``).reverse().join`
`))&&m[r](/\W/g,``)

Edit: Saved 18 bytes thanks to @WashingtonGuedes.
Works by rotating the input grid four times for each directional character, but on the direction where the directional character matches the loop character we do the left gravity thing. Pseudocode:
function slideleft(map) {
    map = map.replace(/[.\w+]/g, match=>movedotstoend(match));
    map = map.replace(/^\w+/gm, match=>changetodots(match));
}
function rotate(map) {
    return joinrows(reverse([for each (column of rows(map)[0])
            joinrow([for each (row of rows(map)) row[column]])
           ]));
}
function gravity(map, directions) {
    for each (direction of directions) {
        for each (angle of '<^>v') {
            if (direction == angle) map = slideleft(map);
            map = rotate(map);
        }
    }
    return letters(map);
}

JavaScript (ES6), 199
Same algortihm of @Neil's answer. The grid is rotated four times for each directional character, when in the right position the gravity shift to left is applied to each row.
x=>y=>(x=>{for(d of y){R='';for(e of'^>v<')x=[...x[0]].map((c,i)=>e!=d?x.map(r=>r[i]).join``:x.map(r=>(c=r[i])<'.'?(q+=p+c,p=''):c>'.'&&q?(q+=c,R+=c):p+='.',q=p='')&&q+p).reverse();}})(x.split`
`)||R

F=x=>y=>(x=>{for(d of y){R='';for(e of'^>v<')x=[...x[0]].map((c,i)=>e!=d?x.map(r=>r[i]).join``:x.map(r=>(c=r[i])<'.'?(q+=p+c,p=''):c>'.'&&q?(q+=c,R+=c):p+='.',q=p='')&&q+p).reverse();}})(x.split`
`)||R

// Less golfed

U=(x,y)=>
{
  x = x.split`\n`;
  for(d of y)
  {
    R = '';
    for(e of '^>v<')
      x = [...x[0]].map(
        (c,i) => e != d
        ? x.map( r => r[i] ).join`` // basic rotation
        : x.map( // rotation with gravity shift
          r=> (c=r[i])<'.' ? (q+=p+c,p='') : c>'.'&&q?(q+=c,R+=c) : p+='.', q=p=''
        ) && q+p
      ).reverse();
  }
  return R
}

console.log=x=>O.textContent+=x+'\n'

;[
  ['abcdef.gh#..\n.......ij.#.\n#..#.......#\n...#.#...###\n.#.......#q#\n.........###',
   [['v>^','dfq']]
  ],
  ['abcde\n.....\n##.##',[['v','abde'],['v>','']]],
  ['######\n#....#\nabcdef\n#.gh..\n######',[['>',''],['<','gh'],['^>','bcde'],['v<','befgh']]]
].forEach(t => {
  var i=t[0]
  console.log(i)
  t[1].forEach(([d,k])=>{
    var r=F(i)(d),ok=[...r].sort().join``==k
    console.log((ok?'OK ':'KO ')+d+' : '+r+(ok?'':' (expected '+k+')'))
  })
  console.log('')
})

Pyth, 143 bytes
(Do we really need that much bytes?)
JhQKeQMe.u:N+"\."H+H"."G;DybVkI}NG=gkN;D'bVlJ=k@JNykVkI}HG=:kH\.).?B)=XJNk;VKIqN\<'J)IqN\v=C_J'J=_CJ)IqN\>=C_CJ'J=C_CJ)IqN\^=CJ'J=CJ;VJVNI}HGpH

Try it online!
How it works
We define a function left which does the leftward gravity thing.
Then, the other directions are implemented by messing with the array so that the desired direction is leftwards, then do left.
The algorithm of left is here:

Do the following until idempotent:
Replace ".X" with "X.", where X represents a letter.

The whole program is divided into the following 6 sections:
JhQKeQ
Me.u:N+"\."H+H"."G;
DybVkI}NG=gkN;
D'bVlJ=k@JNykVkI}HG=:kH\.).?B)=XJNk;
VKIqN\<'J)IqN\v=C_J'J=_CJ)IqN\>=C_CJ'J=C_CJ)IqN\^=CJ'J=CJ;
VJVNI}HGpH

First section
JhQKeQ     Q auto-initialized to evaluate(input())
JhQ        J = Q[0]
   KeQ     K = Q[len(Q)-1]

Second section
Me.u:N+"\."H+H"."G;   @memoized
M                 ;   def g(G,H):
  .u             G      repeat_until_idempotent(start:G, as N):
    :Nxxxxxxyyyyy         return N.replace(xxxxxx,yyyyy)
      +"\."H                               "\."+H
            +H"."                                 H+"."

Third section
DybVkI}NG=gkN;    @memoized
Dyb          ;    def y(b):
   Vk               for N in k:     --TAKES GLOBAL VARIABLE k
     I}NG             if N in G:    --G pre-initialized to "abcde...z"
         =gkN           k = g(k,N)

Fourth section
D'bVlJ=k@JNykVkI}HG=:kH\.).?B)=XJNk;  @memoized
D'b                                ;  def single_quote(b):
   VlJ                       )          for N in range(len(J)): --TAKES GLOBAL VARIABLE J
      =k@JN                               k = J[N] --SETS GLOBAL VARIABLE k
           yk                             y(k) --returns nothing, but MODIFIES GLOBAL VARIABLE k
             Vk                           for H in k:
               I}HG      )                  if H in G:
                   =:kH\.                     k = k.replace(H,".")
                          .?                else:
                            B                 break
                              =XJNk     J[N] = k --MODIFIES GLOBAL VARIABLE J

Fifth section
VKIqN\<'J)IqN\v=C_J'J=_CJ)IqN\>=C_CJ'J=C_CJ)IqN\^=CJ'J=CJ;
VK                                                       ; for N in K:
  IqN\<  )                                                   if N == '<':
       'J                                                      single-quote(J)
          IqN\v          )                                   if N == 'v':
               =C_J                                            J = transpose(reverse(J))
                   'J                                          single-quote(J)
                     =_CJ                                      J = reverse(transpose(J))
                          IqN\>            )                 if N == '>':
                               =C_CJ                           J = transpose(reverse(transpose(J)))
                                    'J                         single-quote(J)
                                      =C_CJ                    J = transpose(reverse(transpose(J)))
                                            IqN\^            if N == '^':
                                                 =CJ           J = transpose(J)
                                                    'J         single-quote(J)
                                                      =CJ      J = transpose(J)

Sixth section
VJVNI}HGpH
VJ           for N in J:
  VN           for H in N:
    I}HG         if H in G: --G = "abc...z"
        pH         print(H)

Ruby, 306 bytes
Anonymous function. Pretty circuitous technique that could probably be optimized.
->s,d{w=[];x=y=0;m={}
s.chars.map{|c|c>?!?(c<?A?c<?.?w<<[x,y]:0:m[c]=[x,y]
x+=1):(x=0;y+=1)}
d.chars.map{|c|q=[c<?=?-1:c<?A?1:0,c>?a?1:c>?A?-1:0];e=1
(n=m.clone.each{|k,v|z=[v[0]+q[0],v[1]+q[1]]
w.index(z)||m.value?(z)?0:m[k]=z}
m.reject!{|k,v|i,j=v;i<0||i>=x||j<0||j>y}
e=(m!=n ?1:p))while e}
m.keys.join}