Talk:Unary

From Esolang
Jump to: navigation, search

Heh, cool. I once made something like this, but quickly scapped it. Now I just have to write an Unary interpreter or something. XD Hmm. Apparently hello world is 0x2924924962924922924924914914000F94A15124925224A14A00924924924928624A36DB71B6DB6E150C 0's.

YET ANOTHER edit here. I just made a brainfuck-to-unary converter in Thue. http://www.filenotfunny.com/bf2un.t Please notify me of any bugs blah blah etc. EDIT: You guessed it, unary-to-brainfuck converter in Thue. http://www.filenotfunny.com/un2bf.t --BodyTag 18:25, 11 Sep 2005 (GMT)

Great, now how to run it without running out of memory :) --Aardwolf 20:46, 11 Sep 2005 (GMT)
Well there's the obvious approach. Make shorter programs. :P --BodyTag 21:01, 11 Sep 2005 (GMT)

One character language

Hey, this finally gave me the idea how to create a language that uses only one character! Yihaaaaa! I've been so stupid for not seeing it before.. --User:Keymaker

But this language has two symbols: 0 and EOF. The fact that it uses one character is merely a technical detail. --Graue 21:27, 11 Sep 2005 (GMT)
Oh please.. :) Would it be necessary to count in the EOF for some reason when making one character language? --User:Keymaker
Surely EOF is meta-data, and not part of the program data itself? --Safalra 13:51, 20 Oct 2005 (GMT)
Absolutely not; how else can an implementation make any sense of how to run the program, other than by looking for the EOF symbol? --Graue 14:26, 20 Oct 2005 (GMT)
Yeah, EOF is part of the program data, but this would count not only for Unary but also for all other languages. Then BF has not 8 but 9 symbols, since when the end of BF code is reached, it is interpreted as finish program. This is then also something to be considered in the BF minimization page. --Aardwolf 14:36, 20 Oct 2005 (GMT)
Iota and Unlambda don't require EOF. --Ihope127 15:20, 20 Oct 2005 (GMT)
Use meta-data, as I said. In Javascript, use document.forms.name.field.value.length, in Java use String.length(). EOF is just a way of representing the end of a file as a character, for languages that don't provide any other way of finding the length/end of a file (or don't have an exception system, so want a call to a next() method to always return), or for programmers who know that a while(c>-1) loop runs faster than a while(!eof()) loop. --Safalra 14:56, 20 Oct 2005 (GMT)
OK, then how do you propose storing that metadata with one symbol? --Graue 15:00, 20 Oct 2005 (GMT)
It's meta-data, so it doesn't get stored as part of the program - it's an implementation detail and can be stored in any way. The program code is an abstraction - if I compress a Unary program, the compressed file may use a variety of symbols, but the Unary program it represents still contains just one symbol. Saying that EOF is part of the language is like saying a 2D language needs a end-of-row symbol as well - of course we could instead use an end-of-column symbol, or specify that the program is padded so that it's width and height are prime numbers, with its width being greater than its height. The point I'm making is that these implementation details are all meta-data, and not part of the program. --Safalra 16:38, 20 Oct 2005 (GMT)
Definitely agree with that. --User:Keymaker
EOF isn't a printable symbol in this programming language, yet in some way it seems to be semantically significant, therefore it must exist in some form. If a Unary program were to be printed on paper, the EOF would be the end of the paper, or the space where the next 0 would be, if there was a next 0 in the first place. Therefore IMO, Unary has 2 symbols. Many of you don't want to thus change the definition of Brainfuck as being a language consisting of 9 symbols, but this is probably just humans being resistant to change. We've defined it as 8 symbols for so long, why change it now..? :) Also, I just wondered.. we could construct a language implementing the same semantics, but with an infinite amount of symbols. Just let the Unary program be represented instead by a positive integer whose value is the number of zeroes. --Anonymous
If you think EOF is another symbol and that makes Brainfuck to have nine symbols, you can still use ] as the end of program symbol instead. In this case, you then do have only eight symbols. --Zzo38 21:30, 31 May 2010 (UTC)

