Vim 36 keystrokes

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

05AB1E, 5 bytes

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.

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.

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!

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.

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

05AB1E, 3 bytes, cracked

Output:

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

Hidden code:

##O

Try it online might come in handy.

Hexagony, 7 bytes, cracked

Output:

a(1) = 2
a(2) = 4

Hidden code:

?#####@

Or alternatively:

 ? #
# # #
 # @

Try it online might come in handy.

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.

Jolf, 11 bytes, Cracked , A011551

c*______x__

c*mf^+91x~P

Original code:

c*^c"10"x~P

Examples:

0 -> 1

12 -> 1618033988749

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

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.

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@^^`

Pyke, 15 bytes

Output

a(2) = 21
a(15) = 17

Revealed code:

#R#D######+##)#

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

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.

C, 71 bytes

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

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

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

Jolf, 16 bytes

Outputs:

a(0) = 0
a(4) = -2
a(51) = 26

Code:

#.‘###4#x##32#mA

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

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

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(1) -> 7
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.)

J, 7 bytes, cracked

Output:

a(0) = 6
a(2) = 27

Code (I have shown more for added difficulty):

#+#:###

Is a tacit verb.

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 _

Jolf, 13 bytes

Outputs:

a(5) = 40
a(8) = 128

Code:

#+~##~####xx#

Interpreter.

Jolf, 3 bytes Cracked, A001477

___

Examples:

0 -> 0

1 -> 1

4 -> 4

9 -> 9

Original Code:

 "%"

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>

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

JavaScript (ES7), 10 bytes

Output

f(0) -> 1
f(1) -> -1

Code

t=>~t##**#

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