text:
Code ladder, Cops

Note: This challenge is finished. Submissions are still welcome but can not win.

This is the cops' thread. The robbers' thread goes here.
Write a code that outputs the integer 1. If you add, remove or substitute a single character (of your choosing), the code should output the integer 2. Change one more character (the same or another), and the code should output 3. Continue like this as far as you can, but maximum up to 10. Default output formats such as ans = 1 are accepted. You can ignore output to STDERR (or equivalent).
You must reveal the language, byte count of your initial code, the number of integers it works for, as well as an optional number of characters of the initial code. Note: You don't have to reveal any characters, but remember that revealing characters might make it harder for the robbers as they must use the same character in the same position. You can choose which character you use to denote unrevealed characters (for instance underscore), but make sure to specify this.
Cops can provide the uncracked code after one week and call the submission "SAFE". The winning submission will be the shortest uncracked submission that produces the number 10. If no uncracked submissions are able to print 10, the shortest code that produces 9 will win, and so on. Note that the robbers don't have to make the same changes as you do, and they don't have to reproduce the exact code (unless you reveal all characters). They must only reproduce the output.
Submissions posted later than November 24th are welcome but not eligible for the win (because there will likely be fewer robbers around).

Example post:
The following post is a submission in the language MyLang, it is 9 bytes long, and it works for numbers 1 - 8.
MyLang, 9 bytes, 8 numbers
This submission works for 1 - 8. Unrevealed characters are indicated with an underscore: _.
abc____i

Leaderboard
Disclaimer: The leaderboard is not tested and uncracked submissions might not appear in the list.

 <link rel="stylesheet" type="text/css" href="//cdn.sstatic.net/Sites/codegolf/all.css?v=7509797c03ea">

Uncracked submissions

 Language	 Score	 User

Sort by: score creation

Safe submissions

 Language	 Score	 User

Not sure I understand... given an arbitrary code in CJam that produces 1, how can I prevent the robbers from adding ) repeatedly to generate the rest of the numbers? The same would be valid for quite a few languages

If that's possible for any program that outputs 1 then it appears CJam is a bad choice of language for this challenge. There's no way to prevent robbers from doing that.

Got it, thanks. As I said, that rules out quite a few golfing languages (an "increment" operator is very common)

@LuisMendo Well, it will certainly make this more interesting...

So a robber is allowed to simply add characters to the code (thereby increasing the byte count)?

@Dopapp, yes. The initial code must have the same length though.

I really want to do something with JSFucky code, but I have neither the time nor the confidence it would even be a good fit for this environment

"maximum up to 10." Does this mean that the code to output 10 must not be modifiable under the given rules to output 11? Would a possible output of 12 be OK?

@DanielJour It can be modifiable up to any number, but the maximum number the robbers need to find is 10. That rule is in place because many submissions can probably be extended to infinity (in theory), so scoring based on the highest achieved number wouldn't make sense.

Snippet added. I haven't tested it properly so there might be uncracked submissions that don't appear in the list.

Re: snippet testing, consider a submission (e.g.) where someone has posted a crack that is invalid, but hasn't removed their comment. I would consider these uncracked, but they do not appear in the list.

You may want to try only disqualifying an entry if the header contains cracked in some form. This is what the redesign userscript currently does.

Does the same character have to be changed?

@CrazyPython, no. From the challenge text: "Change one more character (the same or another),". Note that the changes are incremental. So, to get to 6 you should alter the code you had for 5, not the code you used for 1. Makes sense?