Joke Language

Should Unary be considered a joke language, since in a way it's unique. --Aardwolf 15:00, 22 Oct 2005 (GMT)

Attempt at Python converter

I've tried to make a Brainfuck to Unary converter in Python(currently at [1] However, I'm having two problems with it. The first is that I don't know how to convert numbers from binary to unary in Python. The second is that I can't get the programs to show up right in the Unary to Brainfuck converter if I convert the number by hand.

Does anyone have a clue on how to fix this? 83.109.228.9 16:14, 1 April 2008 (UTC)

For binary to unary, start with a number at zero, then repeatedly double it if the first digit of the binary is a 0, and double it and add 1 if the first digit of the binary is a 1, going through all the digits of the binary number in order; that will give you the length of the unary output you need to produce. (You'll need to use an unbounded integer to do this, otherwise the number will overflow.)

How can a Unary Number System possibly exist?

Read above. Essentially, Unary being base 1 must include all the Whole Numbers up to but not including 1. Thus, we have a range of {0}. Now, using this system, we create an arbitrary number, say 000000 which would be (what we think) the equivalent of 6d or 00000110b. However, if we evaluate our unary number, we come to a problem: 000000 = 0*1^5 + 0*1^4 + 0*1^3 + 0*1^2 + 0*1^1 + 0*1^0 = 0 This is of course a problem, because we cannot use only 0's as we will never have a value other than 0 (being the multiplicative dead) and if we use a 1 then this turns into binary by virtue of the existence of two symbols and the fact that it includes all the whole numbers up to but not including two.

So, from the above, is Unary merely a fancy term for "tally using 0's", otherwise I cannot see a way it can possibly function. -- Hiato 11:24, 4 April 2008 (UTC)

Unary generally refers to a number system where the number of digits represents the size of the number; there is usually only one digit, but that digit is usually 1 (thus an example number would be 111111 = 1*1^5 + 1*1^4 + 1*1^3 + 1*1^2 + 1*1^1 + 1*1^0 = 6). This doesn't exactly follow the pattern used by the other number systems, though. (The base really determines the base of the exponent, rather than the digits used; think about base -2, for instance, which uses 2 digits but has -2 as the base for exponents when calculating digits.) --ais523 09:20, 5 April 2008 (UTC)

In this program we use zeros but they say unary is uaually 1's. One way to do it, is you can use any characters you want in the program, the interpreter will ignore the actual contents of the file and read only the size of the file. This will break if the file has a newline or EOF mark at the end, but the programs that do that can be fixed. In this way, you can also make sparse files in a NTFS file system that are larger than the drive can contain, and it will still work. Of course, even the file size field might not store a large enough number, but the other conversion programs are no better. --Zzo38 14:22, 5 April 2008 (UTC)

Oh, I see - thanks. So essentially Unary is just a fancy tally (as 1^n = 1, n e Q) as opposed to a "true" base n number system. Is this to say that what I put forth would be some kind of Nullary (Base 0 number system?) -- Hiato 20:27, 13 April 2008 (UTC)
Yes, pretty much. I don't blame you for being confused; the standard terminology is inconsistent and confusing. --ais523 20:32, 14 April 2008 (UTC)

Inefficient conversion to number

Instead of adding a 1 before each number when converting to binary, you could let 8 instead of 0 represent '<'.

So you get:

Brainfuck Binary
> 8 (1000)
< 1 (001)
+ 2 (010)
- 3 (011)
. 4 (100)
, 5 (101)
[ 6 (110)
] 7 (111)

Then convert the sequence of numbers as if they were written in base 8 (big endian). In other word: calculate the sum of a*8^n for each number a, where n is the position in the bf-code code counting from the right.

If the above was confusing, here is an example:

If you want to convert +>,< into Unary2 you first convert each character into a number according to above: +>,< -> {2,8,5,1} then add it together to get the number of digits: 2*8^3 + 8*8^2 + 5*8 + 1 = 1577. So +>,< in Unary2 is 1577 zeroes.

With this approach every sequence of zeros has a corresponding brainfuck code, which is not achived with normal Unary.

--Anka 20:24, 3 January 2009 (UTC)

Surely you can't use the digit 8 in base 8? Phantom Hoover 15:01, 5 January 2010 (UTC)
Yes, you cna't use the digit 8 in base 8. Instead, you could change around the order to make 0 mean the ] instruction and put the least significant numbers the first command, and the most significant numbers the last command. So, the zero will always be the last command and can be used as termination, too, in case of not inside of a loop the ] can be used to mark end of a program. And now, if you needed to add on input to the program you could do it in the same way --Zzo38 01:00, 9 January 2010 (UTC)
None of this changes the fact that using digit 8 actually works though. --Ørjan 10:39, 9 January 2010 (UTC)
It does, but it's not using base 8. Phantom Hoover 21:06, 12 January 2010 (UTC)
Well there is balanced ternary, so this might be "hyperimbalanced" octal. Actually Wikipedia calls it bijective base-k numeration. --Ørjan 23:47, 12 January 2010 (UTC)

The way this should be done is as follows:

1) Convert to octal digits ie: '<>+-.,[]' to '01234567'
2) Prefix the whole string with an octal '1' to protect any leading zeros.
3) Convert to decimal.

