text:
Render a version of the BBC Micro owl logo

Can you render out a version of the BBC Micro Owl logo as per above from code?
Rules:

You can use any programming language you like.
Output can be text or graphic.
Circles don't have to overlap.

Winner:

The answer with the most upvotes wins.

Kudos for anyone that attempts this in BBC basic.
You can read about the BBC Micro here

"Most inventive" and "most like the original" is subjective. Please provide an objective winning criterion. (I am voting to close, as per "Questions without an objective primary winning criterion are off-topic, as they make it impossible to indisputably decide which entry should win.")

I have changed the win criteria to the shortest code which I hope is less subjective for everyone.

Maybe [tag:code-golf] is fine but I think this question could suit a [tag:popularity-contest] tag instead.  Most votes wins.  That's objective.  Mob decides.  This encourages interesting results without sacrificing output quality/creativity to save a few chars of code.  Witness the freestyle Olympic rings question.

Good idea I have changed it to most upvotes wins which is fairer. How do I get this taken off hold?

We need a tikz answer.

On no, don't close it!

In what universe is "The answer with the most upvotes wins." not an objective criterion? If that is close-worthy, why even have a popularity-contest tag?

@gastropner that question was visited about 3 years ago here; they've fallen a bit out of favor in recent years but they're still allowed.

I do not think that it is fruitful to close a six years old question with twelve well-received answers.

@Giuseppe Thanks for that link; It strengthens my take that it's absurd that people (who should know much better) voted to close a question based on absolutely nothing.

BBC BASIC
I tried using trig functions to draw proper circles, but that was painfully slow. Came up with this instead:
10 MODE 1
20 GCOL 0,1 : VDU 19,1,3,0,0,0
30 FOR Y%=0 TO 20
40 READ N% : P%=65536
50 FOR X%=0 TO 16
60 IF (N% AND P%)=0 THEN GOTO 160
70 X0% = X%*32+384 : Y0% = 872-Y%*32
80 FOR DX%=-16 TO 16 STEP 8
90 FOR DY%=-8 TO 8 STEP 8
100 PLOT 69,X0%+DX%,Y0%+DY%
110 NEXT DY% : NEXT DX%
120 FOR DX%=-8 TO 8 STEP 8
130 FOR DY%=-16 TO 16 STEP 32
140 PLOT 69,X0%+DX%,Y0%+DY%
150 NEXT DY% : NEXT DX%
160 P%=P%/2
170 NEXT : NEXT
1000 DATA 87381,33410,69905,10280
1010 DATA 69649,33410,82181,40968
1020 DATA 87377,43520,87297,43520
1030 DATA 21761,10880,5441,2720
1040 DATA 1361,552,1093,43682,1

Here's the output:

Wow seriously amazing someone actually took the time to use BBC basic. I'm very impressed!!

That's a nice owl. Are you using a real BBC or an emulator program. If it's an emulator, which one? cos it's not the same as the one I used.

BTW, if you want to draw circles quicker, don't use trig functions, use pythagoras theorem: Y=(R^2-X^2)^0.5 see my answer to the rainbow question. And there's actually a more advanced way of doing it with only addition, based on the fact that (1)+(3)+(5)....(1+2n) = (n+1)^2.

GolfScript
"!C-DD[5v`>U8G`J2zX['b#L*\\q>FQp "{32-}%96base 2base{"   *"2/=}%18/{""*1>17/~n@n}/

The code prints an ascii art version of the logo (run here).
* * * * * * * * *
 *     * *     *
*   *   *   *   *
   * *     * *
*   *       *   *
 *     * *     *
* *     *     * *
 * *         *
* * * * * * *   *
 * * * *
* * * * *       *
 * * * *
  * * * *       *
   * * * *
    * * * *     *
     * * * *
      * * * *   *
       *   * *
      *   *   * *
 * * * * * *   *
                *

Really impressive in 82 characters!

Mathematica
Nothing but grunt work.
w = 20; h = 25; r = .7; r2 = .2; t = Table; d = Disk;
owl = Graphics[{Polygon[{{0, 0}, {w, 0}, {w, h}, {0, h}}],
   ColorData[57, 4],
   t[d[{k, 22}, r], {k, 2, 19, 2}],
   t[d[{18, k}, r], {k, 2, 21, 2}],
   t[d[{k, #}, r], {k, #2}] & @@@ {{21, {3, 9, 10, 11, 17}}, {20, {2,
       6, 10, 14, 18}},
     {19, {5, 6, 7, 13, 14, 15}}, {18, {6, 9, 11, 14}}, {17, {10,
       17}, {16, {16}}, {15, {15}}, {14, {8, 10, 12, 14}},
      {13, {9}}, {12, {9}}}},
   t[d[{# - k, k}, r], #2] & @@@ {{20, {k, 18, 3, -1}}, {19, {k, 16,
       6, -1}}, {18, {k, 16, 5, -1}}, {17, {k, 14, 7, -1}}, {16, {k,
       14, 6, -1}}, {14, {k, 11, 5, -1}}, {14, {k, 12, 5, -1}}},
   t[d[{k, 4}, r], {k, {8, 12}}],
   t[d[{k, 3}, r], {k, 3, 13, 2}],
   d[{8, 13}, r],
   Black, d[{10, 21}, r2], d[{8, 13}, r2], d[{9, 12}, r2],
   t[d[{19 - k, k}, r2], {k, 16, 6, -1}],
   t[d[{17 - k, k}, r2], {k, 14, 7, -1}],
   t[d[{15 - k, k}, r2], {k, 12, 6, -1}],
   t[d[{k, 19}, r2], {k, {6, 14}}]}, ImageSize -> 220]

R
image(t(matrix(as.integer(sapply(c(1397760,567810,1070336,141954,1381696,133794,
                                   1054036,559786,1332560,557218,1052756,131114,
                                   1380368,139272,1064964,557058,1398101),
                                   intToBits)[1:21,]),nr=21)),ax=F)

Results in:

Basically the idea is to take the base-2 representation of the 17 numbers (1397760,  567810, 1070336, 141954, 1381696, 133794, 1054036, 559786, 1332560, 557218, 1052756, 131114, 1380368, 139272, 1064964, 557058 and 1398101), make it into a 21x17 matrix of 1 and 0s and plot the matrix as is.

Pov-Ray
background{color<.14,.01,.01>}
camera{orthographic location z*-2 up y*24 right x*20}
#macro s(X,Y)sphere{<X,Y,0>,1.07,2.6}#end
#declare b=array[17]{1397760,567810,1070336,141954,1381696,133794,1054036,
559786,1332560,557218,1052756,131114,1380368,139272,1064964,557058,1398101}
blob{threshold 0.9 #for(j,0,16,1)#declare V=b[j];#for(i,0,28,1)
#if(mod(V,2))s(j-8,i-10)#end #declare V=floor(V/2);#end #end
pigment{color<1,1,.8>}finish{ambient 1}}

'compile' with
povray +Ibbc.pov -Obbc.png +A0.1 +R9 -W240 -H285

Bash
Since you didn't specify no external resources...
curl -s http://codegolf.stackexchange.com/questions/19214/render-a-version-of-the-bbc-micro-owl-logo | grep '* * *' | sed -n '/code>\*/,/<pre>/p' | sed '$d' | sed 's/<pre><code>//'

Howard - stole your Ascii art, thanks.
Or after I uploaded it here -
curl -s http://textuploader.com/1ojd | sed -n '/<code/,/<\/code>/p' | sed 's/<[^>]\+>//g'

Well that's lateral thinking I suppose...

BBC Basic, random colours, golfed!
149 characters. I'm not that big on golfing (I prefer the code challenges) but I liked the ridiculousness of golfing in BBC basic. BBC emulator at http://www.bbcbasic.co.uk/. Runs in screen mode 6 at the command line.
FORK=6TO185S=K MOD9=5VDU-32*(K MOD18=15),17,128+RND(6)*(ASCMID$("?OSUuLEMSS^H?=A_W",K/6,1)/2^(K MOD6)AND1),32,17,128,32,-13*S,-10*S:NEXT

Explanation (ungolfed version)
No IF statements, because the rest of the line would only be executed if the IF was true (so to ensure the NEXT was reached I would have to do a program with line numbers.) Therefore I made a lot of use of ASC(null character)=0 to control output. Also, I had to cut off the pixel at the bottom right corner to fit the whole command line on the screen after printing (and that saved 2 characters.
I love how BBC basic can recognise an identifier after FOR, even with no white space. FORE, FORD, FORK, FORM, FORS, FORT :-)
 FOR K=6 TO 185

     REM Set S to true(-1) if K mod 9 = 5, otherwise set S to false(0)

     S = K MOD 9=5

     REM If K mod 18 = 15, send asc(space)=32 to the VDU controller,otherwise send 0.
     REM This causes staggering every 2 lines.

     VDU-32*(K MOD18=15)

     REM Vdu 17 for colour. foreground colours start at 0, background colours at 128.
     REM Rnd(6) to choose a bright color. Multiply by the horrible expression.
     REM The horrible expression evaluates to 1 if the pixel is to be printed, 0 if not.
     REM Picture data is stored in base 64 in the string.
     REM MID$ extracts the characters in order.
     REM The FOR loop starts at K=6 so that this will work properly.
     REM Extracted character SHR ((K mod 6)) AND 1 to decide to
     REM colour pixel or not. BBC basic does not have SHR operator.
     REM so we divide by 2^(K mod 6) instead.

     VDU 17,128+RND(6)*
      (ASC(MID$( "?OSUuLEMSS^H?=A_<A^tC|dGxEMh>W" ,K/6,1))/2^(K MOD 6)AND 1)

     REM Print a space in the new background colour

     VDU 32

     REM Change background colour back to black

     VDU 17,128

     REM Print another space

     VDU 32

     REM If S is true (-1) print a carriage return and linefeed. otherwise two 0's

     VDU -13*S,-10*S

 NEXT

Thanks for contributing that's a really clever solution and a nice multicoloured owl, I haven't seen golfed BBC basic before.

Thank you for inspiring me to go and look for a BBC basic emulator. It's a great language that I haven't used in 20 years. It's got a lot of graphics facilities built in without having to include add-on libraries, which makes it an excellent language for golfing a task like this.

Also, first time I've used base 64. It was just right for this image, being 18 pixels for each 2 lines. I will definitely use it again.  The fact that the 6th bit is uppercase/lowercase means you only really have to think about the other five. I found that made it almost as easy as hex once I got into it.

I just did this https://twitter.com/bbcmicrobot/status/1229933895401058304 based on some of your techniques, thanks a lot; I notice however you missed some golfing opportunities. BBC Basic lets you abbreviate commands, eg 'FOR'='F.', 'VDU'='V.', plus x/2^z AND 1 is just x AND 2^z, you don't need SHR

C
ASCII output.
x[]={256,191,424,104,376,60,316,30,286,15,287,15,383,67,403,153,325,102,341,153,511};i=20;mai
n(){for(;i>=0;i--){i&1&&putchar(32);while(x[i]){putchar(x[i]&1?42:32);x[i]>>=1;putchar(32);}pu
tchar(10);}}

Code output:
* * * * * * * * *
 *     * *     *
*   *   *   *   *
   * *     * *
*   *       *   *
 *     * *     *
* *     *     * *
 * *         *
* * * * * * *   *
 * * * *
* * * * *       *
 * * * *
  * * * *       *
   * * * *
    * * * *     *
     * * * *
      * * * *   *
       *   * *
      *   *   * *
 * * * * * *   *
                *

JavaScript - 326 307 285 characters (ASCII)
a=[1716886015,1133746501,253693823,1010572830,3215485048,0];s="";with(Math)
for(y=0;44>y;y++,s+="\n")for(x=0;90>x;x++,s+="#8*+=:-. "[min(floor(d),8)])
for(j=d=0;22>j;j++)for(i=0;9>i;i++)1==((8==i?j+1:a[floor(j/4)]>>i+j%4*8)&1)
&&(d+=50/pow(pow(x-10*(i+j%2/2)-4,2)+pow(2*y-4*j-4,2),1.5));s;

