text:
Unfold in all directions
Input:
A string
Output:
1) First we take remove character at the end of the input-string until we are left with a length that is a square (i.e. 1, 4, 9, 16, 25, 36, etc.)
So abcdefghijklmnopqrstuvwxyz (length 26) becomes abcdefghijklmnopqrstuvwxy (length 25).
2) Then we put this in a square, one line at  a time, left to right:
abcde
fghij
klmno
pqrst
uvwxy

3) We fold it in all four directions, like this (we keep unfolding until the outer folded 'block' has no inner characters to unfold anymore):
      m
     qrs
     l n
     ghi
    abcde
 ihgf   jihg
mn lk   on lm
 srqp   tsrq
    uvwxy
     qrs
     l n
     ghi
      m

Some things to note, when we fold outward, we basically mirror like this (numbers added as clarification, which represents the 'indexes' in these examples):
When we fold out the left side:
 123    to:   321 123
fghij         ihgf   j

When we fold the right side:
 123    to:    123 321
fghij         f   jihg

When we fold upwards:
            3q
            2l
            1g
  b   to:    b
 1g         1
 2l         2
 3q         3
  v          v

When we fold downwards:
 b          b
1g         1
2l         2
3q         3
 v   to:    v
           3q
           2l
           1g

Challenge rules:

You can assume the input will always have at least 1 character (which will also be the output).
Output format is flexible, so you can print to STDOUT or STDERR; return as string-array/list or character 2D-array; single string with new-lines; etc.
The input will only contain alphanumeric characters (a-zA-Z0-9)
You can also use a non-alphanumeric character to fill up the spaces in and/or around the ASCII-art output, like a dot ..
Trailing spaces and a single trailing new-line are optional.
We continue unfolding until the outer folded 'block' has no more centers to unfold.

General rules:

This is code-golf, so shortest answer in bytes wins.
Don't let code-golf languages discourage you from posting answers with non-codegolfing languages. Try to come up with an as short as possible answer for 'any' programming language.
Standard rules apply for your answer, so you are allowed to use STDIN/STDOUT, functions/method with the proper parameters and return-type, full programs. Your call.
Default Loopholes are forbidden.
If possible, please add a link with a test for your code.
Also, please add an explanation if necessary.

Test cases:
Input: abcdefghijklmnopqrstuvwxy
Output:
      m
     qrs
     l n
     ghi
    abcde
 ihgf   jihg
mn lk   on lm
 srqp   tsrq
    uvwxy
     qrs
     l n
     ghi
      m

Input: A
Ouput:
A

Input: ThisIsATest
Output:
  I
 Thi
Is sI
 ATe
  I

Input: HowAboutAVeryLongExampleWhichIsAlsoAnEvenSquareInsteadOfOddOneAndExceeds64Chars
Output:

               An
               ch
              xamp
              i  I
              o  E
              quar
             steadO
             S    e
             s    v
             h    s
             E    l
             VeryLo
            HowAbout
      oLyreVA      noLyreV
  xampl    Eg      el    Examp
hci  Is    hW      As    hi  Ihc
nAo  Ev    sl      ev    so  EnA
  quare    Sn      Ie    Squar
      Odaetsn      fOdaets
            OddOneAn
             steadO
             S    e
             s    v
             h    s
             E    l
             VeryLo
              xamp
              i  I
              o  E
              quar
               An
               ch

Input: Lenght7
Output:
Le
ng

Input: abc
Output:
a

there's a mistake in the test for "HowAboutAVeryLongExampleWhichIsAlsoAnEvenSquareInsteadOfOddOneAndExceeds64Chars": 'h'->'i' near the bottom of the output

SOGL V0.12, 75 bytes
l√u²m√lH»{ā;l⁾:A∫Ba{bIwFIWhFbž;FIbI@ž}};}¹K⁴{ē2\⌡±e{@Κ};⁴┼┼};0E{ē2\⌡№:h++}╚

Try it Here!
This expects the input on the stack, so for ease-of-use I added , at the start. That can cause issues if the input contains only numbers so here
is a a test-suite for that.
70 bytes √lH»{ā;l⁾:A∫Ba{bIwFIWhFbž;FIbI@ž}};}¹K⁴{ē2\⌡±e{@Κ};⁴┼┼};0E{ē2\⌡№:h++}╚ works too, but as I only now implemented √ on strings and the documentation didn't mention that it would floor the length I won't count it.
Explanation:
creating a square from the input

l       get the length of the input
 √      get its square root
  u     floor that
   ²    square it
    m   mold the input to that length
     √  convert it to a square

creating the unfoldings of the square - the idea is to cut out the inner squares to a new array

lH»{                              } (length-1)//2 times do
    ā;                                push an empty array below ToS
      l⁾                              push ToS.length - 2 (ToS here is the square or the previous unfolding)
        :A                            save a copy of that in the variable A
          ∫B                    }     repeat that amount of times, saving iteration on B - cutting the inner square to the empty array
            a{                 }        variable A times do
              bIw                         get the b+1th row of the previous unfolding
                 FIW                      get the (current loops iteration + 1)th character of that
                    h                     swap the 2 items below ToS - so the stack now is [..., prevUnfolding, newArray, character]
                     Fbž                  at [current loops iteration; b] insert that character in the array
                        ;                 swap the top 2 items - the stack now is [..., newArray, prevUnfolding]
                         FIbI@ž           at [current loops iteration+1; b+1] insert a space
                                 ;    get the now not empty array ontop of the stack

add the horizontal unfoldings

¹                    wrap the stack in an array
 K                   push the 1st item of that, which will function as the canvas
  ⁴{              }  iterate over a copy of the remaining items
    ē2\⌡               repeat (e++ divides by 2) times (default for the variable E is the input, which defaults to 0)
        ±                reverse the array horizontally
         e{  }         repeat e times
           @Κ            add a space before ToS
              ;⁴┼┼     add that horizontally before and after the canvas

add the veertical unfoldings

;                get the copy of the foldings above the canvas
 0E              reset the variable E to 0
   {         }   iterate the copy of the foldings
    ē2\⌡           repeat (e++ divides by 2) times (default for the variable E is the input, which defaults to 0)
        №            reverse the array vertically
         :h++      add that vertically before and after the canvas
              ╚  center the canvas vertically

Your 70 byte version is valid as non-competing isn't a thing anymore.

@Shaggy The 75 byte version is valid only because of that as before this challenge √ only worked on numbers. The reason why I'm not counting the 75 byte version is because I feel like it falls under the loophole of adding a built-in just for a challenge

Charcoal, 120 109 bytes
ＡＩ§⪪ＩＸＬθ⁰·⁵.⁰ηＦη⊞υ✂θ×ιηＦ⁴«ＡυεＪ⁰¦⁰Ｆ÷⁺¹η²«Ｆ⁴«Ｆ⁻η⁺κκ§§εκ⁺μκ↷Ａ⮌ＥεＥε§ξνε¶»Ａ⎇﹪ι²Ｅε⮌λ⮌εεＡ⎇‹ι²⁻⁺²⁺κκη⁻η⁺κκκ¿﹪ι²Ｍκ¹Ｍ¹κ

Try it online! Note that Ａ has since been changed to ≔ and the link reflects this. Explanation:
       θ          Input string
      Ｌ           Length
     Ｘ  ⁰·⁵       Raise to the power 0.5
    Ｉ             Cast to string
   ⪪       .      Split on the decimal point
  §         ⁰     Take the first element (integer part)
 Ｉ                Cast to integer
Ａ            η    Assign to h

Calculates h = int(sqrt(len(q))). (Floor was yet to be implemented...)
Ｆη⊞υ✂θ×ιη

Extracts the h slices of length h from the input. (Actually I don't bother truncating the slices to length h.) I use a for loop rather than a Map because I need to Assign the result of the Map somewhere and this is nontrivial when dealing with a Slice.
Ｆ⁴«

The unfolding happens 4 times, once for each direction (down, right, up, left as coded). The loop variable for this loop is i.
   Ａυε

Take a copy of the sliced string.
   Ｊ⁰¦⁰

Jump back to the origin of the canvas so that each unfold starts with the h-by-h square in the same place.
   Ｆ÷⁺¹η²«

Repeat (h+1)/2 times; once for each unfold, plus once for the original square. The loop variable for this loop is k.
          Ｆ⁴«

Repeat 4 times, once for each side of the unfolded square. (I don't use the loop variable l.)
             Ｆ⁻η⁺κκ         Loop h-2k times, loop variable `m`
                    §εκ     Take the `k`th row
                   §   ⁺μκ  Take the `k+m`th column
                            Implicitly print the character

Print one side of the unfolded square. Since this is the kth unfold, the square's side is h-2k, and takes characters k away from the edge of the original square.
             ↷

Pivot ready to print the next side of the square.
               Ｅε       Map over the array (element `m`, index `n`)
                 Ｅε     Map over the array (element `x`, index `p`)
                   §ξν  Take the `n`th element of `x`
              ⮌         Reverse
             Ａ        ε Replace the array with the result

Rotate the sliced string. (Yes, that's a ξ. I don't get to use it often!) Ｅη would also work for the outer Map. The rotation also has the convenient side-effect of truncating the array's width to h.
             ¶»

After printing the side, the cursor moves off the edge of the square. Printing one character fewer fails for squares of side 1 and is less golfy anyway. Having previously pivoted, printing a newline conveniently moves the cursor back to the corner.
            ﹪ι²         Take `i` modulo 2
           ⎇            Choose either
                   ⮌ε   Reverse the array
               Ｅε       Map over the array (element `l`, index `m`)
                 ⮌λ     Reverse each element
          Ａ          ε  Replace the array with the result

Flip the square vertically or horizontally as appropriate.
           ⎇‹ι²                 If `i` < 2
                  ⁺κκ           Double `k`
                ⁺²              Add 2
               ⁻     η          Subtract `h`
                        ⁺κκ     Else double `k`
                      ⁻η        Subtract from `h`
          ≔                κ    Assign back to `k`.

Calculate the displacement to the next unfold.
           ﹪ι²          Take `i` modulo 2
          ¿             If not zero
              Ｍκ¹       `k` across and 1 down
                 Ｍ¹κ    Else 1 across and `k` down

Move horizontally or vertically to the next unfold as appropriate.
Here's a link to the 97-byte version obtained by making use of all the latest Charcoal features including Floor: Try it online! Link is to verbose version of code.

Are you sure this works? TIO just seems to raise an error.

@LyricLy Bah, I thought I was being clever, but failed to actually check that it worked. I'll revert the change.

Crap forgot to make floats work in slices oops

@ASCII-only Doesn't help me, I need to truncate to integer before multiplying anyway.

Right. Well I'm adding floor soon so it won't be as much of a problem :P

@ASCII-only That's great! Out of interest, will you be adding ceiling too? (I'm guessing you might overload ⌊ and ⌈ to perform floor and ceiling if given float arguments.)

Yes (also O_o forgot I had those, was going to use lowercase/uppercase lol, thanks!)

Floor should work now :P

Wait hang on forgot to add verbose version, you'll have to use Minimum for a while I guess

@ASCII-only Right now it's very broken - the current link only works because of caching, I expect.

@Neil D: oops, it appears to be an edge case. I'll look into it ASAP.

@Neil Found it lol, typed \1 instead of \\1 for one of the replacements in the golfer

@ASCII-only Can confirm that Floor saves 5 bytes.


text:
Slice, Slice, Maybe
Everyone loves slicing in python, as in array[5] to access the fifth element or array[:5] to access the zero through fourth element or array[::-1] to reverse an array. However, these all have seemingly distinct notations. When and where should the colons and integers be placed?
Task
Your task is to change any valid slice syntax into a slice with as many colons and integers as possible. To help with that, we will make some definitions. Valid slice syntax is anything directly after "Given a slice" in this section.
Define <POS> to be any positive integer, that is any digit 1-9 followed by any amount of digits 0-9.
Define <NEG> to be any negative integer, that is a - followed by <POS>
Define <INT> to be <POS>, <NEG>, or <ZERO>
Define sgn(a) to be the sign of a: 1 for positive a, -1 for negative a, and 0 for a=0.
For all of the following, a and b are <INT> and c is <POS> or <NEG> unless otherwise specified.

Given a slice [], your program may have undefined behavior.
Given a slice [a], your program or function must return [a:a+k:c] for some <POS> or <NEG> value of c and 0 < abs(k) <= abs(c) and (a+k < 0 if c < 0) and (a+b > 0 if c > 0)
Given a slice [:], your program must return [0::1].
Given a slice [a:], your program must return [a::1].
Given a slice [:b], your program must return [0:b:1].
Given a slice [a:b] where a < b and sgn(a)+sgn(b) != 0 your program must return [a:b:1].
Given a slice [::], your program must return [0::1].
Given a slice [a::], your program must return [a::1].
Given a slice [:b:], your program must return [0:b:1].
Given a slice [::c], your program must return [0::c] if c is <POS> and [-1::c] otherwise.
Given a slice [a:b:] where a < b and sgn(a)+sgn(b) != 0, your program must return [a:b:1].
Given a slice [a::c], your program must return [a::c].
Given a slice [:b:c], your program must return [0:b:c] if c is <POS> and [-1:b:c] otherwise.
Given a slice [a:b:c] your program must return [a:b:c].

Example
The "slice" [5] gives the fifth element of an array.
Your program or function can output [5:6:1] or [5:7:2] or [5:1000:1000] or [5:4:-1] or [5:0:-5].
The program cannot output [5:7:1] or [5:-6:1] or [5:-6:-1] or [5:6:-1].
Test Cases
Input     Output
[1]       [1:2:1]     [Output may vary]
[-1]      [-1:-2:-1]  [Output may vary]
[:]       [0::1]
[1:]      [1::1]
[-1:]     [-1::1]
[0:3]     [0:3:1]
[-3:-1]   [-3:-1:1]
[::]      [0::1]
[0::]     [0::1]
[:5:]     [0:5:1]
[::2]     [0::2]
[::-2]    [-1::-2]
[2:4:]    [2:4:1]
[2::3]    [2::3]
[:2:1]    [0:2:1]
[:2:-1]   [-1:2:-1]
[1:2:3]   [1:2:3]

Rules

You do not have to do any input validation.
The output and input may include or exclude the brackets [].
The output and input may be a 3-tuple instead of a :-delimited string.
This is code-golf, so shortest code in each language wins.

Did anyone else read the title in the same way you'd say "Ice, Ice, Baby!"

@KevinCruijssen That was my intention :)

