text:
Can even numbers become prime?
The Sequence
Everyone knows the only even prime number is 2. Ho-hum. But, there are certain even numbers n where, when concatenated with n-1, they become a prime number.
For starters, 1 isn't in the list, because 10 isn't prime. Similarly with 2 (21), and 3 (32). However, 4 works because 43 is prime, so it's the first number in the sequence a(1) = 4. The next number that works (neither 6 (65) nor 8 (87) work) is 10, because 109 is prime, so a(2) = 10. Then we skip a bunch more until 22, because 2221 is prime, so a(3) = 22. And so on.
Obviously all terms in this sequence are even, because any odd number n when concatenated with n-1 becomes even (like 3 turns into 32), which will never be prime.
This is sequence A054211 on OEIS.
The Challenge
Given an input number n that fits somewhere into this sequence (i.e., n concatenated with n-1 is prime), output its position in this sequence. You can choose either 0- or 1-indexed, but please state which in your submission.
Rules

The input and output can be assumed to fit in your language's native integer type.
The input and output can be given in any convenient format.
Either a full program or a function are acceptable. If a function, you can return the output rather than printing it.
If possible, please include a link to an online testing environment so other people can try out your code!
Standard loopholes are forbidden.
This is code-golf so all usual golfing rules apply, and the shortest code (in bytes) wins.

Examples
The below examples are 1-indexed.
n = 4
1

n = 100
11

n = 420
51

Why do you have to do it in reverse? cQuents doesn't have that mode :(

@StepHen Just for a change of pace; something different than the usual.

I feel this would be much better as a decision problem.

Not only is 2 the only prime number divisible by 2, 3 is also the only prime number divisible by 3, and 5 is the only prime number divisible by 5. In general, a prime number n is always the only prime number divisible by n. It's not special - that's just how prime numbers work.

Jelly,  8  7 bytes
ḊżṖVÆPS

A monadic link taking a sequence member and returning its index in the sequence.
Try it online!
How?
ḊżṖVÆPS - Link: number, n
Ḋ       - dequeue (implicit range) = [ 2   , 3   , 4   ,... ,              n         ]
  Ṗ     - pop (implicit range)     = [   1 ,   2 ,   3 ,... ,                  n-1   ]
 ż      - zip                      = [[2,1],[3,2],[4,3],... ,             [n , n-1]  ]
   V    - evaluate as Jelly code   = [ 21  , 32  , 43  ,... ,         int("n"+"n-1") ]
    ÆP  - is prime? (vectorises)   = [  0  ,  0  ,  1  ,... , isPrime(int("n"+"n-1"))]
      S - sum

TIO Isn't down for me, maybe it just got back up?

Fixed as of 2 mins ago :)

Beautiful! That zip(head(), pop()) trick is really cool. :)

In what encoding is that 7 bytes?

@kylefinn Jelly has its own code-page, click the bytes link in the header to see it.

Haskell, 80 75 70 bytes
5 bytes save thanks to Laikoni
p x=all((>0).mod x)[2..x-1]
g n=sum[1|x<-[4..n],p$read$show=<<[x,x-1]]

Try it online!

I think you can use the shorter prime test p x=all((>0).mod x)[2..x-1] which fails for 1, but this should not matter in this case.

Also show x++show(x-1) can be shortened to show=<<[x,x-1].

@Laikoni Thanks for the tips! I thought the show could be done in a shorter method but I didn't think of a concat map for some reason.

Jelly, 12, 10, 8 bytes
;’VÆPµ€S

Try it online!
1-2 bytes saved thanks to @nmjmcman101, and 2 bytes saved thanks to @Dennis!
Explanation:
     µ€   # For N in range(input()):
;         #   Concatenate N with...
 ’        #   N-1
  V       #   And convert that back into an integer
   ÆP     #   Is this number prime?
       S  # Sum that list

Can you just drop the R and use implicit range?

@nmjcman101 I totally did not know that was a thing. Thanks!

05AB1E, 9 8 7 bytes
Code
ƒNN<«pO

Uses the 05AB1E encoding. Try it online!
Explanation
ƒ          # For N in [0 .. input]..
 NN<«      #   Push n and n-1 concatenated
     p     #   Check for primality
      O    #   Sum the entire stack (which is the number of successes)

Of course this takes advantage of the fact that 05AB1E ignores errors...because I don't think you can check whether '0-1' is prime.

Japt, 15 14 12 11 9 8 bytes
1-indexed.
ÇsiZÄÃèj

Try it
Ç            :Map each Z in the range [0,input)
 s           :  Convert to string
  i          :    Prepend
   ZÄ        :    Z+1
     Ã       :End map
      è      :Count
       j     :  Primes

11 bytes

Gah! Why do I have such a blindspot for Æ and Ç?! Thanks, @Oliver; I'll update when I get back to a computer.

2o+X (with trailing space) would work in place of [XXÉ], though if I ever get around to auto-balancing [] brackets your solution will be a byte shorter. (Actually 2, since you could then do õ_ZÉ]¬nÃèj)

@ETHproductions: These days, the fist thing I do when working with an array is check to see if auto-balancing has been added for []! :D

For some reason I think semicolons have entirely stopped working as well, so I'll try to fix that. Don't think I'll have a chance until tomorrow afternoon though.

Husk, 13 11 10 bytes
1-indexed solution:
#ȯṗdS¤+d←ḣ

Try it online!
Ungolfed/Explanation
         ḣ -- in the range [1..N]
#          -- count the number where the following predicate is true
        ←  --   decrement number,
    S  d   --   create lists of digits of number and decremented
     ¤+    --   concatenate,
   d       --   interpret it as number and
 ȯṗ        --   check if it's a prime number

Thanks @Zgarb for -3 bytes!

£İp is equivalent to ṗ. Also, you could save a byte with #…ḣ instead of £f…N.

Python 2, 87 bytes
-2 bytes thanks to @officialaimm. 1-indexed.
lambda n:sum(all(z%v for v in range(2,z))for i in range(4,n+1)for z in[int(`i`+`i-1`)])

Test Suite.

I am golfing this as soon as possible. Suggestions are welcome.

87 bytes

Pyth, 12 bytes
smP_s+`d`tdS

Try it online! or Verify all Test Cases.

How?
smP_s+`d`tdSQ  -> Full Program. Takes input from Standard Input. Q means evaluated input
                  and is implicit at the end.

 m         SQ  -> Map over the Inclusive Range: [1...Q], with the current value d.
    s+`d`td    -> Concatenate: d, the current item and: td, the current item decremented.
                  Convert to int.
  P_           -> Prime?
s              -> Sum, counts the occurrences of True.

Röda, 73 bytes
{seq 3,_|slide 2|parseInteger`$_2$_1`|{|i|[1]if seq 2,i-1|[i%_!=0]}_|sum}

Try it online!
1-indexed. It uses the stream to do input and output.
Explanation:
{
seq 3,_| /* Create a stream of numbers from 3 to input */
slide 2| /* Duplicate every number except the first and the last
            to create (n-1,n) pairs */
parseInteger`$_2$_1`| /* Concatenate n and n-1 and convert to integer */
{|i| /* For every i in the stream: */
    [1]if seq 2,i-1|[i%_!=0] /* Push 1 if i is a prime
                                (not divisible by smaller numbers) */
}_|
sum /* Return the sum of numbers in the stream */
}

Pyth, 14 bytes
lfP_Tms+`d`tdS

Try it online!
Explanation
              Q    # Implicit input
             S     # 1-indexed range
     m             # For d in range [1, Q]...
      s+`d`td      # Concatenate d and d - 1
 fP_T              # Filter on primes
l                  # Return the length of the list

You beat me by a few seconds, I beat you by a few bytes :P

@Mr.Xcoder My first version was lfTmP_s+\d`tdS`, it's unfortunate that I didn't find your trick by myself at that time :)