Hexagony, 18 Bytes, 10 numbers, SAFE
This submission works for 1 - 10. Unrevealed characters are indicated with an underscore: _.
.__{_]5[$@.;=@$!!1

You can try Hexagony online over here.
My solution:
1:   .<[{8]5[$@.;=@$!!10
2:   .<[{8]5[$@);=@$!!10
3:   2<[{8]5[$@);=@$!!10
4:   3<[{8]5[$@);=@$!!10
5:   4<[{8]5[$@);=@$!!10
6:   5<[{8]5[$@);=@$!!10
6:   7<[{8]5[$@);=@$!!10
8:   7<[{8]5[$@);=@$!!10
9:   8<[{8]5[$@);=@$!!10
10:  9<[{8]5[$@);=@$!!10

Hex for output 1:
Try it Online!
Full Hex:
  . < [
 { 8 ] 5
[ $ @ . ;
 = @ $ !
  ! 1 0

Important parts:
  . < .
 . 8 . 5
. $ @ . ;
 . . $ .
  . 1 .

At the < the memory edge is 0, so it turns up.
Hits 1
Jumps to 5
Jumps over 8, but is reversed at < and gets the 8 on the way back.
Hits 5 again
Jumps over 1
Hits the < at this point, the memory value is 1585 which, mod 256, happens to be ASCII 1
Finally prints and exits with ;@.

Hex for output 2:
Try it Online!
Important parts:
  . < .
 . 8 . 5
. $ @ ) ;
 . . $ .
  . 1 .

This follows the same path, but on the way back it hits a ) which increments the memory edge to 1586, or 2.

Hex for output 3-9:
Try it Online!
Important parts:
  2 < [
 . . ] .
. $ . ) .
 . @ . !
  . 1 .

Hits the 2
Now the memory edge is positive when it gets to <, so it turn down.
The ] changes the instruction pointer, but is immediately comes back with [
) increments to 3
! Prints 3
$ is left over from the first two numbers so we jump over the end (@)
1 changes the memory edge, but that doesn't matter now.
< reflects the pointer back.
Again 1 doesn't matter because we hit @ to end the program.

Retina, 2 bytes, 10 numbers, Cracked
_1

Works for 1 to 10, _ is a hidden character. This shouldn't be too hard, but I hope it provides a somewhat interesting puzzle. :)
You can try Retina online over here.

Argh, can't figure out 10 :p

@LegionMammal978 :)

Cracked by FryAmTheEggman: http://codegolf.stackexchange.com/a/99560/32700

Octave, 55 bytes, 10 numbers, cracked
(o__(O_o_(@(__o)o__-O}_)_(0<O,{_(_o_O-1)+1_@(_1}_)(__o_

_ is the unknown character.
Solution

 (o=@(O,o)(@(O,o)o{2-O}())(0<O,{@()o(O-1)+1,@()1}))(0,o) %then changing the very last 0 to 1,2,3 e.t.c.

 Given x, this does recursively calculate x+1. It is mainly composed of two anonymous functions. One provides an if statement to anchor the recursion:

if_ = @( boolean, outcomes) outcomes{ 2 - boolean}();

 This is just abusing the fact that a boolean values evaluates to 0 or 1. This function accepts a boolean value, and a cell array of two functions, and evaluates one or the other of these two functiosn depending on the boolean value. The second part is the actual recursion:

plus_one = @(n,f) if_(0<n ,{@()f(n-1)+1, @()1})

 As an anyonmous function is anonymous, you cannot directly access it from itsefl. That why we need a second argument f first. Later we will provide  a handle to the function instelf as a second argument, so a final function would looks like so:

plus_one_final = @(n)plus_one(n,plus_one);

 So in this notation my submission becomes:

(plus_one=@(n,f)(@(boolean,outcomes)outcomes{2-boolean}())(0<n,{@()f(n-1)+1,@()1}))(n,f)

 I asked about recursion anchors for anonymous functions in MATLAB a while ago on stackoverflow.

o_O O____o O_O o_O

I'm not so sure whether this is really that difficult to crack=)

Well, it sure as hell isn't easy to crack! Could maybe do it with pen and paper(!)

I take that as a compliment :) I think you will like my solution, but I'm not gonna reveal anything until it is cracked / it is safe.

Cracked

Python 2, 9 bytes, 10 numbers, cracked
print 8/8

No hidden chars. Can you crack it without brute forcing?

Cracked - that was fun :)

Perl, 12 bytes, 10 numbers, Cracked!
Underscores represent unknown characters.
____;say__-9

Probably fairly easy, and it wouldn't surprise me if there were multiple solutions. Still, it might be fun to crack.
(The intended solution was the same as the crack. This is fundamentally just a problem about assigning 10 to a variable in four characters, which is surprisingly difficult in Perl; unlike many golfing languages, it doesn't have a variable that helpfully starts at 10.)

Cracked. At first I thought it was something like $_=1;say;#-9, but I couldn't figure out how to get 10.

Perl, 46 bytes, 10 numbers, safe
The problem
__b_b_\__}_b_b_b_0_;
$b[0]=10;$b{0}=1;say$b[0]

The shorter problems tend to get cracked quickly, so I thought I'd try a longer one. The longer ones also tend to get cracked if people leave enough of a gap to sneak something naughty like say or exit in, so all the gaps here are short. Hidden characters are represented using _.
My solution
sub b{\@_}*b=b$b{0};
$b[0]=10;$b{0}=1;say$b[0]

To print 2, 3, etc., up to 9, keep changing the number assigned to $b{0}  in the second line (i.e. $b{0}=2, $b{0}=3, etc.). The program for 9 looks like this:
sub b{\@_}*b=b$b{0};
$b[0]=10;$b{0}=9;say$b[0]

Then to produce 10, comment out the first line by prepending a # character to it.
Explanation
The first thing to note is that the solution isn't really golfed apart from removing whitespace: if we lay it out with more readable whitespace, we get this:
sub b { \@_ }
*b = b $b{0};
$b[0] = 10;
$b{0} = 1;
say $b[0];

Normally, when you access the arguments of a subroutine in Perl, you do so via copying them out of @_. There's a good reason for this: @_ aliases the arguments the subroutine is given (so, for example, (sub { $_[0] = 3 })->($x) will assign to $x), something that isn't normally desirable.
Although @_ might seem magical, it's actually just using a standard feature of the Perl internals (which is readily available from XS but only comes up in a few weird cases in pure Perl, such as @_ itself): an array doesn't store its elements directly, but rather by reference. Thus, when we call b in the second line below, Perl generates an array (calling it @_) whose first element is a reference to the same storage that $b{0} uses. (Hash values are also stored by reference; $_[0] and $b{0} are both referencing the same storage at this point.) Because @_ isn't doing anything special from an internals point of view, we can take a reference to it just like we could with any other array, causing it to outlive the subroutine it's defined in.
Perl variables also refer to data storage by reference. A long time ago, people used to use code like *x = *y; to set $x as an alias to $y (via making them reference the same thing), likewise @x as an alias to @y, %x as an alias to %y, and so on. That rather breaks the invariant that variables with similar names don't have to act similarly, so modern Perl provides an alternative; assigning a reference to a typeglob overrides only the variable that matches the type of the reference (so *x = \%y would alias %x to point to the same storage as %y but leave, say, $x alone). This syntax notably doesn't care about whether the storage you're aliasing to has a name, so when we assign the return value of b (which is an array reference that's keeping the array formerly called @_ alive) to *b, what happens is that @b is changed to alias the argument list to the call to b (while leaving %b unchanged). This means, notably, that $b[0] and $b{0} now point to the same storage, and assigning to one will therefore change the other. Everything from then on is completely straightforward.
The Perl documentation doesn't really talk about this sort of detail, so I'm not surprised anyone got the crack; the nature of @_ as not quite being like other arrays isn't something that's really emphasised, and most coding styles aim to minimize the effects that this has rather than amplifying them.

I'm so intrigued by this. I've learnt about pseudo-hashes and refreshed my memory on referencing and de-referencing but I can't seem to figure it out!

@DomHastings, ... and I've been fooling around with various demarcation characters for q and s and y and m (mostly trying to get them to end after the $b[0] assignment), but nothing's working for me (yet).

You were both on the wrong track, but admittedly, there's not much help given by the language or by my submission as to what the right track is (I had to leave one clue to avoid leaving too large a gap, but there are plenty of reasons that a program might contain a backslash, it's not always related to references).

I feel like I was frustratingly close. I had sub b{\@_} cemented in my mind, and, although I experimented with *b I couldn't get it! Thanks for the explanation. I might have glossed over it in your explanation, but why does sub b{\@_}*b=b$b[0] not do the same?

You're trying to make the array element and the hash element share memory, so you need to mention both. The array element's implicitly mentioned when you assign an array reference (\@_) to *b, but you have to mention the hash element explicitly yourself. With *b=b$b[0], you're basically just aliasing the new $b[0] (after changing where @b points) to the $b[0] that existed at the start of the program, which is useless.

Of course, that makes sense. Thank you!

JavaScript, 30 bytes, 10 numbers, cracked
alert(Array(_)________.length)

Shouldn't be too hard, but hopefully it's just hard enough to provide a challenge. :) Unrevealed characters are marked with _.

Nice one! I had a swell time solving this one, it was easy, yet challenging at the same time.

Perl, 14 bytes, 10 numbers, Cracked
say_!"___"%""_

Works for 1 to 10. _ are hidden characters.
I think this shouldn't be too hard to crack. I have an harder one, for 22 bytes, I'll post it if this one is cracked.

Original code :
say"!"=~y"%""c

And replace the "!" by a string of the length of the number you wish to print, for instance !, !!, !!!, etc.
However, ais523 found another way :
say"!"+1#"%""r

Cracked. I suspect this isn't what you were going for at all. (I was trying to do something using regex, but this was much simpler.)

JavaScript, 22 bytes, 10 numbers, cracked
Probably rather easy to crack.
alert(__14_337__xc_de)

_ being a hidden character

I'd be shocked if xc_de was anything but a red herring

Cracked!

Jelly, 7 bytes, 10 numbers, cracked
“1‘ỌȮḊ‘

No wildcards.
The crack achieved (to use an eval with an argument) was, as many seem to be in this thread, not the intended one.
The intended crack was:
“1‘ỌȮḊ‘ - (prints 1)
“1‘     - code page index list of characters "1": [49]
   Ọ    - cast to ordinals: ['1']
    Ȯ   - print (with no line feed) and return input: effectively prints "1"
        -     (but if left at this would then implicitly print another "1")
     Ḋ  - dequeue: []
      ‘ - increment (vectorises): []
        - implicit print: prints ""

“1‘ỌŒḊ‘ - (prints 2)
“1‘Ọ    - as above: ['1']
    ŒḊ  - depth: 1
      ‘ - increment: 2
        - implicit print: prints "2"

“1‘ỌŒḊ‘‘ - (prints 3)
“1‘ỌŒḊ‘  - as above: 2
       ‘ - increment: 3
         - implicit print: prints "3"

... keep adding an increment operator to print 4 - 10.

I would be able to crack it if the '‘' was on the next line. So close... :)

Cracked but could you explain what happens for 10, because I got lucky on this one while trying things that might work.

@Hedi Ninja'd me too quickly, I was working on it.

@Hedi - yours was an unintended crack. The way 10 is working for you is, I believe, by evaluating the jelly code in the string 9 with an argument of 0 (the default value of the input), which you then dequeue (no effect) and then increment.

...actually I think the way 10 is working for you is by evaluating the jelly code in the string 9 with an argument of [] - the default value of the input, 0, dequeued - which you then increment., Like “1‘‘‘‘‘‘‘‘‘Ọv0Ḋ¤‘

@Hedi (...or really, more explicitly, like “1‘‘‘‘‘‘‘‘‘Ọv0RḊ¤‘ I think)

Octave, 17 bytes, 10 numbers, Cracked
_od(3_13_13_7_1_)

Original solution

 mod(3*1361357,10)

...

mod(3*1361357,17)

mod(3*1361397,17)

mod(9*1361397,17)

_ is the hidden character.

Cracked! :)

Befunge-93, 11 bytes, 10+ numbers, Cracked
This submission works for at least 1 - 10. Unrevealed characters are indicated with □.
□□5:**-□-.@

Try it online
I must say I was impressed that two people could come up with independent solutions for this, neither of which were what I was expecting. While Martin got there first, I'm giving the "win" to Sp3000 as their solution is more portable.
This was my intended solution though:

g45:**-2-.@
g45:**-1-.@
g45:**-1\.@
g45:**-1\+.@
g45:**-2\+.@
...
g45:**-7\+.@

Because a stack underflow in Befunge is interpreted as 0, the g just reads from 0,0 returning the ASCII value of 'g', namely 103. 45:**- subtracts 100, giving you 3. Then 2- gives you 1.

For the third iteration, the - (subtract) is changed to a \ (swap) instruction, so the 3 becomes the topmost stack entry. And in iteration four, a + (add) instruction is inserted, thus adding the 3 to the 1 giving 4.

Cracked. I'm curious to see what solution you had in mind. :)

@MartinEnder As I commented on your answer, I'd like to leave my intended solution hidden for a while in case someone else wants to attempt a more portable solution. Is that OK?

Of course, that's fine. :)

"15:**-6-.@ gives 1, but I'm not sure whether the fact that " pushes 32 on top (due to implicit spaces) is an artefact of the TIO interpreter or part of Befunge's spec, because trying a few interpreters it seems not all interpreters do that. Does your intended solution depend on this behaviour?

@Sp3000 That wasn't my intended solution, but that's perfectly valid Befunge - the interpreters that don't support that are incorrect. If you post an answer with the rest of the sequence I'd definitely consider that a complete crack.

Cracked. (only saying that in case someone writes a Stack Snippet which looks for the word in comments)

Ruby, 16 bytes, 10 numbers, cracked by xsot
x=##/=#%#
)
###x

# is any character.

Cracked!

R, 21 bytes, 10 numbers Cracked
__i___________i______

Works for 10 numbers. _ is hidden character.
Original solution:

 which(letters%in%"a")

which(letters%in%"b")

 etc.

@StewieGriffin This is my first post on this site and I don't know the norms. I have one more R challenge - a bit trickier, I think. Can I add another answer? Or append it to this one?

Adding a new one it's perfectly fine (as a separate one)  welcome to the site

Did I cracked it here ?

@Tensibai Cracked :)

Octave, 32 bytes, 10 numbers. Cracked
_n_(isprime(floor(s____i__ i____

_ is a hidden character.
You can try Octave online here.

Original solution:
1: nnz(isprime(floor(sqrt(i):pi')))
2: nnz(isprime(floor('sqrt(i):pi')))
3: nnz(isprime(floor('sqrt(i):pia')))
4: nnz(isprime(floor('sqrt(i):piaa')))
...

Very nice! Cracked. Not sure if I reproduced your code though?

@StewieGriffin Well done! I should have revealed more characters... :-D

Damn that was clever :) Too bad you couldn't say it was MATLAB... One more character would probably have made it much harder... I enjoyed it though... I used a full 25 minutes :)

@Stewie Yes, you made good use of non-Matlab features! :-)

Octave, 17 bytes, 10 numbers, Cracked
_i_(__i__(2_5_))

Unrevealed characters are marked with _.
Intended solution:

    fix(asind(2/59))
    fix(asind(3/59))
    fix(asind(4/59))
    fix(asind(5/59))
    fix(asind(6/59))
    fix(asind(7/59))
    fix(asind(8/59))
    fix(asind(9/59))
    fix(asind(9/55))
    fix(asind(9/50))

cracked (finally=) but probably not with your original approach, right?

Nice, added my approach in a spoiler tag :)

Oh your solution is really clever!!!

Octave, 19 bytes, 10 numbers, cracked
__sca__1_)___'-_6_'

_ is the hidden character.
Intended solution:

 pascal(10)('a'-96)'

Cracked

I couldn't remember any function with sca. Coming from you, I should have thought of matrix functions :-)

There is a reason why I made a complete list of Octave function names =)

05AB1E, 5 bytes, 10 numbers, cracked!
Not very hard, but a fun one :)
_[==_

_ is a random character. Uses the CP-1252 encoding. Try it online!

I could almost get it to work, but then it enters an infinite loop...

Cracked

@daHugLenny Hahaha, that's neat! I didn't think of that :).

JavaScript, 22 bytes, 10 numbers, cracked
alert(0_6_4_>_0_2_0_7)

_ is the hidden character.
Hint about the intended solution
The character that needs to be changed to generate all numbers is always the same.

Cracked

@ais523 Well done!

05AB1E, 6 bytes, 10 numbers, cracked
Attempt 2, this time without the three-char string :p.
_ [==_

_ is a random character. Uses the CP-1252 encoding. Try it online!

Cracked

@milk Nice, that was the intended solution :)

C#, 90 bytes, 10 numbers, cracked
using ______________________________________________;class C{static void Main(){_______;}}

I honestly have no idea how hard this is to crack.
Edit: Oops, transcription error. One _ too few after using.
Now cracked by Hedi, who found the intended (barring the class name) solution.

d'oh... one too short for write()

Didnt help... wrong gap. And that semicolon after first gap  thwarted amother idea

Cracked

Python 3, 19 bytes, 10 numbers, cracked
print(??bin()?????)

Unrevealed characters are marked with ?. Tested in Python 3.5.2.

Cracked

JavaScript 21 Bytes, 10 Numbers Cracked
alert(b_oa_"3____1"))

Unrevealed characters are marked with _
Cracked
My Version:
alert(btoa|"3"&("1"))
alert(btoa|"3"^("1"))
alert(btoa|"3"^("0"))
alert(btoa|"3"^("7"))
alert(btoa|"2"^("7"))
alert(btoa|"1"^("7"))
alert(btoa|"0"^("7"))
alert(btoa|"0"^("8"))
alert(btoa|"0"^("8"))
alert(btoa|"2"^("8"))

Cracked

Python 3, 16 bytes, 10 numbers, cracked
print(?%??f?r?t)

Unrevealed characters are marked with ?. This is probably a bit easy since there's only five question marks, but I'm hoping it'll be a fun one.

Cracked

JavaScript 33 Bytes, 10 Numbers Cracked x2
Oops I post posted my line for generating 10 Which Hedi cracked as though it was for 1
alert(_to__"_Xc0__0_B6____Zp=="))

Version intended to post for generating  1
alert(_to__"_Xc0__0_Bf____Zp=="))

