44
\$\begingroup\$

This challenge has two threads. This is the cops' thread. The robbers' thread is located here.

Your challenge is to choose an OEIS sequence and write two full programs in two different languages that produces that nth item in the sequence when given an n via STDIN, or an other forms of standard input, where n is any positive number. However your two programs must be anagrams, meaning each can be rearranged from the other's letters.

Programs must output the decimal of the number followed by optional whitespace to STDOUT. Programs may output to STDERR however it should be ignored and if the hidden case does so it must be clearly stated that this is the case.

If you wish you may also output by character code. However if you do so in your hidden solution you must state such in the body of your submission.

You will then present the OEIS number, the source code for and the name of one language it is in.

Robbers will crack your submission if they find an anagram of the original submission that runs in a language other than the one you already presented. To crack an answer they must only find any language and program which produces the sequence and is an anagram of the original, not necessarily the answer the you were thinking about.

Thus you are incentivized to make it as hard as possible to find any language that does the task using their list of symbols.

Scoring

This is so the shortest un-cracked program is the winner.

Languages

Languages will be considered different if the two proposed solutions do not complete the task in both languages. This will include different versions of the same language as long as neither the cop's solution or the robber's solution produce the correct output in the other's language.

i.e. If the there are two solutions 1 and 2 that are in language A and B respectively solution 2 must not produce the correct output in language A and solution 1 must not produce the correct output in language B.

Safety

Once your submission has been uncracked for a week you may post your solution and declare your post safe. If after a week you choose not to post a solution your answer may still be cracked.

\$\endgroup\$
26
  • 4
    \$\begingroup\$ To browse through random OEIS sequences for ideas, go to oeis.org/webcam \$\endgroup\$
    – mbomb007
    Nov 9, 2016 at 18:15
  • \$\begingroup\$ How would it work with languages that like to use flags to the interpreter, such as perl? Are they disqualified? Are flags counted as part of the code? Are flags "free" (not included in code or divulged at all)? \$\endgroup\$
    – Emigna
    Nov 9, 2016 at 19:19
  • \$\begingroup\$ Can the hidden program exit with an error (after producing the output)? Should that be indicated in the answer? \$\endgroup\$
    – Luis Mendo
    Nov 9, 2016 at 19:34
  • 1
    \$\begingroup\$ Not sure if this would be helpful to anyone else but this highlights any remaining missing characters or any duplicated ones: codepen.io/anon/pen/BQjxRK \$\endgroup\$ Nov 11, 2016 at 8:12
  • 1
    \$\begingroup\$ It'd be nice if there was a stack snippet to show uncracked answers, oldest first. \$\endgroup\$
    – mbomb007
    Nov 16, 2016 at 15:57

32 Answers 32

15
\$\begingroup\$

Python 2, 118 bytes, A042545 Cracked

i=input();s=1/(801**.5-28);a=[0,1]
for p in range(i):a+=[a[-2]+a[-1]*int(s)];s=1/(s-int(s))
print a[i]#,,,.//000fhlmo|

I didn't feel like implementing a trivial sequence, so I decided to go with my PPCG user ID. I wrote this in the other language first, which should give you a clue about what that language is, though I'd bet 100 dollars that this will be cracked in a golfing language before it's cracked in the intended other language.

Note: Due to floating-point precision errors, this is only accurate up to an input of 14. The intended solution is the same way.

Intended solution, JavaScript (ES7)

for(i=prompt(),s=1/(801**.5-28),a=[1,0];i--;s=1/(s-n))
  n=s|0,a.unshift(a[1]+a[0]*n);
alert(a[0])  //#+2:[]giiiiinnpt

Works in pretty much the same way as the Python solution, though the sequence is stored largest-first rather than smallest-first due to the fact that JS does not support negative indexing.