Gives

22435106351709094554740583499471018374086323824602978051445367888078\
766718578331882289274081880939360391420731265470857967681556

For hello world.

Your way gives:

32707674348466873456486849185019037774879633600996454941029677806545\
01690208072722382724096739368698486194641062696711093731510505555569\
1783915006509976318427875342321836

Notice the original is a little longer than the decimal:

>+++++++++[<++++++++>-]<.>+++++++[<++++>-]<+.+++++++..+++.>>>++++++++[<++++>-]
<.>>>++++++++++[<+++++++++>-]<---.<<<<.+++.------.--------.>>+.

The examples on the main page use the octal method; the javascript "converter" is wrong.

--(this comment by 2001:470:1F09:10D6:59EC:8D1F:E4AD:59EF at 19:28, 4 August 2013‎ UTC; please sign your comments with ~~~~)

1 symbol

I've never really been happy with that, and not just because of the EOF. I suppose it comes down to the definition of "symbol" — by this definition of "symbol" more or less all languages have exactly two symbols: 1 and 0. Phantom Hoover 13:32, 20 March 2010 (UTC)

99 bottles of beer

The 99-bottles-of-beer program

>>>>>>>>>>++++++++++[-<++++++++++>]<-<<<<<<<<<++++++++++[->++++>++++>+++
+>++++<<<<]++++++++[->>>++++++++>++++++++<<<<]++++[->>>>++++<<<<]+++++++
+++>-------->++++>>>>>>>[<<<<+++>+>++<<[>>>>[[->+>+<<]>>[-<<+>>]<[>+++++
+++++[->>+>+<<<]<[>>>[-<<<-[>]>>>>[<[>]>[---------->>]<++++++[-<++++++++
>]<<[<->[->-<]]>->>>[>]+[<]<<[->>>[>]<+[<]<<]<>>]<<]<+>>[->+<<+>]>[-<+>]
<<<<<]>>[-<<+>>]<<]>[-]>>>>>>[>]<[.[-]<]<<<<<<]>+<<[>]>>[<<<<<<<++++++.+
.------->>>>>>>>>]<[-]<[-]<<<<<<<<<.>>------.+++++++++++++.>----..<---.-
------.>>>>>>->>>+<<<[>]>>[<<<<<<<<-.+>>>>>>>]>-<<<+<<<<<<<<.>>>-----.<+
.<<.>>----.+++..>+++.<+++>++++++>>[<<<<<.>>+++++++.-.<<.>>>----.<------.
---.<<.>>>+++.<----.+++++++++++..---->+>>-]<<<<.<<.>>>>>>>-[>]>>[-<<<<<-
---.<-------.>---------.<++++.<<.>>>++++.-.<.<<.>>-.>+.++++++++.--------
-.<<<.>>---.>.<+++.<<.>>>++.<---.>+++..<<<.>>++++++++.>+.<<<.>>--------.
>--.---.++++++.-------.<+++.++++>++++++++++<<.<<.>>----------->>>>+>>>>]
<<<<<-]>>+<<<<<<<.>>+++++++++++>>>>>>>]