C, 99 94 bytes
1 indexed. It pains me to write primality tests that are so computationally wasteful, but bytes are bytes after all.
If we allow some really brittle stuff, compiling on my machine without optimizations with GCC 7.1.1 the following 94 bytes works (thanks @Conor O'Brien)
i,c,m,k;f(n){c=i=1;for(;++i<n;c+=m==k){for(k=m=1;m*=10,m<i;);for(m=i*m+i-1;++k<m&&m%k;);}n=c;}

otherwise these much more robust 99 bytes does the job
i,c,m,k;f(n){c=i=1;for(;++i<n;c+=m==k){for(k=m=1;m*=10,m<i;);for(m=i*m+i-1;++k<m&&m%k;);}return c;}

Full program, a bit more readable:
i,c,m,k;
f(n){
    c=i=1;
    for(;++i<n;c+=m==k){
        for(k=m=1;m*=10,m<i;);
        for(m=i*m+i-1;++k<m&&m%k;);
    }
    return c;
}

int main(int argc, char *argv[])
{
    printf("%d\n", f(atoi(argv[1])));
    return 0;
}

Depending on your compiler, you may be able to save some bytes by using n=c; instead of return c;: i,c,m,k;f(n){c=i=1;for(;++i<n;c+=m==k){for(k=m=1;m*=10,m<i;);for(m=i*m+i-1;++k<m&&m%k;);}n=c;}

I can't say I want to use things that even seems to vary with optimization levels. Using GCC, with no optimization -O0 it works, with other optimization flags it doesn't. Interestingly -O1 -O2 and -O3 it returns 0, with -Os it returns 1, with -Og it returns n-1.

You can always specify in your answer how your program should be compiled.

I guess, feels a bit cheap. But I can add an alternative.

I understand, but I wouldn't feel to bad about doing that--it's one of the tips for golfing in C

91 bytes

Perl 6, 45 bytes
{first :k,$_,grep {is-prime $_~.pred},1..∞}

Try it online!
The grep produces the sequence of qualifying numbers, then we look for the key (:k) (ie, the index) of the first number in the list that equals the input parameter $_.

30 bytes

JavaScript (ES6),  49 48  47 bytes
1-indexed. Limited by the call stack size of your engine.
f=n=>n&&f(n-2)+(p=n=>n%--x?p(n):x<2)(x=n+[--n])

Try it online!

Tidy, 33 bytes
index({n:prime(n.n-1|int)}from N)

Try it online!
Explanation
The basic idea is to create a sequence of the valid numbers then return a curried index function.
index({n:prime(n.n-1|int)}from N)
      {n:                }from       select all numbers `n` from...
                               N     the set of natural numbers, such that:
               n.n-1                     `n` concatenated with `n-1`
                    |int                 ...converted to an integer
         prime(         )                ...is prime
index(                          )    function that returns index of input in that sequence

Mathematica, 77 bytes
Position[Select[Range@#,PrimeQ@FromDigits[Join@@IntegerDigits/@{#,#-1}]&],#]&

Ruby, 42+9 = 51 bytes
Uses the -rprime -n flags. 1-indexed.
Works by counting all numbers equal to or below the input that fulfill the condition (or more technically, all numbers that fulfill the n-1 condition). Since the input is guaranteed to be in the sequence, there's no risk of error from a random input like 7 that doesn't "become prime".
p (?3..$_).count{|i|eval(i.next+i).prime?}

Try it online!

Ruby, 62 bytes
->g{(1..g).count{|r|(2...x=eval([r,r-1]*'')).none?{|w|x%w<1}}}

Try it online!
1-indexed

Vyxal, 6 bytes
'‹Jæ;L

Try it Online!
     L # Number of values
'   ;  # Between (implicit) 1 and n
 ‹J    # Where n ++ (n-1)
   æ   # Is prime

Vyxal 3 L, 6 bytes
Ωv&“⌊Ṅ

Try it Online!
1-indexed
Ωv&“⌊Ṅ
Ω       # filter from the range [0... input]
 v&“⌊   # concatenate n+1 and convert to integer
     Ṅ  # prime?
# L flag gets the length of the top of the stack

Created with the help of Luminespire.

QBIC, 25 bytes
[:|p=p-µa*z^_l!a$|+a-1}?p

Explanation
[:|     FOR a = 1 to <n>
p=p-    Decrement p (the counter) by
µ       -1 if the following is prime, or 0 if not
        For the concatenating, we multiply 'a' by 10^LENGTH(a), then add a-1$┘p
        Example 8, len(8) = 1, 8*10^1 = 80, add 8-1=7, isPrime(87) = 0
a*z^_l!a$|+a-1
}       Close the FOR loop - this also terminates the prime-test
?p      Print p, the 0-based index in the sequence.

This uses some pretty involved math-thing with a cast-to-string slapped on for good measure. Making a version hat does solely string-based concatenation is one byte longer:
[:|A=!a$+!a-1$┘p=p-µ!A!}?p

PHP, 203 bytes
<?php $n=($a=$argv[1]).($a-1);$p=[2];$r=0;for($b=2;$b<=$n;$b++){$x=0;if(!in_array($b,$p)){foreach($p as $v)if(!($x=$b%$v))break;if($x)$p[]=$b;}}for($b=1;$b<=$a;$b++)if(in_array($b.($b-1),$p))$r++;die $r;

Try it online!
Uses a 1-based index for output. TIO link has the readable version of the code.

Python 2, 85 bytes
1-indexed
lambda n:sum(all(z%v for v in range(2,z))for i in range(3,n)for z in[int(`i+1`+`i`)])

Test
Improvement to Mr. Xcoder's answer

Java 8, 108 bytes
n->{for(long r=0,q=1,z,i;;){for(z=new Long(q+""+~-q++),i=2;i<z;z=z%i++<1?0:z);if(z>1)r++;if(q==n)return r;}}

0-indexed
Explanation:
Try it online.
n->{                             // Method with integer parameter and long return-type
  for(long r=0,                  //  Result-long, starting at 0
      q=1,                       //  Loop integer, starting at 1
      z,i;                       //  Temp integers
      ;){                        //  Loop indefinitely
    for(z=new Long(q+""+~-q++),  //   Set z to `q` concatted with `q-1`
        i=2;i<z;z=z%i++<1?0:z);  //   Determine if `z` is a prime,
      if(z>1)                    //   and if it indeed is:
        r++;                     //    Increase the result-long by 1
      if(q==n)                   //   If `q` is now equal to the input integer
        return r;}}              //    Return the result

Stax, 10 bytes
1- Indexed
Äm▬á┌╕|°φ♦

Run and debug it
Explanation
Rxr\{$e|pm|+         #Full program, unpacked, implicit input  (Example (4))
R                    #Create [1 to input] range  (ex [1,2,3,4] )
 x                   #Copy value from x register (ex (4) )
  r                  #Create [0 to input-1] range (ex [0,1,2,3)
   \                 #Create array pair using the range arrays (ex [[1,0],[2,1],[3,2],[4,3]])
    {    m           #Map block
     $e|p            #To string, eval string (toNum), isPrime (ex [1,0] => "10" => 10 => 0)
          |+         #Sum the array to calculate number of truths (ex [0,0,0,1] => 1)


text:
"Hello, World!" (Cops' thread)
This is the cops' thread. The robbers' thread is here.
Your challenge is to write a program or function that, with a certain input, prints the exact string Hello, World! and a newline. Capitalization, spacing and punctuation must be exact.
Input may be taken via standard input, a file, or command-line/function arguments. Output may be given via return value, writing to a file, or standard output.
Your program must print Hello, World! for at least one input. When your program is given the wrong input (i.e. the input that does not make it print Hello, World!), it can do whatever you like - crash, print random nonsense, call Chuck Norris, etc.
You may not use a hashing algorithm or any similar methods of obscuring the required input.
Submissions are preferred to be runnable & crackable on TIO. Submissions not runnable or crackable on TIO are allowed, but please include instructions to download / run them.
After one week, this challenge will be closed to future cop submissions. The winner is the shortest code that is uncracked after a week of posting it ("it" being the code, not this challenge). The winner will be accepted after two weeks.
After a week has passed since posting, please mark your answer as safe and show the input (in a > ! spoiler quote). If a robber cracks your submission (before the week ends), please mark it as cracked and show the halting input (in a > ! spoiler quote).
Looking for uncracked submissions?

fetch("https://api.stackexchange.com/2.2/questions/137742/answers?order=desc&sort=activity&site=codegolf&filter=!.Fjs-H6J36vlFcdkRGfButLhYEngU&key=kAc8QIHB*IqJDUFcjEF1KA((&pagesize=100").then(x=>x.json()).then(data=>{var res = data.items.filter(i=>!i.body_markdown.toLowerCase().includes("cracked")).map(x=>{const matched = /^ ?##? ?(?:(?:(?:\[|)([^\]]+)(?:\]|<\/a>)(?:[\(\[][a-z0-9/:\.]+[\]\)])?)|([^, ]+)).*[^\d](\d+) ?\[?(?:(?:byte|block|codel)s?)(?:\](?:\(.+\))?)? ?(?:\(?(?!no[nt][ -]competing)\)?)?/gim.exec(x.body_markdown);if(!matched){return;}return {link: x.link, lang: matched[1] || matched[2], owner: x.owner}}).filter(Boolean).forEach(ans=>{var tr = document.createElement("tr");var add = (lang, link)=>{var td = document.createElement("td");var a = document.createElement("a");a.innerHTML = lang;a.href = link;td.appendChild(a);tr.appendChild(td);};add(ans.lang, ans.link);add(ans.owner.display_name, ans.owner.link);document.querySelector("tbody").appendChild(tr);});});

Uncracked Submissions

Language	Author

Very similar not a dupe though.

As I said in the sandbox, I feel that this is a duplicate of the halting question since any answer there could be posted here instead but with code for and infinite loop replaced with code to print hello world. I won't vote yet because I'd hammer, but I'm pretty convinced this is a dupe.

Obviously sha3 falls into that category, but otherwise where do you draw the line? I mean the mod 1e3 is also a hash function, and I'd even go so far and argue that many of the submissions are going to be hash functions, as this challenge is basically asking for such.

Is the trailing newline entirely necessary? I just added a byte to the end of my submission, but still I see a few other people have missed it off too.

What exactly counts as a hashing algorithm? Would summing the codepoints of a string be a hashing algorithm? How about treating a string as a base-256 number?

@FryAmTheEggman Related, but not dupe. In case of no comparing with "Hello world" its different. For example when doing some input manipulations.

Based on the answers I've seen in the past day, nothing has appeared that convinces me this isn't a duplicate. I'm going to close the cop challenge for now, and if the community disagrees it can be reopened, and if the community agrees they can close the robber thread too.

@FryAmTheEggman now i am developing non dupe crackme. To avoid dupe submissions you can edit rules

@Dopapp this has already been discussed, here (some comments deleted) and in chat. Answers cannot be copy-pasted, nor very easily ported, from that challenge to this one, so they are not duplicates.

Can cop's program interact with crack? i.e. robber's program do calculations, based on debug output of cop's program, and then send suitable for this case input

What's a "similar method of obscuring the required input"? I'm doing some calculations on numerical input in one of my submissions, but nothing that's specifically hard to reverse (like a hash function is), so I guess this is ok?

@FelixPalmen I believe that mostly is directed at one-way functions (hash functions), RSA stuff (giant primes) or the like

I assume that, just wanted to be sure my C64 submission isn't against the rules :)

I think I should post this meta post to gather more discussion as to what kind of inputs are valid; because as it stands, some cracks are really stretching the definition of a input a lot.

Python 3, 191 186 bytes (SAFE!)
Same as my previous answer, but without the noob eval statement, so that somebody actually has to solve the problem I created.
import sys
from numpy import *
e=enumerate
c='Hello, World!'
print(''.join([c[int(sum([c*cos(n*i)for i,c in e(fromiter(sys.argv[1:],float))])+.01)]for n in[2*i+ord(n)for i,n in e(c)]]))

now execute it with the correct parameters, such as python3 hw.py 1 2 3

Edit: previous version was missing a comma in "Hello, World!", and also I realized that it had an unnecesary ennumerate, which is now gone.

Edit 2: Just for fun, here is an almost identical Pyth version (47 bytes) of the same code:
KEJ"Hello, World!"jkm@J.Rs.e*b.t*dk1K0.e+*2kCbJ

Input is taken from stdin and is in the form of a list of arguments, such as [1,2,3]
I see no point in posting a separate answer because if you crack the Pthyon3 version, then you also crack the Pyth version, even without knowing Pyth.

Answer:

 python3 hw.py 10.72800138 13.23008796 19.30176276 16.13233012 18.10716041 0.98306644 8.18257475 19.20292132 10.99316856 -2.15745591 6.01351144 5.45443094 10.41260889

Explanation of code:

''.join() creates the hello world string out of an array of characters from the string "Hello, World!".  The puzzle is solved when those indicies are [0,1,2,3,4,5,6,7,8,9,10,11,12].  Each index is calculated from an input and the constants given on the command line.  The inputs are a hard coded series: [2*i+ord(c) for i,c in enumerate('Hello, World!')].  The funtion that relates the input, the constants, and the output (indicies) is this: sum([c*cos(x*i) for i,c in enumerate(CONSTANTS)]).  This is a classic modelling problem, where you are trying to fit data to your model.

Arriving at the solution, in python:

 from scipy import optimize
x = [2*i+ord(c) for i,c in eumerate('Hello, World!')]
y = [0,1,2,3,4,5,6,7,8,9,10,11,12].
# make your function: 13 terms means we can achieve 13 exact outputs
def f(x,a,b,c,d,e,f,g,h,i,j,k,l,m):
    return sum([c*cos(x*i) for i,c in enumerate([a,b,c,d,e,f,g,h,i,j,k,l,m])])
# curve fit
ans,_ = optimize.curve_fit(f,x,y)
# check answer
[round(f(a,*ans),0) for a in x] # should be 0-12

Just in case you didn't know, literal_eval() in the ast module can be used to safely evaluate expressions, so that the print( code injection problem wouldn't work. It's probably not relevant here, but I just thought I'd mention it.

are you sure this can print Hello, World!? Haven't cracked yet, but it looks like it's missing a comma (only 12 iterations in join loop)

Oh, you are right, it is missing a comma.  I will correct it now.

@Challenger5 thank you, I did not know that.

TeX - 38 bytes Cracked(ish)
This is worth a shot, because I can't imagine anyone on a site about writing short pieces of code would know TeX:
\read16to\x\message{Hello, World!}\bye

To run it, you should get a hold of some form of TeX that allows interactive mode. Save this to a file, and run TeX (or pdfTeX, XeTeX, etc.) on it.
Edit: I'm currently considering this semi-cracked. The intended solution uses input from stdin, but TeXnically input from the way the program is invoked is valid. I'll be adding more devious TeX answers if someone gets the intended method.
Here's the intended solution:

 ^C Ia - The first key is control-c, which causes an error. Then, you press I (capital i) to input a command. Then you type a (or anything else to be typeset). Normally, the message that was printed to stdout would be followed by a space and then a ')'. When you typeset something, it causes the font information to be output after the message. That means that a newline is thrown in, and the ')' gets moved later.

That may be underhanded, but should still be within the rules of the game.

Welcome to PPCG. Good first answer

Wouldn't it suffice to use tex \ Hello, world!\bye (23 bytes)?

@Werner that would allow user input?

Is this actually meant to be cracked? :o

@agoldman: What follows tex is input. Whether that qualifies according to the question I don't know.

You can crack this if you're an evil, devious TeXacker. There will be an answer eventually.

Is using the commandline arguments of tex for "wrapping" this ok?

@FelixPalmen eh, I would consider it only fair to post an answer that interacts with the program written. You can't completely take advantage of the ability to give arbitrary input. But if you're thinking of what I'm thinking, yes that's a fair answer, but not the intended one.

Well, I won't give details here of course. Calling this from my own commandline snippet of TeX commands, I can make it print "Hello, World!" with the newline. But I can't so far with only input from stdin. So you say there's a way to do it? Of course I don't want to submit a "lame" crack ;)

Ok, I suggest this crack. Please judge for yourself if it is somewhat similar to what you had in mind. If fiddling with the environment is considered "wrong", I'll retract it.

texnically oh, gosh.

Sorry, let me fix that

@FelixPalmen I put up the intended input. I still think your crack is at least as fair as what I intended.

><>, 538 bytes, Cracked by rexroni
v
\">/v>v\v</>"
/!?lp%*2di%*2di
a
v   "        "       "
   "l"      "o"  /  "e"
v   "        "     " "
      "   /       "l"/
v    "!"           "
 //   " " "      \
v     \"d"o"   " "    "
      " " "   "o"r"  "!"
v"   "H"       " "    "
"l"   ""
""    "r" "         "
    \  " "l"       "d"  "
v   "     "      "  "  "H"
   "e"         /","     "
v " " "     "  " "
 "e" "W"  /"d""l"
v " " "     "  "      "
   "H"               "!"
v   "                 "
                        v
>>"Hello world?"       >o<
                        ^

Try it online, or you may want to use the fish playground.
The first three lines read in a string from STDIN and use its charcodes mod 26 as coordinates to put the characters ">/v>v\v</>" into the maze below. The intended solution is a 20-character string made of the letters A–Z only (although you're allowed to use anything you want, of course).
Solution:

 The intended input is OCEANICWHITETIPSHARK (it's a fish!). The path through the maze looks like: v
\">/v>v\v</>"
/!?lp%*2di%*2di
a                |  |
v   "        "   |  |"
| v"l"______"o"__/  "e"
v | "        "     " "
| |   "   /       "l"/
v |  "!"           "|
|//   " " "    v_\  |
v|    \"d"o"   " "  | "
||    " " "   "o"r" |"!"
v"   "H"       " "  | "
"l"___""_______ _/__/_____
""    "r" "    | |  "
|>__\  " "l"   | | "d"  "
v   "     "    | "  "  "H"
|  "e"v________/"," |   "
v " " "     "  " "  |
|"e"|"W"  /"d""l"|  |
v " " "     "  " |  | "
<  "H">__________ __\"!"__
v   "            |  | "
    >____________ __ ___v
>>"Hello world?" |  |  >o<
                 |  |   ^

Cracked!  Took me forever.

Hey, I suspected the answer might be a word, but I didn't make any attempt to unscramble it.  I stand even more impressed.

Octave, 59 bytes, Cracked
This works in Octave 4.2.0. I can't guarantee compatibility with all versions.
i=input('');printf('%c',i*~all(isequal(i,'Hello, World!')))

Note: This doesn't print any trailing spaces or newlines. This is what it looks like:

It basically says: "Print the input string, unless the input is 'Hello, World!', in which case it should print nothing (or the null-character).

I'm not sure if %c means string or char...maybe you're hiding something? Also the *~ makes me a bit suspicious...

I'm not sure, but cracked?

@BruceForte prints a null byte at the end of output, I'm not sure that's valid... link

@MDXF Me neither, but it might be. Did you read the motivation in my answer?

@BruceForte I did, but I'm still not sure... guess we'll just have to wait for OP.

My submission doesn't have \00 in there, but it's somewhat similar so I consider it cracked. I won't reveal the "trick" just yet, in case I want to use something related in another answer.

@StewieGriffin But it's not the \n is it? Because that caused quite some confusion in the robber thread.

I'm pretty sure the intended solution is this kind of thing.

@JonathanAllan, yes, that's what I was going for =) I suggest you post that as a separate crack, since it doesn't contain any unprintables and is therefore "more correct".

@BruceForte, no. there was no \n. I thought the question text said "optional trailing newline".

CJam, 7 bytes (cracked)
q5/:i:c

Try it online!
Intended input:

65608656376564465644656476558065568656236564765650656446563665569

Cracked

@JonathanAllan Darn! That wasn't the intended input though.

Explode, 23 bytes, Cracked
@_?&4_-j>5&f^~c>&6\|4>7

More coming, this is just the beginning >:)
Try it online!
Explorer Explanation
There are four explorers in this program. I'm not entirely sure that wait (>) is working correctly.
@_?

Read user input (?), write and extend the tape (@) down (_).
&4_-j>5

For 4 ticks (4), modify the tape (&) downwards (_), jumping by 5 (5), by subtracting (-) 19 (j).
&f^~c>

For 16 ticks (f), modify the tape (&) upwards (^) in a wave (~), alternating no affect, +13, no affect, and -13 (c).
&6\|4>7

For 6 ticks (6), modify the tape (&) in both directions (|), decreasing (\) by 4 (4) each time, and jumping by 7 (7). Decreasing means that it subtracts 4 the first time, 8 the second time, etc.

Cracked but feel free to give an explanation of the goings on :)

@JonathanAllan explanation added, sorry I took so long

MATL, 6 bytes. Cracked
tsZp?x

Try it online!

Cracked, but if this isn't the intended solution, it feels a bit like cheating.

@Dennis The intended solution was ['Hello,' 1 'World!']. Why cheating? :-( The doc/help for D says Most input characters below 32 are replaced by space

I meant cheating on my part, turning an LF newline into a CR+LF newline.

@Dennis Ah, I see. Well, I think it's perfectly valid too

JavaScript (ES6), 173 169 163 150 151 148 143 bytes (Cracked)
Let's have something totally different... and totally evil.
const e=eval,p=''.split,c=''.slice,v=[].every,f=s=>(t=c.call(s),typeof s=='string'&&t.length<81&&v.call(p.call(t,`\n`),l=>l.length<3)&&e(t)(t))

Usage: f(something) // returns 'Hello, World!'
Try it online!

Let us continue this discussion in chat.

Cracked

Nice! That's a real crack.

This was really tough to crack. Good job!

It's directly taken from one of the puzzles I've created on elsewhere :) (I'll let people figure out where I posted the original puzzle.)

Also, bonus challenge: do this without invoke e at all :)

C# (.NET Core), 130 152 bytes, CRACKED
+22 bytes, I forgot about trailing newline... Program works the same as before, the newline is added to any output.
a=>a.Distinct().Select((x,y)=>a.Reverse().Skip(y).First()*x%255).Take(a.First()-33).Concat(new int[]{10}).Select(x=>(char)x).ToArray()

Try it online!
Byte count also includes
using System.Linq;

For a start I went for something not too crazy. It can has multiple answers.
The "official" crack:

    . !$0%>5&8'#?)S*TuE[MRX`+9

Cracked

tcc, 89 bytes, cracked by Dennis
#!/usr/bin/tcc -run
#include <stdio.h>

int main()
{
    puts("\n");
}
#include "/dev/stdin"

This is particularly evil due to tcc's dynamic resolution. Lots of functions are predeclared and trying to overwrite them simply doesn't work.

Could you create a working TIO link for people to play with? (this is no doubt incomplete - maybe it needs compiler flags or something, I have no idea) TBH I don't even know how this is meant to take input...?

Tio's tcc is not going to work. It doesn't get that this must be used as tcc -run rather than a separate compile and link phase.

Maybe it's runnable via a shell through there then, bash is available (I know very little regarding either tcc or bash though). Otherwise I think you should give some detailed instructions to get people going (unless my personal lack of knowledge is the issue here - as I said I don't even know how your code gets any input, all I see is a puts and I thought that outputs.)

Almost have a crack but I'm on mobile and mprotect is being a butt.

cracked

Bash, 62 bytes, (cracked by ArchDelacy)
[[ ! "${1////x}" =~ [[:alnum:]] ]]&&[[ $# = 1 ]]&&bash -c "$1"

No alphanumerics or forward slashes. You should have fun with this one.
Try it online!

cracked by ArchDelacy

brainfuck, 7 bytes cracked
,+[.,+]

Try it online!
Good luck. (doesn't work with every BF interpreter

Does your input work with any BF interpreter, including ones with different tape lengths? Does your input work locally, and not just on TIO?

@StepHen any length of type afaik

cracked

Does your intended solution work on TIO?

@totallyhuman thanks, edited the comment so it looks pro.  I don't know how to put non-printable input on TIO.  I passed input on stdin from a C program with a single printf statement.

@totallyhuman nope. Idk if bug

Cubically, 159 bytes (Cracked)
+53$!7@6:2/1+551$?7@6:5+52$!7@66:3/1+552$?7@6:5+3/1+4$!7@6:5/1+3$?7@6:5+1/1+54$!7@6:3/1+552$?7@6:5+1/1+552$?7@6:5+52$!7@6:1/1+551$?7@6:5+1/1+3$!7@6:1/1+1$(@6)7

This will be pretty easy to those who are comfortable with Cubically. Try it online!

Is anybody comfortable with Cubically? :P

@totallyhuman The language is actually pretty simple once you get used to it, and it's fun to use!

@totallyhuman It looks like there aren't any turning instructions, so this seems like mostly just math with multiples of 9. Very, very convoluted math.

Cracked?  I think I got the intended input, but it doesn't quite work, but I'm pretty sure it fails due to an interpreter bug.  See my explanation in crack post.  If I am right, then you were right that it was actually darn easy : )

6502 machine code (C64), 51 53 bytes (Cracked)
00 C0                     .WORD $C000     ; load address
20 FD AE                  JSR $AEFD
20 EB B7                  JSR $B7EB
8A                        TXA
0A                        ASL A
45 14                     EOR $14
8D 21 C0                  STA $C021
45 15                     EOR $15
85 15                     STA $15
49 E5                     EOR #$E5
85 14                     STA $14
8E 18 D0                  STX $D018
A0 00                     LDY #$00
B1 14                     LDA ($14),Y
20 D2 FF                  JSR $FFD2
C8                        INY
C0 0E                     CPY #$0E
D0 F6                     BNE *-8
60                        RTS
C8 45 4C 4C 4F 2C 20 D7   .BYTE "Hello, W"
4F 52 4C 44 21 0D         .BYTE "orld!", $D

Online demo
Usage: SYS49152,[x],[n], where x is a 16bit unsigned integer and n is an 8bit unsigned integer.

 Input is 52768 and 23 (SYS49152,52768,23)

 The second parameter is directly written to D018, a control register of the VIC-II graphics chip. Using a suitable reference, you can deduce what to write there for setting lowercase mode without changing other modes and the address of the screen memory: $17, or decimal 23. With that, you can follow the arithmetics in the code, so the first parameter ends up with the correct string address in $14/$15 (little-endian). A more in-depth explanation can be found in the crack.

Invoked with wrong values, a crash is very likely.
For cracking, you might want to run it in a local installation of vice, so here's a BASIC loader to paste into the emulator (RUN it to place the program at $C000):
0fOa=49152to49202:rEb:pOa,b:nE
1dA32,253,174,32,235,183,138,10,69,20,141,33,192,69,21,133,21,73,229,133,20,142
2dA24,208,160,0,177,20,32,210,255,200,192,255,208,246,96,200,69,76,76,79,44,32
3dA215,79,82,76,68,33,13

Update: Added two bytes for the load address to make this an executable C64 PRG file in response to the discussion on meta

Are you sure you need to call the comma checking function at the beginning? I'm under the impression that b7eb does that check, too.

b7eb calls aefd, but only after calling ad8a (parse number as float (!)(wtf)(MS)) and b7f7 (convert that float to 16bit unsigned int) -- so I have to first call aefd myself for consuming the first comma.

Cracked! Sweet sweet vengeance!

@AGoldMan finally edited my post. Again, well done! Maybe I can come up with another C64 code that's a bit harder to crack (without being unfair), not sure yet :)

JavaScript (ES6), 102 bytes (Cracked)
The previous version has a massive cheese. Let's try this again...
f=s=>{let r='',i=0;while(i<13)r+=!s[i][0]||s[i]=='Hello, World!'[i]||s[i++];return r};Object.freeze(f)

Try it online!
Author solution:

 new Proxy({v:Array(13).fill(0)},{get:(o,p)=>['a','','Hello, World!'[p]][o.v[p]++]})

Usage:

 var p=new Proxy({v:Array(13).fill(0)},{get:(o,p)=>['a','','Hello, World!'[p]][o.v[p]++]})
 console.log(f(p))

Cracked

Python 2, 63 bytes, cracked
Just to get the ball rolling...
#coding:rot13
cevag vachg()==h'Hello, World!'naq'Hello, World!'

Try it online!

Is it generally accepted for the OP to crack submissions?

cracked

That's interesting... I hadn't realized any "normal" language supports coding in ROT13 o_o

@ETHproductions PHP also has native support for that.

@Arnauld And you're claiming PHP is a normal language?

@NoOneIsHere Er... no. My bad. :-P

Pyth, 18 bytes (Cracked)
IqGQ"Hello, World!

This is extremely easy, and anyone that knows Pyth would crack it in the blink of an eye, but still... Note that you must put the String between quotes.
Try it online!

If anyone cracks it, please edit in yourselves.

Cracked?

@totallyhuman Yep

JavaScript (Browser only), 95 bytes (Cracked)
try{a=JSON.parse(prompt());try{a=='[object Object]'}catch(a){alert('Hello, World!')}}catch(a){}

Not too hard. Has multiple solutions.

cracked: https://codegolf.stackexchange.com/a/137759/31343

@Maltysen. That was fast! :)

Jelly, 11 bytes (cracked)
sLÆ½$Xṙ5O½Ọ

Try it online!
Intended input:

〡㋄ⶐ✐сᑀ⟙ⶐⶐ〡ސЀᶑ〡㋄ⶐ✐сᑀ⟙ⶐⶐ〡ސЀᶑ〡㋄ⶐ✐сᑀ⟙ⶐⶐ〡ސЀᶑ〡㋄ⶐ✐сᑀ⟙ⶐⶐ〡ސЀᶑ〡㋄ⶐ✐сᑀ⟙ⶐⶐ〡ސЀᶑ〡㋄ⶐ✐сᑀ⟙ⶐⶐ〡ސЀᶑ〡㋄ⶐ✐сᑀ⟙ⶐⶐ〡ސЀᶑ〡㋄ⶐ✐сᑀ⟙ⶐⶐ〡ސЀᶑ〡㋄ⶐ✐сᑀ⟙ⶐⶐ〡ސЀᶑ〡㋄ⶐ✐сᑀ⟙ⶐⶐ〡ސЀᶑ〡㋄ⶐ✐сᑀ⟙ⶐⶐ〡ސЀᶑ〡㋄ⶐ✐сᑀ⟙ⶐⶐ〡ސЀᶑ〡㋄ⶐ✐сᑀ⟙ⶐⶐ〡ސЀᶑ

Cracked

@HyperNeutrino Heh that was sneaky, given it lived for over half an hour. ;)

Heh that's cuz I only saw it 10 minutes before seeing it ;P

05AB1E, 20 bytes (Cracked)
Shouldn't be too hard though:
•GG∍Mñ¡÷dÖéZ•2ô¹βƵ6B

Uses the 05AB1E encoding. Try it online!

cracked

Jelly,  20  21 bytes (Cracked)
+1 byte - "...and a trailing newline"
œ?“¥ĊɲṢŻ;^»œ?@€⁸ḊFmṪ⁷

Try it online!
There are, in fact, infinite solutions.

I think I cracked this. My crack works with the ⁸ which is for some reason missing from the TIO link, so I hope I didn't confuse myself.

Sorry about the TIO mistake!

Ly, 12 bytes (Cracked)
n[>n]<[8+o<]

Try it online!
I don't expect this to last very long, but oh well. It didn't last very long.

Cracked

Lua 5.1, 44 bytes (Cracked)
s=...loadstring(#s>4+#s:gsub("%l","")or s)()

Note that Lua 5.1 is a different language than Lua 5.2 or Lua 5.3. "Try it online" doesn't have Lua 5.1. You can check your Lua version by running print(_VERSION). (There should be a solution in any implementation that uses PUC-Rio's Lua 5.1 core.)
As a test harness, you can use something like this:
function test(...)s=...loadstring(#s>4+#s:gsub("%l","")or s)()end

test[[
This is my input!
It can have multiple lines!
]]

Test harness on repl.it

Python3, 192 bytes Cracked I guess
from sys import *
from numpy import *
e=enumerate
c='Hello World!'
w=eval(argv[1])
x=[ord(n)+2*i for i,n in e(c)]
print(''.join([c[int(sum([c*cos(n*i)for i,c in e(w)])+.01)]for i,n in e(x)]))

The text it reads is the first program argument: python3 hw.py '[1,2,3]'
Don't be lame and try to put a print("Hello World!") statement as the argument... it prints an error afterwards anyways (at least on the command line), so I don't think that should count. (Edit: somebody did exactly that)

Cracked. Lame crack, but unrestricted eval must be punished =)

Ruby, 88 bytes, Cracked by w0lf
require'prime'
n=gets.to_i
n.prime?&&$><<n.to_s(36)[0,5].capitalize
$><<", #$'"if/30191/

Try it online!

cracked

C (GCC on TIO), 84 bytes golfed (Cracked)
#include<stdio.h>
main(x){scanf("%d",&x);printf("%2$s","Hello, World!\n",(void*)x);}

Here's an ungolfed version that works too:
#include <stdio.h>
int main(void)
{
    int x;
    scanf("%d",&x);

    printf("%2$s","Hello, World!\n",(void*)x);
}

Golfed: Try it online!
Ungolfed: Try it online!

CJam, 130 bytes (safe)
q'p/{'s/{{"cjaei"#}%{)},{`}%S*}%']*}%'[*~]Y8#,:Y;0a\{{__a#{\{_T=}{1$E}w\;}{"T(:T; _T=co T)
:T)0e] _T=)Y=T\t _T=(Y=T\t"S/=~}?}/}:E~;

Try it online!
This is split across two lines for clarity; the newline is not included.
This is semi-golfed, which makes it that much harder to understand.
There are an infinite number of solutions here. If anybody wants to try and find one, I wish them good luck...
Solution:

 aipeepceeaiaeeeaeeeccsiiiiaesnccccjccccijcjjccejccccjaajaaaijcjeeejaajaijcccccej

How are inputs fed into the function? I tried to feed in some inputs (via arguments and input) but no output whatsoever.

@Voile Inputs are read via STDIN. And yes, most inputs won't produce any visible output.

JavaScript (ES6) 107 Bytes [Thanks Евгений Новиков] (Cracked)
i=r=>{for(e="",n=0;r.length>n;o=r.charCodeAt(++n),e+=String.fromCharCode(((3^o^19)<<1^15^13)<<1));return e}

Call on the i function using a string.
The console.log... is for testing purposes.
Try It Online!

Welcome to PPCG! You can save 8 bytes: (1) remove var, (2) () from one arrow-function argument, (3) replace return to eval("") (4) delete ; at the end. 110 bytes solution: https://pastebin.com/qwdm7fT7 Good luck

Finally got 50 rep, so: Cracked

JavaScript (ES6), 92 bytes (Cracked)
This simple string copy function seems to be really resisting you to copy any strings resembling Hello, World!...
f=s=>{let r='',i=0;while(i<13)r+=s[i]=='Hello, World!'[i]||s[i++];return r};Object.freeze(f)

Try it online!

Röda, 71 bytes (Cracked)
{[[head(_)]..[unpull(1)if[_1>1]]]|[_()|chars|unorderedCount|[_*(_-1)]]}

Try it online!
Usage: push(/* input */) | f() (where f is a variable that holds the function above).

Cracked

JavaScript (ES6), 135 119 bytes, (Cracked)
const t='Hello, World!',g=q=>eval(`(function(p,q${q}){return eval(p),eval(q)})`),f=s=>g('')(s,0)==t&&g('=1')(s,0)!=t&&t

Try it online!

Cracked

C (gcc), 80 bytes, Cracked
#define O(c)(((char**)v)+c)
#define W(c)*(O(c)-**O(2)+x)
main(x,v){puts(W(42));}

Try it online!
Provide command line arguments for the desired output.
The intended input commandline was:

 "Hello, World!" ,

Quick explanation:

 The program does some pointer arithmetics on argv[], using the first char of the second argument and the argument count. See the robbers' post for a full explanation. There are other solutions possible, but the one over there is the most simple one.

Important: This won't work when e.g. built for amd64, therefore the compiler switch -m32 on tio.

Cracked

Perl 5, 23 bytes (Cracked)
eval<>;END{print$x='x'}

Usage: takes one line of input of stdin and evals it. The END block keeps simple attempts like print"Hello, World!\n";exit from working.
Try it Online!

our $x;package X;require Tie::Scalar;@ISA=qw(Tie::Scalar);sub TIESCALAR{my$v;return bless\$v,'X';}sub STORE{}sub FETCH{return "Hello, World!\n"}tie $x,'X';

Cracked

6502 machine code (C64), 94 bytes (Cracked)
00 C0 20 FD AE 20 9E AD 20 A3 B6 A0 00 B9 25 C0 C0 01 F0 21 C0 07 F0 1D C0 0B
F0 19 20 20 C0 C8 D0 EB 51 22 4C D2 FF F0 48 FA A2 1C 6D 72 30 06 A9 03 48 7C
A3 8D 48 C0 B9 26 C0 8D 45 C0 B9 27 C0 8D 46 C0 A2 00 BD FD AE 49 23 20 20 C0
C8 E8 E0 03 D0 F2 C0 0E D0 B5 49 1A 8D 18 D0 60

Disassembled:
00 C0       .WORD $C000       ; load address
20 FD AE    JSR $AEFD
20 9E AD    JSR $AD9E
20 A3 B6    JSR $B6A3
A0 00       LDY #$00
B9 25 C0    LDA $C025,Y
C0 01       CPY #$01
F0 21       BEQ $C033
C0 07       CPY #$07
F0 1D       BEQ $C033
C0 0B       CPY #$0B
F0 19       BEQ $C033
20 20 C0    JSR $C020
C8          INY
D0 EB       BNE $C00B
51 22       EOR ($22),Y
4C D2 FF    JMP $FFD2
F0 48       BEQ $C06F
FA          .BYTE $FA
A2 1C       LDX #$1C
6D 72 30    ADC $3072
06 A9       ASL $A9
03          .BYTE $03
48          PHA
7C A3       .WORD $A37C
8D 48 C0    STA $C048
B9 26 C0    LDA $C026,Y
8D 45 C0    STA $C045
B9 27 C0    LDA $C027,Y
8D 46 C0    STA $C046
A2 00       LDX #$00
BD FD AE    LDA $AEFD,X
49 23       EOR #$23
20 20 C0    JSR $C020
C8          INY
E8          INX
E0 03       CPX #$03
D0 F2       BNE $C044
C0 0E       CPY #$0E
D0 B5       BNE $C00B
49 1A       EOR #$1A
8D 18 D0    STA $D018
60          RTS

Online demo
Important: When load from disk (like in this online demo), the program only works after issuing a NEW command! Without first doing NEW, you'd only ever get an ?OUT OF MEMORY ERROR when trying to pass a string.

Usage: SYS49152,"[string]", where [string] is your input string.
Yes, input is a string this time, and the white area in the screenshot below doesn't tell you anything about the required length.

This should be quite hard to crack, but it's possible calculating everything back, no hashes or similar involved ;) You might need some reference for the C64 ROMs though. Further tip: look for an area only containing data in the disassembly listing :)
Like with my previous entry, here's a BASIC loader to paste into vice, just RUN this and the program is placed at $C000:
0fOa=49152to49243:rEb:pOa,b:nE
1dA32,253,174,32,158,173,32,163,182,160,0,185,37,192,192,1,240,33,192,7,240,29
2dA192,11,240,25,32,32,192,200,208,235,81,34,76,210,255,240,72,250,162,28,109
3dA114,48,6,169,3,72,124,163,141,72,192,185,38,192,141,69,192,185,39,192,141,70
4dA192,162,0,189,253,174,73,35,32,32,192,200,232,224,3,208,242,192,14,208,181
5dA73,26,141,24,208,96

Solution:

 8bitsareenough

Explanation:

 The code basically uses an XOR key of the same length as Hello, World!\n. As this would be quite simple to crack, the key isn't placed in the code as is but there are 3 times 3 bytes that are calculated from the C64's ROMs.

 The 3 times 3 bytes in the data are in the format <key>, <low>, <high>, where <low>, <high> is the start address of 3 bytes in the ROM that are taken as part of our XOR key after XOR'ing them with <key>.

 It's possible to crack it with some reference / disassembly to the C64 ROMs. Of course, it's easier to just try and get the key from the running program. I attempted to prevent the easiest method of doing this (just entering "Hello, World!\n", as XOR is reversed with the same key) by forcing a crash on wrong input. The crack linked cleverly modified the program, so it won't crash.

 Another nice possibility to crack this would have been to spot the single place where output happens: EOR ($22),Y; JMP $FFD2. If you know that fetching a string using the BASIC routines will place a pointer to that string in $22/$23, all you have to do is set a breakpoint at EOR ($22),Y and get the XOR key delivered in the accumulator byte by byte.

And cracked again. This is good fun!

So, unfortunately, I have to give up on this. I could come up with an even harder-to-crack one but 1.) this would increase byte count and 2.) it's too late anyways. Nice job!

PHP, 94 bytes, Cracked
<?=constant(explode(',',$argv[1])[0]."::".explode(',',$argv[1])[1])==262144?"Hello, world
":a;

Try it online!
First codegolf submission, feel free to help me improve this
Cracked, intended input :

ReflectionFunction,IS_DEPRECATED

Because

ReflectionFunction::IS_DEPRECATED = 262144

Cracked.

source: Stack Exchange

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

authors: Евгений Новиков

sort: votes


text:
"Hello, World!" (Robbers' thread)
This is the robbers' thread. The cops' thread is here.
Your challenge is to take an uncracked submission from the cops' thread and find, for what input or inputs, the program will print Hello, World! and a newline. Capitalization, spacing, and punctuation must be exact.
Please comment on the cop's submission when you've cracked their code.

Bash by Sisyphus
Original code:
[[ ! "${1////x}" =~ [[:alnum:]] ]]&&[[ $# = 1 ]]&&bash -c "$1"

Input:
__=; (( __++, __-- ));
(( ___        = __,        ___++));
(( ____       = ___,       ____++));
(( _____      = ____,      _____++));
(( ______     = _____,     ______++));
(( _______    = ______,    _______++));
(( ________   = _______,   ________++));
(( _________  = ________,  _________++));

${!__##-} <<<\$\'\\$___$______$_______\\$___$______$_____\\$___$_______$__\\$___$_______$_________\'\ \$\'\\$___$___$__\\$___$______$_______\\$___$_______$______\\$___$_______$______\\$___$_______$_________,\ \\$___$____$_________\\$___$_______$_________\\$___$________$____\\$___$_______$______\\$___$______$______\\$__$______$___\'

Explanation:
This encodes "echo Hello, World!" as octal escape sequences (\xxx).
Except you also can't use numbers, so the first part builds up variables for the numbers 0-7. You can use those to build a string with octal sequences that will evaluate to give you the actual command.
But eval is also alphanumeric. So instead this pipes that string as input to another instance of bash. $0 contains the name of the command used to invoke Bash, which is usually just bash (or -bash for a login shell) if you're running it normally (through TIO or by pasting it in a terminal). (This incidentally means that if you try to run this by pasting it into a script, things will go horribly wrong as it tries to fork itself a bunch of times.)
But anyway, you can't say $0 directly. Instead, $__ contains the name of $0 ("0"), and you can use indirect expansion to access it (${!__} refers to the contents of $0).
And that, finally, gives you all the pieces you need.

Welcome to Programming Puzzles & Code Golf! I've left a comment on the cop answer. TIO link for the interested: https://tio.run/##jc/LDoIwEAXQPV8xQMMjQAxbHvFDKLkBNy7UjTExIfjrtbxkEIh2QdvbM9NSV/ezUkVBJlmiiQ96PFuL8hcVRVJdbo9rUpZUlo6jjbApp7jf1bqOopMuii2lFJCn5HkEBEGov1FEvp8afQIaR6434bRBR2cDZj4I3wgMTQprBaZGhi0GxgaHbQfmeog9CAY7iaU0kpREYx5tO2opyzIppCul0OdiYOOEjXARdfMqmGpdScvGYrPhTof/w@4X9VXzEXvD3tsW@bD4fSHPWCTdNw

Nice! My solution looked different, but used the same idea - constructing an octal string and using the dollar single quote syntax, and using indirection. Well done =)

05AB1E, Adnan
•GG∍Mñ¡÷dÖéZ•2ô¹βƵ6B

 -107

Try it online!
How?
•GG∍Mñ¡÷dÖéZ•        - big number
             2ô      - split into twos (base-10-digit-wise)
               ¹β    - to base of input
                   B - convert to base (using 012...ABC...abc...):
                 Ƶ6  -   107 (ToBase10(FromBase255(6))+101 = 6+101 = 107)

Negative base...pretty...

totallyhuman, Python 2
A solution is
'Uryyb, Jbeyq!'

Explanation? ----

Pyth: Mr. Xcoder
"abcdefghijklmnopqrstuvwxyz"

G is the built-in for the lowercase alphabet. The code checks for equality against that.

Nice crack :)))

Jelly: EriktheOutgolfer
〡㋄ⶐ✐сᑀ⟙ⶐⶐ〡ސЀᶑ〡㋄ⶐ✐сᑀ⟙ⶐⶐ〡ސЀᶑ〡㋄ⶐ✐сᑀ⟙ⶐⶐ〡ސЀᶑ〡㋄ⶐ✐сᑀ⟙ⶐⶐ〡ސЀᶑ〡㋄ⶐ✐сᑀ⟙ⶐⶐ〡ސЀᶑ〡㋄ⶐ✐сᑀ⟙ⶐⶐ〡ސЀᶑ〡㋄ⶐ✐сᑀ⟙ⶐⶐ〡ސЀᶑ〡㋄ⶐ✐сᑀ⟙ⶐⶐ〡ސЀᶑ〡㋄ⶐ✐сᑀ⟙ⶐⶐ〡ސЀᶑ〡㋄ⶐ✐сᑀ⟙ⶐⶐ〡ސЀᶑ〡㋄ⶐ✐сᑀ⟙ⶐⶐ〡ސЀᶑ〡㋄ⶐ✐сᑀ⟙ⶐⶐ〡ސЀᶑ〡㋄ⶐ✐сᑀ⟙ⶐⶐ〡ސЀᶑ

Jelly, 11 bytes
sLÆ½$Xṙ5O½Ọ

Try it online!
Explanation
The original code can be explained as such:
sLÆ½$Xṙ5O½Ọ  Main link; argument is z
s            Split z into n slices, where n is:
    $
  Æ½         The integer square root of
 L                                      the length of z
     X       Random of a list. Returns a random row of the input put into a square
      ṙ5     Rotate the list left 5 times
        O    Get codepoints
         ½   Floating-point square root
          Ọ  From codepoints

So, just take "Hello, World!" and get codepoints, square them, cast back to codepoints, rotate right 5 times, and then square and flatten the result.

Octave by Stewie Griffin
Not sure if this is the correct solution (on TIO it prints the \00 character), but in my octave-cli shell it looks like this:

Also in the original challenge it says print nothing (or the null-character), so if nothing is the same as \00 then this should be fine.
[72, 101, 108, 108, 111, 44, 32, 87, 111, 114, 108, 100, 33, 0]

Try it online!

find, for what input or inputs, the program will print Hello, World! and a newline

But that's not what the challenge looks like, if so this would me much easier (replace the last 0 with a 10).

@BruceForte That is what the challenge asks: "Your challenge is to write a program or function that, with a certain input, prints the exact string Hello, World! and a newline." is an exact quote from the challenge. And indeed, that makes the answer trivial.

@hvd Yeah, but if you look at the image of the OP his solution does not, that's where the main confusion comes from.

In this case then this submission is invalid, since it prints an extra character. Either it's a 0 and you violate the challenge spec or it's a 10 and you go against the cop's post. Your decision; maybe both ways are invalid. I would take back my upvote.

@HyperNeutrino It only does so on the TIO, not if you actually run the code in an octave-cli shell like the OP does. I guess if you put it that way there's no way to crack this.

By the challenge spec, it's meant to have a trailing newline though.

@HyperNeutrino If this is invalid it's due to Stewie's cop submission, not this crack. (I think.)

Fair enough. I keep my upvote here then.

@HyperNeutrino FWIW this is what I think the intended style of solution is.

@JonathanAllan That looks more likely. And that is very intriguing :o

Python 3 by rexroni
print("Hello, World!") or __import__('sys').exit(0)

Prevent any errors by exiting early.
Try it online!

Ruby, by Histocrat
The magic input is: 1767707618171221 30191World!
Try it online.
Explanation:

the number 1767707618171221 is a prime, and, written in base 36 it is "hello". When capitalized, this produces "Hello", which is printed using $><<
the line $><<", #$'"if/30191/ looks for the number 30191 in the input and writes to stdout a string composed of a comma, a space, and whatever is in the input after the 30191 (using the $POSTMATCH, which is referred here by its short variant, $').

Cubically by MD XF
I imagine this is always dangerous, but I think I have a crack, pending that I am correct in that there is a bug in the interpreter (which I just now compiled).
My input

 0 1 0 1 0 1 0 1 1 0 1 0 0

Output is Hello, World!\n\n\n\n\n\n\n\n\n\n..... with unending newlines.
But I noticed the last section of code:
:1/1+1$(@6)7

sets the notepad to 0x0A (newline) in a scary way, reads input to face 7 (the input face), and then prints the 6 face (notepad face) repeatedly until the 7 face is zero.  If you set face 7 to zero, you should only get one newline.  However, I got infinite newlines and my 13th input WAS a zero, and I can verify that the 7 face is always zero by inserting a "print number from 7 face" in the loop:
:1/1+1$(@6%7)7

then it prints unending \n0 pairs.
I am looking at the specs on the cubically github page and this behavior looks an awful lot like a bug.  Changing the last character of the original program from a 7 to a 0 results in the expected behavior.  The TIO interpreter exhibits the same incorrect behavior.

Should be fixed now, as soon as Dennis pulls Cubically it'll be fixed on TIO.

JavaScript (ES6) by Voile
Input must be a string containing this:
e(
`\
_\
=\
>\
"\
H\
e\
l\
l\
o\
,\
 \
W\
o\
r\
l\
d\
!\
"\
+\
\`
\`
`)

Try it using this:

const e=eval,p=''.split,c=''.slice,v=[].every,f=s=>(t=c.call(s),typeof s=='string'&&t.length<81&&v.call(p.call(t,`\n`),l=>l.length<3)&&e(t)(t))

input='e(\n`\\\n_\\\n=\\\n>\\\n\"\\\nH\\\ne\\\nl\\\nl\\\no\\\n,\\\n \\\nW\\\no\\\nr\\\nl\\\nd\\\n!\\\n\"\\\n+\\\n\\`\n\\`\n`)'
console.log(f(input))

If you don't care about the trailing newline requirement for the output, you can replace the last 6 lines with this instead:
!"
`)

How I did it
The restrictions on the input are that it's a string, each line is two bytes long or less, and that the total length is 80 bytes or less. My first attempt after understanding that correctly was this:
_
=>
`\
H\
e\
l\
l\
o\
,\
 \
W\
o\
r\
l\
d\
!
`

Note: the \s are to ignore the newlines in the string in the input. This is incredibly crucial to the answer, and I can't believe that I stumbled upon it on accident. (I was familiar with it before but forgot about it)
But this didn't work, since the => has to be on the same line as the arguments. Thankfully, I had the idea of wrapping something similar in a string and putting an eval in my input to reduce it to one line, resulting in my final answer. After the eval in the input occurs, the following is generated as a string (which is then eval'd to a function and then run):
_=>"Hello, World!"+`
`

This was really tough to crack, but I succeeded in the end.
Also, first crack ever!

Lua 5.1 by tehtmi
Pass this as the first argument:
C=("").char;_G[C(112,114,105,110,116)](C(72,101,108,108,111,44,32,87,111,114,108,100,33))

Assuming the original code is in a file tehtmi.lua, run (in bash or a similar shell):
lua tehtmi.lua 'C=("").char;_G[C(112,114,105,110,116)](C(72,101,108,108,111,44,32,87,111,114,108,100,33))'

It also works on Lua 5.3, which is what TIO uses, so why don't you try it online? I haven't tested on a implementation that uses the "PUC-Rio's Lua 5.1" core (because I can't really find any information), but my solution probably also works there.
How?
It runs the first argument as code, but only if it contains less than 5 lowercase characters.
The trick is to run print("Hello, World!"). Another way this can be run is using _G["print"]("Hello, World!"), which only uses strings.
But we can't use the string directly due to the lowercase-count restriction, however, you can run ("").char to get the function string.char, that can convert from a series of bytes to a string. I assigned it to an uppercase variable (so we don't hit the limit) so we can use it to construct both the print and the Hello, World! strings that can be used like above.

Ah, well done! I was thinking of using next instead of char which doesn't work on Lua 5.3 due to randomization of iteration order.

JavaScript (ES6) By Ephellon Dantzler
{length:1, charCodeAt:()=>(e='Hello, World!', String.fromCharCode=()=>'')}
Try it online!
That was pretty easy.
I noticed that any string inputs wouldn't be possible to output Hello, World! because the whole thing inside String.fromCharCode will only return multiples of 4, and ! has a char code of 33. So clearly we just have to hack the whole program. Hacking built-ins in JavaScript is trivial if one doesn't try to stop them (and even if one does so, there are usually lots of workarounds...).

JavaScript (ES6), Voile
Simple proxy that only returns the wanted character every 3rd time it's called.
var i = 0;
var string = "Hello, World!";
var proxy = new Proxy([], {
  get: function(target, property) {
    if (!(++i%3)) {
      return string[property];
    }
    return [1];
  }
});

Try it online!

Yes, this is the intended solution :) Proxy needs more love.

JavaScript: ThePirateBay
I override the valueOf() and toString() methods of the parsed objects so that coercion fails with a TypeError.
{"valueOf": 7, "toString": 7}

Umm, I can't seem to understand. Please elaborate or something? Especially the dalksdjalkdjaS djalksdjalksdja part, it somewhat confuses me.

@EriktheOutgolfer I edited out the spam part, but I have no idea why it was there.

@EriktheOutgolfer oh lol. That was passing to stop my answer from auto-converting to a comment.

@Maltysen Well there's an [edit] button right there which can be useful next time ;)

CJam, Erik the Outgolfer
q5/:i:c

 00072001010010800108001110004400032000870011100114001080010000033

Try it online!
How?
q       - Take input (string)
 5/     - split into chunks of five
   :i   - cast to integers
     :c - cast to characters

C# (.NET Core), Grzegorz Puławski
The solution I found makes very substantial use of unprintable characters, so attempting to paste it here didn't work well. The byte values for the input are:
109, 89, 4, 121, 3, 11, 8, 29, 37, 38, 27, 25, 72, 4, 4, 4, 3, 3, 3, 4, 4, 37, 3, 27, 4, 3

Or the string version is available in the input field of the TIO link.
Try it online!
The original program would take the distinct characters in the input, then reverse the input and multiply the elements of the two lists. Thus I created a string 26 characters long where the first 13 characters were distinct, the last 13 characters all also appeared in the first 13, and each pair of indexes [i, 26-i] multiplied to the byte value of the i-th character in Hello, World!.

Great job! You managed to omit the Take(a.First()-33) trap. It also made me realise I forgot Disctinct on the Reverse, but oh well, still made for a nice challenge I think. Also it had %255 so you could use higher numbers, in printable ASCII.

Ly, LyricLy
n[>n]<[8+o<]

 2 25 92 100 106 103 79 24 36 103 100 100 93 64

Try it here (although the page does not render the newline).
n takes input, trys to split on spaces and cast to ints, these get put on the stack. o prints ordinal points, and 8+ does what one would think. So input needs to be 8 less than the codepoints in reverse order split by spaces.

This doesn't print a trailing newline, does it?

Ah oops, easily rectifiable!

...actually is it? I would have thought 2 would work - is that just the herokuapp page not rendering it?

Yeah, adding 2 works. The page just doesn't render trailing newlines.

C (gcc), by Felix Palmen
Original code:
#define O(c)(((char**)v)+c)
#define W(c)*(O(c)-**O(2)+x)
main(x,v){puts(W(42));}

Arguments:
"Hello, World!" ","

Try it online!
Explanation:
W(c) is calculating the address of a string from the argument list to print out. It starts with the address of the cth argument (O(c)), which is the 42nd argument in this case, and then subtracts the first character of the second argument (**O(2)) as an integer offset, and then adds x, which is the number of arguments.
W(c) uses the second argument, so you know there need to be at least 3 of them (0, 1, 2). Then "Hello, World!" can go in the first argument, and then to address that argument you need a character whose ASCII value fits in the equation "42-x+3=1". That happens to be ",".

Great explanation, I'll edit my post as soon as I'm on a PC :)

6502 Assembly (C64) - Felix Palmen

The correct answer is ,52768,23

The explanation is slightly involved.
00 c0                          ;load address
20 fd ae      jsr $aefd        ; checks for comma
20 eb b7      jsr $b7eb        ; reads arguments

The code first checks for a comma (syntax necessity) and then reads in two arguments, the first of which is a WORD, stored little-endian in memory location 0014 and 0015, the latter of which is stored in the X register.
8a              TXA            ;Store second argument into A (default register)
0a              ASL            ; bitshifts the second argument left (doubles it)
45 14           EOR $14        ; XOR that with the low byte of first argument
8d 21 c0        STA $c021      ; Drop that later in the program

That's pretty clever, using our input to rewrite the program. It eventually rewrites the counter for the output loop at the end of the program.
45 15           EOR $15        ; XOR that with the high byte of the first argument
85 15           STA $15        ; Put the result in $15
49 e5           EOR #$e5       ; XOR that with the number $e5
85 14           STA $14        ; Put that in $14

Here comes the devious part:
8e 18 d0        STX $d018      ; stores the original second argument in d018

on the C64, d018 is a very important byte. It stores the reference points for things involving the screen's output. See here for more info. If this gets a wrong value, it will crash your C64. In order to print the requisite mixed upper and lowercase letters, this needs to be $17.
Now we begin our output loop:
a0 00               ldy #$00       ; zeroes out the Y register
b1 14               lda ($14),y    ; puts the memory referenced by the byte
                                   ;   starting at $14 (remember that byte?)
                                   ;   into the default register
20 d2 ff            jsr $ffd2      ; calls the kernal routine to print the char stored in A
c8                  iny            ; increment Y
c0 0e               cpy #$0e       ; test for equality with the constant $0e

That constant is what got written over before. It clearly determines how long the loop runs. It happens to be the right value already, but we need to stick 0e there again.
d0 f6                   bne *-8        ; jump back 8 bytes if y and that constant weren't equal
60                      rts            ; ends the program

The rest is just the information which we need to print out, starting at memory address c025.
So it's just following the math from there.

Absolutely correct, congrats. Might take me a while to properly edit my post, I'm on mobile now.

The d018 was very clever, and i like how you posted a hint secretly.

d018 was the intended door-opener ... the hint was accidental, i meant $FF there, but then decided to leave it.

6502 Machine Code (C64) - Felix Palmen
The correct answer is

8bitsareenough

The code is rather complicated, involving a lot of self modifying. So instead of fully reverse engineering it, you can just use it to crack itself.
Here's a slightly more helpful disassembly of the code, to help understand what happened. The syntax is for KickAssembler.
*=$c000       // LOAD ADDRESS
jsr $aefd     //checks for a comma
jsr $ad9e     /*Reads in an argument. Stores length of it into
                $61, with the address of the stored arg in $62-3*/
jsr $b6a3     /*Evaluates the string, leaving the pointer on $22-3
                and the length on A*/ //I think

ldy #$00
loop: lda thedata,y
cpy #$01
beq shuffle
cpy #$07
beq shuffle
cpy #$0b
beq shuffle
tricks: jsr output
iny
bne loop
output: eor ($22),y      //XOR's A with the y-eth letter of our input
jmp $ffd2               //good old CHROUT, returns to tricks above
thedata: .byte $f0,$48,$fa,$a2, $1c,$6d,$72,$30
.byte $06,$a9,$03,$48,$7c,$a3
shuffle: sta $c048      //drops A in mystery+4, over the constant
lda $c026,y
sta $c045               //overwrites the low byte of mystery
lda $c027,y
sta $c046               //overwrites the high byte of mystery
ldx #$00
mystery: lda $aefd,x
eor #$23
jsr output
iny
inx
cpx #$03
bne mystery
cpy #$0e
bne loop
eor #$1a
sta $d018
rts

Labelling it up like this was enough for me to see that the code XORs a bunch of constants that are hidden around in order to print out what we need. Since XOR is reversible, if you input the desired output, it'll tell you what the key is.
So I switched the last line
/*from sta $d018
to*/ jsr $ffd2

so it would print the last required input instead of crashing on a wrong input.
And that's that!
If there's any interest, I'll crack the code more.

Wow, this is in fact a huge shortcut, I probably should have forced a crash on wrong input earlier in processing. There was another shortcut possible btw, using the debugger of vice. But whatever, it's the correct solution.

I didn't know that vice has a debugger. This is what I get for learning a language just to crack answers.

Edited my post, with some explanations. Good job, just modifying the program not to crash of course is a quite obvious way, I didn't think of this.

Nitpick: "drops A in mystery+1, over the constant" <- that's actually mystery+4 with your label. Offests are in bytes :) and FWIW, self-modification is quite common even in serious 6502 code, as long as the code runs from RAM.

Explode, Step Hen
@_?&4_-j>5&f^~c>&6\|4>7

 Rh/qi?,Wcr+du

Try it online!

Trying to work out what all the "explorers" are actually doing hurts one's head too much, so I just reverse engineered it (literally :p - starting from the rightmost character I offset each in turn along [and around] the printable character range).

Good job :) I'll add an explanation in a couple hours when I'm back at my PC

C (tcc) by Joshua
int puts(const char *s)
{
    printf("Hello, World!%s", s);
}

Try it online!

Darn. I had this exact crack but couldn't get it working on TIO. +1

Sorry 'bout that. Fwiw it's fixed now.

Do you know what the problem was?

I know how I fixed it (tcc had to be built with SELinux support), but I'm not sure what that does or why it was needed in the first place.

MATL by Luis Mendo
tsZp?x

Try it online!

Jelly by Jonathan Allan
Original code:
œ?“¥ĊɲṢŻ;^»œ?@€⁸ḊFmṪ⁷

Try it online!
Input:

1,2586391,2949273,3312154,3312154,1134001,362881,2223505,766081,1134001,1497601,3312154,1860601,140

Explanation:

Mainly, it is necessary to understand what the code does. The first thing it does is it takes the string "!,Word Hel" (with all the needed characters except newline) and creates a bunch of permutations of them. The inputs specify permutation numbers, and each pair of permutations from the input is applied to the string exluding pairs where the first permutation is applied first. Basically, P2(P1(S)), P2(P2(S), P2(P3(S)), ..., P2(PN(S)), P3(P1(S)), ..., P3(PN(S)), ... ..., PN(P1(S)), ..., PN(PN(S)). These are all concatenated together. Then the last input is reused to take every PNth character from this big string. So, I take PN = len(S)*N = 10*N. This means we'll take the first character of P2(P1(S)), the first character of P3(P1(S)), all the way up to the first character of PN(P1(S)). To simplify further, I let P1 = 1 which is the identity permutation. Then it suffices to choose any P2 that permutes "H" into the first position, a P3 that permutes "e" into the first position and so on. Luckily, small permutation numbers like the one already chosen for PN don't affect the earlier characters in the string, so PN leaves "!" at the beginning of the string. (If this wasn't true, it would still be possible to solve by choosing a different P1.)

It takes 14 permutations of the list of the 14 permutations, flattens, dequeues and then takes every 140th character.

JavaScript (ES6), Voile
Given the 81 character limit, this probably isn't the intended solution
global.g = ()=>"Hello, World!";
var str = "g";

Try it online!

Genious. passing one char string with global manipulation. Seems, that it is intended solution

That's not the intended solution :(

Now that I'm thinking about it, I don't think it's allowed to do tons of stuff like this before passing input in a function, unless said stuff can also be composed as part of the input (e.g inside the function which will be evaluated inside), since the challenge requires you to make a input that will result in 'Hello, World!', not a full program. Otherwise pretty much nothing can be safe. So I think this crack might be invalid?

@Voile It very well may be. I think it's fair to read the task as if the input must stand alone (i.e. without changes to the external system) - especially if this isn't the intended solution :) No need to mark your cop as cracked.

My idea of the definition of input is like this: you can put your input inside a standalone variable (e.g var answer=/*something*/, in which passing this variable into the function gives you the target result. Putting global assignments inside a thunk function which is evaluated inside cop function is okay because the variable itself will do all the necessary work. Straight out doing assignments before function evaluation is definitely off the limits, though.

@Voile Anyway suggest to add link to this crack with mark of "unintended". You don't specified input conditions. But if you can find [meta] post, that set this rule by default, this crack will be annulated.

I've made a meta post discussing about this. Feel free to leave some discussions there.

@Voile If this is invalid, can't the answer be changed to [g=()=>"Hello, World!\n","g"][1] to make it valid? f([g=()=>"Hello, World!\n","g"][1]) => Hello World!\n

@milk No, because the input passed ("g") relies on non-input (it relies on having a global variable set) to work. If the passed input set the global variable (e.g. if the input was 'g=()=>"Hello, World!",g'), then it would be valid.

The global variable is set as part of the input and conforms to the f(something) usage.

@milk No the global variable is set as part of the statement that's between the parentheses when calling the function - it is not, however, given as input. The statement [g=()=>"Hello, World!","g"][1] evaluates to "g", and only that string is given as input. f never sees the declaration.

><> by Not a tree
This was an EPIC puzzle!  I loved it!
Example solution:

 TIHANICWHITEOCPSEARK

Wish I could upvote Not a tree's post three more times.

Does anybody know if it is possible to add a hidden answer that contains a block of code/preformatted text?

Well done! Your solution isn't identical to mine, but it's functionally the same. I'm glad you enjoyed the puzzle!

And you can make a hidden codeblock (with difficulty) by surrounding it with <pre><code> ... </code></pre> instead of the usual four-spaces method, and using
 instead of newlines.

TeX, by A Gold Man
Original source:
\read16to\x\message{Hello, World!}\bye

This already prints Hello, World!, but the newline is missing. The input is just placed in \x which is never used. In order to be able to modify the output, I guess we need to do some preparations (like, "lay a trap") before calling this code, so \x is actually expanded. It can be done when invoked like this (assuming the original source is in x.tex in the current directory):
tex '\def\vfill{\x}\input./x'

This first redefines \vfill (which is part of the expansion of \bye) to expand to our \x, so now we can provide some input printing the missing newline:
\newlinechar=`@\message{@}

This sets the character used for newlines in \message to @ and immediately uses it.

This whole thing modifies the environment the original program will run in, so if there are any objections to this method, I'll retract it.

Not what I had in mind, but very clever. The intended solution is way more evil. I'll consider myself cracked.

Just for the record, I thought that you were going to \let \message to \relax, which would then typeset the hello world with a newline (implicitly). But this is way better.

@AGoldMan There's an ongoing meta discussion about what form of input is allowed, I posted an answer for discussion there about your cop. If you're sure your intended solution works with any TeX implementation, I'd say feel free to consider my crack invalid and you're probably on a straight line to winning the cop part of this challenge (and I might score second as noone attempted to crack my C64 code so far, hehe)

Brainfuck by 2EZ 4RTZ
Correct input:
Gdkkn+\x1fVnqkc \x09\xff, where \xHH indicates non-ASCII-printable hex character.
Explanation:
You just take the character codes of "Hello, World!\n" and subract one from each value.  The last character \xff (255) causes the program to exit after you add one (since the 255+1 overflows to 0 and the loop exits).

Darn, I had this crack but couldn't get it working on TIO ;-; +1

Yeah, TIO doesn't work, that's what had me tripped up all this time.

Is this valid as the interpreter linked is specifically TIO? (on which 0xFF doesn't work from what I've tried)

I wrote a BF interpreter for fun once, so I passed input from a C program where I could specify hex inputs : )

@dzaima lol TIO doesn't work. I just linked it since lazy.

@2EZ4RTZ Should've mentioned it. I had a solution in half a minute but couldn't get it to work on TIO (s brainfuck).

@dzaima well here is the thing. I did that too. I felt like cracking should end up going the same way

C (GCC on TIO) by MD XF
4195875

Try it online!
How?
It tries to print the second argument as a string, which is a pointer we can determine on the input. It just so happens that at location memory 4195875 starts the "Hello, World!\n" string.
The number was determined by adding print("%p", "Hello, World!"); before the printf, converting the hexadecimal number to decimal and tried it out on the original TIO. However, it showed me the printf format string. By trying out some numbers, I found out that the string is located before the format string.
So in memory, it would look like this (as a C string):
Hello, World!\n\0%2$s\0

This also means that any update to the compiler might break the solution.

JavaScript (Node.js) By Voile
['Hello, World!','','','','','','','','','','','','']
Try it online!

Röda by fergusq
[1, "HH", 1, "eellloo", 1, ",,", 1, "  WWoo", 1, "rr", 1, "ll", 1, "dd", 1, "!!"]

Try it online!
Explanation coming in a bit...

JavaScript (ES6), Voile
var i = 0;
var string = `"${t}"`;
var answer = "i++?0:q=string";
console.log( f(answer) );

Try it online!

That's not the intended solution :) I'll fix it and be back later.

PHP by LP154
PDO,FETCH_CLASSTYPE

Try it online!
(TIO doesn't have the PDO class defined, so the above demo uses a codepad that does)
Another solution:
ReflectionFunction,IS_DEPRECATED

Try it online!

Perl 5, by Chris
Original code:
eval<>;END{print$x='x'}

Input:
our $x;package X;require Tie::Scalar;@ISA=qw(Tie::Scalar);sub TIESCALAR{my$v;return bless\$v,'X';}sub STORE{}sub FETCH{return "Hello, World!\n"}tie $x,'X';

I'm not sure this is the intended solution. It works by changing the behavior of $x using a tie. The tie here is very simple, ignoring any STORE access and returning our desired output for any FETCH.
Try it online!

Pretty much my intended solution, yes.

I thought this was not cracked (forgot to refresh the cop thread), so I found this (simple) solution : print"Hello, World!\n";close(STDOUT);.

That's a nice trick!

JavaScript (ES6), Voile
Input:
!(v.call=()=>true)||"()=>`Hello, World!\n`"

Cop code:
const e=eval,p=''.split,c=''.slice,v=[].every,f=s=>(t=c.call(s),typeof s=='string'&&t.length<81&&v.call(p.call(t,`\n`),l=>l.length<3)&&e(t)(t))

Try it online
This overwrites the v.call() method to always return true, but that part of the input is falsified and discarded for the string part which passes the string type check and length check, and eval's to the desired output Hello, World!\n.
If Birjolaxew's crack is not accepted, maybe this one will.

authors: Евгений Новиков

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


text:
Find the longest rep digit
Your task is to take a positive number as input, n, and output the length of the longest rep-digit representation of n in any base. For example 7 can be represented as any of the following
111_2
21_3
13_4
12_5
11_6
10_7
7_8

The rep-digits are 111_2 and 11_6, 111_2 is longer so our answer is 3.
This is a code-golf question so answers will be scored in bytes, with fewer bytes being better.
Test Cases
1   -> 1
2   -> 1
3   -> 2
4   -> 2
5   -> 2
6   -> 2
7   -> 3
8   -> 2
9   -> 2
10  -> 2
11  -> 2
26 -> 3
63  -> 6
1023-> 10

Sample implementation
Here is an implementation in Haskell that can be used to generate more test cases.
f 0 y=[]
f x y=f(div x y)y++[mod x y]
s x=all(==x!!0)x
g x=maximum$map(length.f x)$filter(s.f x)[2..x+1]

Try it online!

Asuming base > 1 ?

@H.PWiz Yes.  base 1 doesn't really make any sense.

...and input >= 3 I guess :)

@JonathanAllan No, input can be as small as 1.  Is there a problem with that?

Oh OK, just makes 2 an edge case (the base being higher than the input)

@JonathanAllan Yes 1 and 2 are edge cases, but to be clear you are not outputting the base with the longest rep digit just the length.

you can add test cases 63->6 and 1023->10 if you like

Rep-digits can use any digit, not just 1, right? I think it would be good to have more test cases to cover those.

@WheatWizard I think 26 does it for instance, it's 222 in base 3.

222,333,444,555,666,777,888,999 all work here are the first 69 if my code is correct (including the edge case of 2)

@xnor I must have made a mistake.  I'll add that right away. :)

Can bases go above 10?  If so, for bases > 10, should we include characters a-z?  What about bases > 36?

@RickHitchcock Bases can go arbitrarily high.  Since you don't have to output any numbers in any base other than 10, I don't care how you represent other bases, but they should work for bases larger than 36.

Jelly,  9  7 bytes
-2 thanks to caird coinheringaahing (‘Ḋ$ -> ‘€ and use of the newer alias for Ðf, Ƈ.)
b‘€EƇZL

A monadic link accepting and returning numbers
Try it online! or see a test suite (inputs one to 32 inclusive).
How?
b‘€EƇZL - Link: number, n
  €     - for each (i in [1..n]):
 ‘      -   increment = i+1
        - -> [2,3,4,...,n+1]
b       - convert (n) to those bases
    Ƈ   - filter keep if:
   E    -   all elements are equal
     Z  - transpose
      L - length (note:  length of the transpose of a list of lists is the length of the
        -                longest item in the original list, but shorter than L€Ṁ)

Or maybe I should have done:
b‘€EƇZLo1

...just for the Lo1z.

So...I'm not the only one to have figured out ZL is shorter than L€Ṁ...

7 bytes

@cairdcoinheringaahing Good spot on the ‘€, this was about a year into my use of Jelly, I should probably have known better by then!

JavaScript (ES6), 62 bytes

f=(n,b=2,l=0,d=n)=>d?n%b<1|n%b-d%b?f(n,b+1):f(n,b,l+1,d/b|0):l
<input oninput=o.textContent=f(this.value)><pre id=o>

I love the unnecessarily golfed test HTML

Haskell, 86 81 79 bytes
2 bytes saved thanks to Laikoni
0!y=[]
x!y=mod x y:div x y!y
length.head.filter(all=<<(==).head).(<$>[2..]).(!)

Try it online!
Since this has died down a bit, here's my approach.  It's a golfed version of the sample code I made for the question.  I think it can definitely be shorter.  I just thought I'd put it out there.

Pointfree is a bit shorter: length.head.filter(all=<<(==).head).(<$>[2..]).(!).

@Laikoni Thanks! For some reason I wasn't able to figure out how to get it into point-free notation.

I can recommend http://pointfree.io/ which is based on the point free converter of lambdabot.

@Laikoni I use pointfree.io quite a bit.  I must have not tried it here.  I usually get pretty good results though.

Husk, 13 11 bytes
-2 bytes thanks to zgarb
L←fȯ¬tuMBtN

Try it online!

mm can be M, and ṠoΛ=← can be ȯ¬tu. There's not yet a built-in for checking that all elements of a list are equal...

M is not even on the wiki yet :(

ΓoΛ= also works as four bytes

Oops, M should be in the docs, since we've had it for a while. I should fix that. But it's basically the dual of Ṁ.

05AB1E, 8 bytes
L>вʒË}нg

Try it online!
-1 thanks to kalsowerus.

L>вʒË}нg for 8 bytes

@kalsowerus Didn't know you can use lists like that...thanks!

Mathematica, 71 bytes
Max[L/@Select[Array[a~IntegerDigits~#&,a=#,2],(L=Length)@Union@#==1&]]&

Try it online!

Brachylog, 12 bytes
+₁⟦₁b∋;?ḃ₍=l

Try it online!

Python 3, 92 87 bytes
5 bytes thanks to Halvard Hummel.
g=lambda n,b,s=1:s*(n<b)or(n%b**2%-~b<1)*g(n//b,b,s+1)
f=lambda n,b=2:g(n,b)or f(n,b+1)

Try it online!

-5 bytes

APL (Dyalog Unicode), 28 26 bytes
Saved 2 bytes thanks to Adám!
{⌈/≢¨⍵/⍨1=≢∘∪¨⍵}⊢⊥⍣¯1⍨¨1+⍳

Try it online!
Pretty straightforward implementation.
{⌈/≢¨⍵/⍨(1=≢∘∪)¨⍵}⊢⊥⍣¯1⍨¨1+⍳
                           1+⍳ ⍝ Make a range [2, n + 1]
                          ¨   ⍝ For each b in that range
                   ⊢⊥⍣¯1⍨    ⍝ Interpret n in base b (gives a vector of integers)
     ⍵/⍨                      ⍝ Keep the representations where
         1=≢∘∪¨⍵             ⍝ it's a repdigit
              ¨⍵             ⍝ For every representation,
          ≢∘∪                 ⍝ is the length of it, without duplicates
        1=                    ⍝ equal to 1?
   ≢¨                         ⍝ Get the length of each of the remaining representations
 ⌈/                           ⍝ Get the biggest length

You can remove the parenthesis with no change in functionality (though you'll gain a speed-up).

@Adám Thanks, I didn't think to take advantage of APL's arrayness

Husk, 7 bytes
LḟEMBtN

Try it online!
Explanation
LḟEMBtN
     tN  on numbers 2,3,4...
   MB    map input to digits in base 2,3,4...
 ḟE      find first list that only has one unique element
L        length of that

Mathematica, 58 bytes
FirstCase[#~IntegerDigits~Range[#+1],l:{a_ ..}:>Tr[1^l]]&

Throws an error (because base-1 is not a valid base), but it is safe to ignore.
Of course, it is okay to take the length of the first repdigit (FirstCase), since numbers in lower bases cannot be shorter than in higher bases.

TI-BASIC, 37 bytes
Input N
For(B,2,2N
int(log(NB)/log(B
If fPart(N(B-1)/(B^Ans-1
End

Prompts for N, returns output in Ans.
Explanation
As an overview, for each possible base B in sequence it first calculates
the number of digits of N when represented in base B, then checks whether N is divisible by the value represented by that same number of 1-digits in base B.
Input N            Ask the user for the value of N.
For(B,2,2N         Loop from base 2 to 2N. We are guaranteed a solution
                   at base N+1, and this suffices since N is at least 1.
int(log(NB)/log(B  Calculate the number of digits of N in base B,
                   placing the result in Ans.
                   This is equivalent to floor(log_B(N))+1.
          (B-1)/(B^Ans-1   The value represented by Ans consecutive
                           1-digits in base B, inverted.
If fpart(N         Check whether N is divisible by the value with Ans
                   consecutive 1-digits, by multiplying it by the inverse
                   and checking its fractional part.
                   Skips over the End if it was divisible.
End                Continue the For loop, only if it was not divisible.
                   The number of digits of N in base B is still in Ans.

CJam (17 bytes)
{_,2>3+fb{)-!}=,}

Online test suite. This is an anonymous block (function) which takes an integer on the stack and leaves an integer on the stack.
Works with brute force, using 3 as a fallback base to handle the special cases (input 1 or 2).

Perl 6, 49 bytes
{+first {[==] $_},map {[.polymod($^b xx*)]},2..*}

Try it online!
Explanation
{                                               }  # A lambda.
                  map {                   },2..*   # For each base from 2 to infinity...
                        .polymod($^b xx*)          #   represent the input in that base,
                       [                 ]         #   and store it as an array.
  first {[==] $_},                                 # Get the first array whose elements
                                                   # are all the same number.
 +                                                 # Return the length of that array.

The polymod method is a generalization of Python's divmod: It performs repeated integer division using a given list of divisors, and returns the intermediate remainders.
It can be used to decompose a quantity into multiple units:
my ($sec, $min, $hrs, $days, $weeks) = $seconds.polymod(60, 60, 24, 7);

When passing a lazy sequence as the list of divisors, polymod stops when the quotient reaches zero. Thus, giving it an infinite repetition of the same number, decomposes the input into digits of that base:
my @digits-in-base-37 = $number.polymod(37 xx *);

I use this here because it allows arbitrarily high bases, in contrast to the string-based .base method which only supports up to base 36.

You can remove the [] around polymod by changing $_ to @_

K (ngn/k), 24 bytes
{|/x{#{1=#?x}#y\x}'2+!x}

Try it online!

x{...}'2+!x call the inner {...} lambda on the input n, paired up with each number from 2..n+1

y\x convert the input to the current base
{1=#?x}# filter down to representations containing only a single unique digit
# return the length of this representation (0 if it contained multiple digits)

{|/...} return the maximum across all potential bases

Pyth, 13 bytes
lhf!t{TjLQ}2h

Try it online!

Java 8, 111 bytes
n->{int r=0,i=1,l;for(String t;++i<n+2;r=(l=t.length())>r&t.matches("(.)\\1*")?l:r)t=n.toString(n,i);return r;}

Byte-count of 111 is also a rep-digit. ;)
Explanation:
Try it here.
n->{                            // Method with Integer as parameter return-type
  int r=0,                      //  Result-integer
      i=1,                      //  Index-integer
      l;                        //  Length-integer
  for(String t;                 //  Temp-String
      ++i<n+2;                  //  Loop from 2 to `n+2` (exclusive)
      r=                        //    After every iteration, change `r` to:
        (l=t.length())>r        //     If the length of `t` is larger than the current `r`
        &t.matches("(.)\\1*")?  //     and the current `t` is a rep-digit:
         l                      //      Change `r` to `l` (the length of the rep-digit)
        :                       //     Else:
         r)                     //      Leave `r` as is
    t=n.toString(n,i);          //   Set String representation of `n` in base-`i` to `t`
                                //  End of loop (implicit / single-line body)
  return r;                     //  Return the result-integer
}                               // End of method

Lambdas were introduced in Java 8.

@Jakob Woops.. Not sure why I typed 7.. Either because I recently looked back at a Java 7 answer of mine, or just a typo.. Thanks for the correction either way, should of course have been 8... >.>

Java 8, 79 bytes
A lambda from Integer to Integer.
n->{int m,b=2,l;for(;;b++){for(m=n,l=0;m>0&m%b==n%b;l++)m/=b;if(m<1)return l;}}

Ungolfed lambda
n -> {
    int m, b = 2, l;
    for (; ; b++) {
        for (m = n, l = 0; m > 0 & m % b == n % b; l++)
            m /= b;
        if (m < 1)
            return l;
    }
}

Checks radices in increasing order from 2 until a rep-digit radix is found. Relies on the fact that the smallest such radix will correspond to a representation with the most digits.
m is a copy of the input, b is the radix, and l is the number of digits checked (and ultimately the length of the radix-b representation).

Burlesque, 24 bytes
(see correct solution below)
J2jr@jbcz[{dgL[}m^>]

See in action.
J2jr@ -- boiler plate to build a list from 2..N
jbcz[ -- zip in N
{dgL[}m^ -- calculate base n of everything and compute length
>]    -- find the maximum.

At least if my intuition is right that a rep-digit representation will always be longest? Otherwise uhm...
J2jr@jbcz[{dg}m^:sm)L[>]

:sm -- filter for "all elements are the same"

Base-2 representation will always be longest, try for example with input 26 and you'll see that your first solution is incorrect

Ruby, 60 bytes
->n{(2..n).filter_map{d=n.digits _1
!d.uniq[1]&&d.size}.max}

Attempt This Online!

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


text:
What's the date, in Usenet time?
September 1993 is known on Usenet as the September that never ended. Thus, for example, the day this question is being posted is Saturday, September 8740, 1993.
Your program or function should take any Gregorian date (with positive year) as input and return the same date as output if it's prior to September 1993 or the date on the September 1993 calendar if thereafter.
You may accept YYYY-MM-DD, YYYY/MM/DD, MM/DD/YYYY, DD/MM/YYYY, D-Monthnameabbr-YYYY, or any other popular format that uses the entirety of the year (as opposed to the year modulo 100). You need only accept one such format, of your choosing. Output format must match the input format.
Sample input → output:

Sunday, 6 August 2017 → Sunday, 8741 September 1993
Tuesday, 28 January 1986 → Tuesday, 28 January 1986

Or:

2017-08-06 → 1993-09-8741
1986-01-28 → 1986-01-28

In the interest of more interesting answers, the use of a built-in function designed for this purpose (such as the UN*X sdate command) is disallowed. Aside from that and the standard exceptions, this is golf, so the shortest answer wins.

you mean I can't use DateDifference so that people here can comment on Mathematica's builtins???

@Jenny_mathy, this DateDifference? I guess you can use it, yeah, why not?

JavaScript (ES6), 48 bytes

f=
s=>(d=new Date(s)/864e5-8643|0)>9?'1993-09-'+d:s
<input size=10 oninput=o.textContent=/\d{4}(-\d\d){2}/.test(this.value)?f(this.value):``><pre id=o>

Based on @Mr.Xcoder's algorithm.

Python 3, 109 bytes
from datetime import*
i=input()
z=date(*map(int,i.split())).toordinal()-727806
print([i,'1993 09 %d'%z][z>9])

Try it online!
-59 bytes thanks to notjagan
-3 bytes thanks to Mr. Xcoder
-2 bytes thanks to officialaimm
-12 bytes thanks to Jonathan Allan

-54 bytes.

Or better yet, -59 bytes.

123 bytes (-62)

-8644+1 can be -8643..

@Mr.Xcoder Needs to be z>9 otherwise you lose the leading zero on the day.

109 by improving further upon the above comments: d=datetime(*map(int,i.split()));z=d.timestamp()/86400-8644+1 -> z=date(*map(int,i.split())).toordinal()-727806.

Mathematica, 55 bytes
If[(s=#&@@{1993,9}~DateDifference~#)>0,{1993,9,s+1},#]&

I/O

{2017, 8, 6}  ->{1993, 9, 8741}
{1986, 1, 28}->{1986, 1, 28}

-6 bytes thanx to user202729

Would you consider shift the time mark {1993,9,1} back by a day, so as to remove the +1, saving 2 bytes?

Thanks. I should try to be more polite next time. And I don't even know {1993,9,0} is allowed.

Perl 5, 102 + 16 (-MTime::Local -F-) = 118 bytes
$,='-';say @F=($t=timelocal(0,0,0,$F[2],$F[1]-1,$F[0]-1900)-749433599)>0?(1993,'09',31+int$t/86400):@F

Try it online!
Takes the date as "YYYY-MM-DD"
I think I did the count right on the command line options.  I'm sure someone will correct me if I didn't.

C# (.NET Core), 107 bytes
s=>{var d=(System.DateTime.Parse(s)-new System.DateTime(1993,8,31)).TotalDays;return d<1?s:"9/"+d+"/1993";}

Try it online!
Takes dates as M/D/YYYY (numbers below 10 written with only 1 digit). Written from my mobile phone using the API by heart.

Gaia, 78 bytes
ℍZ¤∨4Ė
:'//d¦[1993₉31];>\{\‡:(…1993>↑¦365+¦¤ṇ↑∂K∂k,=;((<¤)-243]_ḥΣ“1993/09/”¤+}?

Try it online!
Explanation
First, we have a helper function that determines if a year is a leap year.
ℍ       100
 Z      Divmod year by 100, pushing the first 2 digits, then the second 2 digits
  ¤     Swap
   ∨    Logical OR, gives the left-most non-zero number
    4Ė  Check for divisibility by 4

The main function does the rest of the work:
:              Push two copies of the input.
'//            Split the top on on slashes.
d¦             Parse each section as a number.
[1993₉31]      Push the list [1993 9 31].
;>             Copy the date and check if its less than that.
\              If it is, delete the list and leave the input string on top.
{              Else:
 :(             Copy the date and get the year.
 …1993>         Get the range from 1993 to year-1.
 ↑¦365+¦        Map each to 365+(whether it's a leap year).
 ¤              Swap, bring the date back to the top.
 ṇ↑             Pull out the year and check if it's a leap year.
 ∂K∂k,          Push the pair of lists [[days in months in a leap year] [days in months]]
 =              Index the result of checking if the year is a leap year into the pair.
 ;((<           Get the first (month number - 1) elements.
 ¤              Swap, bring date back to the top.
 )              Get the day.
 -243           Push -243 (243 is the number of days between Jan 1 1993 and Sept 1 1993).
 ]              Wrap everything in a list.
 _              Flatten the list.
 ḥ              Remove the first element (the input string).
 Σ              Sum it.
 “1993/09/”¤+   Append the resulting number to "1993/09/".
}?             (end if)
               Implicitly display whatever is on top of the stack.