\$\endgroup\$
7
  • 2
    \$\begingroup\$ I can't get the case of A042545(15) to work. OEIS says that it is 53000053, but your program says that it is 27666361 (at least on my machine). \$\endgroup\$
    – boboquack
    Nov 10, 2016 at 22:38
  • \$\begingroup\$ @boboquack The output for 16 is actually 53000053, but after that there doesn't seem to be any matching terms. I wonder why... \$\endgroup\$ Nov 11, 2016 at 1:33
  • \$\begingroup\$ Maybe a floating point error that gets progressively worse? \$\endgroup\$
    – boboquack
    Nov 11, 2016 at 1:45
  • 3
    \$\begingroup\$ Cracked. \$\endgroup\$
    – Dennis
    Nov 11, 2016 at 6:11
  • 1
    \$\begingroup\$ Dammit, I was right! :( This was as close as I got: gist.github.com/dom111/bd9be933cb8ccd0e303601bf73d525b6 Thanks for the workout anyway, I needed |() but just couldn't get them! \$\endgroup\$ Nov 11, 2016 at 14:34
10
\$\begingroup\$

Brain-Flak, 24 bytes, A000290, Safe

Yet another square solution. This time there is nothing but parentheses

({(({}[()])()){}[()]}{})

The intended solution was in Brain-Flueue, a version of brain-flak that uses queues instead of stacks. The program was:

({(({})[()]){}}{})[()()]

The languages are considered distinct because neither of the two programs halt when run in the other language.

\$\endgroup\$
12
  • \$\begingroup\$ This would work in Glypho if input/output using character code is allowed... \$\endgroup\$
    – jimmy23013
    Nov 9, 2016 at 21:51
  • \$\begingroup\$ @jimmy23013 what is Glypho? \$\endgroup\$
    – Wheat Wizard
    Nov 9, 2016 at 21:51
  • 6
    \$\begingroup\$ esolangs.org/wiki/Glypho ((([{}{}{]]}[)))((){))(} \$\endgroup\$
    – jimmy23013
    Nov 9, 2016 at 21:52
  • \$\begingroup\$ @WheatWizard If it's cracked, can you edit the answer to show that? \$\endgroup\$
    – mbomb007
    Nov 11, 2016 at 16:52
  • \$\begingroup\$ @mbomb007 It is not cracked \$\endgroup\$
    – Wheat Wizard
    Nov 11, 2016 at 16:59
7
\$\begingroup\$

Python 2, 38 bytes, A000290 Cracked by Emigna

def e(X):return X*X
print e(input())##

This will probably be very easy to crack. I'm mostly posting this as a starting point.

Orignial solution in CJam:

ri:XX*e#def ()return X
e#pnt (input())
\$\endgroup\$
1
  • 2
    \$\begingroup\$ Cracked \$\endgroup\$
    – Emigna
    Nov 9, 2016 at 15:56
7
\$\begingroup\$

CJam, 7 bytes, A005843 Cracked!

ri2*e#^

This is a basic 2*n sequence.

Explanation:

r          e# read input
 i         e# convert to integer
  2*       e# multiply it by 2
    e#^    e# this is a comment that is ignored by the interpreter

Try it online!


Original Solution, Carrot

#^i*2er

Carrot is an esolang created by me. I have stopped developing it a long time ago. The reason I chose this is because I hoped that it would be hard for other languages to comment out the unnecessary parts of the code.

Explanation:

#^            This pushes the input to the stack (anything before the ^ is the stack)
  i           Convert stack to integer
   *2         Multiply it by 2
     er       These are ignored because they are not Carrot commands
              Implicit output

Try it online!

\$\endgroup\$
4
  • 1
    \$\begingroup\$ ri#e^*2 would work in Jelly if * were multiplication instead of exponentiation. So close... \$\endgroup\$ Nov 9, 2016 at 17:31
  • 3
    \$\begingroup\$ Cracked :). \$\endgroup\$
    – Adnan
    Nov 9, 2016 at 19:38
  • \$\begingroup\$ I had everything but the r in pyth. Exciting to see the original code for this one. \$\endgroup\$
    – Emigna
    Nov 9, 2016 at 20:34
  • 1
    \$\begingroup\$ @Emigna I added the original code \$\endgroup\$
    – user41805
    Nov 10, 2016 at 7:45