Although you haven't logged on since September, I am wondering how exactly the 3-tuple I/O option is supposed to work... are blanks before/after colons represented by arbitrary non-integer elements, or does everything have to be a string? Are missing colons represented by a different arbitrary non-integer element, or can input tuples have less than three elements?

@UnrelatedString generally, I/O here is permissive, so the answer to your first question is: you can do anything that works for you. On your second question, having an tuple with less than 3 elements would be ambiguous. For example, [a:] and [:b] have different behavior despite having the same elements.

Thanks for the quick response, and welcome back! The ambiguity shouldn't be an issue with an element (I'll call it e) that would represent an empty slot, since [a:] would be (a,e) and [:b] would be (e,b), so if that's the only reason not to use variable-size tuples (or nested tuples) then I'll go ahead and do it unless I can think of a more convenient encoding.

Python 2, 101 96 90 85 82 bytes
def f(r):l=len(r);b=r[l>1]+'1'*(l<2);c=(r+[0,b])[2]or'1';print r[0]or~-('.'<c),b,c

Try it online!
Explanation:
Basically a golfed version of:
f(r):
 if len(r)==1:return [r[0],r[0]+'1',r[0]+'1']            # [a, a1, a1] where a1 is further from 0 than a
 if len(r)==2:return [r[0]or'0',r[1],'1']                # [a or 0, b, 1]
 if len(r)==3:return [r[0]or -1*(r[2]<0),r[1],r[2]or'1'] # [a or 0|-1, b, c or 1]

Change return to print for 85 bytes

Kotlin 354 330 bytes
Submission
fun f(i:List<Int?>):List<Int?>?{
val N=null
val Z=mutableListOf(0,N,1)
if(i.none{it!=N})return Z
val v:Int=i[0]?:0
val z:Int=if(i.size==3)i[2]?:1 else 1
val p=if(v<0)-1 else 1
return when(i.size){1->listOf(v,v+p,p)
2->listOf(v, i[1], z)
3->{if(i[0]==N&&i[2]!=N&&i[2]!!<0)Z[0]=-1
return i.zip(Z).map{it.first?:it.second}}
else->N}}

Beautified
fun f(input: List<Int?>): List<Int?> {
    if (input.none { it != null }) return listOf(0, null, 1)
    val item0: Int = input[0] ?: 0
    val step: Int = if (input.size == 3) input[2] ?: 1 else 1
    val direction = if (item0 < 0) -1 else 1
    return when (input.size) {
        1 -> listOf(item0, item0 + direction, direction)
        2 -> {
            listOf(item0, input[1], step)
        }
        3 -> {
            val D = mutableListOf(0, null, 1)
            if (input[0] == null && input[2] != null && input[2]!! < 0) D[0] = -1
            return input.zip(D).map { it.first ?: it.second }
        }
        else -> listOf()
    }
}

TryItOnline
Link

Python 3, 268 bytes
import re
w='([^:]*)'
def f(x):
	(a,b,c,d,e)=re.findall('\[%s(?:(:)%s(?:(:)%s)?)?\]'%(w,w,w),x)[0]
	g=int(a)if a else(-1if e and int(e)<0else 0)
	return'[%s:%s:%s]'%(g,c if c else(g+(1if g>0else-1)if not(b or d)else''),e if e else((1if g>0else-1)if not(b or d)else 1))

Try it online!

source: Stack Exchange

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

sort: votes