is represented in Unary as a string of

325639678472417068822939875156474133601604199695311805459089882092281292
320021959505273992278098266269511623093421446786535577912162057464703117
510613456476283544768091483691050380134353082413584417237050508186170311
100841758475294808822182897650558939889181821968359721314718466765453544
642917705283465122416321901781623594919162207226465487108911718755078561
258397319468795144125849589702335828364689893204973341033492024695611620
630251915376043695257250405459896426236766476054881147140737211608267502
071035082611987546796166597621183311452085996664573566015407455499558986
329235961518840901288913840735765978638808714474372075845072241192251838
014337491535621715532385499208500869158941559378141072165437305878437850
878695018487992734730233885948276901724490150298159234876718327828396339
142881148637400648433892457677190096164128393288567742613801869417478826
68978930079236103

zeroes. Wow. Jleedev 18:05, 31 May 2010 (UTC)

In fact unless I'm mistaken the length of that number should be approximately log 8/log 10 ~ 0.903 of the length of the brainfuck program. --Ørjan 08:19, 1 June 2010 (UTC)

Converter in sed/dc

I made converters for Unary<->Brainfuck using only dc and sed (and wc at the beginning to get the file size). If you're using Windows, you just need sed and dc.sed.

Convert Unary to Brainfuck:

wc -c filename | sed -e "s/ .*/ 8opq/" | dc | sed -e "s/0/>/g;s/1/</g;s/2/+/g;s/3/-/g;s/4/./g;s/5/,/g;s/6/[/g;s/7/]/g"

Convert Brainfuck back to Unary:

sed -e ":a;s/[^-][><+.,]//g;s/>/0/g;s/</1/g;s/+/2/g;s/-/3/g;s/\./4/g;s/,/5/g;s/\[/6/g;s/]/7/g;$!{N;s/\n//;ba};s/^/8i/;s/$/ [0P1-d0!=a]dsaxq/" filename | dc

The second one will print a LOT of zeroes! Just change the [0P1-d0!=a]dsaxq to pq to print a decimal number instead.

Another way using "lookup tables" which actually turned out to be longer (and probably slower):

wc -c filename | sed -e "s/ .*/ 8opq/" | dc | sed -e "s/$/0>1<2+3-4.5,6[7]/;:a;s/\([0-7]\)\(.*\(.\)\1.\)/\3\2/;ta;s/.\{16\}$//"
sed -e ":a;s/[^-][><+.,]//g;s/$/0>1<2+3-4.5,6[7]/;:b;s/\([-][><+.,]\)\(.*\1\(.\)\)/\3\2/;tb;s/.\{16\}$//;$!{N;s/\n//;ba};s/^/8i/;s/$/[0P1-d0!=a]dsaxq/" filename | dc

Ian 06:27, 3 March 2011 (UTC)

Quine

Quine in Unary anyone? Is it possible?

I don't think so. --(this comment by 46.13.153.55 at 01:04, 19 January 2012 UTC; please sign your comments with ~~~~)