Unrevealed characters are marked with _
alert(btoa|"0Xc0"-0xBf|!("Zp=="))
alert(btoa|"0Xc0"-0xBe|!("Zp=="))
alert(btoa|"0Xc0"-0xBd|!("Zp=="))
alert(btoa|"0Xc0"-0xBc|!("Zp=="))
alert(btoa|"0Xc0"-0xBb|!("Zp=="))
alert(btoa|"0Xc0"-0xBa|!("Zp=="))
alert(btoa|"0Xc0"-0xB9|!("Zp=="))
alert(btoa|"0Xc0"-0xB8|!("Zp=="))
alert(btoa|"0Xc0"-0xB7|!("Zp=="))
alert(btoa|"0Xc0"-0xB6|!("Zp=="))

Cracked

I added a crack for the intended version. I'll try to find a way to get to your solution for 10:  console.log(atob|"0Xc0"-0xB6|("Zp==")) I think

I updated my answer with what should be the intended crack.

Python, 10+ numbers, 61 bytes, Cracked!
Here was the code I posted:
try:x
except:print(__import__('sys').??c??n??()[????b????e???

The original code was:
try:x
except:print(__import__('sys').exc_info()[2].tb_lineno)

Basically, it throws an error ('x' is not defined) and then prints the line the error was found on. So, just keep adding newlines at the beginning to increment the number.
I knew it wouldn't be hard to crack - I just wanted a funny way to print numbers - but I wasn't expecting Sp3000 to get it so fast, that's some pro skills!

Cracked - amusing, but yeah there aren't really many options :P

@Sp3000 yeah, I wanted to make sure nobody could squeeze in deleting what's on STDOUT and printing a number, but I guess I narrowed it down too much. Ah well.

Revealing sys definitely made it a lot simpler, since it gave a nice starting point for searching :P

Acc!!, 10 bytes, 9 numbers, cracked
?????????_

Works for 1 to 9. ? is a hidden character.

Interesting one. Cracked here

05AB1E, 11 bytes, Cracked!
3628801__0_

Works from 1-10. _ is a hidden character.
Intended Solution:
3628801R¬0+ # 1
3628801R¬1+ # 2
3628801R¬2+ # 3
3628801R¬3+ # 4
3628801R¬4+ # 5
3628801R¬5+ # 6
3628801R¬6+ # 7
3628801R¬7+ # 8
3628801R¬8+ # 9
3628801R¬9+ # 10

Cracked!

Octave, 25 bytes, 9 numbers. Cracked
__a__repmat(__one___,__)_

_ is a hidden character.

@StewieGriffin Sorry!! Only 9. My mistake. I'm really sorry. Edited

cracked

Sorry =P I'm gonna post a replacement=)

@Stewie It's been my fault, sorry! I'll post a modified version later, since my original solution is different

For the record, my crack was identical to flawr's. I've posted another Octave one here.

@StewieGriffin I posted the new version here

Just found a new, very simple crack: 1%a__repmat(__one___,__)_

@Stewie Heh, good catch!

Octave, 24 bytes, 9 numbers, cracked
_a__repmat(__one___,__)_

_ is a hidden character.
(Inspired by @LuisMendo's challenge.)

Oh you're way too quick!!!

JavaScript, 9 bytes, 10 numbers, Cracked
alert(__)

_ is the hidden character.

Cracked

Octave, 26 bytes, 10 numbers. Cracked
__a__repmat(_+one___1+__))

_ is a hidden char.
New variation...

The intended solution was:
>> eval(repmat('+ones',1+''))
ans =  1

>> eval(repmat('+ones',1+2'))
ans =  3

>> eval(repmat('+ones',1+9'))
ans =  10

cracked but probably again nowhere close to what you intended=)

@flawr I have updated with my solution

This will be my last (and hopefully best one).

@Stewie Looks difficult! That is, funny :-)

Octave, 21 bytes, 10 numbers, Cracked
disp(fpr___f__e_(_'_)

This works for 1-10. _ are hidden characters. This will be my last and hopefully best post.
Intended solution:

 disp(fpr= -fopen('')) and disp(fpr=1-fopen('')) for 2...10

Explanation:

 disp(fprintf('_')) will actually print _1 if executed, so fpr___f was chosen to throw people off. The f was needed in fopen so there was only one additional space. fopen('') returns -1 since it fails to open a file with an empty name. fpr= -fopen('') makes fpr = 1.

Last? Forever? For all of PPCG?

Are you sure nothing is missing here? What fpr is is quite obvious, that leaves four spots, that each need a closing parenthesis.

Nevermind, cracked (but is this what you had in mind??)

Oooh, the fopen is neat=)

@flawr. thanks :) I like the sequence you found too :)

To clear up why I was confused: I firs searched for something like disp(fprintf(det(''))) but that had a character too much and only would have worked up to 9.

Pyth, 4 bytes, 9 numbers -  Cracked
.__Q

Not super difficult, but should hopefully be fun.

Cracked :)

Python 2, 17 bytes, 10 numbers, cracked
print len([????])

The hidden character is ?.

Cracked

Nice, that was fast.

...and the intended crack?!

Yes, it's what I had in mind.

Hexagony, 7 bytes, 10 numbers, Cracked
1<@|!__

Works for 1 to 10, _ are hidden characters. I hope I didn't overlook any cheap way to work around the intended solution (I'm looking forward to clever ways to work around the intended solution ;)).
You can try Hexagony online over here.