Probably not the shortest code. I tried to be as close as possible to the original logo, using only ASCII.
To execute : copy paste to javascript console (eg: chrome or firefox).
Note : the script might take a little time to run so if nothing come just after pressing enter, be a little patient.

You can shorten this by doing m=Math; and then doing m.floor, m.pow etc.

Even moreso by wrapping the outermost for-loop in a with (Math) and then omitting Math. at each occurence.  Move the s+= parts to the for-loop header (next to y++/x++) to get rid of some braces.  I think it's typical to use alert/prompt for I/O when golfing in JS, so I'd go with alert(s) at the end instead.

Thanks for tips and comments. I am a beginner when it comes to code size optimizing :) About alert / prompt suggestion : I tried to use them, but there is some issues : browsers (chrome at least) seems to automatically wrap text if line is too long, which broke logo.

CoffeeScript
Code isn't golfed. It uses some metaballs-ish algorithm to simulate "stickyness" of the circles. ASCII owl was shamelessly stolen from other answers :)
canvas = document.createElement 'canvas'
canvas.style.backgroundColor = '#240202'
canvas.style.transform = 'scale(0.5) translate(-480px,-570px)'
W = canvas.width = 960
H = canvas.height = 1140
D = 50
R = D / 2
ctx = canvas.getContext '2d'
imageData = ctx.getImageData 0, 0, W, H
data = imageData.data
owl = '''

\ * * * * * * * * *
\  *     * *     *
\ *   *   *   *   *
\    * *     * *
\ *   *       *   *
\  *     * *     *
\ * *     *     * *
\  * *         *
\ * * * * * * *   *
\  * * * *
\ * * * * *       *
\  * * * *
\   * * * *       *
\    * * * *
\     * * * *     *
\      * * * *
\       * * * *   *
\        *   * *
\       *   *   * *
\  * * * * * *   *
\                 *
'''.split '\n'

insideDot = (x, y) ->
  w = 0
  for du in [-1..1] then for dv in [-1..1]
    u = x // D + du
    v = y // D + dv
    continue unless owl[v]?[u] is '*'
    dx = x - (u * D + R)
    dy = y - (v * D + R)
    d = dx * dx + dy * dy
    w += 1 / (d * d)
    return yes if w > 0.0000008
  no

for y in [0...H] then for x in [0...W] when insideDot x, y
  i = (y * W + x) * 4
  data[i] = data[i+1] = data[i+3] = 255
  data[i+2] = 214

ctx.putImageData imageData, 0, 0
document.body.appendChild canvas

Watch it destroy the coffeescript.org documentation (hit Run):

BBC Basic+GXR
Very late to this but: the 'bbcmicrobot' account on twitter which runs progs<280 chars or so added the Acorn GXR ROM, allowing drawing circles and ellipses. I thought, what could I draw with a couple of circles? And this came to me. It's based in part on the answer by @Level River Street, tho I've used abbreviated basic commands, used bit testing instead of SHR and changed the bit representation:
2MO.2:P."HOW TO DRAW AN OWL":MOV.200,700:PL.&91,120,0:MOV.250,450:PL.0,-200,0:PL.&C1,155,250:V.29,640;130;
5F.G=0TO188:Z=(G MOD18)>8:X=G MOD9*2-Z:Y=G DIV18*2-Z
6IFASC(MID$("@|WhFMxeG|tC^|A_|A?]HSNSEuLUMS?G",(G+6)DIV6,1))AND2^(G MOD6) MOV.X*36,Y*36:PL.&99,24,0
8N.G

My original tweet is here

PHP
Building upon the ascii art versions of the logo submitted previously and using this as the array to render a graphical version using the GD library.
$circleWidth = 34;
$circleHeight = 34;
$movement = 24;
$canvasWidth = 480;
$canvasHeight = 570;
$image = imagecreatetruecolor($canvasWidth, $canvasHeight);
$backgroundColour = imagecolorallocate($image, 36, 2, 2);
ImageFillToBorder($image, 0, 0, $backgroundColour, $backgroundColour);
$circleColour = imagecolorallocate($image, 255, 255, 214);
$coordinates ='
* * * * * * * * *
 *     * *     *
*   *   *   *   *
   * *     * *
*   *       *   *
 *     * *     *
* *     *     * *
 * *         *
* * * * * * *   *
 * * * *
* * * * *       *
 * * * *
  * * * *       *
   * * * *
    * * * *     *
     * * * *
      * * * *   *
       *   * *
      *   *   * *
 * * * * * *   *
                * ';
$coordinates = str_split($coordinates);
$coordinateX = $movement;
$coordinatY = $movement;
$i=1;
foreach ($coordinates as $coordinate) {
    if ($i < 19) {
        if ($coordinate == '*') {
            ImageFilledEllipse($image, $coordinateX, $coordinatY, $circleWidth, $circleHeight, $circleColour);
        }
        $coordinateX = $coordinateX + $movement;
        $i++;
    } else {
        $i=1;
        $coordinateX = $movement;
        $coordinatY = $coordinatY + $movement;
    }
}
header("Content-type: image/png");
imagepng($image);
imagedestroy($image);

Results in:


text:
LARGEST program to reverse a single line from stdin with no redundant code
The biggest program that reads a single line (terminated by your choice from NULL/CR/LF/CRLF) from stdin, reverses it, then prints it to stdout.
No redundant code [code which could safely be deleted] such as
return ;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;

or redundant data that's used to stop code being redundant:
char* data = <kernel source code>;
if (md5sum(data) != <hash>) {
    return 1; //Fail for no good reason because it lets us add 1000000 lines of data
}

Basically, the largest implementation of a string reverse, with no obvious attempt to game the question.
[edit]
I am tempted to say that the code must be finite for unbounded input length, but there have been some clever and interesting O(>1) length solutions.  I instead ask that people avoid posting simple brute-force lookup-list solutions as separate answers (comments are fine!).

Longest code is [tag:code-bowling] rather than [tag:code-trolling]

@Gareth: Cheers, changed