text:
The Original Number (II)
This challenge is essentially identical to this one with just one difference: it is now allowed to shuffle letters anywhere in the string.
Scenario
John has an important number, and he doesn't want others to see it.
He decided to encrypt the number, using the following steps:
His number is always a non-decreasing sequence (ie. "1123")
He converted each digit into English words. (ie. "123" -> "ONETWOTHREE")
And then, rearrange the letters randomly. (ie. "ONETWOTHREE" -> "EEWOOHRNTET")
John felt that his number were safe in doing so. In fact, such encryption can be easily decrypted :(

Task
Given the encrypted string s, your task is to decrypt it and return the original number.

Rules

This is code golf, so the shortest answer in bytes wins
You can assume that the input string is always valid
The input string only contains uppercase letters
The original numbers are always arranged in ascending order
You may return the number in string or integer format
The letters will only be shuffled between one word, not between the whole string. The letters can be shuffled anywhere in the string.
The numbers will only be from 1 to 9 inclusive (ONE to NINE)

Possible Unscrambled String
Here is a list of the strings just after they have been converted to strings from the numbers:
 1 -> ONE
 2 -> TWO
 3 -> THREE
 4 -> FOUR
 5 -> FIVE
 6 -> SIX
 7 -> SEVEN
 8 -> EIGHT
 9 -> NINE

Examples
"NEO" -> 1
"NWEOOT" -> 12
"TOEERWNEHOT" -> 123
"IHNEVGENNEISTE" -> 789
"WEETVTRFSVUHNEEFRHIXEOINSNIEGTOONIEE" -> 123456789
"EWHEWROETOTTON" -> 1223
"ONEWESTV" -> 27 (thanks, ETHproductions!)

Suggested test case: something like "ONEWESTV" -> 27 (includes a number that doesn't actually appear)

@ETHproductions Great idea! Added.

Why there is not the "ZERO"?

@RosLuP John hates leading zeroes...

Python 2, 123 bytes
c=map(input().count,"OWHUFXSGIQ")
i=4
for j in"71735539994":c[i*2]-=c[int(j)];i=-~i%5
s=""
for n in c:i+=1;s+=`i`*n
print s

A full program taking quoted input and printing John's number.
Try it online! or see a test-suite
How?
Let's work with the example "NEONSEXTOWNII" (to yield 1269, and be somewhat Leisure Suite Larry-esque!)
First c=map(input().count,"OWHUFXSGIQ") takes input and counts the number of each of OWHUFXSGIQ - these are letters that appear in each number in ascending order, with 2,4,6, and 8 having their "own" letters (WUXG), plus an extra letter, Q to append a zero to the the end and make the length of the resulting list even. For the example:
[2,1,0,0,0,1,1,0,2,0] <- c
 O W H U F X S G I Q  <- is the counts of these letters
 1 2 3 4 5 6 7 8 9 0  <- which "relate to" these digits in John's number
   2   4   6   8   0  <- these will be correct as the letters are unique to their words

The entries for 1, 3, 5, 7, and 9 need adjusting to correct the abundance of the other letters. This is performed by the next loop:
i=4
for j in"71735539994":c[i*2]-=c[int(j)];i=-~i%5

Note that the entries to adjust are alternate ones (1,3,5,7,9,1,3,5,...), so we can add two to an index variable at each step and modulo by 10 to stay in range if we need to traverse more than once (which we do). To save some bytes we can increment by one and modulo by 5 and use double the index.
Since the adjustments for 9 require the most work we start there - it resides at index 8 so we start at i=4.
The string "71735539994" then gives the indexes, j, of the values to remove at each stage (where we have ensured the ninth index will contain zero by using "Q" when creating c); c[i*2]-=c[int(j)] performs each individual adjustment and i=-~i%5 moves i to the next index (where -~i is -(-1-i) or i+1 saving parentheses (i+1)%5) keeping i*2 within the bounds of c.
Thus we first subtract the number at index j=7 from that at index i*2=8, subtracting the number of "G"s counted from the number of "I"s, adjusting the "NINE" count down by the (correct) number of "EIGHT"s (which also has an "I"). We then move onto i=0 (-~4%5 = (4+1)%5 = 0), referencing index i*2 = 0 which is for "ONE" and subtract the value found at index j=1 the entry counting "W" and hence "TWO", adjusting the count of "O"s down. By the end of the loop we have the corrected counts:
[1,1,0,0,0,1,0,0,1,0] <- c   (for 1223333448 it would be: [1,2,4,2,0,0,0,1,0,0])
 1 2 3 4 5 6 7 8 9 0

so all that remains is to print out what c now represents (1269). i is now back at 0, so we increment it at the start of the loop and use it as our digit:
s=""
for n in c:i+=1;s+=`i`*n
print s

The back ticks, `i`, are Python2 shorthand for repr(i) which gets a string representation of an object (the digit character in question as a string) and multiplying a string by a number creats a new string of that many repeats (here we only show n=0 turning `i` from say "5" to "" and n=1 turning keeping say "6" as "6", but it also works for larger positive integers, so "3"*4 becomes "3333" for example.)

05AB1E, 31 bytes
[{‘Z€µ‚•„í†ìˆÈŒšï¿Ÿ¯¥Š‘#NSèJ{Q#

Try it online!
Explanation
[                                   # start loop
 {                                  # sort input
  ‘Z€µ‚•„í†ìˆÈŒšï¿Ÿ¯¥Š‘#            # push the list ['Z','ONE','TWO','THREE','FOUR','FIVE','SIX','SEVEN','EIGHT','NINE']
                        N           # push the current iteration counter
                         S          # split to list of digits
                          è         # index into the list with each
                           J{       # join to string and sort
                             Q#     # if the strings are equal, exit loop
                                    # implicitly print iteration counter

Very inefficient for large input.

‘Z€µ‚•„í†ìˆÈŒšï¿Ÿ¯¥Š‘#            # push the list ['Z','ONE','TWO','THREE','FOUR','FIVE','SIX','SEVEN','EIGHT','NINE'] : can you explain a little, I struggle to understand how any string can be generated.

@CyrilGandon: ‘ delimits an upper-case compressed string of space separated words. Z means Z. All other 2-symbol pairs denote a compressed word from 05AB1E's dictionary. So for example €µ translates as ONE.

Nice, how do you compress a string contains in the dictionary? Something with the unicode value of the pair?

@CyrilGandon: You take the line number of the word in the dict (2420 for hello) and subtract 1. This gives us 2419. The symbols we need are the symbols which are followed by 24 and 19 in the docs. In our case this is 24=Ÿ and 19=™, so HELLOwould be ‘Ÿ™‘

There is also a compressor written by Adnan you can use in most instances. The link is a bit long, but you can find it in the 05AB1E chat room. That is also a good place to ask if have any further questions :)

Retina, 112 97 bytes
O`.
}`GH
8
X
6
H
3
+`F(.*)O(.*)U
4$1$2
+`O(.*)W
2$1
+`F(.*)V
5$1
+`N(.*)V
7$1
}`NO
1
NN
9
T`L
O`.

Try it online!
-12 bytes thanks to @Neil
-3 bytes by use of L character classes in transposition
How it Works
Basically, this relies on the fact that letters are only used in certain number names. For example SIX is the only name which contains an X. This gets trickier with the fact that some words overlap in letters, such as both FIVE and SEVEN using V. This could be corrected for by identifying FIVE with F(.*)V.

@RickHitchcock Fixed. The recursion on conversion to 8 was not working properly

@RickHitchcock. Fixed the recursion for all of them.

Annoyingly GH and NO would be adjacent, except for any previous 8 or 1 from a prior substitution...

Perhaps }`GH 8 would work for 8 - the } would cause the characters to be sorted again, thus placing any remaining G and H together.

@Neil Nice idea. I was also able to do that for NO -> 1, which was convenient.

Kotlin 1.1, 359 352 331 327 325 bytes
Submission
fun r(r:String):String{var s=""
val f=r.split(s).groupingBy{it}.eachCount()
val c=Array(10,{0})
c[8]=f["G"]?:0
c[6]=f["X"]?:0
c[4]=f["U"]?:0
c[2]=f["W"]?:0
c[1]=(f["O"]?:0)-c[2]-c[4]
c[3]=(f["R"]?:0)-c[4]
c[7]=(f["S"]?:0)-c[6]
c[5]=(f["V"]?:0)-c[7]
c[9]=((f["N"]?:0)-c[1]-c[7])/2
for(i in 1..9)for(x in 1..c[i])s+=i
return s}

Does not work on TryItOnline due to Kotlin 1.1 not being supported
Test
fun r(r:String):String{
val f=r.split("").groupingBy{it}.eachCount()
val c=Array(10,{0})
c[8]=f["G"]?:0
c[6]=f["X"]?:0
c[4]=f["U"]?:0
c[2]=f["W"]?:0
c[1]=(f["O"]?:0)-c[2]-c[4]
c[3]=(f["R"]?:0)-c[4]
c[7]=(f["S"]?:0)-c[6]
c[5]=(f["V"]?:0)-c[7]
c[9]=((f["N"]?:0)-c[1]-c[7])/2
var s=""
for(i in 1..9)for(x in 1..c[i])s+=i
return s}

data class TestData(val input: String, val output: String)

fun main(vararg args:String) {
    val items = listOf(
    TestData("NEO" , "1"),
    TestData("NWEOOT" , "12"),
    TestData("TOEERWNEHOT" , "123"),
    TestData("IHNEVGENNEISTE" , "789"),
    TestData("WEETVTRFSVUHNEEFRHIXEOINSNIEGTOONIEE" , "123456789"),
    TestData("EWHEWROETOTTON" , "1223")
    )
    for (item in items) {
        val out = r(item.input)
        if (out != item.output) {
            throw AssertionError("Bad result: $item : $out")
        }
    }
}

Logic

I used the sheet above to work out the simplest way to solve each letter

Green = Solve by itself
Blue = Needs greens to solve
Orange = Needs blues to solve
Red = Needs oranges to solve

Edits

-7 - Whitespace changes by w0lf
-21 - Shrank listOf to Array
-4 - Removed unneeded brackets
0  - Added logic in
-2 - Re-using empty string thanks to kevin-cruijssen

Just noticed I'm exactly tied with you with my Java 8 answer (127 bytes), using a similar approach. ;) But one question: can't you change var s="" and return s to r="" and return r by reusing the input-String, which you no longer need at that point? I never programmed in Kotlin before, so it could be that I talk nonsense here. ;p

Unfortunately not

https://discuss.kotlinlang.org/t/immutable-function-parameters-with-kotlin-1-1/2240/5

Ah yes, that was of course a possibility; parameters being final by default. Hmm, one other thing you might be able to golf: Place the var s="" as the first thing in the method, and replace val f=r.split(""). with val f=r.split(s).. Again, no idea if it works. Too bad TIO doesn't support v1.1 yet, otherwise I would try these suggestions myself before I make myself sound stupid..

Jelly, 37 bytes
1ðDị“©ȯ¿w¶&ÇhṆỌƘ#Ȯʋ~¢CNẓ_»ŒuḲ¤ẎŒ!ċð1#

Try it online!
-1 thanks to Jonathan Allan.

This times out for some inputs larger than 7 characters (ex: NINEFIVE, THREEFIVE). Is it a bug, or is the code just inefficient?

@w0lf the latter (Œ! means "permutations")

Save a byte using "AA" rather than "!": ...“©ȯ¿w¶&ÇhṆỌƘ#Ȯʋ~¢CNẓ_»...

@JonathanAllan oh is AA a word?

It's the first word in the short dictionary, yes.

@JonathanAllan mmm uppercase...btw I can't open the dictionary file without slowdown

No need to open the file itself if you have jelly installed - you can just use Python and do: import dictionary as d; d.short[0]. Edit: mind you it's only a 2.5MB text file :/

Let us continue this discussion in chat.

Too much slow For the string ONEWESTVONEONEONEONE

@RosLuP But it works. The challenge spec doesn't specify a specific timeout.

If it is not specified a timeout this C code would be ok for above main(){while(1);}

@RosLuP Huh? How does that return the correct result?

Java 8, 248 234 bytes
s->{int x=0,a[]=new int[10];for(String t:"2WO;4UORF;6XSI;8GI;5FI;7S;3R;1O;9I".split(";"))for(;s.indexOf(t.charAt(1))>=0;a[t.charAt(0)-48]++)for(String z:t.split(""))s=s.replaceFirst(z,"");for(s="";x++<9;)for(;a[x]-->0;)s+=x;return s;}

Code Explanation:
s->{
    // Array to count how often which number appears
    int a[]=new int[10];
    // The first character behind the number serves the identification
    // the other characters get removed to identify the other numbers later
    for(String t:"2WO;4UORF;6XSI;8GI;5FI;7S;3R;1O;9I".split(";"))
        // Check if the string contains the id
        for(;s.indexOf(t.charAt(1))>=0;a[t.charAt(0)-48]++)
            // Remove the relevant charcters
            for(String z:t.split(""))
                s=s.replaceFirst(z,"");
    // Clear the string to write the output
    s="";
    // write the numbers sequential into the output
    for(int x=0;x++<9;)
        for(;a[x]-->0;)
            s+=x;
    return s;
}

-14 Thanks to Olivier Grégoire

234 bytes

Perl 5, 100 bytes
99 bytes code + 1 byte for -n switch.
${$_}++for/./g;@a=($O-$W-$U,$W,$H-$G,$U,$F-$U,$X,$S-$X,$G,$I-$F+$U-$X-$G);print$_ x$a[$_-1]for 1..9

Try it online!

Java 8, 346 345 344 336 327 bytes
s->{int g=c(s+=" ","G"),u=c(s,"U"),w=c(s,"W"),x=c(s,"X"),f=c(s,"F")-u,h=c(s,"H")-g,v=c(s,"V")-f,o=c(s,"O")-u-w,i=c(s,"I")-f-x-g;return d(s=d(s=d(s=d(s=d(s=d(s=d(s=d(s=d("",o,1),w,2),h,3),u,4),f,5),x,6),v,7),g,8),n,9);}int c(String...s){return~-s[0].split(s[1]).length;}String d(String s,int i,int n){for(;i-->0;s+=n);return s;}

Try it here.
General explanation:
I've looked at the occurrences of each character in the alphabet:
E 13357789
F 45
G 8
H 38
I 5689
N 1799
O 124
R 34
S 67
T 238
U 4
V 57
W 2
X 6

I first counted all occurrences of the single-matches characters: G=8; U=4; W=2; X=6.
Then all occurrences of two-matched characters, which also match one of the four above, which I can subtract from their counts: F=5; H=3.
Then I did the same again for V=7 (by subtracting F=5).
Then the same for all three-matches characters that were left: O=1; N=9.

But because N has two occurrences in NINE, I had to do an additional -1 for every occurrence of N, so I've used I=9 instead (by subtracting three previous matches instead of two).

Code Explanation:
s->{                    // Method with String as parameter and return-type
  int g=c(s+=" ","G"),  //  Amount of 8s (and append a space to `s` first, for the .split)
      u=c(s,"U"),       //  Amount of 4s
      w=c(s,"W"),       //  Amount of 2s
      x=c(s,"X"),       //  Amount of 6s
      f=c(s,"F")-u,     //  Amount of 5s
      h=c(s,"H")-g,     //  Amount of 3s
      v=c(s,"V")-f,     //  Amount of 7s
      o=c(s,"O")-u-w,   //  Amount of 1s
      i=c(s,"I")-f-x-g; //  Amount of 9s
  return d(             //  Return the result by:
   s=d(
    s=d(
     s=d(
      s=d(
       s=d(
        s=d(
         s=d(
          s=d("",       //   Making the input String `s` empty, since we no longer need it
                 o,1),  //   Append all 1s to `s`
         w,2),          //   Append all 2s to `s`
        h,3),           //   Append all 3s to `s`
       u,4),            //   Append all 4s to `s`
      f,5),             //   Append all 5s to `s`
     x,6),              //   Append all 6s to `s`
    v,7),               //   Append all 7s to `s`
   g,8),                //   Append all 8s to `s`
  i,9);                 //   And then returning `s` + all 9s
}                       // End of method

int c(String...s){  // Separate method with String-varargs parameter and int return-type
                    //  `s[0]` is the input-String
                    //  `s[1]` is the character to check
  return~-s[0].split(s[1]).length;
                    //  Return the amount of times the character occurs in the String
}                   // End of separated method (1)

String d(String s,int i,int n){
               // Separate method with String and two int parameters and String return-type
  for(;i-->0;  //  Loop from the first integer-input down to 0
      s+=n     //   And append the input-String with the second input-integer
  );           //  End of loop
  return s;    //  Return the resulting String
}              // End of separated method (2)

Damn, I would have thought that adding to a list then sorting it would be shorter (it's not). Well done!

Well, in the end, I outgolfed you, but not by much ;)

Axiom, 351 bytes
s:="GXUWRFVIONETHS";e:EqTable(CHAR,INT):=table();v:=[8,6,4,2,3,5,7,9,1];z:=[k for k in 1..46|prime?(k)];F(x,y)==>for i in 1..#x repeat y;F(z,e.(s.i):=z.i);t:=[1787026,2451,16445,5957,16036207,130169,20372239,495349,20677];h(a)==(r:=1;F(a,r:=r*e.(a.i));j:=[];F(v,while r rem z.i=0 repeat(r:=r quo t.i;j:=cons(v.i,j)));j:=sort j;k:=0;F(j,k:=k*10+j.i);k)

ungolfed commented results
s:="GXUWRFVIONETHS" -- tutte le lettere di ONE..NINE in ordine di importanza
e:EqTable(Character,Integer):=table()
v:=[8,6,4,2,3,5,7,9,1]              -- numeri da controllare in quell'ordine di apparizione di v
z:=[k for k in 1..46|prime?(k)]     -- 14 numeri primi da associare a s
F(x,y)==>for i in 1..#x repeat y
F(z,e.(s.i):=z.i)                   -- riempie la tavola associando numeri primi alle lettere "GXUW..."
t:=[1787026,2451,16445,5957,16036207,130169,20372239,495349,20677]  -- prodotto di numeri primi 1787026 dovrebbe essere HEIGHT
h(a)==
     r:=1 ;F(a,r:=r*e.(a.i))        -- calcola il numero associato alla stringa a
     j:=[];F(v,while r rem z.i=0 repeat(r:=r quo t.i;j:=cons(v.i,j)));j:=sort j  -- leva il nome dei numeri che man mano trova, aggiunge a j
     k:=0 ;F(j,k:=k*10+j.i)         -- costruisce il numero decimale k, da j vettore ordinato
     k                              -- ritorna tale numero k
------------------------------------------------------
(8) -> h("IHNEVGENNEISTE")
   (8)  789
                                                    Type: PositiveInteger

Python 3, 225 bytes
def f(s):
	r=[]
	for i,w in zip([2,4,6,8,3,5,7,1,9],["WTO","UFOR","XSI","GEIHT","HTREE","FIVE","VSEEN","ONE","NINE"]):
		while s.count(w[0]):
			r+=[i]
			for l in w:s="".join(s.split(l,1))
	return "".join(sorted(map(str,r)))

Try it online!
Straightforward: remove the digits which are identified by a specific letter first.

Python 3, 125 bytes
lambda s:''.join(min(w)*(2*sum(map(s.count,w[:2]))-sum(map(s.count,w)))for w in"O1WU W2 H3G U4 F5U X6 S7X G8 IUFXG9".split())

Try it online!
After reading the linked challenge I realized this is a variation on mdahmoune's Python solution, which is itself based on Draco18s's ES6 solution, but hey, at least we golfed off two bytes.
Like that solution, we compute the answer through a linear combination of the number of occurrences of certain letters. We encode the linear combinations briefly by writing them as words where the first two letters are to be added and everything afterwards is to be subtracted. Sometimes a character is needed to pad the first two characters; we use this to hide the digit we want to output (which will never occur in the input, so won't affect our algorithm), which we extract with min.

R, 154
u=utf8ToInt(s)-71
m=sum
b=m(u==16)
d=m(u==14)
f=m(u==17)
a=m(u==8)-b-d
g=m(u==12)-f
cat(rep(1:9,c(a,b,m(u==11)-d,d,m(u==15)-g,f,g,m(!u),(m(u==7)-a-g)/2)))

Try it online!

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


text:
I'm thinking of a number (Cop's Thread)

Robber's Thread here

In this cops-and-robbers challenge cops will think of a positive integer.  They will then write a program or function that outputs one value when provided the number as input and another value for all other positive integer inputs.  Cops will then reveal the program in an answer keeping the number a secret.  Robbers can crack an answer by finding the number.
Here's the catch: this is not code-golf, instead your score will be the secret number with a lower score being better.  Obviously you cannot reveal your score while robbers are still trying to find it.  An answer that has not been cracked one week after its posting may have its score revealed and be marked safe.  Safe answers cannot be cracked.
It probably goes without saying but you should be able to score your answer.  That is you should know exactly what value is accepted by your decision machine.  Simply knowing that there is one is not enough.
Use of Cryptographic functions
Unlike most cops and robbers challenge which ask you not to use cryptographic functions, this challenge not only entirely allows them but encourages them.  You are free to create answers in any way as long as you are trying to win.  That being said, answers using other methods are also welcome here.  The goal of the challenge is to win, and as long as you don't cheat nothing is off the table.

If you allow crytographic functions, I would recommend putting a time limit on programs.

@Okx Why?  Sleeps and other slowdowns can be removed when brute forcing.

I downvoted this challenge because, in most languages, it can be simply cracked using a mapping algorithm or a simple loop. I consider that a bit too easy for a [tag:cops-and-robbers] challenge.

I feel like there are going to be a lot of cops who know one (probably the smallest) accepted value but don't know if there are more right answers or what they are.

@Mr.Xcoder You are free to downvote however I will point out that that is kind of the point of the challenge and not in my opinion a flaw.  The challenge is mostly fun for cops who have to make it as hard to brute force as possible by slowing down computation.  More creative answers will should make brute forcing more and more difficult allowing them to use smaller and smaller numbers.

@WheatWizard Now that I see your point, I undownvoted.

Must the program terminate without erroring for all positive integers?

@Stephen Yes it must.

@WheatWizard Do you have to find the decimal representation of the given number in order to crack it?

@flawr I'm going to say yes, you need to find the decimal representation of the given number.

@WheatWizard I assume it would not be winning, but it would not be possible to crack e.g. a program that just compares the input to A(9,9) where A is the Ackerman function.

@flawr Yes I got that idea from your comment, however if we start allowing people to crack with descriptions of numbers it becomes hard to discern what is a crack and what is not.  Using the Ackerman function however might fall under not being able to score your own answer, as if I give you a large number of similar size you would have trouble determining which is bigger.

@WheatWizard Ah right, that is actually a clever requirement in your challenge (that I totally missed :)

Looking at the answers below, this challenge would really benefit from a time limit imposed on both correct and incorrect inputs (even if it's 30 minutes or so). Many answers don't even allow testing the found number against the given code

I agree with @michi7x7, it should be possible to test the answers with both correct and incorrect inputs and a time limit could ensure that. The limit can be very large – even like 24 hours could be fine, as that would prevent brute forcing, but allow testing of couple of inputs.

So we have two safe answers with a score of 1! This proves what I knew before--this challenge is pretty bad.

@Joshua I don't think this "proves the challenge is bad".  You may have the opinion that it is bad but I feel it perfectly fine that some users have attained the perfect score.  Would you call a test bad if some students in the class attain a 100%?  The test may be bad for different reasons but people doing well does not prove anything about the quality of the test.

Could you please rule if this, this, and this answer are valid? I've voiced my concerns in the comments.

@Dennis I am going to say no, they are not valid.  Answers should only accept one value.

They might accept only one value. The thing is that we don't know.

@Dennis Ok I don't know.  Maybe this challenge should just be closed as unclear anyway.  Everyone except me seems to think its not fun and I don't really have a opinion on this issue.  It might be best to let it die.

@tfbninja I don't do javascrpit either

Tampio, Cracked
m:n tulos on luvun funktio tulostettuna m:ään, missä luku on x:n kerrottuna kahdella seuraaja, kun x on luku m:stä luettuna
x:n funktio on luku sadalla kerrottuna sadalla salattuna, missä luku on x alempana sadan seuraajaa tai nolla
x:n seuraajan edeltäjä on x
x:n negatiivisena edeltäjä on x:n seuraaja negatiivisena
nollan edeltäjä on yksi negatiivisena
x salattuna y:llä on örkin edeltäjä, missä örkki on x:n seuraajan seuraaja jaettuna y:llä korotettuna kahteen
sata on kiven kolo, missä kivi on kallio katkaistuna maanjäristyksestä
kallio on yhteenlasku sovellettuna mannerlaatan jäseniin ja tulivuoren jäseniin
tulivuori on nolla lisättynä kallioon
mannerlaatta on yksi lisättynä mannerlaattaan
maanjäristys on kallion törmäys
a:n lisättynä b:hen kolo on yhteenlasku kutsuttuna a:lla ja b:n kololla
tyhjyyden kolo on nolla
x:n törmäys on x tutkittuna kahdellatoista, missä kaksitoista on 15 ynnä 6
x ynnä y on y vähennettynä x:stä

Run with:
python3 suomi.py file.suomi --io

The instructions for installing the interpreter are included in the Github page. Please tell if you have any difficulties running this.

 The program in pseudocode. The program performs very slowly because my interpreter is super inefficient. Also, I didn't use any opt-in optimizations available, which can reduce the evaluation time from several minutes to about 10 seconds.

Is there no online interpreter for Tampio?

@Shaggy Not yet, unfortunately. I should probably ask if it could be added to TIO.

Cracked

Perl 6 — Cracked!
In a strict sense, this isn't an acceptable submission because it doesn't try very hard to win. Instead, it hopes to offer a pleasant puzzle.
It is a "pure math" program which is intended to be cracked by contemplation. I'm sure that you could bruteforce the solution (after cleaning up some sloppy programming I've purposefully committed), but for "full credit" (:--)), you should be able to explain what it does on the math grounds.
sub postfix:<!>(Int $n where $n >= 0)
{
	[*] 1 .. $n;
}

sub series($x)
{
	[+] (0 .. 107).map({ (i*($x % (8*π))) ** $_ / $_! });
}

sub prefix:<∫>(Callable $f)
{
	my $n = 87931;
	([+] (0 .. $n).map({
		π/$n * ($_ == 0 || $_ == $n ?? 1 !! 2) * $f(2*π * $_/$n)
	})).round(.01);
}

sub f(Int $in where $in >= 0)
{
	∫ { series($_)**11 / series($in * $_) }
}

You are supposed to crack the function f(). (That's the function that takes one natural number and returns one of the two results.) Warning: As shown by @Nitrodon, the program actually behaves wrongly and "accepts" an infinite number of inputs. Since I have no idea of how to fix it, I just remark for the future solvers that the number I had in mind is less than 70000.
If you try to run this in TIO, it will time out. This is intentional. (Since it's not supposed to be run at all!)
Finally, I tried to write some reasonably clear code. You should be mostly able to read it fluently even if you're not familiar with the language. Only two remarks: the square brackets [op] mean reducing ("folding", in Haskell lingo) a list with the operator op; and the sub called postfix:<!> actually defines a postfix operator named ! (i. e. used like 5! -- it does exactly what you would expect). Similarly for the prefix:<∫> one.
I hope that somebody enjoys this one, but I'm not sure if I got the difficulty right. Feel free to bash me in the comments :—).
Try it online!

Cracked

Per @Nitrodon's crack, "While 11 is the only answer in theory, the sampling in the integral is imperfect. Consequently, any integer of the form 87931k+11 should work.". This renders this answer in violation of the challenge rules (requiring only one correct answer), and therefore subject to deletion.

@pppery, well, feel free to flag it if you like. I admit that there's an error, but, honestly, I don't think that it needs to be deleted because of that. And apparently a couple more people (quite more than average) thought this was worth of their upvote in spite of the error. Do as you wish, but I'm not deleting it nor fixing it.

For future reference, I decided not to flag this answer for deletion (although I did flag a bunch of other answers to this question)

JavaScript, Cracked
I've obfuscated this as much as I can, to the point where it can't fit within this answer.
Try it here!
Click Run, then type in console guess(n)
Returns undefined if you get the wrong answer, returns true otherwise.
Edit: Somehow I overlooked the part about my score being the number. Oh well, my number is very very big. Good luck solving it anyways.

Cracked

Jelly, score: ...1 (cracked)
5ȷ2_c⁼“ḍtṚøWoḂRf¦ẓ)ṿẒƓSÑÞ=v7&ðþạẆ®GȯżʠṬƑḋɓḋ⁼Ụ9ḌṢE¹’

Try it online!
1Really expected me to reveal it? Come on! Oh well, it has a score of 134. There, I said it!

Cracked

@Mr.Xcoder It lived long...

I just added Ç€G and the range 1...1000 as input :P

You saw the 5ȷ2_ part right?

No, I didn't even look at the code lol. Just added the test suite and saw where the 1 is, then I have pasted the string from the beginning until the 1 in a Python script and counted the number of zeros before it...

@Mr.Xcoder You could've just used Ç€T fyi

I know, but I had the Python script ready and wanted to use it :)

Haskell, cracked
This is purely based on arithmetic. Note that myfun is the actual function, while h is just a helper function.
h k = sum $ map (\x -> (x*x)**(-1) - 1/(x**(2-1/(fromIntegral k)))) [1..2*3*3*47*14593]
myfun inp | inp == (last $ filter (\k -> h k < (-7.8015e-5)  )[1..37*333667-1]) = 1
          | otherwise = 0

main = print $ show $ myfun 42 -- replace 42 with your input

Try it online!

The program must finish without error on all inputs. Does this even finish within a day on unlimited memory?

You do need quite a bit of memory but you certainly don't need unlimited memory.  It probably depends on the implementation and on on your hardware. But it is obviously designed to take some time to compute in order to make brute force attacks difficult and encourage analyzing the program. Good luck :)

Cracked?

Python 2 (cracked)
I wouldn't suggest brute force. Hope you like generators!

print~~[all([c[1](c[0](l))==h and c[0](l)[p]==c[0](p^q) for c in [(str,len)] for o in [2] for h in [(o*o*o+o/o)**o] for p,q in [(60,59),(40,44),(19,20),(63,58),(61,53),(12,10),(43,42),(1,3),(35,33),(37,45),(17,18),(32,35),(20,16),(22,30),(45,43),(48,53),(58,59),(79,75),(68,77)]] + [{i+1 for i in f(r[5])}=={j(i) for j in [q[3]] for i in l} for q in [(range,zip,str,int)] for r in [[3,1,4,1,5,9]] for g in [q[1]] for s in [[p(l)[i:i+r[5]] for p in [q[2]] for i in [r[5]*u for f in [q[0]] for u in f(r[5])]]] for l in s + g(*s) + [[z for y in [s[i+a][j:j+r[0]] for g in [q[0]] for a in g(r[0])] for z in y] for k in [[w*r[0] for i in [q[0]] for w in i(r[0])]] for i in k for j in k] for f in [q[0]]]) for l in [int(raw_input())]][0]

Try it online!
Outputs 1 for the correct number, 0 otherwise.

Cracked

@LeakyNun Wow, a bit faster than I expected.

Finding a sudoku solver online isn't hard.

There's some problem with your sudoku checker: you checked the horizontal lines and the vertical lines alright, but you only checked the first three cells.

@LeakyNun You're right, an a should be i+a. I've fixed it, but it's cracked anyway shrug

Java, Cracked by Nitrodon
import java.math.BigDecimal;

public class Main {
    private static final BigDecimal A = BigDecimal.valueOf(4);
    private static final BigDecimal B = BigDecimal.valueOf(5, 1);
    private static final BigDecimal C = BigDecimal.valueOf(-191222921, 9);
    private static BigDecimal a;
    private static BigDecimal b;
    private static int c;

    private static boolean f(BigDecimal i, BigDecimal j, BigDecimal k, BigDecimal l, BigDecimal m) {
        return i.compareTo(j) == 0 && k.compareTo(l) >= 0 && k.compareTo(m) <= 0;
    }

    private static boolean g(int i, int j, BigDecimal k) {
        c = (c + i) % 4;
        if (j == 0) {
            BigDecimal l = a; BigDecimal m = b;
            switch (c) {
                case 0: a = a.add(k); return f(C, b, B, l, a);
                case 1: b = b.add(k); return f(B, a, C, m, b);
                case 2: a = a.subtract(k); return f(C, b, B, a, l);
                case 3: b = b.subtract(k); return f(B, a, C, b, m);
                default: return false;
            }
        } else {
            --j;
            k = k.divide(A);
            return g(0, j, k) || g(1, j, k) || g(3, j, k) || g(3, j, k) || g(0, j, k) || g(1, j, k) || g(1, j, k) || g(3, j, k);
        }
    }

    private static boolean h(int i) {
        a = BigDecimal.ZERO; b = BigDecimal.ZERO; c = 0;
        return g(0, i, BigDecimal.ONE);
    }

    public static void main(String[] args) {
        int i = Integer.valueOf(args[0]);
        System.out.println(!h(i) && h(i - 1) ? 1 : 0);
    }
}

I wanted to try something different than the usual hash and random functions. You can pass the number as a command line argument. Outputs 1 if the correct number is given and 0 otherwise. For small numbers you can also try it online.
Hint:

 The main part of the program implements a variant of a very well known algorithm. Once you know what it does, you will be able to optimize the given program to calculate the secret number.

Explanation:

 This program implements the traversal of the quadratic variant (type 2) of the well known Koch curve (image from Wikipedia):

 The secret number is the first iteration which doesn't pass through the point (B, C). As correctly recognized by Nitrodon, except of the first iteration we can safely ignore the recursion of all parts of the curve, which don't pass through the given point. By changing a line in the original program accordingly, we can check the correct number even in the online interpreter.

Cracked, I think; the running time is too long to verify directly, but I checked with easier values and my crack seems to work.

PHP, safe, score:

 60256

<?php

$a = $argv[1];

$b ='0123456789abcdefghijklmnopqrstuvwxyz';

$c = strlen($b);

$d = '';
$e = $a;
while ($e) {
    $d .= $b[$e % $c];
    $e = floor($e / $c);
}

echo ((function_exists($d) && $d($a) === '731f62943ddf6733f493a812fc7aeb7ec07d97b6') ? 1 : 0) . "\n";

Outputs 1 if correct, 0 otherwise.
Edit: I don't think anyone even tried to crack this because:

 it would be easy to brute force.

Explanation:

 I take the input and convert it to "base 36", but I don't reverse the remainders to produce the final number. The number 60256 is "1ahs" in base 36. Unreversed, that is "sha1", which is a function in PHP. The final check is that sha1(60256) equals the hash.

Pyth, Cracked by Erik the Outgolfer*
I tried to obfuscate this as much as possible.
hqQl+r@G7hZ@c." y|çEC#nZÙ¦Y;åê½9{ü/ãÑª#¤
ØìjX\"¦Hó¤Ê#§T£®úåâ«B'3£zÞz~Ð£ë"\,a67Cr@G7hZ

Try it here!

 *The number was 9.

cracked

Octave, score: ???
It's pretty much guaranteed that no other number will have the exact same 20 random numbers in the end of the list of 1e8 of numbers.
function val = cnr(num)
rand("seed", num);
randomints = randi(flintmax-1,1e4,1e4);
val = isequal(randomints(end+(-20:0))(:), ...
 [7918995738984448
  7706857103687680
  1846690847916032
  6527244872712192
  5318889109979136
  7877935851634688
  3899749505695744
  4256732691824640
  2803292404973568
  1410614496854016
  2592550976225280
  4221573015797760
  5165372483305472
  7184095696125952
  6588467484033024
  6670217354674176
  4537379545153536
  3669953454538752
  5365211942879232
  1471052739772416
  5355814017564672](:));
end

Outputs 1 for the secret number, 0 otherwise.
I ran this in Octave 4.2.0.

"Sleeps and other slowdowns can be removed when bruteforcing."
Good luck with that :)

it doesn't seem to even run on tio

@Okx It times out on TIO, but it does run in the desktop version.

Why the downvote?

@WheatWizard probably because it's theoretically possible that it has multiple numbers.  Also, it's kinda boring tbh. I would have liked to see more mathy solutions, RNG is kinda boring.

Can you add a TIO link, please?

@Shaggy please read above.  It doesn't work on TIO. (times out)

@Riker But because you're guessing at a seed to the RNG, he's using the RNG itself as his function which is actually deterministic. But yeah, considering it's relying on the difficultly of inverting what you hope is a one-way function, one might as well, just encrypt a string "true" with a random number and then the challenge almost amounts to breaking whatever encryption scheme was chosen to discover the private key.

dc
#!/bin/dc
[[yes]P] sy [[no]P] sn [ly sp] sq [ln sp] sr [lp ss] st [ln ss] su
?  sa
119560046169484541198922343958138057249252666454948744274520813687698868044973597713429463135512055466078366508770799591124879298416357795802621986464667571278338128259356758545026669650713817588084391470449324204624551285340087267973444310321615325862852648829135607602791474437312218673178016667591286378293
la %
d 0 r 0
=q !=r
10 154 ^ 10 153 ^ +
d la r la
<t !<u
1 la 1 la
>s !>n

Try it online!

Note: This submission has been modified since it was submitted.  The original submission (below) was invalid and cracked by Sleafar in the comments below.  (An input of 1 gives rise to the output yes, but there is one other number that gives the same result.)
#!/bin/dc
[[yes]P] sy [[no]P] sn [ly sp] sq [ln sp] sr
?  sa
119560046169484541198922343958138057249252666454948744274520813687698868044973597713429463135512055466078366508770799591124879298416357795802621986464667571278338128259356758545026669650713817588084391470449324204624551285340087267973444310321615325862852648829135607602791474437312218673178016667591286378293
la %
d 0 r 0
=q !=r
10 154 ^ 10 153 ^ +
d la r la
<p !<n

Try it online!

The online interpreter returns "yes" for the input "1". Does this count as cracked now?

@Sleafar Sigh...yes, that was a stupid mistake on my part.

However, that means that this challenge is now invalid, since there are two inputs that make it print yes, so I'm not sure if you're allowed to claim it.  I'll add a corrected version to this post, but leave the original up in case you are.

Ly, score 239, cracked
(1014750)1sp[l1+sp1-]28^RrnI24^=u;

Try it online!
I'm banking on nobody knowing Ly here, although I know how easily that could change... sweats
Explanation:
(1014750)1sp[l1+sp1-]              # meaningless code that counts up to 1014750 and discards the result
                     28^Rr         # range from 255 to 0
                          nI       # get the index from the range equal to the input
                            24^=   # check if it's 16
                                u; # print the result

Cracked

Brain-Flak, score 1574 (cracked)
<>(((((((((((((((((((([([(((()()()){}){}){}])]){})))){}{}{}{}()){}){})){}{})){}{})){}((((((((()()){}){}){}){}[()]){}){}){}){}())){})){}){}{}{}){})(((((((((((((((((((()()){}){}()){}){}){}()){}){}()){}){})){}{}())){}{})){}{}){}){}){})(((((((((((((((()()){}()){}()){}){}){}()){}){}){}()){}){}){}()){}()){}()){})<>{({}[()])<>({}({})<({}({})<({}({})<({}({}))>)>)>)<>}({}<>(){[()](<{}>)}<>)

Try it online!

Cracked

Ruby, safe, score:

 63105425988599693916

#!ruby -lnaF|
if /^#{eval [$F,0]*"**#{~/$/}+"}$/ && $_.to_i.to_s(36)=~/joe|tim/
  p true
else
  p false
end

Try it online!
Explanation:

 The first conditional checks the input number for narcissism. The thread I originally wrote for was coincidentally bumped around the same time I posted this, but I guess nobody noticed. The second converts the number to base 36, which uses letters as digits, and checks if the string contains "joe" or "tim". It can be proven (through exhaustion) that there is only one narcissistic number named either Joe or Tim (Joe), because the narcissistic numbers are finite. Proof that they're finite: the result of taking an n-digit number, raising each digit to the nth power, and summing is bounded above by n*9^n, while the value of an n-digit number is bounded below by n^10. The ratio between these terms is n*(9/10)^n, which eventually decreases monotonically as n increases. Once it falls below 1, there can be no n-digit narcissistic numbers.

Swift 3 (53 bytes) - Cracked
func f(n:Int){print(n==1+Int(.pi*123456.0) ?222:212)}

How to run this? – f(n:1).
Test Here.

Cracked

@Mr.Xcoder Heh well done, guess it was too easy

Python 3, score 1 (safe)
Not a very interesting solution, but better a safe cop than a dead cop.
import hashlib

def sha(x):
    return hashlib.sha256(x).digest()

x = input().encode()
original = x

for _ in range(1000000000):
    x = sha(x)

print(int(x==b'3\xdf\x11\x81\xd4\xfd\x1b\xab19\xbd\xc0\xc3|Y~}\xea83\xaf\xa5\xb4]\xae\x15wN*!\xbe\xd5' and int(original.decode())<1000))

Outputs 1 for the target number, 0 otherwise. Input is taken from stdin. The last part (and int(original.decode())<1000) exists only to ensure only one answer, otherwise there would obviously be infinitely many answers.

Can you add a TIO link, please?

For future robbers: The integer doesn't seem to be in smaller than 100000000.

b'3\xdf\x11\x81\xd4\xfd\x1b\xab19\xbd\xc0\xc3|Y~}\xea83\xaf\xa5\xb4]\xae\x15wN*!\xbe\xd5' doesn't seem to decode...is there really a secret number?

@EriktheOutgolfer Whoops, that was added in last-minute, fixing..

@Mr.Xcoder No, it is much smaller.

@Shaggy It will timeout on TIO, it took about half an hour on my computer to run the billion iterations of SHA256.

Any robbers fancy forming a team to solve this one?  We just need to split the numbers less than 1000 up among us so we have time to compute the iterated-SHA digests before the deadline.

@JohnGowers do you know BOINC? I would run that.

Unless you can prove that 1 is the only solution, this answer is invalid. The burden of proof should be on the person claiming to have a valid answer.

The example given in that meta question is very different from mine. There a collision (while practically impossible to find) exists with probability 1. The probability of my answer being incorrect is roughly 4e-72 (since it's equivalent with the probability of duplicates when sampling with replacement 999 items from 2^256.

https://codegolf.meta.stackexchange.com/questions/13641/is-it-okay-if-a-submission-has-an-extremely-small-chance-of-not-functioning-prop applies

TI-BASIC, score: 196164532 non-competing
Returns 1 for secret number, 0 otherwise.
Ans→rand
rand=1

Refer to the note on this page on the rand command for more info.

Is this guaranteed to have exactly one matching input number?

@Riker: I think the TI calculator uses some kind of floating point internally; if RAND uses the same floating point as the rest of it, I'm pretty sure there's only 1 solution.

@Joshua I believe it uses L'Ecuyer's Algorithm.

@Joshua "pretty sure" isn't enough.  Unless you can prove that only 1 solution exists, this isn't a valid answer.

@Riker: Wheat Wizard is enforcing no such thing.

Unless you can prove that 196164532 is the only solution, this answer is invalid. The burden of proof should be on the person claiming to have a valid answer.

@Dennis: Probe for 196164532*2; if that's not a solution than there is no other solution.

Java, score: 3141592 (Cracked)
\u0070\u0075\u0062\u006c\u0069\u0063\u0020\u0063\u006c\u0061\u0073\u0073\u0020\u004d\u0061\u006e\u0067\u006f\u0020\u007b
\u0073\u0074\u0061\u0074\u0069\u0063\u0020\u0076\u006f\u0069\u0064\u0020\u0063\u006f\u006e\u0076\u0065\u0072\u0074\u0028\u0053\u0074\u0072\u0069\u006e\u0067\u0020\u0073\u0029\u007b\u0066\u006f\u0072\u0028\u0063\u0068\u0061\u0072\u0020\u0063\u0020\u003a\u0020\u0073\u002e\u0074\u006f\u0043\u0068\u0061\u0072\u0041\u0072\u0072\u0061\u0079\u0028\u0029\u0029\u007b\u0020\u0053\u0079\u0073\u0074\u0065\u006d\u002e\u006f\u0075\u0074\u002e\u0070\u0072\u0069\u006e\u0074\u0028\u0022\u005c\u005c\u0075\u0030\u0030\u0022\u002b\u0049\u006e\u0074\u0065\u0067\u0065\u0072\u002e\u0074\u006f\u0048\u0065\u0078\u0053\u0074\u0072\u0069\u006e\u0067\u0028\u0063\u0029\u0029\u003b\u007d\u007d
\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\u0020\u0061\u0072\u0067\u0073\u0029\u0020\u007b\u0069\u006e\u0074\u0020\u0078\u0020\u0020\u003d\u0020\u0049\u006e\u0074\u0065\u0067\u0065\u0072\u002e\u0070\u0061\u0072\u0073\u0065\u0049\u006e\u0074\u0028\u0061\u0072\u0067\u0073\u005b\u0030\u005d\u0029\u003b
\u0064\u006f\u0075\u0062\u006c\u0065\u0020\u0061\u003d\u0020\u0078\u002f\u0038\u002e\u002d\u0033\u0039\u0032\u0036\u0039\u0039\u003b\u0064\u006f\u0075\u0062\u006c\u0065\u0020\u0062\u0020\u003d\u0020\u004d\u0061\u0074\u0068\u002e\u006c\u006f\u0067\u0031\u0030\u0028\u0028\u0069\u006e\u0074\u0029\u0020\u0028\u0078\u002f\u004d\u0061\u0074\u0068\u002e\u0050\u0049\u002b\u0031\u0029\u0029\u002d\u0036\u003b
\u0053\u0079\u0073\u0074\u0065\u006d\u002e\u006f\u0075\u0074\u002e\u0070\u0072\u0069\u006e\u0074\u006c\u006e\u0028\u0028\u0061\u002f\u0062\u003d\u003d\u0061\u002f\u0062\u003f\u0022\u0046\u0061\u0069\u006c\u0022\u003a\u0022\u004f\u004b\u0022\u0020\u0029\u0029\u003b
\u007d\u007d

I don't think the obfuscation is going to do anything except add an annoying first step.

Cracked

@EngineerToast no, not really, it was purely for scaring off lazy people.

Java, 164517378918, safe
import java.math.*;import java.util.*;
public class T{
    static boolean f(BigInteger i){if(i.compareTo(BigInteger.valueOf(2).pow(38))>0)return false;if(i.longValue()==0)return false;if(i.compareTo(BigInteger.ONE)<0)return false;int j=i.multiply(i).hashCode();for(int k=3^3;k<2000;k+=Math.abs(j%300+1)){j+=1+(short)k+i.hashCode()%(k+1);}return i.remainder(BigInteger.valueOf(5*(125+(i.hashCode()<<11))-7)).equals(BigInteger.valueOf(0));}
    @SuppressWarnings("resource")
    public static void main(String[]a){long l=new Scanner(System.in).nextLong();boolean b=false;for(long j=1;j<10;j++){b|=f(BigInteger.valueOf(l-j));}System.out.println(f(BigInteger.valueOf(l))&&b);}
}

Don't you need to specify the solution for your answer to be considered safe?

@pppery The secret number is the score for this one, is it not?

Yes, it seems like I failed to read the answer properly last week. Sorry.

C (gcc), score ???
#include <stdint.h>
#include <stdio.h>
#include <string.h>
#include <wmmintrin.h>

#include <openssl/bio.h>
#include <openssl/pem.h>
#include <openssl/rsa.h>

union State
{
    uint8_t u8[128];
    __m128i i128[8];
} state;

void encrypt()
{
    BIO *key = BIO_new_mem_buf
    (
        "-----BEGIN PUBLIC KEY-----\n"
        "MIGfMA0GCSqGSIb3DQEBAQUAA4GNADCBiQKBgQC5CBa50oQ3gOPHNt0TLxp96t+6\n"
        "i2KvOp0CedPHdJ+T/wr/ATo7Rz+K/hzC7kQvsrEcr0Zkx7Ll/0tpFxekEk/9PaDt\n"
        "wyFyEntgz8SGUl4aPJkPCgHuJhFMyUflDTywpke3KkSv3V/VjRosn+yRu5mbA/9G\n"
        "mnOvSVBFn3P2rAOTbwIDAQAB\n"
        "-----END PUBLIC KEY-----\n",
        -1
    );

    RSA *rsa = PEM_read_bio_RSA_PUBKEY(key, &rsa, NULL, NULL);

    uint8_t ciphertext[128];

    RSA_public_encrypt(128, state.u8, ciphertext, rsa, RSA_NO_PADDING);
    memcpy(state.u8, ciphertext, 128);
}

void verify()
{
    if (memcmp
    (
        "\x93\xfd\x38\xf6\x22\xf8\xaa\x2f\x7c\x74\xef\x38\x01\xec\x44\x19"
        "\x76\x56\x27\x7e\xc6\x6d\xe9\xaf\x60\x2e\x68\xc7\x62\xfd\x2a\xd8"
        "\xb7\x3c\xc9\x78\xc9\x0f\x6b\xf0\x7c\xf8\xe5\x3c\x4f\x1c\x39\x6e"
        "\xc8\xa8\x99\x91\x3b\x73\x7a\xb8\x56\xf9\x28\xe7\x2e\xb2\x82\x5c"
        "\xb8\x36\x24\xfb\x26\x96\x32\x91\xe5\xee\x9f\x98\xdf\x44\x49\x7b"
        "\xbc\x6c\xdf\xe9\xe7\xdd\x26\x37\xe5\x3c\xe7\xc0\x2d\x60\xa5\x2e"
        "\xb8\x1f\x7e\xfd\x4f\xe0\x83\x38\x20\x48\x47\x49\x78\x18\xfb\xd8"
        "\x62\xaf\x0a\xfb\x5f\x64\xd1\x3a\xfd\xaf\x4b\xaf\x93\x23\xf4\x36",
        state.u8,
        128
    ))
        exit(0);
}

static inline void quarterround(int offset)
{
    int dest = (offset + 1) % 8, src = offset % 8;

    state.i128[dest] = _mm_aesenc_si128(state.i128[src], state.i128[dest]);
}

int main(int argc, char *argv[])
{
    if (argc != 2)
        exit(0);

    uint64_t input = strtoull(argv[1], NULL, 0);

    state.i128[0] = _mm_set_epi32(0, 0, input >> 32, input);

    for (uint64_t round = 0; round < 0x1p45; round += 2)
    {
        quarterround(0);
        quarterround(2);
        quarterround(4);
        quarterround(6);

        quarterround(7);
        quarterround(1);
        quarterround(3);
        quarterround(5);
    }

    encrypt();
    verify();
    puts("something");
}

Since cryptographic solutions are encouraged, here. Exactly one positive integer will print something, all others will print nothing. This takes a long time, so it cannot be tested online.

Python 3, score unknown, Cracked by Bubbler
def check(x):
    if x < 0 or x >= 5754820589765829850934909 or pow(x, 18446744073709551616, 5754820589765829850934909) != 2093489574700401569580277 or x % 4 != 1:
        return "No way ;-("
    return "Cool B-)"

Try it online!
Simple, but may take some time to brute-force ;-) Looking forward to a fast crack ;-)
Footnote: the first two and the last conditions make the answer unique.
BTW how the score is calculated?
Hint 1

 You may expect there will be 264 answers within 0 <= x < [the 25-digit prime], but actually there are only 4, and the last condition eliminates the other 3. If you can crack this, then you will also know the other 3 solutions.

Cracked.

Aceto, safe
  P'*o*7-9JxriM'lo7*9Yxx.P',xe*ikCKxlI.D+∑\a€'#o*84/si5s:i»I9Ji8:i+∑€isi.s1+.i2\H/iQxsUxsxxsxiss*i1dJi/3d2*Ji-d*id*IILCh98*2JixM'e9hxBNRb!p

Outputs TrueFalse if correct, FalseFalse otherwise
The number was

15752963

Try it online!

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


text:
I'm thinking of a number (Robber's thread)