Cracked

@Riley Wow, that was fast (and that's more or less the intended solution; I had _! for the wild cards and inserted the ) for 10).

So 1 would be 1<@|!_! and 10 is 9<@|!_!(? That doesn't seem to work for me (for 10, it would hit 9, <, _, @ and not print anything).

@Riley no, you'd still put the ) after the first ! to get 9<@|!)_!.

Okay. Thanks .This one was fun :)

I added a new solution that doesn't increase the size of the hex.

Perl, 31 bytes, 10 numbers Cracked by ais523
One more go at this, before I reveal my intended solution.
__e_$a,_<__$_;1 while_$a_;say$_

Original code:
open$a,"<",$0;1 while<$a>;say$.  #Prints 1

The code must be saved as a file and not run from the command line, but the file name is not important, as it gets stored in $0.  This code reads the file as long as there is text left, and prints $. which contains the number of lines in the original code.  Adding a newline pretty much anywhere not inside a word or variable will increase $. by 1.
open$a,"<",$0;
1 while<$a>;say$.   #Prints 2
------
open$a,"<",$0;

1 while<$a>;say$.   #Prints 3
------

et cetera

Cracked!. This is almost certainly the intended solution.

Perl, 31 bytes - 10 numbers - Cracked by ais523
__e_$a__<__$_;1 while_$__;say$_

_ is the hidden character.
I am not posting my solution here, because the crack is in a completely different direction from what I did, so I'll be creating a new challenge for that one.  The cracked solution is below:
 $e=$a+q<1_$>;1 while!$e ;say$e  #Prints 1 (note the leading space)
 $e=$a+q<1_$>+1 while!$e ;say$e  #Prints 2
 $e=$a+q<1_$>+2 while!$e ;say$e  #Prints 3
 $e=$a+q<1_$>+3 while!$e ;say$e  #Prints 4
 $e=$a+q<1_$>+4 while!$e ;say$e  #Prints 5
 $e=$a+q<1_$>+5 while!$e ;say$e  #Prints 6
 $e=$a+q<1_$>+6 while!$e ;say$e  #Prints 7
 $e=$a+q<1_$>+7 while!$e ;say$e  #Prints 8
 $e=$a+q<1_$>+8 while!$e ;say$e  #Prints 9
 $e=$a+q<1_$>+9 while!$e ;say$e  #Prints 10

Cracked!

R, 22 bytes, 10 numbers, Cracked
_et_______)____is_____