6
\$\begingroup\$

2sable, 15 bytes, A000290, Cracked!

Hopping on the same n2 train :p.

*?"!#$&<=@\^{|}

Try it online!

\$\endgroup\$
3
  • 2
    \$\begingroup\$ Almost looks like Malbodge with the symbols in order like that :P \$\endgroup\$ Nov 9, 2016 at 17:05
  • 3
    \$\begingroup\$ Cracked :D \$\endgroup\$ Nov 9, 2016 at 23:55
  • 1
    \$\begingroup\$ @ConorO'Brien Hahaha, I was pretty certain this wasn't possible in Jelly, Pyth, 05AB1E and MATL. Nice job! :) \$\endgroup\$
    – Adnan
    Nov 10, 2016 at 10:31
5
\$\begingroup\$

Brain-Flak, 44 bytes, A000290 Cracked

<({({})({}[()])}{}))()()()turpentine/"*"*4splint>

Try it online!


Original solution, Python 2

print(input()**(len(set("{}{}{}[]()<>"))/4))
\$\endgroup\$
3
  • 2
    \$\begingroup\$ Cracked :) \$\endgroup\$
    – Adnan
    Nov 9, 2016 at 16:00
  • \$\begingroup\$ Now I'm really curious. What was your original intended solution? I can tell it's python because I see len set input and print (and because I know you like python) but I can't figure out how that squares a number \$\endgroup\$
    – DJMcMayhem
    Nov 9, 2016 at 16:02
  • \$\begingroup\$ @DrMcMoylex added \$\endgroup\$
    – Wheat Wizard
    Nov 9, 2016 at 16:05
5
\$\begingroup\$

Excel, 12 bytes, A000012 Cracked

=IF(1=1,1,1)

Maybe not the toughest, but a fun one to crack.

\$\endgroup\$
1
  • \$\begingroup\$ Cracked \$\endgroup\$
    – Emigna
    Nov 9, 2016 at 20:31
5
\$\begingroup\$

Python 2, 25 bytes, A000583, cracked

Y=input("");print`Y**4`,X

This program exits with an error after printing the output.


My hidden code (substantially different from the cracked solution!):

Actually, 25 bytes

4,n`*`Y")ii(*nppruttY;="X

Try it online!

Explanation:

4,n`*`Y")ii(*nppruttY;="X
4,n                        input, repeat 4 times
   `*`Y                    do * until the stack stops changing (fixed-point combinator)
       ")ii(*nppruttY;="X  push this string and immediately pop and discard it
\$\endgroup\$
1
  • \$\begingroup\$ Cracked \$\endgroup\$
    – Adnan
    Nov 10, 2016 at 11:40
5
\$\begingroup\$

Python, 118 bytes, A042545, Safe

i=int(input());s=pow(801.0,0.5);a=[0|0,1]
for Moshprtflmah in range(i):s=1./(s%1);a+=[a[-2]+a[-1]*int(s)];
print(a[i])

This time it works in both 2 and 3. And there's no comments! What will you do?

Note: As with the old solution, this loses precision after the first 15 terms due to floating-point arithmetic errors.

Intended solution, JavaScript (ES6)

giiiiinnnnprt:
i=prompt([n=+2]);s=Math.pow(801,.5);for(a=[1,0];i--;a.unshift(a[1]+a[0]*(s|0)))s=1/(s%1)
alert(a[0])   

Though I kept several old versions, I somehow managed to lose this copy, but fortunately piecing it together from the others wasn't too hard. I see now that I had an extraneous prt in both programs that could have been golfed out. Oh well.

\$\endgroup\$
2
  • \$\begingroup\$ I thought I would remind you that you can mark this as safe if you wish. \$\endgroup\$
    – Wheat Wizard
    Jan 1, 2017 at 23:39
  • \$\begingroup\$ @WheatWizard Thanks, I've added my intended solution. \$\endgroup\$ Jan 18, 2017 at 18:28
5
\$\begingroup\$

Python 2, 124 bytes, A144945, [Safe]