Cop's thread here

In this cops-and-robbers challenge cops will think of a positive integer.  They will then write a program or function that outputs one value when provided the number as input and another value for all other positive integer inputs.  Cops will then reveal the program in an answer keeping the number a secret.  Robbers can crack an answer by finding the number.
Your job as robbers is to find that number.  Once found you can make an answer here detailing the number and how you found it.  You should link the original answer being cracked in your answer.
Your score will be the number of cracks with more being better.

Are "hunches" good enough to post here, instead of definite proof?

@OlivierGrégoire You should know that your answer works for sure.

But I must know it, I don't have to prove it with the program given in the cops thread? Can I prove it otherwise, using math for instance?

@OlivierGrégoire Sure that's fine.  As long as you know your answer is correct.  You need not actually run the program if it takes too long.

Java, by okx
Note: the original challenge to which this post answers has been deleted, it's however still accessible with the link to anyone having the privilege to see deleted answers. The explanations below include what the challenge was about.
Number: 18
The code is effectively looking for primes with the form 112n-2.
By this Wikipedia list, we know that the 20th largest known prime number has 2,900,832 digits. No prime with the form 112n-2 are in that list, so that digit number will be our limit.
All numbers of the form 112n-2 that have at most that many digits have this constraint: n < 22. Factordb tells us that 11222-2 has 4,367,918 digits. This is proof enough.
The code by okx limits us to n above 6.
So, let's do the list:
112n-2 is factorizable for n = 7, 8, 9, 10, 11, 12, 13, 14, 15, 16, 17, 19, 20 and 21 (factors proofs are on factordb.com and wolfram alpha; factordb has some proofs that wolfram alpha hasn't and vice-versa).
The only value n for which we can't prove the factorization is 18 (factordb, WolframAlpha).
So (a) if there is a prime number of the form 112n-2 with n > 6, then (b) 6 < n < 22, and (c) I proved each number with such n is composite except for 18, so (d) the prime we're looking for has n = 18.
Note that I don't exclude that 11218-2 is composite. I haven't proved that that number is a prime: I only proved that if the OP thought about that number, it can only be 18. If that number is indeed a prime, congrats to okx for finding it :-)
However
There are no proof that 11218-2 is the only number, though. It's the only number in the range of numbers for which we can currently prove the primality.
So I don't exclude the fact that one day someone might prove that 11251-2 or 112124-2 is prime.
I therefore believe that the original entry by okx is invalid because there are no such proof that for n between 19 and the (231-1)231-1 (the theoretical limit of Java's BigInteger), there are no other primes.

11^(2^51) - 2 is divisible by 7. Or any odd n.

And iff n is divisible by 5, 11^(2^n)-2 is divisible by 23.

There's some connection to Pascal's triangle here. "Each row of Pascal’s Triangle sums to the set of exponents of two {1, 2, 4, 8, 16, 32, 64, 128, 256, 512, 1024…}, and that’s interesting.
What’s more interesting? The digits of each row represent an exponent of eleven {11, 121, 1331, 14641, 161051, 1771561…}"
Or maybe I'm seeing patterns where none exist

Sorry guys, I bruteforced my way here. I haven't analyzed in details ;)

@OlivierGrégoire  Oh please, you could have let us go on a wild goose chase for a day or three ;)