_ is a hidden character.
See the redux version.

Cracked ( http://codegolf.stackexchange.com/a/100298/10801 )

C++, Linux platform, 10 numbers, 468 bytes, Cracked
Ok so previously my puzzle played with technically undefined behavior (and the gimmick was stabilizing it) and had some transcription error. I have improved my process so I expect there aren't transcription errors. This time I am not playing with undefined behavior at all and would rather just reject invoking it. I think I can justify this as being completely defined by either the language or the platform. $ is the replacement character as I needed real _ characters in this puzzle.
#include <unistd.h>
#include <iostream>
#include <fstream>

$$$$$$$$$$$$$ {
    std::ofstream *garbalgase()
    {
        std::ofstream *golgi = new std::ofstream;
        golgi->open("/dev/null");
        return golgi;
    }

    std::ostream * const jawbone = garbalgase();
    $$$$$ int value = $_$$$$$$;
}

int main()
{
    $$$$$ $$$$$$$$/$$int vl = value;
    if (fork() == 0)
    {
        $$$$$$$$$$$<std::ostream $*>($jawbone) = &std::cout;
        vl -= 4;
        _exit(0);
    }
    (*jawbone) << (vl - 9) << std::endl;
}

Edit: Stock solution is based on an incorrect understanding of the rules where you may insert one character to get the 1. As it's already cracked I won't be correcting it. Good luck finding the stock solution though.

Maybe you should specify the compiler and flags a solution has to work under? I have a crack, but it needs -fpermissive.

@Lynn: There's a way of getting rid of the need of -fpermissive.

Cracked. I assume this isn't the intended solution.

Python 2, 26 bytes, 10 numbers, cracked
Let's try this again.
print r___e(3______+_[___]

Works for 1-10; _ is the hidden character.

Cracked - also if you're reposting, be careful of newlines, because I feel like something might be workable with those too.

Java, 10+ digits, 1446 bytes SAFE
Revenge of the Unicode
\u___9\u___D\u___0\u___F\u___2\u___4\u___0\u___A\u___1\u___6\u___1\u___E\u___9\u___F\u___E\u___A\u___B\u___3\u___C\u___1\u___3\u___3\u___0\u___D\u___B\u___0\u___5\u___2\u___C\u___9\u___3\u___0\u___3\u___4\u___1\u___4\u___9\u___3\u___0\u___6\u___F\u___9\u___4\u___0\u___D\u___1\u___9\u___E\u___8\u___3\u___4\u___2\u___9\u___E\u___7\u___B\u___D\u___1\u___9\u___4\u___8\u___2\u___F\u___7\u___3\u___0\u___5\u___8\u___3\u___5\u___0\u___4\u___9\u___F\u___E\u___B\u___6\u___9\u___C\u___5\u___4\u___5\u___3\u___3\u___2\u___9\u___0\u___4\u___F\u___2\u___0\u___6\u___4\u___0\u___D\u___0\u___E\u___5\u___7\u___0\u___6\u___9\u___C\u___5\u___4\u___5\u___3\u___3\u___2\u___9\u___0\u___4\u___F\u___2\u___8\u___9\u___B\u___3\u___5\u___E\u___E\u___D\u___9\u___3\u___3\u___E\u___3\u___8\u___1\u___2\u___5\u___4\u___3\u___5\u___3\u___2\u___5\u___4\u___3\u___E\u___7\u___5\u___4\u___A\u___1\u___6\u___1\u___9\u___F\u___6\u___9\u___C\u___5\u___4\u___5\u___3\u___3\u___2\u___9\u___0\u___4\u___F\u___2\u___1\u___3\u___3\u___5\u___3\u___3\u___8\u___9\u___E\u___3\u___5\u___4\u___8\u___6\u___4\u___C\u___1\u___9\u___B\u___E\u___5\u___7\u___0\u___0\u___2\u___9\u___E\u___4\u___3\u___4\u___2\u___5\u___1\u___D\u___8\u___E\u___5\u___7\u___0\u___6\u___9\u___C\u___5\u___F\u___5\u___4\u___0\u___5\u___4\u___3\u___4\u___2\u___5\u___1\u___D\u___8\u___6\u___4\u___9\u___9\u___E\u___0\u___2\u___9\u___E\u___4\u___8\u___7\u1__1\u___7\u___5\u___7\u___1\u___7\u___9\u___B\u___D\u___D

No comments this time :P and it only works on the Oracle Java :P
_ as redaction like usual
Solution:
\u0069\u006D\u0070\u006F\u0072\u0074\u0020\u006A\u0061\u0076\u0061\u002E\u0069\u006F\u002E\u002A\u003B\u0063\u006C\u0061\u0073\u0073\u0020\u004D\u007B\u0070\u0075\u0062\u006C\u0069\u0063\u0020\u0073\u0074\u0061\u0074\u0069\u0063\u0020\u0076\u006F\u0069\u0064\u0020\u006D\u0061\u0069\u006E\u0028\u0053\u0074\u0072\u0069\u006E\u0067\u005B\u005D\u0061\u0029\u0074\u0068\u0072\u006F\u0077\u0073\u0020\u0045\u0078\u0063\u0065\u0070\u0074\u0069\u006F\u006E\u007B\u0046\u0069\u006C\u0065\u0044\u0065\u0073\u0063\u0072\u0069\u0070\u0074\u006F\u0072\u0020\u0066\u0064\u0020\u003D\u0020\u006E\u0065\u0077\u0020\u0046\u0069\u006C\u0065\u0044\u0065\u0073\u0063\u0072\u0069\u0070\u0074\u006F\u0072\u0028\u0029\u003B\u0073\u0075\u006E\u002E\u006D\u0069\u0073\u0063\u002E\u0053\u0068\u0061\u0072\u0065\u0064\u0053\u0065\u0063\u0072\u0065\u0074\u0073\u002E\u0067\u0065\u0074\u004A\u0061\u0076\u0061\u0049\u004F\u0046\u0069\u006C\u0065\u0044\u0065\u0073\u0063\u0072\u0069\u0070\u0074\u006F\u0072\u0041\u0063\u0063\u0065\u0073\u0073\u0028\u0029\u002E\u0073\u0065\u0074\u0028\u0066\u0064\u002C\u0031\u0029\u003B\u006E\u0065\u0077\u0020\u0050\u0072\u0069\u006E\u0074\u0053\u0074\u0072\u0065\u0061\u006D\u0028\u006E\u0065\u0077\u0020\u0046\u0069\u006C\u0065\u004F\u0075\u0074\u0070\u0075\u0074\u0053\u0074\u0072\u0065\u0061\u006D\u0028\u0066\u0064\u0029\u0029\u002E\u0070\u0072\u0069\u006E\u0074\u0028\u0027\u1111\u0027\u0025\u0027\u0111\u0027\u0029\u003B\u007D\u007D

Deobfuscated:
import java.io.*;class M{public static void main(String[]a)throws Exception{FileDescriptor fd = new FileDescriptor();sun.misc.SharedSecrets.getJavaIOFileDescriptorAccess().set(fd,1);new PrintStream(new FileOutputStream(fd)).print('\u1111'%'\u0111');}}

Entire Thing relies on some dirty Oracle Java classes trickery to link a Filedescriptor object to the 1 Filedescriptor which is stdout
Got the hack from stackoverflow

Got up to the initialisation of FileDescriptor fd, then I got stuck

timezone checking, need to know if the 7days are over

@KritixiLithos Solution uncovered since its safe

Hexagony, 15 bytes, 10 numbers, Cracked!
[!?>!@!__\!?!!!

_ can be replaced by any characters.
Oh my.. the code is getting angry due to cheap solutions! Will this keep standing when the wall of ! and ? are guarding the most hearted secret?
Last submission even if this has got any cheap solutions :)
Intended solution
For 1 to 9, there are easy changes:

[!?>!@!1#\!?!!!  With 1~9 replacing the 1

However for 10,

1!?>!@!9#\!?!!!  Which prints the 1 and then use a numerical jump so we run in a reversed fashion, which in turn goes to ?! prints a 0 and stops.  Really wanted to make some that changes IPs.  By the way, all 3 submissions are with the intention to use # to print an 1 and then a 0.  See if I come up with other nice ideas - if yes I hope more people would find it interesting to play in hexagons!

Cracked. Is this what you were looking for? :)

Haha, impressed though not exactly what I have in mind. One more mirror, one more freedom - it seems that only ! are real blockers :D Enjoyed playing this game!

Ahhh, I thought you might be printing 1 and 0 separately, using a ? to get the 0, but I couldn't figure out a good way to get a 1 back at the end and then move exactly through !?!@ (plus irrelevant stuff). That's nice. :) (Too bad, it's so hard to constrain the problem sufficiently without giving too much away.)

><> Fish 23 bytes cracked
"H__;v+2__?
  _  >l?!;n

_ is the intended missing characters.
Hopefully a bit more complicated than my last one but probably still easy to bypass.

Cracked.

@Martin Ender - Yep you got it, clearing the stack and using the implicit input being -1 :)

PHP, 38 bytes, 10 numbers (cracked)
<?php__n_p___(_n=___(__=1___echo___?>
_ marks hidden characters.
May be too easy, might have left too much freedom. Have fun!

Cracked. You left way too much freedom, unfortunately.

Good job, I'll see if I can repost this with less hidden characters without making it too obvious

OCaml (interpreted), 51 bytes, 10 numbers (Cracked)

By "interpreted" I mean that it should be run with the command ocaml rather than compiled to native code with ocamlopt.

The hidden character is ^.
^^t^r^^^^-^^^^-^^r^^^^=^^^^^^^r^^^^r^^^^^^^(^^^0/0)

Cracked. The same trick still works, even though it's harder to fit everything in this time.

아희(Aheui), 19 bytes (6 chars + 1 newline), 10 numbers
봃法희
반_뭉

Works for 1 to 10. _ is the hidden character. Shouldn't be that hard.
Bonus: It works for 0 too.
Try it online!

Cracked.

Pyth, 3 bytes, 10 numbers (Cracked)
I think it's a very simple one, and will easily get cracked.
So, it goes like this: (hidden characters: _)
__Q

Cracked http://codegolf.stackexchange.com/a/99603/53251

Octave, 21 bytes 9 numbers, cracked
_a__repmat(_one___,__

_ is a hidden character.
My idea:

  a=[repmat(bone,0),9]

Yes, I'm still trying to solve yours, but it is quite hard so far=) Hint: one of the _ is just an space.

Cracked! =) Couldn't leave it be... That was a really good one! :)

Man, still not my solution, I'm going insane!! Can you crack _repmat(_one___,__? EDIT: Yes you can... +repmat( ones(),1) ok I'll post my original solution=)

@StewieGriffin I just wanted to mislead with the one (and I suspect LuisMendo wanted this in his original challenge too=)

I would never have gotten that... Haven't even heard of bone...

Haha, bone is one of a few colourmaps, I knew it from Matlab, as it is used to display x-ray images with the "analog" feel =)

I just realized several Octave submissions have quite simple cracks: This one for instance: aa='repmat(_one_';,+1 (works up to 10).

JavaScript, 15 bytes, 10 numbers, cracked
alert(_+"+____)

Another short one, this time with an unfinished string >:-)

Cracked? :)