Ok, I'm really confused about the goal of this. You tagged this as [tag:popularity-contest], which implies a subjective competition, but you've defined an objective winning criteria. Then you've also tagged it [tag:code-trolling], which implies that you want some sort of useless or misguided answers to a relatively simple and undereducated question, but your challenge is not so simple and deliberately asking for a particular level of complexity. The challenge, as stated, is strictly [tag:code-bowling] only.

@Iszi: I'm new to this site...

Note: least efficient and largest are not necessarily the same.

Largest I can think of: if (!strcmp(input, "aaa")) printf("aaa"); else if (!strcmp(input, "aab")) printf("baa");, etc. So I guess the correct solution to this challenge is to figure out the longest possible size of an answer on stackexchange and implement as many compares as possible in it that reverse parts of the string.

I suppose that this challenge should require a finitely long code that can theoretically deal with an infinitely long input.

I wish we could reopen this question, as it is definitely interesting.

Meanwhile something like the Doge answer is definitely redundant code since every character in the variable name but one can be removed safely

C# – Something about 90 KB, but actually, ~90×n for any n
See https://gist.github.com/mormegil-cz/8581459 for the full source code. A short preview version to taste:
var c1 = Console.Read();
if (c1 > 0 && c1 != 13)
{
    var c2 = Console.Read();
    if (c2 > 0 && c2 != 13)
    {
        var c3 = Console.Read();
        if (c3 > 0 && c3 != 13)
        {
            // ...
            Console.Write((char)c3);
        }
        Console.Write((char)c2);
    }
    Console.Write((char)c1);
}
Console.WriteLine();

And because writing the source code seems a bit repetitive, let’s use a simple tool:
void Main()
{
    const int MAX_DEPTH = 1000;
    Console.WriteLine("using System;");
    Console.WriteLine("using System.Text;");
    Console.WriteLine();
    Console.WriteLine("class C");
    Console.WriteLine("{");
    Console.WriteLine("\tstatic void Main()");
    Console.WriteLine("\t{");
    for (int i = 0; i < MAX_DEPTH; ++i)
    {
        var indent = new string('\t', i + 2);
        Console.WriteLine("{0}var c{1} = Console.Read();", indent, i);
        Console.WriteLine("{0}if (c{1} > 0 && c{1} != 13)", indent, i);
        Console.WriteLine("{0}{{", indent);
    }
    var restIndent = new string('\t', MAX_DEPTH + 2);
    Console.WriteLine("{0}var rest = new StringBuilder();", restIndent);
    Console.WriteLine("{0}for (var c = Console.Read(); c > 0 && c != 13; c = Console.Read())", restIndent);
    Console.WriteLine("{0}{{", restIndent);
    Console.WriteLine("{0}\trest.Append((char)c);", restIndent);
    Console.WriteLine("{0}}}", restIndent);
    Console.WriteLine("{0}var restArray = rest.ToString().ToCharArray();", restIndent);
    Console.WriteLine("{0}Array.Reverse(restArray);", restIndent);
    Console.WriteLine("{0}Console.Write(new string(restArray));", restIndent);
    for (int i = MAX_DEPTH - 1; i >= 0; --i)
    {
        var indent = new string('\t', i + 2);
        Console.WriteLine("{0}\tConsole.Write((char)c{1});", indent, i);
        Console.WriteLine("{0}}}", indent);
    }
    Console.WriteLine("\t\tConsole.WriteLine();");
    Console.WriteLine("\t}");
    Console.WriteLine("}");
}