Cracking this would have earned you a 500 rep bounty! Too late!

Number of ways to place 2 queens on an n X n chessboard so that they attack each other.

I hope it's not too easy. I arranged my code so the whitespace is clearly visible. Those are spaces and newlines only.

Note: intended solution outputs via character code

n=input();print((3+2)*n*n+~0*6*n+1)*n/3;            +6;



























+7+7+7+7+7+7+7+7+7;+++++++++++++++9+9*9*9

Try it online

Intended Solution, Headsecks:

r2=ni***p**
(
 
 
p((0 ;3+++3;+;/
 
 
)
 
 
 
 
 
i+++nn
 +)7
n
 
n+++ 
 
 
17+~
 +)7;97++++7
 
 
69+9n+ ++7+n 69
 +7+ ++7
 
 
**7+++tut

This is equivalent to the following BF program:

>>,[->>>+>>>+>>>+++++<<<<<<<<<]>>>->>>>>>-<<<[[>+<-]>[>>[<<<+>>+>-]<[>+<-]<-]<<<<]>>+++>[-<-[<+<<]<[+[->+<]<+<<]>>>>>]<<<.,.
\$\endgroup\$
0
4
\$\begingroup\$

Fuzzy Octo Guacamole, 26 bytes, A070627 [Safe]

49++*5^pm#]%:"?:.=:#,|"1:@

Test cases:

1 -> 1
3 -> 23
5 -> 1

Solution:

^::::|*?1=#@]","%.#49++5pm

Works in Magistack.

\$\endgroup\$
2
  • \$\begingroup\$ Hello! Just reminding you that this answer can be marked as safe. No need to rush but no one has cracked it in a week. Good job, I am eager to see a solution \$\endgroup\$
    – Wheat Wizard
    Nov 17, 2016 at 19:51
  • \$\begingroup\$ Cool, I'll do it and the other once when I get home. \$\endgroup\$
    – Riker
    Nov 17, 2016 at 21:30
3
\$\begingroup\$

Pyth, 75 bytes, A004526 Cracked, milk

More of a playful test than anything, but:

/Q/////////////////****22222 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2;;;;;

Try it online!

Milk's solution (Convex):

2/Q2 2/2/2/2/2/2/2/2/2/2/2/2/2/2/2/2/2/2*2*2*; 2*;                 2; 2; 2;

Try it online