@JollyJoker that's just from the binomial theorem: (10+1)^n = sum (nCr) 10^r

Damn, the original challenge got deleted. Am I required to delete this answer as well?

Probably you should.

@OlivierGrégoire I think you should be okay.  The solution took the same amount of effort, regardless of the original post.

Perl 6, by Ramillies
11

The function series($x) is simply the first 108 terms of the Taylor series for e^x evaluated at i*(x % 8*π).  Since e^2πi = 1, this reduces to simply e^ix: the % 8*π serves only to bound the error of the truncated series.
The ∫ function integrates the provided Callable in the interval [0,2π] using the trapezoid method.  The integrand in question is (e^ix)^11/(e^inx), or simply e^(11-n)ix.  This integrates to 0 in that interval for all n != 11.  At n = 11, the integrand reduces to simply 1.  Hence the answer is 11, and the desired output is 6.28.
While 11 is the only answer in theory, the sampling in the integral is imperfect.  Consequently, any integer of the form 87931k+11 should work.

Very nicely done! You surprised me with the last paragraph however. I'll put it to some thought.

Ah, I now see the problem. I'm afraid I can't remove it however (even if I use intervals of different widths, you would use the product of the widths as a coefficient for your k)... Thanks for pointing it out.

Tampio, fergusq
Number: 27
The program prints nolla for 27 and "1" negatiivisena for all other inputs. It times out on TIO, unfortunately, but works offline.
Whew, this was a fun one to work through. Wiktionary and this Finnish dictionary I found online actually helped a surprising amount, as a lot of Tampio syntax relies on inflection.
I first tried translating the program into Haskell-like pseudocode, but the "case system" of Tempio and how function calls worked kept tripping me up. Eventually, I ended up running all of the code from the definition of sata downward, which gave me surprisingly easily that sata == 55, and funktio wasn't difficult to reverse engineer from there as it was simple arithmetic that could be deduced from trial and error.