@Adnan Aw man, that was a little easier than I expected... nice job :) My intended solution was alert("+"+10-9), changing the 9 to smaller digits for larger numbers.

JavaScript, 12 bytes, 10 numbers, Cracked
Let's play with arrays:
alert(_[__])

_ is a hidden character.

I wanted robbers to think that the first hidden character was a +, but i didn't realize that would work.
Intended solution :

 alert(-[~0])
 alert(-[~1])
 alert(-[~2])
 ...
 alert(-[~9])

Cracked (again)

Python 2, 49 bytes, 10 numbers, cracked
y=10__;s='09________';print int(s[8__________:y])

_ is the hidden character.

Cracked by boboquack
The initial code was
y=10-0;s='0987654321';print int(s[8+y:]+s[y-1:y])

Cracked

C, 10+ numbers, 216 bytes, Cracked
#include <stdio.h>

FILE *a, *b;

void x() { ____________ int x; x = __; ________a___d____x_;}
void y() { ____________ int x; fprintf(b,"%d\n",x);}
int main() {a=fopen("/dev/null", "w");b=stdout;x();y();return 0;}

If your solution doesn't work with -O1 I will reject it.
Cracked by Dada. Original file:
#include <stdio.h>

FILE *a, *b;

void x() { /**/volatile int x; x = 07; fprintf(a,"%d\n", x);}
void y() { /**/volatile int x; fprintf(b,"%d\n", x);}
int main() {a=fopen("/dev/null", "w");b=stdout;x();y();return 0;}

The maximum is 10 numbers

I'm not sure that you can arbitrarily add you own rules.

-O1 needs to stand because works only with -O0 results in too hard to guess what some other machine's undefined behavior does.

@KritixiLithos: The limit may be 10 but mutating it to get larger than 10 doesn't seem to be blockable.

Cracked. I guess you had something like that in mind?

