# The Programming Language Quiz, Mark II - Robbers

Cops challenge

## The Robbers' Challenge

1. Find a vulnerable answer. That is, an answer which hasn't been cracked yet and which isn't safe yet either.

2. Crack it by figuring out its language. That is, find any language in which the given program is a valid program (subject to the rules outlined in the Cops' Challenge above). It doesn't matter if this is the language the cop intended.

Once you have found a working language, post an answer to the Robbers' thread and comment below the Cop's answer. If you don't have enough reputation to comment, say this in your answer and someone will comment for you.

The output format must be the same as the cop's intended solution in order to constitute a valid crack.

Every user only gets one guess per answer. This includes telling other people the answer, or hints towards your guesses. You must not crack your own answer (obviously...).

The user who cracked the largest number of answers wins the robbers' challenge. Ties are broken by the sum of bytes of cracked answers (more is better).

Good luck Robbers!

• Important: Please be nice to TIO and don't just (write a script or manually) test all of the languages there. TIO is very busy already. – user202729 Feb 7 '18 at 11:37
• I feel like the whole Cops/Robbers thing is backwards. Shouldn't the Robbers be hiding their programs and Cops be trying to bust them? – Jo King Feb 8 '18 at 6:29
• @JoKing ... just PPCG terminology. There is no reason to be incompatible, and there is absolutely no reason to change all the past cops-and-robbers ---questions--- challenges. – user202729 Feb 8 '18 at 10:19

# brainfuck, posted by user71546

// Calculate the digit sum of 2^64
var sum = 1 + 8 + 4 + 4 + 6 + 7 + 4 + 4 + 0 + 7 + 3;
var b = " "[2 > 1 && (sum = sum + 7 + 0 + 9 + 5 + 5 + 1 + 6 + 1 + 6) + 0 < -88];
var c = "a" > [2 < +3 ? console.log(sum) > -1 : 0];

Try it online!

# SuperCollider, posted by Nathaniel

for(1,100,"% "postf:_)

$sclang test.sc *** Welcome to SuperCollider 3.8.0. *** For help type ctrl-c ctrl-h (Emacs) or :SChelp (vim) or ctrl-U (sced/gedit). 1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26 27 28 29 30 31 32 33 34 35 36 37 38 39 40 41 42 43 44 45 46 47 48 49 50 51 52 53 54 55 56 57 58 59 60 61 62 63 64 65 66 67 68 69 70 71 72 73 74 75 76 77 78 79 80 81 82 83 84 85 86 87 88 89 90 91 92 93 94 95 96 97 98 99 100 # Befunge-93, posted by osuka_ shovv fRom-0to*1E#' <iostream ?>e[10]++;B:12\;g\=||( @. >!1:then.do+^\x61@ :^A&>#+:$#[itex]eaaq The carefully aligned v>^< suggested a 2-D language. A little experimenting showed that it works in Befunge-93 (MTFI): Try it online! • That was quick! I figured that if anything, it would be the directionals that would give it away. I realized I could've abused vertical and horizontal conditionals (especially since an underscore looks really innocuous), but that was only after I posted – osuka_ Feb 8 '18 at 13:05 # Symbolic Python, posted by MD XF _=+([]==[]), __('_+=-~_[~([]>[])],;'*-~-~-~-~-~-~-~-~-~-~-~-~-~-~-~-~-~-~-~-~-~-~-~-~-~-~-~-~-~-~-~-~-~-~-~-~-~-~-~-~-~-~-~-~-~-~-~-~-~-~-~-~-~-~-~-~-~-~-~-~-~-~-~-~-~-~-~-~-~-~-~-~-~-~-~-~-~-~-~-~-~-~-~-~-~-~-~-~-~-~-~-~-~-~-~-~-~-~([]==[])) Try it online! The []==[] part makes me think it's some dynamic typing language with [] means something and == compares equality. Probably Javascript. Try running the program in Javascript gets the error message ReferenceError: __ is not defined Ok. So what is defined? The line right above that contains _=, so _ is defined. It can only be some language such that two adjacent _ are treated as two different tokens. Spaced does not work because ==. ## Lost, posted by Jo King /@<<<<<< >>>>>>@\ v \/ v % ^^ % ? \ / ? >1+:455* * -+?^:> ?v /^^\ v? ^ \oo/ ^ ^ \!/ ______ \!/ ^ ^ v \____/ v ^ ^<<< >>>^ Try it online! # Wise, posted by Jo King ~-<<:>>-~ ||<<<:<:>:>>>|| |[: ?-~]| Try it online! ## 1+, posted by ivzem 11+""*""*"+""+++1\1<#":1+^"/^"\^<#: There's an interpreter here. # Whirl, posted by Jo King +------------------------------------------------------------+ |111111111111111111111111111111111111111111111111\       |
|000110011000111100011100100/010 0010 %p0-d% 0+{10000/111    |
|111000100111110001001000011 / 1111000100111110001001  frick |
|000 {01111110001(( 001111100010010000 1111110001()\ () !    |
|001111100010010000111 111000100111 1100010010000111111000100|
|111110001001(0000111)11100010011111!}000100100001111110001  |
|0011111|_0001001000011111100010011111 000100100001111110 001|
|001111100010010000111#1110001 001111100010010000111111000100|
|11111 H) /!00010010000111 1/1 100/0100111110001001000       |
| 011111100  & 01001111100010010000  111111000100111110001001|
|@  00001 11111000100111110 00100100001 111110 001001 111    |
| 1000 1001000011 11110 00100111110001001000011111100010  the|
|the 01111 100010010000111 111000 1001 111100010010 00011111 |
|1000100JO   1111100 010010000111 +=   11100010 011 11 KING  |
| 1000100100001 11111000100111110001 "0010000111111000100111 |
|110001001000011 11110 00100127  : 1111000100100 001   1     |
|11   11000100  11111000100100001111110001001111100010010000 |
|11111100 a  01001111100010  010000111111   000100111        |
| 1 1 0 0 0 1 0 0 1 0 0 0 0 1 1 1 1 1 1 0 0 0 1 0 0 1 1 1 1 1|
|00 01 00 10 00 01 11 11 10 00 10 01 11 11 00 01 00 10 00 01 |
| 111 110 001 001 111 100 010 010 000 111 111 000 100 111 110|
|0010 0100 0011 1111 0001 0011 1110 0010 0100 0011 1111 0001 |
| 00111 11000 10010 00011 11110 00100 11111 00010 01000 01111|
|110001 001111 100010 010000 111111 000100 111110 001001     |
| 0000111 1110001 0011111 0001001 0000111 1110001 0011111    |
|00010010 00011111 10001001 11110001 00100001 11111000       |
| 100111110 001001000 011111100 010011111 000100100 001111110|
|0010011111 0001001000 0111111000 1001111100 0100100001      |
|                      ^1111100010^                          |
|0 111110001001000011111100010011111000100100001111110001    |
|0011111000100100001111110001001111100010010000111111000100  |
|  111110001001000011111100010011111000100100001111110001001 |
|   111100010010000111111000100111110001001000011111100010   |
| 0111110001001000011111100010011111000100100001111110001    |
|0011111000100100001111110001001111100010010000111111000100  |
|  1111100010010000111111000100111110001001000011111100010011|
|11100010010000 111111000100111110001001000011111100010011   |
|11100010010 00011111100010011111000100100001111110001001    |
|11110001+ 00100001111110' 001001111 10001001000011111100010 |
| 011111000100100001  1111100 010011  11100010010 00011      |
|1111JKL5 000100111110   0010010000   11111  1000   10011    |
|111 J 6700010010000111111^& E 00010011 L  11100 L 0 Y? bin  |
|100[print()100001111110   -001001111100010010000111]  111000|
|100 not 1111100 BRAIN010010000 FU1111 11000100CK  111110001 |
| rk:start 0010 0001111110001001 1111  0001001000011111100   |
|0100111110 dckx 001001  000011111  1000100111  11000100 help|
|100001 111110001001111100010010000111111000 1001111100010010|
|000-[111111000100??11111000100100001>1111100 {x=0-100}px    |
|111110001 00100001  11111000100111110 0010010000111111000100|
|1111 1000100100 +++001111  110001 0011111000  100100001 1111|
|100010  011111000100100001111<-1100010011111000100 10000111 |
|111 eval('\b00010011111000100100001111')-110001001--1111000-|
|1001000011]1111000100111110001001000011111100  010011111000 |
|10 +01>0000111 1  1 100 01001 1111 0001001 000011--1111  -  |
|0001001111100010010000111111000 1001111100010010000111111000|
|10011[111-0 0 01001000011 11110001001111100  010   010000111|
|111000 <100  1111100+010010 00 0.11111100010011111000100100 |
|001111110001001111100010>0100001111110001001111100010010000 |
|011000101010010101010111000000101011001]010100101010000 1010|
|111111111111111111111111111111111111111111111111111111111111|
+------------------------------------------------------------+

This had quite a few red herrings. I tried Nhohnhehr, Brain-Flak, PATH, Cardinal and SNUSP before leaving this feeling a bit stumped. Then dylnan's mention of Fortuna reminded me of Whirl.

Try it online!

# Beatnik, posted by MD XF

aAaAa>>u<<TWELVE>>ooooooooo<<if(i < 100); print("oOOoOooOoOoO");
done:
PutNumbersFromOneToOneHundredInclusiveFunctionZD<GOTO 100>;
executes(print); language(CPlusPlusE::PublicUI);

Try it online!

# Super Stack!, posted by MD XF

1 1 if pop dup output 1 add dup 101 swap sub fi

# O, posted by MickyT

['d#,;r]o

Online interpreter: https://o-lang.herokuapp.com/

I recognized it immediately by the o at the end.

• yeh, the o definitely was a give away :) – MickyT Feb 11 '18 at 6:26

## BrainCurses, posted by Conor O'Brien

' !'d[:-%_%]

There's an interpreter here

1i101

Try it online!

# ecpp + C (gcc), posted by MD XF

#rule control_flow foreach
#rule control_flow in
#def foreach a in b..c: for (int a = b; a <= c; a++)

int main(void)
{
int a = 1, b = 100;
foreach i in a..b:
printf("%d ", i);
}

Try it online!

# Locksmith, posted by Conor O'Brien

import java.util.Random;
interface Main{
public	static void  main(String[]args){
for(int	i  	=0; i  <		90*  11; i ++)
System. out.println(i);
f(   	 	7);
g();
}
public static 	int f(int n){System.out.println(n);if(n<=0)return+n&3;
else return f(	n/7)*6	+7*f(n-5)+7;
}
public static void g(){
Random k=new Random(45);
String j="YmlULmxZXERFZmNvbg==";
int m;
for(int i=m=0;i<121;i++){
m+=j.charAt(0)+j.	charAt(i&1)+k.nextInt();
}
System.out.println(k.nextInt((int)Math.pow(7201,19))^6^m);
}
}

Try it online!

+\100\1

Try it online!

# MATL, posted by Stewie Griffin

False T
For nnz(100) T+1
'cout <<' T
)o:
bux bux Q
hu

Try it online!

• I'm, curious... Do you know how it works? – Stewie Griffin Feb 7 '18 at 19:42
• @StewieGriffin I'm not really familiar with MATL, but parts of the code, i.e. nnz and T, reminded me of MATL programs I've seen on PPCG. – ovs Feb 8 '18 at 10:23
• I guess nnz has been in explanations. z alone is equivalent to nnz(x) in octave. – Stewie Griffin Feb 8 '18 at 10:36

(].[]%<100@9)&

Try it online!

# Jolf, posted by Conor O'Brien

Lazy!~1

I wasn't sure what this was so I decided to dive down deeper into some of the languages you developed!

• Good job! Nice to see someone looking at my languages ;D – Conor O'Brien Feb 8 '18 at 20:51

# Self-modifying Brainfuck, posted by Jo King

v<[-=0lfn_v#:-d<]
<[/_>]/@-0>_?!:^"d.

Try it online!

## False, posted by MD XF

1a:[a;101-][a;.a;1+a:" "]#

An online interpreter can be found here.

# Lily, posted by tfbninja

for i in 1...100:{print(i)}

Try it online!

# JavaScript, posted by Colin Robertson

n=1;while(n<101){console.log(n);n++;}

Try it online!

# Hy, posted by DLosc

(defn !(&optional(> 1))(if(< > 101)(do(print >)(!(inc >)))))(!)

You can try it e.g. if you manually type the code into this interpreter.

# Gambas, posted by Christopher

Public Sub Main()
Dim num as short
For num = 1 To 100 Step 1
print num
Next
End
'1-100.print

# 2sable, posted by DevelopingDeveloper

$123 @(% #ZZ &^0 *i*j F=1,2,3,4,5,6,7,8,9,10,11,12,13,14,15,16,17,18,19,20,21,22,23,24,25,26,27,28,29,30,31,32,33,34,35,36,37,38,39,40,41,42,43,44,45,46,47,48,49,50,51,52,53,54,55,56,57,58,59,60,61,62,63,64,65,66,67,68,69,70,71,72,73,74,75,76,77,78,79,80,81,82,83,84,85,86,87,88,89,90,91,92,93,94,95,96,97,98,99,100,101$ 123
@(%
#ZZ
&^0
*i*j

Try it online!

~th5@.oLh

Try it here.

# Io, posted by iovoid

a := "+++++++++[>+.+.+.+.+.+.d.+.+.+.+.<-]";for(q,1,a at(23),q println)

It works by indexing the string to get d which has an ascii value of 100 to use as the upper limit of the for loop.

• I've downloaded Io and it does indeed work. – NieDzejkob Feb 11 '18 at 15:26
• Try it online! – Dennis Feb 11 '18 at 15:34
• @Dennis wasn't expecting it to be on TIO so fast. – Potato44 Feb 11 '18 at 18:22

# Coconut, posted by Laikoni

main :: RunIO
main = print (list (range (1, 101)))

list :: Fn ((Range, Int) -> (List, Int))
list = xs -> List.fromObj (xs)

range :: Fn ((Pair, Int) -> (Range, Int))
range = (x,y) -> {x..y}

# Underload, posted by Esolanging Fruit

lpvO.U%C$j<{YNXzbF[=/n'A5 7KYL3$3IZvrP>P%LJ&fv[5]$3( ){u}Z'K7s{lA8}pNZvmLwEGevRo?I>H38{q}[d/hJrkcp7F]e7$H[
L(]WCrrWxbb[M][6]m\[DH]j98Ki&H<n=Nn=|{f}UMs-_5b?-ixC/
5V_M{R}w@+[N2P]eg998dq;[Qq]-od|XoX{P}{N,}#G($)%tdZN*?[ Z];fUK{_H26DY'R|sdQy;%P#g}|X{IQvM}cXDMmvG1O[i-][{s}]3I L:hw2s ="dY0g/4YS14#>Y.GIs=KMm"H[&]r3[G])VgE(hCLyP8cs[ V]j[W]jg:cvp6X8:lNchdg8;55{o}P]{*Q}qc[y$]sZ?P60EI[_]wt
:6TIyK'XRfR<[>HG]*|Xz]o[z]0A[T]t{"}*}[8#N5wy[{nU}[W]N;
+h?p{nRgy}W{[u]vIJX?{sl,};4>.}Z/Km>1]]:pMp-0<[[,].Q$J *&nL0Jg]{/{J),[[{[s]j}]]=f7f B:5k}"B{1A}}{*T}1Tr/cRX w lBKJ_6UoC^QBC{8}/G'x2&Le3w[u]&T-hpUA2/c.>Zb[N]|pX[8,]X t2@^.{h}K7lo{<d}xozh>wb?Hello worldHello worldHello wo Try it online! Outputs in Unary, with$ for the value and a newline for the delimiter.