It certainly exists mathematically by general principles, and I think we could construct the corresponding Brainfuck program, but the actual Unary program probably won't fit in our universe. --Ørjan 03:07, 19 January 2012 (UTC)
It would be interesting to know at least one such number. In itself this isn't the most difficult task: create a program which is a brainfuck quine, but which instead of printing its code as brainfuck symbols creates in its internal memory the binary number needed in Unary. This part is easy. After that, the program should convert it to unary using a method such as this Markov algorithm (found it from Wikipedia but I think it works):
'|0'->'0||'
'1' -> '0|'
'0' -> 
And print the resulting long list in '0' characters. Actually this is moderately easy too, only tedious as string-matching tends to be in this language. However -- to get to know this number we don't need to print it. The program must have in its code the functionality for converting the binary string into unary and printing it as '0's, even if it never needs to be executed for one to get the result: one might insert a character like '#' in the brainfuck code just before the converting part starts -- and why not end the program too, as further execution isn't necessary -- and modify the brainfuck interpreter to dump the memory when a '#' is encountered. That memory dump would reveal the number in binary, which could be taken from there and converted to decimal (for a better and more logical presentation) with a simple Python program (for example). I might do this but not today. --Keymaker 12:33, 19 January 2012 (UTC)
One of the more difficult quines around here. And also one of the more interesting ones:) Markov algorithm implementation would be quite tricky. 46.13.153.55 22:17, 19 January 2012 (UTC)

A quine in Unary

This is a quine in Unary, prepared the way I sketched above. The binary number before it is converted to unary has 11401 digits. If anyone visits an alternate universe and has a chance to run this program, tell me if it works. The number below, presented in unary format of '0' characters in a row, is a quine in Unary (divided into rows of 100 digits for better legibility):

5717288862995240796671108315851727059032429888697302336669412399309573836349908840177580116736614563
7542001478945391027941251636503991161656977619465399484570681433081059774184083002633344757887849270
2908613882908168867637282596648914407902821648635054942485156519086239517305702705783520430327882724
6493236239932529527743466756943858918105636677988348463699506921362743539039698783432290318704590502
7014043340233318399507627393431631604192305520856885469719401504607930142046890176911809823076746092
4846552476679293134684448847449288151944932525087248192275095934337598653981534386220451824875829915
8425383570829131374304858831789470047021240846331235440607306509955127450305909891954094543797260200
6809054348537748584639627195810870961763535447729397046427209757550177938666875693834020079489401582
4708091428944573831257244094409870775301993104432870895478408037450837230273086589639225269690034191
6647889525602820355509802179983640962676370128705570157753729437702328269377926786597419773912850361
2697826661418147307490745859151430596125380681402393386498540726716960485610793111688826874803945168
3353551414447462928850923445503652021793168648510513597305336955173718471931736313986020652567023366
2573160372100373181588585037247362809813913982803638508533619324595861641554186669173314780352042110
6764235752406899568739623059342176831051696439559197401830517339677050874000152752009234419700562335
5537596657473766544801370212627256410732664011822421191103127619073582845123484719578718376300070162
3559697187867665447056668665472415760087515853199535840722669319157651180411707498446946868000728225
3645047729376722728027830359847931381630353918463099666897923000492574941415862715967160037902320389
4575932729998748035419783450180418397923824642227478374530825875117414862969170359605774864660165183
5322584938677546251543880527416956480705944725311597939528470788168416013456117592029593807489999785
7754994231777473857077540442648191973318696846843127043160597249863794695612602222961479708711722582
3565342748501153741450722494697466495557622414355168111360033562039346636733121121610857454876606487
4437948112225917562671449140064129184323117813007771036103741140919976957421088770020828622820980756
8174997997844642548903739554176395687320173802080968908508233365267783712263290308322496412573662449
1672540404024051399430701347505739704581760444853708889328730053965944499104791856210999740898398825
9186576198880958655481027359139130943867357146964187267415766784479053752668195347802707054927335288
4306427366831035594880608591499890907843012343484264435376659310820975773157891566438967632147776593
7156616387196395610946243206146663560610797140874906254178018061181083047209661789909286724851898477
5738007026336011756203966009491341221782766858121421205681271800962739039717580099932017189089936737
6419938680039814317850253008266050001472296498186497785170629898188206247899408324336455988266359449
1418634537443259947411981605363306172530522346606185828881879282631498937150281652951729913616393089
6586743466638537074611269401244227647666143845006402001658338575901447415469814028796125724122303196
5993488234459874456623787668065374732778460003479662413672767907224747177590741751760965542222986054
4695004718249668190489544232936202367307609329582839156431588444789676252562273585535627566417124298
9413198142731138300100775368824022737929340526046584250462996845583114493685190164404352197775191277
52414574327366464226160312027143