Intended solution (///):

/*///;2/;// ///22/Q//2;///;//;***2222222222222222222222                    

Try it online

Takes input in the form of 2's before the last semicolon and outputs the correct number of Q's.

The sequence is 0-indexed (i.e. 0 is 0, 1 is 0, 2 is 1, ...)

Found slight syntactical mistakes in the ///, so edited all solutions.

\$\endgroup\$
1
  • \$\begingroup\$ Cracked \$\endgroup\$
    – milk
    Nov 10, 2016 at 7:32
3
\$\begingroup\$

MATL, 7 bytes, A000217, cracked

:sp{1}x

The sequence is n(n+1)/2 (triangular numbers), starting at input n=1 as specified by the challenge: 1, 3, 6, 10, ... (Output for input 0 is not guaranteed to be the same in the two programs).

The program in the other language exits with an error (after producing the correct output in STDOUT).

Try it online!

:            % Push [1 2 ... n], where n is implicit input
 s           % Sum of that array. Gives the desired result
   p         % Product of that. Gives the same number
    {1}      % Push a cell array containing number 1
       x     % Delete it
\$\endgroup\$
2
  • 1
    \$\begingroup\$ Cracked! \$\endgroup\$
    – Steven H.
    Nov 10, 2016 at 3:38
  • \$\begingroup\$ @StevenH.Well done! My original solution was x:ps{}1 \$\endgroup\$
    – Luis Mendo
    Nov 10, 2016 at 7:54
3
\$\begingroup\$

Python 2, 37 bytes, A000290 Cracked

print(input()**(1+1))
"'10°3¢','m'"
\$\endgroup\$
1
  • 3
    \$\begingroup\$ Cracked \$\endgroup\$
    – Emigna
    Nov 9, 2016 at 16:31
3
\$\begingroup\$

Python 3, 27 bytes, A000012, Cracked

No input this time!

if 1:
    if 1:
        print( '1' )

The indents are tabs, but not to save bytes - they are required for whitespace.

I don't think it needs a TIO link or explanation!

(Probably won't take long to crack in some way)

Intended answer (Whitespace):

-Start-
    
    
    if1:if1:print('1')
-End-

(Start and end not part of the program)

Sorry, I forgot to add that it prints to STDERR:

Try it online!

\$\endgroup\$
7
  • 1
    \$\begingroup\$ Cracked. \$\endgroup\$
    – milk
    Nov 10, 2016 at 22:11
  • \$\begingroup\$ I feel like this is supposed to be Whitespace, but that would print an error to STDERR as it's lacking the required linefeeds to end in [LF][LF][LF]. \$\endgroup\$ Nov 10, 2016 at 22:12
  • 1
    \$\begingroup\$ @milk Not you again! :D \$\endgroup\$
    – boboquack
    Nov 10, 2016 at 22:16
  • 1
    \$\begingroup\$ @boboquack It does work, but it does print to STDERR (which you can see by activating the Debug mode on TIO), and the challenge says that answers need to specify whether the hidden language writes to STDERR. \$\endgroup\$ Nov 10, 2016 at 22:23
  • \$\begingroup\$ Cracked again. \$\endgroup\$
    – Oliver Ni
    Nov 11, 2016 at 5:01
3
\$\begingroup\$

Fuzzy Octo Guacamole, 11 bytes, A001844 [Safe!]

hha02^d+**+

A crack that sort-of works is dh*h++^2*0a, in Pyth. It's not the right output format though.

My code is still out there! (and it's not in Pyth)

Test Cases:

0 -> 1
1 -> 5

Solution:

^++d0ah*2*h

In Jolf.

\$\endgroup\$
8
  • 1
    \$\begingroup\$ I swear, this looks like it was made for Jolf, but I just can't figure out that d... \$\endgroup\$ Nov 10, 2016 at 2:14
  • \$\begingroup\$ Cracked (I hope...) \$\endgroup\$ Nov 10, 2016 at 2:33
  • \$\begingroup\$ @ETHproductions ah, nice. Not sure if it counts though? See edit. \$\endgroup\$
    – Riker
    Nov 10, 2016 at 2:56
  • \$\begingroup\$ My code prints a newline, but no space. Same with the valid code. \$\endgroup\$
    – Riker
    Nov 10, 2016 at 2:57
  • \$\begingroup\$ @EasterlyIrk Despite what I said I do not consider the answer provided a crack. I everything I said still holds true however I do not consider leading whitespace valid output and I will amend the question to reflect that. \$\endgroup\$
    – Wheat Wizard
    Nov 10, 2016 at 3:58
2
\$\begingroup\$

WinDbg, 39 bytes, A000007 Cracked by jimmy23013

~e.block{j(0>=@$t0)?@$t0+(1<7);??0}t":"

The difficult sequence of 0**n.

Input is done by passing a value in the pseudo-register $t0.

My original solution was C#:

@t=>(object)(0<@t?0:1)??"$$700~lk.{}+";
\$\endgroup\$
1
2
\$\begingroup\$

JavaScript ES6, 38 bytes, A000290, Cracked

J=>eval(Array(J).fill(J).join`+`)|2-2;

This square train is pretty nifty, but isn't going anywhere fast. (Get it? square train? as in, wheels? no? okay, fine. critics.)


Intended answer: Reticular (Try it online!),

in2Jo;=>eval(Array(J).fill(J).j`+`)|-2
in      take input, convert to number
  2J    raise to the second power
    o;  output and terminate; ignores following chars
\$\endgroup\$
2
  • 2
    \$\begingroup\$ Your code is trying to convince me that the other language is J :P \$\endgroup\$ Nov 9, 2016 at 23:50
  • \$\begingroup\$ Cracked. \$\endgroup\$
    – Wheat Wizard
    Nov 10, 2016 at 0:37
2
\$\begingroup\$

MATL, 13 bytes, A002275 Cracked!

i:"@ax'1']
v!

Try it online!

Explanation:

i           % Grab input
 :          % Push (range(1,input))
  "         % For each element in this range:
   @        %   Push it
    a       %   Is is truthy?
     x      %   Delete it
      '1'   %   Push '1'
         ]  %   End loop
v           % Join all of these '1's together
 !          % Transpose and display
\$\endgroup\$
2
  • 1
    \$\begingroup\$ I feel like this is in Vim but for the life of me I can't crack it \$\endgroup\$
    – Wheat Wizard
    Nov 9, 2016 at 19:47
  • \$\begingroup\$ Cracked :) \$\endgroup\$
    – Wheat Wizard
    Nov 10, 2016 at 1:13
2
\$\begingroup\$

2sable, 13 bytes, A002378, Cracked!

Hoping I didn't miss something. Computes a(n) = n × (n + 1):

>*?"!&)<=@\\}

My version:

?"\>@&*})<\=!

Or the unfolded version:

  ? " \
 > @ & *
} ) < \ =
 ! . . .
  . . .

Note that the > in the top-left corner is unused (except for the 2sable program). I did this to confuse the robbers (but that obviously didn't work haha).

Try it online!

\$\endgroup\$
2
  • \$\begingroup\$ Cracked. :) \$\endgroup\$ Nov 10, 2016 at 12:46
  • \$\begingroup\$ @MartinEnder Nice job! I'll update my answer with the original submission :). \$\endgroup\$
    – Adnan
    Nov 10, 2016 at 13:08
2
\$\begingroup\$

2sable, 15 bytes, A087156

D1QiA0*<}.;2->>

Try it online

The sequence of non-negative numbers, except for 1.

\$\endgroup\$
0
2
\$\begingroup\$

Befunge 93, 14 bytes, A121377, Cracked by milk!

&52* %68*+ .@Q

Fun fact: The intended solution to this is the first time I've ever used that language.

My solution in Pyth. &@ print an error, but that goes to STDERR which according to the OP is ignored.

+%Q*5 2*6 8.&@
\$\endgroup\$
1
  • \$\begingroup\$ Cracked \$\endgroup\$
    – milk
    Nov 11, 2016 at 6:55
2
\$\begingroup\$

Python 2, 35 bytes, A048735, Safe

print(lambda u:u&u<<1)(input())>>1

The original solution was in my own programming language Wise.

:<<>&>print(lambda uuu1)(input())1

Most of the characters are irrelevant no-ops. The important characters are the first six. : creates two copies of the first item on the stack. <<> bit shifts twice to the left and once to the right which is equivalent to bit shifting once to the left. & takes the bitwise and of the top and second item (the original and the bit shifted copy). Lastly > bit shifts once to the right.

\$\endgroup\$
2
\$\begingroup\$

05AB1E, 5 bytes, A000012, Safe

$;$1?

Sequence of 1's. Try it online

Intended Solution: Arcyou

1;$$?

Try it online. I couldn't find documentation for this language, so don't have an explanation of how it works exactly.

\$\endgroup\$
4
  • \$\begingroup\$ Stupid semicolon... I could almost use Retina, but I can't have both the 1 and ;. \$\endgroup\$
    – mbomb007
    Nov 11, 2016 at 16:47
  • 1
    \$\begingroup\$ This has not been cracked \$\endgroup\$
    – Wheat Wizard
    Nov 12, 2016 at 17:44
  • \$\begingroup\$ It looks like this answer can now be marked as safe. Since I spent quite a deal of time trying to crack this one I am quite eager to see the intended answer. \$\endgroup\$
    – Wheat Wizard
    Nov 17, 2016 at 19:59
  • \$\begingroup\$ Shouldn't this answer be marked as "accepted" now? \$\endgroup\$
    – mbomb007
    Feb 9, 2017 at 16:49
1
\$\begingroup\$

Python 2, 70 Bytes, A000217 Cracked!

I have a feeling this won't be cracked in the language I used for the other version, we will see :)

o=input()
v=0
i=1
while o:
 v+=i
 i+=1
print v


#|  d00->1@@@++-^,,[

I realized afterwards I had incorrectly obfuscated the code (it doesn't change the posted answer's validity). Here's the code I started with in Haystack:

v
0
v
0
i
1
-
>      d0[v
^-1@+@d+1@?,,o|
\$\endgroup\$
1
1
\$\begingroup\$

05AB1E, 9 bytes, A000042 Cracked!

1×,1*-^$)

This is the Unary representation of natural numbers (OEIS). So if the input was 3, for example, then output would be 111.

Explanation:

                    # implicit input
1                   # pushes 1 to the stack   
 ×                  # pushes "1" × (the input)
  ,                 # outputs the stack
   1*-^$)           # irrelevant

Try it online!


Original Solution, Carrot

1^*$-1×^)

Explanation

1^             Push "1" to the stack
  *            Multiply the string by
   $-1         ...the input (as an integer) minus 1 times
      ×,)      Ignored by the interpreter

The * multiplies the string by (n+1) times, so that a^*3 results in aaaa and not aaa. So that is why I subtracted 1 from the input.

Only now I realise that the ) has been irrelevant in both the languages :D

Try it online!

\$\endgroup\$
3
  • \$\begingroup\$ Cracked. \$\endgroup\$
    – Oliver Ni
    Nov 10, 2016 at 17:39
  • \$\begingroup\$ What was the original hidden language? \$\endgroup\$
    – Wheat Wizard
    Nov 10, 2016 at 17:53
  • \$\begingroup\$ @WheatWizard Whoops, thanks for finding that. I added the language now \$\endgroup\$
    – user41805
    Nov 10, 2016 at 17:54
1
\$\begingroup\$

J, 2 bytes, A000290, Cracked

*~

Well, might as well start going for those two-byters. Yields n × n, or n2.

intended solution, Jolf, 2 bytes

*~

Well. Yeah. This is my own language and I think it works because ~ looks for an extended character, but doesn't find one, so it just ignores it. ¯\_(ツ)_/¯ Oops.

\$\endgroup\$
4
  • 2
    \$\begingroup\$ Cracked! \$\endgroup\$
    – Steven H.
    Nov 11, 2016 at 1:27
  • \$\begingroup\$ @StevenH. nice job! I edited with intended solution. \$\endgroup\$ Nov 11, 2016 at 1:30
  • \$\begingroup\$ @ConorO'Brien your intended solution was not a valid solution. In order for languages to be considered distinct neither the original or the solution can be a polyglot in both languages \$\endgroup\$
    – Wheat Wizard
    Nov 11, 2016 at 1:31
  • \$\begingroup\$ @WheatWizard Oh. That's awkward. \$\endgroup\$ Nov 11, 2016 at 1:33
1
\$\begingroup\$

ABCR, 24 bytes, A023443 Cracked!

70: Quit xi. Classy queue!

There's a bunch of no-ops. Calculates n - 1.

\$\endgroup\$
0
1
\$\begingroup\$

05AB1E, 8 bytes, A000042, Cracked

F1}J,(1&

Test cases:

1 -> 1
2 -> 11
3 -> 111
\$\endgroup\$
1
1
\$\begingroup\$

Ouroboros, 6 bytes, A000012 Cracked

)49.o(

Always outputs 1.

\$\endgroup\$
2
  • \$\begingroup\$ Cracked. \$\endgroup\$ Nov 11, 2016 at 17:41
  • \$\begingroup\$ @DLosc sorry for posting in the wrong place but you haven't been on chat in ages ;_; \$\endgroup\$
    – ASCII-only
    Nov 12, 2016 at 0:14

Your Answer

By clicking “Post Your Answer”, you agree to our terms of service, privacy policy and cookie policy

Not the answer you're looking for? Browse other questions tagged or ask your own question.