Change MAX_DEPTH to get a larger score (or possibly an internal C# compiler error?).

On a MS C# compiler I have here, MAX_DEPTH=2385 seems to be the maximum (corresponding to a source size of ~220 KB), anything larger causes fatal error CS1647: An expression is too long or complex to compile. :-)

For extra bytes, why not use stuff from Microsoft.CSharp to compile your code and run it instead of printing it :D

Or make it Java! That program might fill your hard drive with all the System.out.println()s!

I think this challenge would perfectly suit COBOL :D

Wouldn't this be called redundant because it can safely be replaced by a recursive call?

@ThomasWeller replacement != deletion

C#
6710 bytes
212 lines of code including 6 comments
3 classes, 2 interfaces, 1 file
using System;
using System.Collections.Generic;

namespace StringReverse
{
    public class Program
    {
        public static void Main(string[] args)
        {
            UnreversedString unreversed = Console.ReadLine();
            ReversedString reversed = ReverseString(unreversed);
            Console.WriteLine(reversed);
        }

        public static ReversedString ReverseString(UnreversedString unreversed)
        {
            // We know that string reversing is recursive.
            // We also know that recursion is confusing.
            // Therefore, we will use a recursive algorithm without actually using recursion.
            // This will greatly "simplify" our code. ;)
            Stack<IString> stringStack = new Stack<IString>();
            stringStack.Push(unreversed);
            Random random = new Random();
            do
            {
                if (stringStack.Peek() is UnreversedString)
                {
                    IString unreversedString = stringStack.Pop();
                    if (unreversedString.Length < 2)
                    {
                        ReversedString reversedString = unreversedString.ToString();
                        stringStack.Push(reversedString);
                    }
                    else
                    {
                        int randomInt = random.Next(unreversedString.Length);
                        IString firstHalfOfUnreversedString = unreversedString.Substring(0, randomInt);
                        IString secondHalfOfUnreversedString = unreversedString.Substring(randomInt);
                        stringStack.Push(firstHalfOfUnreversedString);
                        stringStack.Push(secondHalfOfUnreversedString);
                    }
                }
                else
                {
                    IString firstString = stringStack.Pop();
                    IString secondString = stringStack.Pop();
                    if (secondString is UnreversedString)
                    {
                        stringStack.Push(firstString);
                        stringStack.Push(secondString);
                    }
                    else
                    {
                        ReversedString newReversedString = secondString.ToString() + firstString.ToString();
                        stringStack.Push(newReversedString);
                    }
                }
            }
            while (stringStack.Count > 1);
            return stringStack.Pop() as ReversedString;
        }
    }

    // We need a common way to treat strings, because they all need to be stored in the same stack.
    public interface IString
    {
        int Length
        {
            get;
        }

        IString Substring(int startIndex);
        IString Substring(int startIndex, int length);
    }

    public interface IString<T> : IString where T : IString<T>
    {
        new T Substring(int startIndex);
        new T Substring(int startIndex, int length);
    }

    // We also need a way to differentiate between them.
    public class UnreversedString : IString<UnreversedString>
    {
        private string unreversedString;

        public string UnreversedStringValue
        {
            get
            {
                return this.unreversedString;
            }
            set
            {
                this.unreversedString = value;
            }
        }

        public int Length
        {
            get
            {
                string unreversedString = this;
                return unreversedString.Length;
            }
        }

        public UnreversedString Substring(int startIndex)
        {
            string unreversedString = this;
            return unreversedString.Substring(startIndex);
        }

        public UnreversedString Substring(int startIndex, int length)
        {
            string unreversedString = this;
            return unreversedString.Substring(startIndex, length);
        }

        IString IString.Substring(int startIndex)
        {
            return this.Substring(startIndex);
        }

        IString IString.Substring(int startIndex, int length)
        {
            return this.Substring(startIndex, length);
        }

        public override string ToString()
        {
            return this.UnreversedStringValue;
        }

        public static implicit operator string(UnreversedString unreversedString)
        {
            return unreversedString.ToString();
        }

        public static implicit operator UnreversedString(string unreversedString)
        {
            UnreversedString newUnreversedString = new UnreversedString();
            newUnreversedString.UnreversedStringValue = unreversedString;
            return newUnreversedString;
        }
    }

    public class ReversedString : IString<ReversedString>
    {
        private string reversedString;

        public string ReversedStringValue
        {
            get
            {
                return this.reversedString;
            }
            set
            {
                this.reversedString = value;
            }
        }

        public int Length
        {
            get
            {
                string reversedString = this;
                return reversedString.Length;
            }
        }

        public ReversedString Substring(int startIndex)
        {
            string reversedString = this;
            return reversedString.Substring(startIndex);
        }

        public ReversedString Substring(int startIndex, int length)
        {
            string reversedString = this;
            return reversedString.Substring(startIndex, length);
        }

        IString IString.Substring(int startIndex)
        {
            return this.Substring(startIndex);
        }

        IString IString.Substring(int startIndex, int length)
        {
            return this.Substring(startIndex, length);
        }

        public override string ToString()
        {
            return this.ReversedStringValue;
        }

        public static implicit operator string(ReversedString reversedString)
        {
            return reversedString.ToString();
        }

        public static implicit operator ReversedString(string reversedString)
        {
            ReversedString newReversedString = new ReversedString();
            newReversedString.ReversedStringValue = reversedString;
            return newReversedString;
        }
    }
}

Mornington Crescent, 1480 1587 bytes
+107 bytes thanks to Cloudy7
Take Northern Line to Moorgate
Take Metropolitan Line to Moorgate
Take Metropolitan Line to Wembley Park
Take Metropolitan Line to Wembley Park
Take Jubilee Line to West Ham
Take Hammersmith & City Line to West Ham
Take Hammersmith & City Line to Euston Square
Take Hammersmith & City Line to Euston Square
Take Circle Line to Liverpool Street
Take Central Line to Liverpool Street
Take Central Line to Oxford Circus
Take Victoria Line to Oxford Circus
Take Victoria Line to Victoria
Take Victoria Line to Victoria
Take District Line to Bank
Take Waterloo & City Line to Bank
Take Waterloo & City Line to Waterloo
Take Waterloo & City Line to Waterloo
Take Bakerloo Line to Piccadilly Circus
Take Piccadilly Line to Piccadilly Circus
Take Piccadilly Line to Turnpike Lane
Take Piccadilly Line to Turnpike Lane
Take Piccadilly Line to Piccadilly Circus
Take Piccadilly Line to Piccadilly Circus
Take Bakerloo Line to Waterloo
Take Waterloo & City Line to Waterloo
Take Waterloo & City Line to Bank
Take Waterloo & City Line to Bank
Take District Line to Victoria
Take District Line to Victoria
Take Victoria Line to Oxford Circus
Take Victoria Line to Oxford Circus
Take Central Line to Liverpool Street
Take Central Line to Liverpool Street
Take Circle Line to Euston Square
Take Hammersmith & City Line to Euston Square
Take Hammersmith & City Line to West Ham
Take Hammersmith & City Line to West Ham
Take Jubilee Line to Wembley Park
Take Metropolitan Line to Wembley Park
Take Metropolitan Line to Moorgate
Take Metropolitan Line to Moorgate
Take Northern Line to Mornington Crescent

This code goes around in a huge loop using every single line but the Piccadilly Line, ending in Piccadilly Circus. Then it goes to Turnpike Lane, which reverses the string, before finally unwinding the loop and returning to Mornington Crescent.
Try it online!

Windows Command Script - 101 + 76*361 + 78*362 + ... + 276*36100 bytes
Note: max string length is 100, and the string is limited to alphanumeric characters
@echo off
echo.Enter string to reverse
set /p i=:
call :%i%
cscript //nologo rev.js
pause&exit/b
:a
echo.WScript.Echo("a".split("").reverse().join(""));>rev.js
exit /b
:aa
echo.WScript.Echo("aa".split("").reverse().join(""));>rev.js
exit /b
:aaa
.... and so on

Generated by:
@echo off
echo.Generating code... (this will take a LOOOONG time)
echo>b.cmd @echo off
echo>>b.cmd echo.Enter string to reverse
echo>>b.cmd set /p i=:
echo>>b.cmd call :%%i%%
echo>>b.cmd cscript //nologo rev.js
echo>>b.cmd pause^&exit/b
goto b
:a
echo>>b.cmd :%1
echo>>b.cmd echo.WScript.Echo("%1".split("").reverse().join(""));^>rev.js
echo>>b.cmd exit /b 1
set tmp=%1
if not "%tmp:~100,1%"=="" (
exit /b 0
)
:b
for %%a in (a b c d e f g h i j k l m n o p q r s t u v w x y z 0 1 2 3 4 5 6 7 8 9) do call :a %1%%%a

Have fun waiting...

I should have expected Windows CMD to take the lead here, after past experiences trying to port a 5-line bash script over to Windows... [took >100 lines of CMD, thanks largely to lack of backtick and programs not respecting the basic streams].

This gives me an idea for a hybrid golf/bowling question...
Post a sh script and equivalent cmd script - the objective is to maximise (lines of cmd / lines of sh) without redundancy

Brainfuck: 72 bytes
>>+[-<,[+[-----------[---[+++++++++++++>>+<]]]]>]<<[.[-]<]++++++++++.[-]

Suports CR/LF/CRLF no change EOF, -1 EOF and 0 EOF to get the bytecount up so it's very compatible.
Getting it larger is puishing it since BF is such a compact language. It's really better for golfing :-p

To do better in this challenge, consider converting your program to Unary or VerboseFuck

@ppperry I'll leave it to someone else as I don't find those dialects very interesting. I have no problems reading and following the code in this answer even two years after I wrote it, but a lot of BF dialects are just obscured syntax from the original that are far harder to read. Why would one want obscure BF?

Becuase they're longer and this is a [tag:code-bowling] challenge

You may find this answer a rule-bending one, you'll decide whether it's valid or not.
This code:

Is self-commented;
Handles every string from STDIN and outputs it in STDOUT;
Handles IO exceptions;
Has very bad memory usage;
Is very unefficient;
Will eventually end...

This answer is between the code-trolling and the code-bowling: it is trolling the user that reads/uses/wrote that code (am I trolling myself?), but it actually works; could be much shorter, but there is no redundant code (if you delete even one of the lines or the commands, it won't work). Also, it won't seem (at least, didn't to me) it is attempting to game the question.
C# - 6.825 7.037 bytes
using System;
using System.Collections.Generic;
using System.IO;
using System.Linq;
using System.Text;

namespace Console
{
    class Program
    {
        private const string omgAreYouDumbYouHaveToUseThisProgramThisWay = "Oh gawd please type the command this way! programName inputfile.txt outputfile.txt";
        static int Main(string[] sgra)
        {
            StreamWriter initializeThisStreamWriterHereBecauseItsCool = null;
            StreamReader initializeThisStreamReaderHereBecauseItsEvenCooler = null;
            if (sgra.Length < (calculateIntegerToAdd()+calculateIntegerToAdd()))
            {
                int didYouNoticeThatSgraIsArgsBackwardsAhahImSoFunny = calculateIntegerToAdd();
                WriteThisLineHereAndNowDidYouHearMeh(omgAreYouDumbYouHaveToUseThisProgramThisWay);
                return didYouNoticeThatSgraIsArgsBackwardsAhahImSoFunny;
            }
            try
            {
                initializeThisStreamWriterHereBecauseItsCool = new StreamWriter(sgra[calculateIntegerToAdd()]);
                initializeThisStreamReaderHereBecauseItsEvenCooler = new StreamReader(sgra[calculateIntegerToAdd()-calculateIntegerToAdd()]);
                System.Console.SetOut(initializeThisStreamWriterHereBecauseItsCool);
                System.Console.SetIn(initializeThisStreamReaderHereBecauseItsEvenCooler);
            }
            catch (IOException thisExceptionWouldMakeMyProgramCrashButICatchedItHaha)
            {
                TextWriter thisWillWriteIfThereIsAnyRuntimeErrorBecauseCrapHappenz = System.Console.Error;
                int valueThatWillBeReturnedBecauseThereIsAnErrorWowItsSoBad = calculateIntegerToAdd();
                thisWillWriteIfThereIsAnyRuntimeErrorBecauseCrapHappenz.WriteLine(thisExceptionWouldMakeMyProgramCrashButICatchedItHaha.Message);
                thisWillWriteIfThereIsAnyRuntimeErrorBecauseCrapHappenz.WriteLine(omgAreYouDumbYouHaveToUseThisProgramThisWay);
                thisWillWriteIfThereIsAnyRuntimeErrorBecauseCrapHappenz.Close();
                return valueThatWillBeReturnedBecauseThereIsAnErrorWowItsSoBad;
            }
            string thisIsGoingToBeReversedButHowPleaseTellMe = WootAreYouDoingDontMessAroundAndReadThatLine();
            char[] imGoingToStoreAllCharactersHereBecauseItsFun = new char[thisIsGoingToBeReversedButHowPleaseTellMe.Length];
            for (int awfulCounterWhyAreYouHere = calculateIntegerToAdd()-calculateIntegerToAdd(); awfulCounterWhyAreYouHere < thisIsGoingToBeReversedButHowPleaseTellMe.Length; awfulCounterWhyAreYouHere++)
            {
                imGoingToStoreAllCharactersHereBecauseItsFun[awfulCounterWhyAreYouHere] = thisIsGoingToBeReversedButHowPleaseTellMe.ElementAt(awfulCounterWhyAreYouHere);
            }
            char[] thisIsTheSolutionIllCheckIfMineIsEqual = new char[imGoingToStoreAllCharactersHereBecauseItsFun.Length];
            int pseudoAuxiliaryCounterThatIWillIncrementInTheForCycleAwesome = thisIsGoingToBeReversedButHowPleaseTellMe.Length-thisIsGoingToBeReversedButHowPleaseTellMe.Length;
            for (int awfulReversedCounterWhyAreYouHere = imGoingToStoreAllCharactersHereBecauseItsFun.Length-calculateIntegerToAdd();awfulReversedCounterWhyAreYouHere>-calculateIntegerToAdd();awfulReversedCounterWhyAreYouHere--)
            {
                thisIsTheSolutionIllCheckIfMineIsEqual[pseudoAuxiliaryCounterThatIWillIncrementInTheForCycleAwesome] = imGoingToStoreAllCharactersHereBecauseItsFun[awfulReversedCounterWhyAreYouHere];
            pseudoAuxiliaryCounterThatIWillIncrementInTheForCycleAwesome =     pseudoAuxiliaryCounterThatIWillIncrementInTheForCycleAwesome + calculateIntegerToAdd();
            }
            int cycleCounterBecauseIWantToSeeHowMyAlgorythmIsUnefficient = pseudoAuxiliaryCounterThatIWillIncrementInTheForCycleAwesome-pseudoAuxiliaryCounterThatIWillIncrementInTheForCycleAwesome;
            while (new String(imGoingToStoreAllCharactersHereBecauseItsFun) != new String(thisIsTheSolutionIllCheckIfMineIsEqual))
            {
                imGoingToStoreAllCharactersHereBecauseItsFun = bogoSortCanSu_Ehm_CannotBeatMyAlgorythmsAwesomeness(imGoingToStoreAllCharactersHereBecauseItsFun);
                cycleCounterBecauseIWantToSeeHowMyAlgorythmIsUnefficient = cycleCounterBecauseIWantToSeeHowMyAlgorythmIsUnefficient + calculateIntegerToAdd();
            }
            string omgIHaveASolutionHowLongDidItTake = new String(imGoingToStoreAllCharactersHereBecauseItsFun);
            WriteThisLineHereAndNowDidYouHearMeh(omgIHaveASolutionHowLongDidItTake);
            initializeThisStreamWriterHereBecauseItsCool.Close();
            return cycleCounterBecauseIWantToSeeHowMyAlgorythmIsUnefficient;
        }

        public static char[] bogoSortCanSu_Ehm_CannotBeatMyAlgorythmsAwesomeness(char[] uselessVariableWhichIsGoingToBeUsedAsInput)
        {
            char[] uselessVariableWhichIsGoingTobeReturned = uselessVariableWhichIsGoingToBeUsedAsInput;
            Random thisWillDecideWhichIndexesAreGoingToBeSwapped = new Random();
            int firstIndexToBeSwappedRandomlyGenerated = thisWillDecideWhichIndexesAreGoingToBeSwapped.Next(uselessVariableWhichIsGoingTobeReturned.Length);
            int secondIndexToBeSwappedRandomlyGenerated = thisWillDecideWhichIndexesAreGoingToBeSwapped.Next(uselessVariableWhichIsGoingTobeReturned.Length);
            char tempVariableWhichWillBeUsedForSwap = uselessVariableWhichIsGoingTobeReturned[firstIndexToBeSwappedRandomlyGenerated];
            uselessVariableWhichIsGoingTobeReturned[firstIndexToBeSwappedRandomlyGenerated] = uselessVariableWhichIsGoingTobeReturned[secondIndexToBeSwappedRandomlyGenerated];
            uselessVariableWhichIsGoingTobeReturned[secondIndexToBeSwappedRandomlyGenerated] = tempVariableWhichWillBeUsedForSwap;
            return uselessVariableWhichIsGoingTobeReturned;
        }

        public static void WriteThisLineHereAndNowDidYouHearMeh(string stringToBeWrittenHereAndNow)
        {
            System.Console.WriteLine(stringToBeWrittenHereAndNow);
        }

        public static string WootAreYouDoingDontMessAroundAndReadThatLine()
        {
            string thisStringIsGoingTobeReturnedOmgWhatDoIDoWhatDoIDo;
            thisStringIsGoingTobeReturnedOmgWhatDoIDoWhatDoIDo = System.Console.ReadLine();
            return thisStringIsGoingTobeReturnedOmgWhatDoIDoWhatDoIDo;
        }

        public static int calculateIntegerToAdd()
        {
            Random thisWillGenerateNumbersUntilItGetsOneItMayTakeAWhile = new Random();
            int isThisIntegerEqualToOneOrNot = 0;
            while (isThisIntegerEqualToOneOrNot != 1)
            {
                isThisIntegerEqualToOneOrNot = thisWillGenerateNumbersUntilItGetsOneItMayTakeAWhile.Next(0,10);
            }
            int thisIntegerIsEqualToOne = isThisIntegerEqualToOneOrNot;
            return thisIntegerIsEqualToOne;
        }
    }
}

Wow.  Just wow.  This code is dangerous, it tempts usage of the "doge" meme on SE...  So awesome!  Much variables!

I think that the =null in the StreamReader initializers is unnecessary code.

Also, there is more than one occurence where you say a=b;return a (except with way longer variable names), which is redundant.

source: Stack Exchange

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

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

sort: votes


text:
The Quickest Fox in the East
In the spirit of Hello world! with NO repetition
Write a program that prints the string "the quick brown fox jumps over the lazy dog" with optional newline. The entire program must not repeat any characters.
Note that the string to be printed does repeat characters, so you will have to get around that limitation somehow.
Note that the winning condition is popularity-contest, i.e. the highest-voted answer wins.
Update: To make this a little easier, repetition is allowed but you must attempt to minimize it. Programs with less (or no) repetition are given precedence over programs with some repetition.

I'm afraid this is probably too hard, if not outright impossible.  Hello world! without repetitions was hard enough that people had to resort to very niche languages or outright couldn't solve the task completely at all, and this one is considerably harder on top of that.

Well, it sure is impossible in C. You can't call functions or use macros.

I recommend: print the given string with as few repeated characters as possible.

@FireFly didn't take long to have answers :)

@SirDarius apparently so. I'm impressed.

@FireFly Added a clause allowing people to use repetition anyway, we may get some interesting answers.

I was seriously considering trying to do this in C#, but immediately realised that any valid program needs to sets of curly brackets :(

Microsoft Word from 97 to 2003 (and some Mac Word versions) — 10 characters
No repetitions, but doesn't quite match specs - 10 characters:
=rand(2,1)

Output:
The quick brown fox jumps over the lazy dog.
The quick brown fox jumps over the lazy dog.

Matches specs, other than capitalization and punctuation, one repetition - 10 characters:
=rand(1,1)

Output:
The quick brown fox jumps over the lazy dog.

Newer versions of Microsoft Word use =rand.old(1,1) which duplicates d and 1.
There might be a way to use a field {=SUM(3,-2)} as input to rand() but my installation is having issues with fields -- namely, they're not working...
"Bob" has confirmed that {=SUM(3,-2)} (with some difficulty) can be used to replace the first 1, but = is repeated...
=rand({=SUM(3,-2)},1)

Provided you get Word to update SUM first, the output is:
The quick brown fox jumps over the lazy dog.

I'm not sure the given syntax is right, but I don't have any systems that old to test it on. For newer versions though, it should be =rand.old(1,1). I suppose you're trying to use 3-2 to replace the first 1, but it doesn't appear to be working for me in 2010 with rand.old or rand.

I don't have a system here either, will check when I get home. Might need to use braces { ... } as delimiters, but I'm pretty sure expressions can be used in any function. If not, I'll revise!

I can confirm the {=SUM(3,-2)} works in Word 2007. But the method is a bit complicated. First, you must insert a field code (Ctrl + F9). Then, right click => edit field => formula => advanced => type in the formula. Because typing it in directly doesn't work for whatever reason. Now click in the field and evaluate with Shift + F9. And add the =rand.old()

Is it necessary to use =SUM, or could simply use arithmetic operators directly, as 3-2?

@supercat - We tried that, and for some reason, Word does not accept expressions as parameters of =rand(), e.g. =rand(3-2,1) would be perfect. I actually didn't try =rand({=3-2},1), but it should work the same way, with duplication of =.

Sclipting — 36 characters
덆둥긇굵늖꽫긆깲닷덮긂롦닲롸껂걪덖륰댲걯덦넬댢건늆넠닆굺뎒걤닶댬首坼

(expects empty input)
Explanation:
Push the string "the quick brown ,fo,x, jumps ove,r the lazy dog,"
덆둥긇굵늖꽫긆깲닷덮긂롦닲롸껂걪덖륰댲걯덦넬댢건늆넠닆굺뎒걤닶댬
Retrieve last character from the string (",")
首
Regular expression string-split
坼

The result is the list ["the quick brown ", "fo", "x", " jumps ove", "r the lazy dog", ""], which is automatically concatenated into a single string for output.

I count 105 bytes, not to mention several repeats. Char 235, for example, is used 20 times.

"Must not repeat any characters", not "must not repeat any bytes".

I'm not surprised Timwi, your own language is perfect for "no repeated characters" challenges.

Perl 6 (76 chars, no doubles)
The script (will be mangled by the board software, but there's En Space up to Thin Space and NL and LF and tab)
say　EVAL    lc q{<the Quiţk Brown fïX jUmpS ůvťɲ Tɨå ìšzY dOg>~&(127.CHR
x
43)}

It uses EVAL (thanks again for making it uppercase) and <foo bar> quote words which supports all the special space characters as word separators.
say joins the list of strings using space, works nicely here :)
Next I use ~& and 127 to bit shuffle to plain ascii. Extra complication: 'Ŭ'.lc becomes 'ŭ' so that becomes an s instead of the r I needed. Adding 128 some extra times helps :)

A version with backslash escapes instead of unicode characters to show they're all different
say\x[3000]EVAL\x[9]lc q{<the\x[2003]Qui\x[163]k\x[2004]Brown\x[2005]f\x[EF]X\x[2006]jUmpS\x[2007]\x[16F]v\x[165]\x[272]\x[2008]T\x[268]\x[E5]\x[2009]\x[EC]\x[161]zY\x[200A]dOg>~&(127.CHR\x[0A]x\x[0D]43)}

If you want to verify they're all unique, use this script (I used Qb"string" to have basic quoting with only backslash escapes)
.say for
Qb"say\x[3000]EVAL\x[9]lc q{<the\x[2003]Qui\x[163]k\x[2004]Brown\x[2005]f\x[EF]X\x[2006]jUmpS\x[2007]\x[16F]v\x[165]\x[272]\x[2008]T\x[268]\x[E5]\x[2009]\x[EC]\x[161]zY\x[200A]dOg>~&(127.CHR\x[0A]x\x[0D]43)}"
.comb.Bag.grep(*.value > 1).map: {.key.ord.base(16) ~ " $_"  }

Or execute it directly using
EVAL Qb"say\x[3000]EVAL\x[9]lc q{<the\x[2003]Qui\x[163]k\x[2004]Brown\x[2005]f\x[EF]X\x[2006]jUmpS\x[2007]\x[16F]v\x[165]\x[272]\x[2008]T\x[268]\x[E5]\x[2009]\x[EC]\x[161]zY\x[200A]dOg>~&(127.CHR\x[0A]x\x[0D]43)}"

PHP - 67 bytes
<?echo$g^¶¥€¼½ˆ•.${~˜}=ÂÍåœÌýü¡¦Åþ¾’‹Ï†£‘Æ²áºëÓâæÝ—ß™ó–Ž¸·³ø‰ï®ÜØÔ;

Copy-Paste, save as Latin-1 (Ansi).
This is a 7-byte xor-cipher, using the string ¶¥€¼½ˆ• for salt.
One repeated character: $.

You can shorten it another 3 character by using <?= since you are already using short tags

Ah, sorry, just noticed you already use =

@KristofferSHansen I think it should be possible to use eval('Return$g=binary;') in some cryptic form (perhaps bit inversion) to avoid the $ repetition, and then the = would be freed up as well.

The opening tag should not be included in the byte count.

@TecBrat The final ; can be replaced by closing tag: should that not be counted either? In short, I disagree. If your code doesn't run as-is, it's not a complete program.

This php -r 'echo "Hello World\n";' at the command line writes Hello World and a line break. Wouldn't it be correct to only count echo "Hello World\n"; in this case?

Haskell, 71 characters
map(\c->chr$mod(ord c)128)"tŨeఠquiţkĠbŲɯwnȠfѯxРjѵŭŰsܠůvťѲठѴѨѥਠlšzyଠɤկg"

Yet another 7-bit modulo solution.
Repeated characters:
c 3
d 2
m 2
o 2
r 2
( 2
) 2
" 2

First time golfing with Haskell; anyone more experienced in the language, feel free to improve. I wanted to make the anonymous function point-free to avoid having to mention a variable twice, but I don't know if it'd be a net benefit.

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