Below is the brainfuck program (likewise divided into lines of 100 characters). If you translate it to Unary it should become the number above (in unary of course).

And it does! I just tried -- that is, converting the Unary program's binary phase to decimal, converting it to unary would be impossible... But of course if the number matches in decimal it matches in unary as well. --Keymaker 00:59, 21 January 2012 (UTC)
>+++++>++>++++++>+>+++++>+++++>+>++++++>+>+++++>+>++++++>+>+++++>+>++++++>+++>+++++>+++++>+>+++>++>+
+++>++++++>++>++++++>+++>+++++>++>++++++>++>+++++>++>++++++>+>+++++>+++++>+>++++++>+>+++++>+>++++++>
+>+++++>+>++++++>++>+++>+++++>+++++>+>+++>++>++++>++++++>++>++++++>+++>+++>+++>+++++>++>++++++>++>++
+++>++>++++++>+>++++>++++++>+>++++++>+>+++++>+>++++++>+>+++++>++++>+++++>++>+++>+>++++>++++++>+>++++
++>++>++>+++++>++>++++++>+>+++++>+++++>+++++>+>++++++>+>+++>++>++>+++++>++>++++++>+>++++>++++++>+>++
+++>+>++++++>+++>+>++++>+++++>++++>+++++>++++>+++++>++++>+++++>++++>+++++>++++>+++++>++++>++>++++>+>
+>+>+++++>+>+>+>++++++>+++>+++>+>+>+>+++>+>+>+>+++>+++++>++>++>++>++++++>+>++++++>++>+++++>++++>+>+>
+>+++++>+>+>+>++++++>+++>+++>+>+>+>+++>+++>+>+>+>+++>+++>+++++>++>++>++>++++++>++++++>+>++++++>++>++
+++>++++>+>+>+>+++++>+>+>+>++++++>+++>+++>+>+>+>+++>+++>+>+>+>+++>+++++>++>++>++>++++++>++++++>+>+++
+++>++>+++++>++++>+>+>+>+++++>+>+>+>++++++>+++>+>+>+>+++>+++>+>+>+>+++>+++>+++++>++>++>++>++++++>+++
+++>+>++++++>++>+++++>++++>+>+>+>+++++>+>+>+>++++++>+++>+>+>+>+++>+++>+>+>+>+++>+++++>++>++>++>+++++
+>++++++>+>++++++>++>+++++>++++>+>+>+>+++++>+>+>+>++++++>+++>+>+>+>+++>+>+>+>+++>+++>+++++>++>++>++>
++++++>++++++>+>++++++>++>+++++>++++>+>+>+>+++++>+>+>+>++++++>+++>+>+>+>+++>+>+>+>+++>+++++>++>++>++
>++++++>++++++>++>+++++>++>++++++>+>++++++>+++>+++>++>+++>+++++>++>+++>+>+>+++++>+++++>+>+++>+>+++>+
+>++>++++>++++++>+>+++++>++>+++>+>++++>++++++>+>++++>+++++>++++>+++++>++++>+>+++++>+>+++>+>+++>++>++
>++++>++++++>+>+++++>++>+++>+>++++>++++++>+>+++++>++>+++>+>++++>+++++>++>++++>+>+++++>++++>++++++>++
++++>++++++>++>+++++>++++>++>++++>+>+>+>+++++>+>+>+>++++++>++>++>++>+++++>+++++>+>+>+>+++>++>++>++>+
+++>++++++>++>++>++>++++++>+>+>+>+++>+++>+++>++>++>++>+++>+++>+++>++>++>++>++++>++++>++++>++>++>++>+
++++>++>++>++>++++++>+>++++>+>+>+++++>+>+>+>++++++>+++>+++++>+>+>+>++++++>+>++++++>++>++>++++++>++++
++>+>++++++>++>++>++>+++++>++>++>++>++++++>+>+++++>++>++>+++>+>+++>+>++++>++++++>++>++>+++++>+>+>+++
>++>++>++++>++++++>+>+++++>++++>+>+>+>+++++>+++++>+>+++>+>+++>++>++>++++>++++++>+>+++++>++>+++>+>+++
+>++++++>+>++++>+++++>++>+++>+>++++>+++++>++>++++>+>++++>++++++>++>+++++>++++>++>++++>++++>+>+>+>+++
++>+>+>+>++++++>++>++>++>+++++>+++++>+>+>+>+++>++>++>++>++++>++++++>++>++>++>++++++>+>+>+>+++>+++>++
+>++>++>++>++>++>++>+++++>++>++>++>++++++>+>++++>+>+>+++++>+>+>+>++++++>+++>+++++>+>+>+>++++++>++>++
>++++++>+>++++++>+>++++++>++>++>++>+++++>++>++>++>++++++>++++++>+>+++++>++>++>+++>+>+++>+>++++>+++++
+>++>++>+++++>+>+>+++>++>++>++++>++++++>+>+++++>++++>+>+>+>+++++>+++++>+>+++>+>+++>++>++>++++>++++++
>+>+++++>++>+++>+>++++>++++++>+++>+>++++>+++++>++>++++>+>+++++>++++>++++++>++++++>++>+++++>++++>++>+
+++>++>++>++>+++++>++>++>++>++++++>+>++++>+>+>+++++>+>+>+>++++++>+>+>+>+++++>+++++>++>++>++>+++>+>+>
+>++++>++++++>+>+>+>++++++>++>++>++>++>++>++++++>+>+>++++++>++>++>++>+++++>++>++>++>++++++>++++++>+>
+++++>+>++++>++>++++>++++++>+>++++++>+>+++++>+++>+++>+++>+++++>+>+++>+++>+++>+++>+++>+++>+++>+++>++>
++++>++++++>+>+++++++>+>+>++++++[<]>[[>]>[>]>[>]+[[>+<-]<]+[<]<[<]>[[>]>[>]>[>]<+[[>+<-]<]+++[<]<[<]
>-]>]>[>]>[-[<+>-]>]<<[<]>[[[>]>+<<[<]>-]>[>]+>-[-[-[-[-[-[-<->>>[>>>]++>>>+>>>+[<<<]>]<[->>>[>>>]++
>>>++>>>++[<<<]]>]<[->>>[>>>]++>>>++>>>+[<<<]]>]<[->>>[>>>]+>>>++>>>++[<<<]]>]<[->>>[>>>]+>>>++>>>+[
<<<]]>]<[->>>[>>>]+>>>+>>>++[<<<]]>]<[->>>[>>>]+>>>+>>>+[<<<]]<[<]>]++
%
<+[<+>>[[>+>+<<-]>[<+>-]>-[-[->[>+>+<<-]>[<+>-]>[<+>-[<->[-]]]<[-<->>>[>>>]<<<[[>>>+<<<-]<<<]>>>+++<
<<+++<<<---<<<[<<<]>->>[>>>]+[>>>]>]<<]]>]<<<[<<<]>[<<+>+>-]<<[>>+<<-]>[->>>[[>+>+<<-]>[<+>-]>-[<+>-
[<->-]<[-<-->>>[>>>]<<<[[>>>+<<<-]<<<]>>>+++<<<<<<[<<<]>->>[>>>]+[>>>]<<]>]>]<<<[<<<]]>[<<+>+>-]<<[>
>+<<-]>[->>>[[>+>+<<-]>[<+>-]+>-[<->[-]]<[-<-<<<[<<<]>->>[>>>]>>>[[<<<+>>>-]>>>]<<<<<]>>]<<<[<<<]]>[
>-<-]>]>[+++[>++++++++<-]>.>>]

The "%" in between is meta-data for the brainfuck interpreter (the "#" of the plan somewhere above). Once the brainfuck interpreter reaches that point it can print all the memory and quit. The code after "%" is for the Markov algorithm and printing the resulting unary number in '0's. Suffices to say, it's pointless to try running this program till it completes. :) --Keymaker 00:41, 21 January 2012 (UTC)