PowerShell, 7 bytes, 10 numbers, Cracked
Works for 1 through 10. Hidden characters are _.
___(__0

Intended solution: +!@()+0 and swap out the 0 on the end for successively larger numbers.

Cracked. I'm curious to know if this is the original code though.

@Dada That is not the original code, but a good solution.

Java, 70 bytes, 10 Numbers, Cracked
__________________________ ____(_____________________________)________
_ is the hidden character
Edit: major flaw fixed

Is this a full program?

yeah :P golfed though

Cracked!

><> Fish 5 bytes 10 numbers Cracked by Emigna
_2__;

It should be easy to guess but I threw in a little curve ball to make it slightly harder.

Cracked

@Emigna it's very hard to make this not work in Fish but my original was i2+n; maybe I should work on a new one aha.

Javascript 19 bytes 10 numbers Cracked
alert((_1*1_10__1_)

Unrevealed characters are marked with _
Cracked! Guess i should have blotted better
alert((11*1+10)%10)
alert((11*2+10)%10)
alert((11*3+10)%10)
alert((11*4+10)%10)
alert((11*5+10)%10)
alert((11*6+10)%10)
alert((11*7+10)%10)
alert((11*8+10)%10)
alert((11*9+10)%10)
alert((11*9+10)%11)

Cracked

QBasic, 13 bytes, 10 numbers, cracked
__I_T__O_(3))

Works for 1-10. _ is the hidden character.

Cracked! http://codegolf.stackexchange.com/a/99852/14306

Perl, 26 bytes, 10 numbers Cracked by ais523 and Sunny Pun
____;@a=($_..10);say$a[__]

I'm almost positive there's an alternate solution to this problem, but let's see if anyone else can find it because I haven't been able to see it.
Edit: It looks like two people managed to circumvent what I was trying to do!
ais523's solution:
____;@a=($|..10);say$a[+1]  #Prints 1
____;@a=($|..10);say$a[1+1] #Prints 2
...
____;@a=($|..10);say$a[9+1] #Prints 10

Sunny Pun's solution:
$_=0;@a=($_..10);say$a[+1]  #Prints 1
...
$_=9;@a=($_..10);say$a[+1]  #Prints 10

Intended solution:
$[=1;@a=($[..10);say$a[$[]  #Prints 1
$[=2;@a=($[..10);say$a[$[]  #Prints 2
$[=3;@a=($[..10);say$a[$[]  #Prints 3
$[=4;@a=($[..10);say$a[$[]  #Prints 4
$[=5;@a=($[..10);say$a[$[]  #Prints 5
$[=5;@a=($[..10);say$a[-$[]  #Prints 6
$[=4;@a=($[..10);say$a[-$[]  #Prints 7
$[=3;@a=($[..10);say$a[-$[]  #Prints 8
$[=2;@a=($[..10);say$a[-$[]  #Prints 9
$[=1;@a=($[..10);say$a[-$[]  #Prints 10

While deprecated, $[ still allows you to modify the indexing of arrays (typically, 0-based).  It prints a warning to STDERR, but OP says that any output to STDERR can be ignored.

Here's your alternate solution: Cracked!

Please check if this is an alternate solution or not :)

I'm guessing Sunny Pun's crack is the intended solution. (Interestingly, starting from Sunny Pun's version of the string, you can get from 1 up to 10 using either of our methods.)

Surprisingly, neither of you got the intended solution.  I should have added one more byte, which would have made both of your answers wrong.

Perl, 31 bytes, 10 numbers Cracked by ais523
__e_$a__<__$_;1 while_$a_;say$_

My original post was cracked with a solution that wasn't even in the realm of what I was going for, so I'm adding a single extra byte that renders the previous solution (hopefully) unsalvageable.
Once again cracked in a way I haven't accounted for:
the;$a+=<1\$>;1 while!$a ;say$a #Prints 1
the;$a+=<1\$>+1 while!$a ;say$a #Prints 2
...
the;$a+=<1\$>+9 while!$a ;say$a #Prints 10

Cracked!. Not quite the same principle this time, but still close enough.

Perl, 7 bytes, 9 numbers, Cracked!
say$_-_

Underscores represent unknown characters.
The solution (as found by feersum) was to use a literal control-F to replace the first underscore, thus finding the predefined variable that has the value 2.

Cracked

Isn't this 7 bytes?

Yes, it's 7 bytes. Apparently I can't count today.

Python 2, 26 bytes, 10 numbers, cracked by feersum and Destructible Watermelon
Third try's the charm?
print r___e(3_4____+_[___]

Works for 1-10, _ is hidden.

Destructible Watermelon got the general idea I was going for. Here's my solution:

print r"10e(3246578+9["[0]
print r"10e(3246578+9["[5]
print r"10e(3246578+9["[4]
print r"10e(3246578+9["[6]
print r"10e(3246578+9["[-6]
print r"10e(3246578+9["[-7]
print r"10e(3246578+9["[-5]
print r"10e(3246578+9["[-4]
print r"10e(3246578+9["[-2]
print r"10e(3246578+9["[:2]

Cracked

COW, 51 bytes, 10 numbers Cracked by Kritixi Lithos
MoO ___ ___ ___ ___ ___ ___ ___ ___ ___ ___ ___ OOM

Original code:
MoO Mo_ Mo_ Mo_ Mo_ Mo_ Mo_ Mo_ Mo_ Mo_ Mo_ Mo_ OOM #Prints 1
MoO MoO Mo_ Mo_ Mo_ Mo_ Mo_ Mo_ Mo_ Mo_ Mo_ Mo_ OOM #Prints 2
...
MoO MoO MoO MoO MoO MoO MoO MoO MoO MoO Mo_ Mo_ OOM #Prints 10 (the last two operations were red-herrings)

For a Javascript-based interpreter to use for testing, you can go here.
_ is hidden character

Cracked!

Wentel x87, 36 bits/8 = 4.5 bytes, 2 numbers
____________0110______00____00______

Is there an online interpreter? I'm having some trouble getting it to run from the version on github (I don't use Python much).

@Riley Download "main.py" and run python3 main.py. Type bits in and press enter to start execution. Pass -d to activate debugger.

Thanks, I must have been using python2. In the documentation (and the examples) it looks like 1001 8 times would print the ASCII value of 11111111, but when I run it, I need a 9th 1001 or 1000 for it to print. To crack this, which method should I use?

@Riley Go by the specification, not the interpreter.

Do you have a chatroom for Wentel x87? I had a few questions about the specs.

@Riley no, but you can ask them here.

I don't think I understand the 0001 instruction. If the execution pointer points to 0001aaaaaaaabbbbbbbb and the value at memory[current] == memory[aaaaaaaa] then the instruction pointer is moved to bbbbbbbb? And, do you have an interpreter that will print the correct values when the intended solution is run?

@Riley 1. Yes. This is just a branch. Execution pointer is just what code is run. You can always use the source. 2.Yes - it's main.py.

I ask because output doesn't seem to match the specs (see above) and for 0001 in main.py looks like it moves to that instruction then moves 4 past the provided address.

@Riley Clarify, please? There's an example of a while loop in the examples md

In ifexec: execution_pointer = ... then execution_pointer += 4 wouldn't this move the pointer 4 places past where it was pointed to? And for the output question, 10001000100110011000100010001001 should print 1 as far as I can tell, but it doesn't. I need to add another 1000 or 1001 (a 9th bit) to get it to print.

@Riley The array is one bit per entry, if I'm not mistaken.

Let us continue this discussion in chat.

Python 2, 111 bytes, 10 numbers (cracked)
How about some random digits?
The hidden character is E.
print +int('''3EE5EE6EE0EE2EE5EE6EE4EE9EE1EE5EE9EE4EE6EE7EE5EE7E''')%int('''2EE0EE9EE8EE9EE2EE3EE5EE0EE3EE6''')

Cracked

@Sp3000 Nice job, I don't see any L since print does str not repr.

Yeah, I forgot that REPL does repr and hence wasn't the same as print - confused myself for a sec there

JavaScript (ES6), 63 bytes, 10 numbers, cracked
This challenge is quite fun, so here's one last submission. :-)
eval([...(n=0,"l?0?a?(?x?")].sort(_=>[...????+[]][n++]).join``)

? is a hidden character.
NB: similarly to my two other entries, this code is supposed to print (not return) 1.

Cracked!

R, 8 bytes, 10 numbers, Cracked
_a___+__

Original solution (as the cracked is a little different, but works):

 cat(1+0)
 cat(1+1)
 ...
 cat(1+8)
 cat(1+9)

Possibly cracked...

Octave, 16 bytes, 10 numbers (cracked)
As a cop, it's my duty to keep this site clean and remove any explicit content. I found1 a piece of code referring to a diabolical body part that I've decided to censor here using underscores, _.
ev_l('P_NIS'-2_)

1: Well, I found it on the screen after I wrote it.

gah... 9 and 10 are tough

"Krrrrk".... and cracked. http://codegolf.stackexchange.com/a/100331/10801

also: nice red herring at the beginning with the text :P

QBasic, 12 bytes, 10 numbers, cracked
All right, let's try this:
_INT(_O_(3))

Works for 1-10. _ is the hidden character.

Finally, the crack used my intended approach. :P

Cracked.

OCaml (interpreted), 51 bytes, 10 numbers (Cracked)
By "interpreted" I mean that it should be run with the command ocaml rather than compiled to native code with ocamlopt.
The hidden character is ^.
^^t^r^^^^-^^^^-^^r^^^^=^^^^^^^r^^^^r^^^^^^^(^^^^/0)

Cracked. This works in both the interpreter (specifying the file name on the command line, which I think is what you wanted?) and the compiler, so it can't be the intended solution.

Aceto, 5 bytes, 9 numbers, safe
_ are unrevealed chars
__xx_

Try it online!

Acc!!, 46 bytes, 10 numbers, cracked
?
Count i while ?????????????????
}
Write ????

Works for 1 to 10, with ? as the hidden character.

Original solution:

1
Count i while _/10 {
Write 49
0
}
Write 48+_

The initial accumulator value goes from 1 to 9 and then to 99. Whenever it is less than 10, _/10 is 0 and the loop doesn't execute. When it is greater than 10, the inner loop writes a 1 and sets the accumulator to 0, which breaks out of the loop and writes a 0.

Cracked

TI-Basic, 13 tokens, 10 numbers, cracked
DelVar A1→θ
__>A
θ

_ represents a hidden token. Hopefully this isn't too easy xD

How many _s are there?

Two @KritixiLithos

Which calculator version of TI-Basic is this? (Keep in mind that only "free" languages can be used in [tag:cops-and-robbers])

It's TI-83/84 BASIC. Try https://www.cemetech.net/sc/ or https://www.cemetech.net/projects/jstified/

@Timtech It does seem to require a ROM in order to run, is that correct?

You should be able to grab 2.55MP from https://education.ti.com/en/us/software/details/en/B7DADA7FD4AA40CE9D7911B004B8C460/ti84plusoperatingsystem EDIT: Here's a tutorial I found online that can emulate based off of the .8xu from the first link http://frewin.weebly.com/ti-calculator-emulator.html

Is there an free emulator of TI available? The license of the OS says you may only use it with an TI emulator from TI itself (and I only found a non-free one =/  ).

Quick search shows a wabbitemu emulator. Check it out - https://www.youtube.com/watch?v=8FbN-iSRiCE

I only see 12 tokens. Regardless, the byte count should be present.

Cracked

Python, 28 bytes, 10 numbers, cracked!
_____ (__________)_(_____*4)_

Intended solution:
print (ord("a"   )-(24   *4))

Cracked (python 2): print (0+1+0*1000)+(0*0*0*4) , print (1+1+0*1000)+(0*0*0*4)  e.t.c...

the official post

Why did you include so much space? I'd consider that dangerous :)

@flwar to throw you off

ASMD, 10 bytes Cracked!
1_**_**_*÷

Hidden characters are denoted by _.
This should be really easy to crack.
Works from 1 to 10.

Why is this non-competing?

@StewieGriffin The latest commit for ASMD was only a few hours ago and it was created today

Cracked?

Java 10+ numbers 126 tokens
____00________007____________00______________________________t____o_____in_(___"___42________00____00____".___________0)___;__
_ is redacted

Cracked

Hexagony, 15 bytes, 10 numbers, Cracked!
\!?___<3__!?_<3

What kind of love (<3) is this? This is the love of Hexagons :P
I believe this is not a hard one but a hearty one (Pun intended).

Sorry, cracked, but definitely not the way you intended.

Ruby, 81 bytes, 10 numbers, cracked by feersum
require'digest/md5'
p Digest::MD5.digest('########')[n=0].ord^'straYNpraq'[n].ord

# is the placeholder character. Is this a standard loophole yet? Not that it's uncrackable I don't think, I've left in some weaknesses intentionally and I'm sure unintentionally.

Cracked

Python 2, 33 bytes, 9 numbers
#__________________
riny
________

(how mysterious?)

Cracked.

Python 2, 26 bytes, 10 numbers, cracked
print r___e(_______+_[___]

Works for 1-10; _ is the hidden character.

Cracked in a non-intended way, I believe

ASMD, 8 bytes, Cracked!
____+++C

Works from 1-10.

asmd.py doesn’t implement C, but it’s listed in commands.txt. What’s up there? Also, you should specify if _ is a wildcard (I assume it is.)

Cracked, I think

@Lynn Oh. I will fix that

tinylisp, 43 bytes, 10 numbers
((v(d f(q((n)(i n(s 1(s 0(f(___))))1)))))0)

Works for 1-10; _ is hidden.

I think this is safe now...?

QBasic, 12 bytes, 10 numbers, cracked
Previous version's red herring created a loophole...
_I_T__O_(3))

Works for 1-10. _ is the hidden character.

Cracked.

R, 22 bytes, 10 numbers SAFE
_et___e_(_)____is_1___

_ is hidden character
Solution:

 set.seed(4);rpois(1,1)

set.seed(4);rpois(1,2)

set.seed(4);rpois(1,3)

set.seed(4);rpois(1,4)

set.seed(4);rpois(1,5)

set.seed(4);rpois(1,6)

set.seed(4);rpois(1,7)

set.seed(6);rpois(1,7)

set.seed(6);rpois(1,8)

set.seed(6);rpois(1,9)

Hexagony, 12 bytes, 10 numbers, Cracked!
[!_>!_!1_@!_

_ can be replaced by any characters.
Seems that love doesn't belong to here should not stay here, to keep the world more interesting :P
Spent time finding cheap alternatives.  So giving out much tips so that it is harder to crack (I hope impossible) with cheap alternatives !_!

Edited to avoid a cheap solution breaking my <3

I'm afraid it's still not secure. Cracked.

Oh... then I should type up my intended solution - seems I don't have the mind to block all unintended mirrors... Thanks for playing @MartinEnder :)

Maybe try another one with fewer _? To be fair, it seems pretty hard to get a secure cop in Hexagony. I'd love to see one, but I'm not sure yet how to write one myself.

Mm... Basically the same for me, ready for a post edit? @MartinEnder This should be my final try :P

Fine by me, but you might want to make a new post at some point. :P

Python 2, 109 bytes, 10 numbers
from hashlib import *
h=md5()
h.update('__[_')
if h.hexdigest()=='88f4002e27b0902c7018359da9bc5b44':print(0+1)

Hashing functions are discouraged, as they aren't in the spirit of the challenge. http://meta.codegolf.stackexchange.com/a/7627/34718; http://meta.codegolf.stackexchange.com/a/10027/34718

This is 110 bytes.

Cracked

Hexagony, 18 bytes, 10 numbers, Cracked!
This submission works for 1 - 10. Unrevealed characters are indicated with an underscore: _.
.__{_]5[$@__=@_!!1

You can try Hexagony online over here.
I posted a follow-up using the same indended solution, but with fewer hidden characters here.

Cracked. As I told Sunny Pun, I doubt that a program at this size can be sufficiently constrained with so many wildcards.

It's hard to not give it away but also not allow trivial solutions. If I had given something like this would you have gotten it? .__{_]5[$@.;=@$!!1

That one is definitely a lot harder.

@MartinEnder I almost went with that one, but because I already knew the intended solution I thought it gave it away.

Feel free to post that as a new cop, still haven't figured it out.

@MartinEnder Posted Good Luck :)

Python 3, 56 bytes, 6 numbers, Cracked
Quite a simple concept, should be easily crackable. The 'mystery characters' are indicated with underscores.
print(_______(str(ord(x))for x in ________).___________)

Cracked. Pretty sure you had something else in mind...? :)

@StewieGriffin yep, shouldn't have put so many mystery chars :P