Can someone help me comment this on the original post, by the way? My rep is way too low for that - thanks!

I've left a comment on the original.

@WheatWizard thanks!

Python 3, Erik Brody Dreyer
Number: 105263157894736842
Try it online!

How?
Everyone's favorite tool: OEIS!

Go to oeis.org
Search "last digit first doubles number"
Find Entry A087502 entitled

Smallest positive integer which when written in base n is doubled when the last digit is put first.

Find the base 10 entry (105263157894736842)
Confirm it works

Can't comment on Erik's post due to lack of rep. Welp, can only hope he sees this :)

Not sure if I would have thought of OEIS in this case, but just a few days ago I saw this

JavaScript, by Eli R
The number is 7464822360768511
I first disabled the anti-debugging function (by overwriting Function.prototype.constructor to a function with evals any code except debugger) then debugged the guess function by stepping into it.
From what I understood the guess function initializes a random number generator on a fixed seed then generate a random number and compare it to the input. As the input isn't used in the random number generation it can be ignored allowing to skip directly to the result.

Amazing job. That's exactly how it works.

Jelly, Erik the Outgolfer's answer
Number: 134
The following program:
5ȷ2_c⁼“ḍtṚøWoḂRf¦ẓ)ṿẒƓSÑÞ=v7&ðþạẆ®GȯżʠṬƑḋɓḋ⁼Ụ9ḌṢE¹’

can be cracked using the number 134. This outputs 0 for all numbers except for 134, which gives 1.
Try it online!

How did I find it?
TBH, I have no idea how it works. I have added Ç€G at the end and mapped over [1...1000] to see where the 1 is. Then, I ran  script to count the number of zeros before the 1.

This just checks that (500-x) choose (x) is equal to 11087887200298332182662619677215658902328839774316188391031942332464244226619146288405430113510542767630, which it is for x=134 (as you found).

Ly, LyricLy
Answer: 239
I already wrote two Ly programs, so this wasn't too difficult.
I think I would have somehow used the result from the loop in case someone tries to remove it. BTW, the fragment nI means that it doesn't always terminate successfully.

Python 2, Sisyphus
print~~[all([c[1](c[0](l))==h and c[0](l)[p]==c[0](p^q) for c in [(str,len)] for o in [2] for h in [(o*o*o+o/o)**o] for p,q in [(60,59),(40,44),(19,20),(63,58),(61,53),(12,10),(43,42),(1,3),(35,33),(37,45),(17,18),(32,35),(20,16),(22,30),(45,43),(48,53),(58,59),(79,75),(68,77)]] + [{i+1 for i in f(r[5])}=={j(i) for j in [q[3]] for i in l} for q in [(range,zip,str,int)] for r in [[3,1,4,1,5,9]] for g in [q[1]] for s in [[p(l)[i:i+r[5]] for p in [q[2]] for i in [r[5]*u for f in [q[0]] for u in f(r[5])]]] for l in s + g(*s) + [[z for y in [s[aprint~~[all([c[1](c[0](l))==h and c[0](l)[p]==c[0](p^q) for c in [(str,len)] for o in [2] for h in [(o*o*o+o/o)**o] for p,q in [(60,59),(40,44),(19,20),(63,58),(61,53),(12,10),(43,42),(1,3),(35,33),(37,45),(17,18),(32,35),(20,16),(22,30),(45,43),(48,53),(58,59),(79,75),(68,77)]] + [{i+1 for i in f(r[5])}=={j(i) for j in [q[3]] for i in l} for q in [(range,zip,str,int)] for r in [[3,1,4,1,5,9]] for g in [q[1]] for s in [[p(l)[i:i+r[5]] for p in [q[2]] for i in [r[5]*u for f in [q[0]] for u in f(r[5])]]] for l in s + g(*s) + [[z for y in [s[i+a][j:j+r[0]] for g in [q[0]] for a in g(r[0])] for z in y] for k in [[w*r[0] for i in [q[0]] for w in i(r[0])]] for i in k for j in k] for f in [q[0]]]) for l in [int(raw_input())]][0]

Try it online!
Answer:
126437958895621473374985126457193862983246517612578394269314785548769231731852649

Explanation
Slightly less convoluted:
print~~[all(
	[len(str(l))==81 and str(l)[p]==str(p^q)
		for p,q in [(60,59),(40,44),(19,20),(63,58),(61,53),(12,10),(43,42),(1,3),(35,33),(37,45),(17,18),(32,35),(20,16),(22,30),(45,43),(48,53),(58,59),(79,75),(68,77)]
	]
	+
	[{i+1 for i in range(9)}=={int(i) for i in l}
		for s in [[str(l)[9*u:9*u+9] for u in range(9)]]
			for l in s + zip(*s) + [[z for y in [s[i+a][j:j+3] for a in range(3)] for z in y] for k in [[w*3 for w in range(3)]] for i in k for j in k]]) for l in [int(raw_input())]][0]

Try it online!
Firstly, this part:
[len(str(l))==81 and str(l)[p]==str(p^q)
        for p,q in [(60,59),(40,44),(19,20),(63,58),(61,53),(12,10),(43,42),(1,3),(35,33),(37,45),(17,18),(32,35),(20,16),(22,30),(45,43),(48,53),(58,59),(79,75),(68,77)]
]

checks if the sudoku is in the following form:
.2.|...|...
...|6..|..3
.74|.8.|...
-----------
...|..3|..2
.8.|.4.|.1.
6..|5..|...
-----------
...|.1.|78.
5..|..9|...
...|...|.4.

Then this part checks for validity:
[{i+1 for i in range(9)}=={int(i) for i in l}
        for s in [[str(l)[9*u:9*u+9] for u in range(9)]]
            for l in s + zip(*s) + [[z for y in [s[a][j:j+3] for a in range(3)] for z in y] for k in [[w*3 for w in range(3)]] for i in k for j in k]]

Pyth, Mr. Xcoder
hqQl+r@G7hZ@c." y|çEC#nZÙ¦Y;åê½9{ü/ãÑª#¤
ØìjX\"¦Hó¤Ê#§T£®úåâ«B'3£zÞz~Ð£ë"\,a67Cr@G7hZ

Try it here. Number: 9

Well done! It lived long

@Mr.Xcoder I just removed the hqQ part :p

That's weird. I tried 9 but it didn't work. That was before it was temporarily deleted, though, so it may not originally have been 9.

@Shaggy Me too, but after it was undeleted.

Swift 3, TheIOSCoder
Number: 387849.
This returns 222 for the number above, and 212 for others.
Test Here.

How?
The relation is quite obvious: .pi*123456.0 multiplies 3.1415... by 123456.0 and converts it to an Integer. This means it is equal to 387848. Then, it checks if the parameter equals the number above incremented by 1 (n==1+...). The value is 387848 + 1, which is 387849...

Java, Sleafar
23

The program traces n iterations of a fractal, and checks whether a specific point is removed in the nth iteration.  In each iteration, each segment is replaced by eight smaller segments in the following pattern:
  +
  |
+-+
|
+-+-+
    |
  +-+
  |
  +

Since no points are ever added to the line y=.5 after the first iteration, I only had to handle the set of points included along this line.  This set is similar to the construction of the Cantor set, but with the middle half removed instead of the middle third.
The program I used to crack it:
import java.math.BigDecimal;

public class Main {

        public static int f(BigDecimal x) {
                BigDecimal[] result = x.divideAndRemainder(BigDecimal.ONE);
                if (result[0].compareTo(BigDecimal.ZERO) == 0 || result[0].compareTo(BigDecimal.valueOf(3)) == 0) {
                        return 1+f(result[1].multiply(BigDecimal.valueOf(4)));
                }
                return 0;
        }

	public static void main(String[] args) {
		BigDecimal x = new BigDecimal(args[0]);
		System.out.println(f(x));
	}
}

Try it online!

This is correct, congratulations!

Java, user902383
The secret number is 3141592
Explanation:
After expanding all the \u00xx escapes, you get:
public class Mango {
static void convert(String s){for(char c : s.toCharArray()){ System.out.print("\\u00"+Integer.toHexString(c));}}
public static void main(String[] args) {int x  = Integer.parseInt(args[0]);
double a= x/8.-392699;double b = Math.log10((int) (x/Math.PI+1))-6;
System.out.println((a/b==a/b?"Fail":"OK" ));
}}

(the convert method isn't used).
This computes some floating point math on the result, and then requires that a/b isn't equal to itself. The number for which that is true is nan, which is produced by 0/0. It turns out that if a is 0, then b is log10(0/pi + 1) which is also 0, so a has to be 0 and x has to be 392699*8.

Haskell, flawr
I think the number is 12018.
I found it by defining in PARI/GP f(x,k)=1/x^2-1/x^(2-1/k) and g(k)=sumpos(x=1,f(x,k))-sumpos(x=12345679,f(x,k)) and some binary searching.
I don't like that one could trivially transform the program into one that returns the number and uses the same time and memory as the original program needs for any input.

Brain-Flak, Nitrodon
The number is:
1574

Try it online!
Here's the program I use to crack it
n!(0:_)=n
n!a=(n+1)!zipWith(+)a(tail a++[0])
main=print$0![45646,253224,392678,8676,-24]

Try it online!

Python 3, user71546
def check(x):
    if x < 0 or x >= 5754820589765829850934909 or pow(x, 18446744073709551616, 5754820589765829850934909) != 2093489574700401569580277 or x % 4 != 1:
        return "No way ;-("
    return "Cool B-)"

print(check(141421356237))

Try it online!
The number is 141421356237.
The other three numbers which satisfy the first two conditions are 1459265341309891512760823, 5754820589765688429578672, and 4295555248455938338174086.
How I solved it
The gist of this challenge is to find the number that meets the following, given the prime p = 5754820589765829850934909 and a value a = 2093489574700401569580277:

0 <= x < p
x ** (2 ** 64) % p == a
x % 4 == 1

The second one can be rephrased to "find the modular square root of modular square root of ... (64 times) of a modulo p."
Since the given prime is 5 modulo 8, we can use the following formula from the above link (though I couldn't find the reference that supports it):
\$ v = (2a)^{(p-5)/8} \mod p \$
\$ i = 2av^2 \mod p \$
\$ r = av(i-1) \mod p \$
\$ r' = p - r \$
Then we have two output values r and r' for an input value a. But not every number has such a square root, so we have to check if r*r % p == a is actually met.
So I wrote a quick J script to find the 64th modular square roots.
p =: 5754820589765829850934909x
a =: 2093489574700401569580277x
powmod =: p&|@^

f =: monad define
for. i.64 do.
  v =: p | (2*a) powmod (p-5)%8
  i =: p | 2*a*v*v
  x =: p | a*v*i-1    NB. Apply the above formula
  a =: (a=p|x*x) # x  NB. Filter by actually being the modular square root
  a =: a, p-a         NB. Concat r with r'
  a
end.
)

res =: f ''

Try it online!
res has the four values shown above; the last filtering by modulo 4 gives the answer.

Link to "module square root" is dead.


text:
Matrix in Range
The Challenge
Given an integer n>0 output a n+1 X n+1 matrix containing all integers from 1 to 2n as shown in the test cases bellow
Test Cases
n=1

1  2
2  2

n=2

1   2   4
2   3   4
4   4   4

n=5

1   2   3   4   5   10
2   3   4   5   6   10
3   4   5   6   7   10
4   5   6   7   8   10
5   6   7   8   9   10
10  10  10  10  10  10

n=10

1   2   3   4   5   6   7   8   9   10  20
2   3   4   5   6   7   8   9   10  11  20
3   4   5   6   7   8   9   10  11  12  20
4   5   6   7   8   9   10  11  12  13  20
5   6   7   8   9   10  11  12  13  14  20
6   7   8   9   10  11  12  13  14  15  20
7   8   9   10  11  12  13  14  15  16  20
8   9   10  11  12  13  14  15  16  17  20
9   10  11  12  13  14  15  16  17  18  20
10  11  12  13  14  15  16  17  18  19  20
20  20  20  20  20  20  20  20  20  20  20

I think that the pattern is pretty easy, so let's see who will give the shortest answer in bytes.
This is code-golf
Rules
Input must be an integer (1-indexed)
Output can be a matrix (as shown in the test cases) or a list of lists

R, 53 bytes
function(n)rbind(cbind(outer(1:n,1:n,`+`)-1,2*n),2*n)

Uses the outer "product" to generate all sums of the range 1,...,n as a matrix, subtracts 1 from each, then binds 2*n as a column on the right and a row on the bottom, recycling as needed, and returns a matrix as the result.
Try it online!
R, 78 bytes
More naive implementation.
function(n){m=matrix(2*n,n+1,n+1)
for(i in seq(n))m[1:n,i]=(0:(2*n))[1:n+i]
m}

Try it online!

+1 nice, I was thinking about outer but hadn't quite got there

Mathematica, 61 46 bytes
ArrayFlatten@{{##-1&~Array~{#,#},2#},{2#,2#}}&

thanx @alephalpha for -15 bytes

ArrayFlatten@{{Array[+##-1&,{#,#}],2#},{2#,2#}}&

+##-1& can just be ##-1& and you can use infix Array: ArrayFlatten@{{##-1&~Array~{#,#},2#},{2#,2#}}&

MATL, 12 10 bytes
:&+q,!GEYc

Try it online!
Explanation
:       % Input n (implicit). Push range [1 2 ... n]
&+      % matrix of pairwise additions
q       % Subtract 1
,       % Do twice
  !     %   Transpose
  GE    %   Push 2*n
  Yc    %   Concatenate that value to all rows, thus extending the matrix
        % End (implicit). Display (implicit)

Haskell, 48 bytes
f n=[[i..n-1+i]++[2*n]|i<-[1..n]]++[2*n<$[0..n]]

Try it online!

Octave, 38 37 35 bytes
@(n)[(x=1:n)+x'-1 z=~x'+2*n;z' 2*n]

Try it online!
or
@(n)~(k=blkdiag((x=1:n)+x'-1,0))*2*n+k

Try it online!

Jelly, 11 bytes
+þḶ;€Ḥ;ḤzḤG

Try it online!

Was just about to post byte for byte without the G which is superfluous to requirements

Nice use of outer product

@JonathanAllan another solution uses ;€ḤZ;€Ḥ...

...and yet another is Ḷ;Ḥ©µ+þ‘«® ;p

@JonathanAllan and another uses +€Ḷ;Ḥṁ€;€Ḥ :p

The G isn't needed, is it?

JavaScript (ES6), 64 bytes

f=
n=>[...Array(n+1)].map((_,i,a)=>a.map((_,j)=>n-i&&n-j?i-~j:n+n))
<input type=number min=0 oninput="t.innerHTML=f(+this.value).map(a=>`<tr>${a.map(b=>`${b}	`).join``}
`).join``">

Java 8, 99 bytes
Lambda from Integer to int[][] (e.g. Function<Integer, int[][]>). Surprisingly resistant to golfing.
n->{int p=n+1,o[][]=new int[p][p],i=0,r,c;while(i<p*p)o[r=i/p][c=i++%p]=r<n&c<n?r-~c:2*n;return o;}

Try It Online
Ungolfed lambda
n -> {
    int
        p = n + 1,
        o[][] = new int[p][p],
        i = 0,
        r, c
    ;
    while (i < p * p)
        o[r = i / p][c = i++ % p] =
            r < n & c < n ?
                r - ~c
                : 2 * n
        ;
    return o;
}

Acknowledgments

-1 byte thanks to Kevin Cruijssen

You can golf a byte by starting i=0 and putting the ++ at [c=i++%p].

Python 2, 64 62 61 bytes
-3 bytes thanks to Mr. Xcoder.
lambda n:[range(i+1,i-~n)+[n*2]for i in range(n)]+[[n*2]*-~n]

Try it online!
I'm probably missing a key pattern though.
Python 2, 76 bytes
lambda n:[[[n*2,i-~j][n-i and n-j>0]for j in range(n+1)]for i in range(n+1)]

Try it online!

As usual, *(n+1) is *-~n.

Some more obfuscation for 61 bytes

If you want to adopt the Python 3 version too, the shortest I could get is 64 bytes

The 76 bytes version can be reduced to 72 bytes

Pyth, 18 bytes
+m+rd+QdyQSQ]*]yQh

Maybe I am missing an obvious pattern (cc @totallyhuman)...
Test Suite.
"Pretty print" Test Suite.

Proton,  48  44 bytes
-4 bytes thanks to @totallyhuman!
n=>[(i+1..i-~n)+[n*2]for i:0..n]+[[n*2]*-~n]

Try it online!

44 bytes.

@totallyhuman thanks.

Japt, 17 16 bytes
õ_óU pU*2ÃpUô@*2

Try it online!

R, 54 63 67 bytes
function(n)cbind(rbind(sapply(1:n-1,'+',1:n),2*n),2*n)

Try it online!
Thanks to @Guiseppe for the pointer for sapply and the 9 bytes

Actually, this approach can be improved as well: sapply(1:n-1,'+',1:n) but then it's a mere 1 byte more than using outer (the quotes are obviously backticks)

`\`` works for escaping backticks in a code block delimited by backticks @Giuseppe

Recursiva, 50 bytes

Only 10 bytes shorter than python and thus it is official, Recursiva is not a golfing-language at all... It is an esolang though. :D

|{Ba+++++'PJ"	"W+Z~}B+~}'Va'+}'Va'AD'VaJ"	"W*;aADa

Try it online!

Röda, 44 bytes
f n{seq 1,n|[[seq(_,_1+n-1)]+2*n];[[2*n]*n]}

Try it online!
Explanation:
f n{seq 1,n|[[seq(_,_1+n-1)]+2*n];[[2*n]*n]}
f n{                                       } /* Function f(n)         */
    seq 1,n                                  /* Sequence 1..n         */
           |                                 /* For each _1:          */
              seq(_,_1+n-1)                  /*   Sequence _1.._1+n-1 */
             [             ]                 /*   As list             */
                            +2*n             /*   Append 2*n          */
            [                   ]            /*   Push to the stream  */
                                   [2*n]     /* List [2*n]            */
                                        *n   /* Multiplied by n       */
                                  [       ]  /* Push to the stream    */

Dyalog APL, 29 bytes
Requires ⎕IO←0
{(S,⍨1+¯1 ¯1↓∘.+⍨⍳⍵+1)⍪S←2×⍵}

Try it online!
How?

1+¯1 ¯1↓∘.+⍨⍳⍵+1 the upper-left portion of the array
(S,⍨...)⍪S←2×⍵ the corner

C (gcc), 119 116 115 107 bytes
i,j;f(n){for(;j<n;j++,printf("%d\n",2*n))for(i=0;i++<n;printf("%d\t",j+i));for(;j=i--;printf("%d\t",n*2));}

Try it online!

i<n+1 is i<=n (117 bytes).

@Mr.Xcoder Thanks !

101 bytes

><>, 84+2 Bytes
+2 for -v flag
Prints with tabs between values, and newlines between rows. Also prints a trailing tab on the last line.
Try it online
1:r:&r&)?\0:r:&r&(?\~$:@2*nao1+!
a0./:r:0~<.17+1o9\ \$:@$:@+n9o1+
   \&r&)?;$:@2*n /

Pre-golfing
1>:r:&r&)?\0>    :r:&r&(?\~$:@2*nao1+\
            \+1o9n+@:$@:$/
 \                                   /
          \~0>:r:&r&)?;$:@2*n9o1+\
             \                   /

SOGL V0.12, 22 bytes
∫HA.∫a+}.«¹}¹.I.«r∙rο+

Try it Here!
leaves output on the stack, which you can view in the console

Jelly, 14 bytes
R+’r@R;€Ḥz0;€Ḥ

Try it online!

Perl 5, 56 bytes
$,=$";say($_..$_+$"-1,$"*2)for 1..($"=<>);say(($"*2)x$")

Try it online!

J, 29 bytes
(}:@(][\1+i.@+:),]#+:),.>:#+:

ungolfed
(}:@(] [\ 1+i.@+:) , ]#+:) ,. >:#+:

explanation
(}:@(] [\ 1+i.@+:)                   NB. make the inner part of the matrix
          1+i.@+:                      NB. 1..2*n, where n is the input
    (] [\ 1+i.@+:)                     NB. fork: infixes (sliding window) of length n, over 1..2*n
(}:@                                   NB. remove last element
                   , ]#+:)           NB. add a row of 2*n to the end
                           ,. >:#+:  NB. add a column of 2*n to entire result above

Try it online!

Heh, my APL answer and your answer have the same byte count! Can you add an explanation please?

@Zacharý, updated.  fwiw, this could probably be golfed at least a bit further by someone like myself, and perhaps by additional 10+ bytes by a J expert.

Kotlin, 59 bytes
Array(n+1){c->Array(n+1){r->when(n){c,r->n*2;else->1+c+r}}}

Try it online.

Clojure, 153 135 bytes
List of lists? Yay, Lisp
(fn[n](loop[r[] i 0 d (* 2 n)](if(= i n)(conj r(conj(repeat n d)d))(recur(conj r(conj(vec(map #(+ i %)(range 1(inc n))))d))(inc i)d))))

Ungolfed:
(defn a[n]
  (loop [r[] i 0 d (* 2 n)]
    (if(= i n)
      (conj r(conj(repeat n d)d))
      (recur
        (conj r
            (conj (vec (map #(+ i %)(range 1(inc n)))) d))
        (inc i)
        d))))

Anonymous function that takes the input as argument and returns a list of lists.
Output of n=5:
[[1 2 3 4 5 10] [2 3 4 5 6 10] [3 4 5 6 7 10] [4 5 6 7 8 10] [5 6 7 8 9 10] (10 10 10 10 10 10)]

05AB1E, 17 bytes
FLN+I·¸«ˆ}·¸I>.×ˆ

Try it online!
Explanation
F                   # for N in [0 ... input-1]
 L                  # push range [1 ... input]
  N+                # add N to each
    I·¸«            # append input*2
        ˆ           # add to global list
         }          # end loop
          ·¸        # push [input*2]
            I>.×    # repeat it input+1 times
                ˆ   # add to global list
                    # implicitly output global list

Actually, 23 bytes
;;Rnkp@;r♀+@;τ;(♀q)@α@q

Try it online!
Explanation:
;;Rnkp@;r♀+@;τ;(♀q)@α@q
;;                       two copies of input
  R                      range(1, input+1)
   n                     copy input times
    kp@                  push stack to list, remove first element
       ;r                push range(input)
         ♀+              pairwise addition (add the value in the range to each value in the corresponding list)
           @;            duplicate input again
             τ;          input*2, duplicate that
               (♀q)      append input*2 to each list
                   @α@q  append a row of input*2

Clojure v1.8, 97 bytes
#(conj(mapv(fn[i](conj(vec(range i(+ % i)))(* 2 %)))(range 1(inc %)))(vec(repeat(inc %)(* 2 %))))

Try it online!
Explanation
(range 1(inc %))                           Numbers from 1 to 'n'
(mapv ... (range 1(inc %)))                For each one of these numbers
(fn[i](conj(vec(range i(+ % i)))(* 2 %)))  Create the numbers from 'i' to (n+i-1), convert to vector and insert '2*n' to the vector
#(conj ... (vec(repeat(inc %)(* 2 %))))    Insert to the previous vector a vector of repeated '2*n's

Fortran (GFortran), 93, 82 bytes
SUBROUTINE M(n)
PRINT*,(CHAR(10),(i-1+j,i=1,n),2*n,j=1,n)
PRINT*,(2*n,j=1,n+1)
END

Try it online!


text:
Code Golf Banner
Ouput the following banner:
   _____          _         _____       _  __
  / ____|        | |       / ____|     | |/ _|
 | |     ___   __| | ___  | |  __  ___ | | |_
 | |    / _ \ / _` |/ _ \ | | |_ |/ _ \| |  _|
 | |___| (_) | (_| |  __/ | |__| | (_) | | |
  \_____\___/ \__,_|\___|  \_____|\___/|_|_|

The code that has the fewest bytes wins! I'm interested to see what clever formulas some of you come up with, bare in mind I just created this in notepad with no clever formula in mind so you may not be likely in finding one.

Welcome to PPCG! you may not be likely in finding one. - haha, we always do :)

On the scale of humanity I consider myself good at maths - but it still always amazes me :)

Sorry, but I'm afraid this looks far too similar to an older challenge for me to leave open. There isn't much difference even in the character sets used in the questions, you just have an extra comma and a backtick. To try to avoid things like this, I'd recommend the sandbox for your future challenges.

Jelly, 128 bytes
“UyɠȯaẹṇṾƊSḳẋƘø;ṫṃ42MọẆẇB3tʂñṅƈṠUẈṣcC\ÑḢ¦¿$Ọỵịnß⁻ȥ2¶ø⁸Ḥ¢ȮN÷ẹƘḣƘßFĠC⁸⁴ʠe'ȮƊẹġƒhSṅsɼĖḟṘʋÆỌVKɠeḌ⁽ṗ?=ƈƥḍP⁴ĿḳaɲƬ*ṪñṪ’ṃ“_/|\`( ),”s46Y

Try it online!
This is just a direct compression, no tricks :).

Only a single comma - save a byte with “ı<ƇŒṃ¹Ḅzs:"ḳ'/sṀ6%Ðæẏŀ®4²ɱ⁼aṢ%®ƬIẒḢaŀ¡ʂĠɲ\ḢḂġṁDṭỵþ[ỴUzg⁽ȯṄẸa⁶XñṂ®ṄrTÇƊv?iḅozṁJhḢỵw⁴ṛFjĊ¬Ɲ¿PṿdƘ⁼¢fƘmṪṇȯ>B’ṃ“ /|\()_”s46Y”,-27¦`

...infact only a single backtick too, so save another two with: “Ṣ<ⱮL¶(ædẓ¹-ėȯ£IḍṄØ0!ḍḢṭẊƁ⁺-ȥ?½ƝṙOṬiŒɓỊoŻị~Çẉ®6⁺K@Ṃn\ẸṄɲWb°⁵Ƥ2¶ẓ^&ṪḳyBẈẸŀṪM¦ọĠKṚṃƙ}¦Ṛ²Ỵœ⁴>0B⁸3ạ1¥ɓ’ṃ“ /|()_”s46Y”,-27¦”`159¦`

Why are downvotes being given for a valid answer posted before this question was marked as a duplicate?