text:
Sort a list of numbers
About Code-Bowling:

In golf, you try to get the lowest score (smallest application, most elegant, etc). In Bowling, you try to get the highest score. So if you follow, the goal of a Code-Bowling challenge is to make the biggest, most bastardized, hardest to maintain piece of code that still meets the requirements of the challenge. However, there's no point in making source longer just for the sake of it. It needs to seem like that added length was from design and not just padding.

The Challenge:
Create a program that sorts a list of numbers in ascending order.
Example:
Input: 1, 4, 7, 2, 5
Output: 1, 2, 4, 5, 7
Code: Obviously this wouldn't be a good answer, since there aren't many WTFs in there
function doSort(array $input) {
    sort($input);
    return $input;
}

Rules:
There are no real rules.  As long as the program functions, have at it!
Remember: This is code-bowling, not golf.  The objective is to make the worst, most bastardized code that you can!  Bonus points for code that looks good, but is actually deceptively evil...

I wish I still had the calendar queue code I wrote once...

sort(sort(sort(sort(sort(sort(myarray)))))) Guarantees perfect sorting!

Reminds me of https://github.com/EnterpriseQualityCoding/FizzBuzzEnterpriseEdition

Sorting by user input. What can be worse?
function sort(array) {
    newArray = new Array
    notSorted = true;
    while (notSorted) {
        sortfail = false;
        i = -1
        for (;;) {
            if ((++i + 1) == array.length) break;
            if (confirm("is " + array[i] + " less than " + array[i + 1])) {
                newArray[i] = array[i]
                newArray[i + 1] = array[i + 1]
            } else {
                newArray[i] = array[i + 1]
                newArray[i + 1] = array[i]
                array[i] = newArray[i]
                array[i + 1] = newArray[i + 1]
                sortfail = true
            }
        }
        array = newArray;
        if (!sortfail) notSorted = false
    }
    return array
}

console.log(sort([2,1,3]))

See live example

You can do better than that... :-D

Better and still sort correctly? That's a pain. This is algorithmically horrible. I don't need to make the code that much more horrible.

User input is often wrong.  Users may be drunk, or high, and there may also be adversaries who give you the wrong order on purpose. Should randomly shuffle and ask again until you have a fair number of answers for the same pairing.

@Paul the lack of defence on user input is one of the major advantages of this code bowl. I guess having completely useless validation on user input would be better then none.

not sure about the manual element of this.

this doesn't sort correctly for me (on the array [5,4,3,2,1], for example)

class Array
  def sort
    self.permutation.min
  end
end

Ah, the elegance of Ruby...
self.permutation results in an enumerator. No harm done, yet. The innocent looking .min however sucks this enumerator into an array. This array's size explodes when the number of elements rises. Not to mention this ruines a fine pre-existing sort.

It's code bowling if you haven't seen it before – you must write the longest code! ;)

I'm going for the 'good looking but deceptively evil' bonus :)

I'd say that this looks perfectly fine to any SQL programmer. Now the compiler just has to figure that what you wanted was just a simple sort.

Bogosort!
import random

def is_sorted(seq):
    for x, y in zip(seq[:-1], seq[1:]):
        if x > y:
            return False
    return True

def sort(seq):
    while not is_sorted(seq):
        random.shuffle(seq)

damnit you beat me to it...

This is bogosort

Efficiency: O(2n random)

Perl Bubble Sort
push(@m,'0');$a=<>;push(@m,$a);
$a=pop@m;push(@c,$a);
push(@m,'p');$a=pop@m;$b=pop@m;$hash{$a}=$b;
$a=pop@c;push(@c,$a);for(1..$a){$a=<>;push(@m,$a);
push(@m,'p');$a=pop@m;push(@m,$hash{$a});
$a=pop@m;$b=pop@m;$hash{$a}=$b;
push(@m,'p');$a=pop@m;push(@m,$hash{$a});
push(@m,'1');$a=pop@m;$b=pop@m;push(@m,$b+$a);
push(@m,'p');$a=pop@m;$b=pop@m;$hash{$a}=$b;
}$a=pop@c;push(@m,$a);
push(@m,'2');$a=pop@m;$b=pop@m;for(1..$a){push(@m,$b);};
$a=pop@m;$b=pop@m;push(@m,$b*$a);
$a=pop@m;push(@c,$a);
$a=pop@c;push(@c,$a);for(1..$a){push(@m,'1');$a=pop@m;push(@m,-$a);
push(@m,'p');$a=pop@m;$b=pop@m;$hash{$a}=$b;
$a=pop@c;push(@c,$a);for(1..$a){push(@m,'p');$a=pop@m;push(@m,$hash{$a});
push(@m,'1');$a=pop@m;$b=pop@m;push(@m,$b+$a);
push(@m,'p');$a=pop@m;$b=pop@m;$hash{$a}=$b;
push(@m,'p');$a=pop@m;push(@m,$hash{$a});
$a=pop@m;push(@m,$hash{$a});
push(@m,'p');$a=pop@m;push(@m,$hash{$a});
push(@m,'1');$a=pop@m;push(@m,-$a);
$a=pop@m;$b=pop@m;push(@m,$b+$a);
$a=pop@m;push(@m,$hash{$a});
$a=pop@m;$b=pop@m;if($b < $a){push(@c,1)}else{push(@c,0)};
$a=pop@c;push(@c,$a);for(1..$a){push(@m,'p');$a=pop@m;push(@m,$hash{$a});
$a=pop@m;push(@m,$hash{$a});
push(@m,'t');$a=pop@m;$b=pop@m;$hash{$a}=$b;
push(@m,'p');$a=pop@m;push(@m,$hash{$a});
push(@m,'1');$a=pop@m;push(@m,-$a);
$a=pop@m;$b=pop@m;push(@m,$b+$a);
$a=pop@m;push(@m,$hash{$a});
push(@m,'p');$a=pop@m;push(@m,$hash{$a});
$a=pop@m;$b=pop@m;$hash{$a}=$b;
push(@m,'t');$a=pop@m;push(@m,$hash{$a});
push(@m,'p');$a=pop@m;push(@m,$hash{$a});
push(@m,'1');$a=pop@m;push(@m,-$a);
$a=pop@m;$b=pop@m;push(@m,$b+$a);
$a=pop@m;$b=pop@m;$hash{$a}=$b;
}$a=pop@c;push(@m,$a);
$a=pop@m;
}}push(@m,'0');push(@m,'p');$a=pop@m;$b=pop@m;$hash{$a}=$b;
$a=pop@c;push(@c,$a);for(1..$a){push(@m,'p');$a=pop@m;push(@m,$hash{$a});
$a=pop@m;push(@m,$hash{$a});
$a=pop@m;print$a;
push(@m,'p');$a=pop@m;push(@m,$hash{$a});
push(@m,'1');$a=pop@m;$b=pop@m;push(@m,$b+$a);
push(@m,'p');$a=pop@m;$b=pop@m;$hash{$a}=$b;
}

I was going for the "every single line looks like the same piece of line noise" look. The first line of input (on STDIN) tells the program how many numbers there are, while the next N number of lines contain one number that needs to be sorted.

stack-based perl :)

I would like to have an explanation of how it works? I have some guess

Generic, multithreaded bogosort in Java
46 seconds to sort 4 numbers
I thought it would be elegant with support for generics.
Also, multithreading is always nice, so I use that instead of randomization: This program generates one thread for each number to be sorted. Each thread tries to insert its element into an array object, and when all elements have been inserted, the program will check if the array is sorted. If not, try again. Off course this insertion needs to be synchronized.
ElementInserter
This will be the class that we use for the threads.
This class holds one element and tries to insert it into its sortedArray:
class ElementInserter<E extends Comparable<? super E>> implements Runnable {
    E element;
    SortedArray<? super E> target;

    ElementInserter(E e, SortedArray<? super E> a) {
        element = e;
        target = a;
    }

    @Override
    public void run() {
        target.insert(element);
    }
}

sortedArray
Sports a straight-forward insert method. When last element has been inserted, it checks if the array is sorted.
class SortedArray<E extends Comparable<? super E>> {
    boolean sorted; int i = 0; E[] a;

    SortedArray(E[] e) { a = e; }

    synchronized public void insert(E e) {
        while (!sorted) {
            a[i++] = e;

            if (i == a.length) {
                sorted = true;

                for (int j = 1; j < i; ++j)
                    if (a[j-1].compareTo(a[j]) > 0) {
                        sorted = false;
                        i = 0;
                        notifyAll();
                    }

                if (sorted) {
                    for (int j = 0; j < a.length; ++j) System.out.print(a[j]+" ");
                    System.out.println();
                    notifyAll(); // allow all threads to terminate
                }

            } else
                try { wait(); }
                catch(InterruptedException x) { }
        }
    }
}

Main method
Parses command line arguments as Integers, creates a new array and a new thread for each Integer:
    public static void main (String[] args) {
        Integer[] i = new Integer[args.length];
        SortedArray<Integer> c = new SortedArray<Integer>(i);

        for (String s : args)
            new Thread(new ElementInserter<Integer>(Integer.parseInt(s), c)).start();
    }

Test run
Execution time will depend on the original order of the elements and your scheduler implementation. This is on a dual-core 2.9 GHz Intel i7 MacBook Pro:
$ time java Main 3 1 2 4
1 2 3 4

real    0m46.307s
user    0m14.629s
sys     0m26.207s

Haha +1 I got a kick out of this

JavaScript (with animation!). 8172 chars. Few hours for 6 numbers.
We like lottery, right? Similar to Bogosort by dan04, but using physics and animation...
(function(){var e={},v=!1,G=/abc/.test(function(){abc})?/\b_super\b/:/.*/,H=function(c,a,b){return function(){var l=this._super,s;this._super=b[c];try{s=a.apply(this,arguments)}finally{this._super=l}return s}};e.Class=function(){};e.Class.extend=function a(b){var l=this.prototype;v=!0;var s=new this;v=!1;for(var c in b)s[c]="function"===typeof b[c]&&"function"===typeof l[c]&&G.test(b[c])?H(c,b[c],l):b[c];b=function(){!v&&this.init&&this.init.apply(this,arguments)};b.prototype=s;b.prototype.constructor=
b;b.extend=a;return b};e.Events={};var k=e.Events,z,A,w=Object.prototype.toString,I=document.createEvent,r=Date.now;k.EventListener=e.Class.extend({handleEvent:function(){},init:function(a){this.handleEvent=a}},"EventListener");z=k.EventListener;k.Event=e.Class.extend({timeStamp:0,type:"",target:null,cancelable:!1,defaultPrevented:!1,preventDefault:function(){this.cancelable&&(this.defaultPrevented=!0)},initEvent:function(a,b){this.type=a;this.target=b;this.timeStamp=r()}},"Event");A=k.Event;var t=
Object.create(null);e.createEventType=function(a,b){t[a]=A.extend(b,a);return t[a]};e.createEvent=function(a){return null!=t[a]?(a=new t[a],a.timeStamp=r(),a):I(a)};k.EventTarget=e.Class.extend({_listeners:{},addEventListener:function(a,b,l){var c=this._listeners[a];if(!(null!=c&&function(){for(var a="object"===typeof l?l:null,d,e=0,f=c.length;e<f;e++)if(d=this.listeners[e],d.listener.handleEvent===b&&d.scope===a)return!0;return!1}())){var d={listener:"object"===typeof b&&b.handleEvent?b:new z(b),
scope:"object"===typeof l?l:null};"[object Array]"===w.call(c)?c.push(d):this._listeners[a]=[d]}},removeEventListener:function(a,b,c){a=this._listeners[a];if("[object Array]"===w.call(a)){c="object"===typeof c?c:null;for(var d=0,e=a.length;d<e;d++)if(a[d].listener.handleEvent===b&&a[d].scope===c){a.splice(d,1);break}}},dispatchEvent:function(a){a.target||(a.target=this);var b=0,c=this._listeners[a.type],d=c.length,e;if("[object Array]"===w.call(c))for(;b<d;b++)e=c[b].listener.handleEvent,e.call(c[b].scope,
a);return a.defaultPrevented}},"EventTarget");for(var B=0,k=["ms","moz","webkit","o"],h=0;h<k.length&&!window.requestAnimationFrame;++h)window.requestAnimationFrame=window[k[h]+"RequestAnimationFrame"],window.cancelAnimationFrame=window[k[h]+"CancelAnimationFrame"]||window[k[h]+"CancelRequestAnimationFrame"];window.requestAnimationFrame||(window.requestAnimationFrame=function(a){var b=r(),c=Math.max(0,16-(b-B)),d=window.setTimeout(function(){a(b+c)},c);B=b+c;return d});window.cancelAnimationFrame||
(window.cancelAnimationFrame=function(a){clearTimeout(a)});var x=window.clearInterval,C=window.setInterval,D=e.Class.extend({fn:function(){},args:[],thisArg:window,sleepTime:0,init:function(a,b,c){this.method=a||function(){};this.thisArg=b||window;this.args=c||[]}},"FunctionToCall"),r=Date.now,u=Object.create(null);u.animation=0;u.steady=1;u.as_fast_as_possible=2;e.Timer=e.Events.EventTarget.extend({ANIMATION:0,STEADY:1,AS_FAST_AS_POSSIBLE:2,TimerEvent:e.createEventType("TimerEvent",{FPS:0,targetFPS:0,
delta:0,initEvent:function(a,b){if(null==b.getFPS||null==b.targetFPS||null==b.dt)throw notATimerException;this.FPS=b.getFPS();this.targetFPS=b.targetFPS;this.delta=b.dt;this._super(a,b)}}),_clearIntervalFlag:!1,_recursionCounter:0,_tickHandlersFromMethod:Object.create(null),running:!1,paused:!1,mode:0,autoStartStop:!0,setAutoStartStop:function(a){this.autoStartStop=a},prevTime:0,dt:0,maxDelta:0.05,setMaxDelta:function(a){this.maxDelta=a},sysTimerId:-1,targetFPS:50,setFPS:function(a){this.targetFPS=
a;if(this.running&&this.mode===this.STEADY){x(this.sysTimerId);var b=this;this.sysTimerId=C(function(){b.tick()},1E3/a)}},getFPS:function(){return 1/this.dt},queue:[],addToQueue:function(a,b,c){var d=new D(a,b,c),e;this.queue.push(d);var f=function J(f){0<d.sleepTime?d.sleepTime-=f.delta:(e=a.apply(b,[f].concat(c)),"number"===typeof e&&0<e?d.sleepTime=e:!0!==e&&(this.removeEventListener("tick",J,this),this.queue.splice(this.queue.indexOf(d),1)))};null==this._tickHandlersFromMethod[a]?this._tickHandlersFromMethod[a]=
[f]:this._tickHandlersFromMethod[a].push(f);this.addEventListener("tick",f,this);this.autoStartStop&&!this.running&&this.startLoop()},removeFromQueue:function(a){var b=this._tickHandlersFromMethod[a];a=this.queue.indexOf(a);if(-1!==a){for(var c=0,d=b.length;c<d;c++)this.removeEventListener("tick",b[c],this);return this.queue.splice(a,1)}},getQueue:function(){return this.queue.slice(0)},pause:function(){this._clearIntervalFlag=this.paused=!0;this.dt=0},resume:function(){this.paused=!1;this.startLoop()},
startLoop:function(){this.prevTime=r();this.running=!0;if(this.mode===this.steady){var a=this;this.sysTimerId=C(function(){a.tick()},1E3/this.targetFPS)}else this.tick()},tick:function(){if(this._clearIntervalFlag&&-1!==this.sysTimer)x(this.sysTimerId),this.sysTimerId=-1,this._clearIntervalFlag=!1;else if(!this.paused){var a=r();this.dt=(a-this.prevTime)/1E3;this.dt>this.maxDelta&&(this.dt=this.maxDelta);if(0===this.dt&&4>this._recursionCounter)this._recursionCounter++,this.tick();else{0<this._recursionCounter&&
(this._recursionCounter=0);var b=e.createEvent("TimerEvent");b.initEvent("tick",this);this.dispatchEvent(b);this.prevTime=a;a=!(this.autoStartStop&&0>=this.queue.length);if(this.mode===this.AS_FAST_AS_POSSIBLE&&a){var c=this;setTimeout(function(){c.tick()},0)}if(this.mode===this.ANIMATION&&a){var d=this;requestAnimationFrame(function(){d.tick()})}a||(this.running=!1,this.mode===this.STEADY&&-1!==this.sysTimerId&&(x(this.sysTimerId),this.sysTimerId=-1))}}},init:function(a){this.mode="number"===typeof a?
a:u[a];if(null==this.mode||0>this.mode||2<this.mode)this.mode=0}},"Timer");e.Timer.ANIMATION=0;e.Timer.STEADY=1;e.Timer.AS_FAST_AS_POSSIBLE=2;e.Timer.FunctionToCall=D;var j=[2,3,5,8,4,6],m=new (e.Class.extend({displace:0,velocity:0,drag:0.01,tickInterval:10,update:function(a){this.displace+=this.velocity*a.delta;this.velocity*=1-this.drag},init:function(){}})),q=j.slice(0),k=new e.Timer(0),h=document.createElement("div");h.style.width=23*j.length-28+"px";h.style.height="22px";h.style.overflowX="hidden";
h.style.overflowY="hidden";h.style.border="1px #555 solid";h.style.fontFamily='Consolas, "Courier New"';for(var c=[],f=0;f<j.length;f++)c[f]=document.createElement("div"),c[f].style.width="20px",c[f].style.height="20px",c[f].style.display="inline-block",c[f].style.position="relative",c[f].style.left=f+1===j.length?"-22px":"0px",c[f].style.top=f+1===j.length?"-22px":"0px",c[f].style.border="1px #AAA solid",c[f].style.textAlign="center",c[f].innerHTML=j[f],h.appendChild(c[f]);var g=0,d=1,n,p,E=0,F=
0,y=0;m.velocity=1E3*Math.random()+500;document.getElementsByTagName("body")[0].appendChild(h);k.addToQueue(function(a){if(5>m.velocity)if(0===g){for(a=0;a<c.length;a++)if((m.displace+22+22*a)%(22*j.length)-22<11*c.length&&(m.displace+22+22*a)%(22*j.length)>11*c.length){n=c[a];E=parseFloat(n.style.left);break}for(a=0;a<c.length;a++)if((m.displace+22+22*a)%(22*j.length)<11*c.length&&(m.displace+22+22*a)%(22*j.length)+22>11*c.length){p=c[a];F=parseFloat(p.style.left);break}y=p.offsetLeft-n.offsetLeft;
g=1}else if(1===g)n.style.backgroundColor="rgba(255,255,0,"+Math.round(1-d)+")",p.style.backgroundColor="rgba(255,255,0,"+Math.round(1-d)+")",d-=10*a.delta,0>d&&(g=2);else if(2==g)n.style.backgroundColor="rgba(255,255,0,"+Math.round(1-d)+")",p.style.backgroundColor="rgba(255,255,0,"+Math.round(1-d)+")",d+=10*a.delta,1<d&&(g=3,n.style.backgroundColor="rgba(255,255,255,0)",p.style.backgroundColor="rgba(255,255,255,0)",d=0);else if(3==g)n.style.left=E+d*y+"px",p.style.left=F-d*y+"px",d+=2*a.delta,1<
d&&(g=4);else if(4==g){if(d-=a.delta,0.5>d){a=c.indexOf(n);var b=c.indexOf(p),e;e=n.innerHTML;c[a].innerHTML=p.innerHTML;c[b].innerHTML=e;e=q[a];q.splice(a,1,q[b]);q.splice(b,1,e);b=-1/0;for(a=0;a<q.length;a++){if(q[a]<b){g=5;break}b=q[a]}g=5===g?5:6}}else if(5===g)d=1,m.velocity=1E3*Math.random()+500,g=0;else{if(6===g)return d=1,g=0,document.getElementsByTagName("body")[0].innerHTML+=q,!1}else{m.update(a);for(a=0;a<c.length;a++)b=(m.displace+22+22*a)%(22*j.length),a+1===j.length&&(b+=22*(j.length-
1)),c[a].style.left=b-22*a-22+"px"}return!0})})();

However, I used a bit of Google Closure Compiler to, er... I don't know. But it looks uglier, right?
It's like one of those lottory wheels, and each time it stops it swaps to numbers in the middle.
You can have a play here: http://jsfiddle.net/VkJUE/5/ (to understand what I mean)
It does work, a bit, except that it may take hours for 6 numbers. However, I tested it on 3 numbers and it works fine!

Ruby Metasort
#I know Ruby has a built-in method to order an array,
#but I can't remember what it is.  Oh well, metaprogramming to the rescue!
#I'll just try all of the available methods, and see which one works.

#check whether an array is ordered
def is_in_order? arr
  arr.is_a?(Array) && (0...(arr.size-1)).all? {|i| arr[i]<arr[i+1]}
end

Array.instance_methods.each do |meth|
  begin
    possibly_ordered_array = ARGV.map(&:to_i).send(meth)
    #have to check both that the new array is ordered, and that it's still the same size,
    #so that methods that change the array's elements don't create false positives.
    if is_in_order?(possibly_ordered_array) && possibly_ordered_array.size == ARGV.size
      puts possibly_ordered_array.join(", ")
      exit 0 #success!
    end
  rescue
    #method needed an argument or something
  end
end

exit 1 #could not order the array

Though I can't take credit for this Java code, Smoothsort is a good example of the tradeoff between readability and performance:
static final int LP[] = { 1, 1, 3, 5, 9, 15, 25, 41, 67, 109,
  177, 287, 465, 753, 1219, 1973, 3193, 5167, 8361, 13529, 21891,
  35421, 57313, 92735, 150049, 242785, 392835, 635621, 1028457,
  1664079, 2692537, 4356617, 7049155, 11405773, 18454929, 29860703,
  48315633, 78176337, 126491971, 204668309, 331160281, 535828591,
  866988873 // the next number is > 31 bits.
};

public static <C extends Comparable<? super C>> void sort(C[] m,
    int lo, int hi) {
  int head = lo; // the offset of the first element of the prefix into m

  int p = 1; // the bitmap of the current standard concatenation >> pshift
  int pshift = 1;

  while (head < hi) {
    if ((p & 3) == 3) {
      sift(m, pshift, head);
      p >>>= 2;
      pshift += 2;
    } else {
      // adding a new block of length 1
      if (LP[pshift - 1] >= hi - head) {
        // this block is its final size.
        trinkle(m, p, pshift, head, false);
      } else {
        // this block will get merged. Just make it trusty.
        sift(m, pshift, head);
      }

      if (pshift == 1) {
        // LP[1] is being used, so we add use LP[0]
        p <<= 1;
        pshift--;
      } else {
        // shift out to position 1, add LP[1]
        p <<= (pshift - 1);
        pshift = 1;
      }
    }
    p |= 1;
    head++;
  }

  trinkle(m, p, pshift, head, false);

  while (pshift != 1 || p != 1) {
    if (pshift <= 1) {
      // block of length 1. No fiddling needed
      int trail = Integer.numberOfTrailingZeros(p & ~1);
      p >>>= trail;
      pshift += trail;
    } else {
      p <<= 2;
      p ^= 7;
      pshift -= 2;

      trinkle(m, p >>> 1, pshift + 1, head - LP[pshift] - 1, true);
      trinkle(m, p, pshift, head - 1, true);
    }

    head--;
  }
}

private static <C extends Comparable<? super C>> void sift(C[] m, int pshift,
    int head) {
  C val = m[head];

  while (pshift > 1) {
    int rt = head - 1;
    int lf = head - 1 - LP[pshift - 2];

    if (val.compareTo(m[lf]) >= 0 && val.compareTo(m[rt]) >= 0)
      break;
    if (m[lf].compareTo(m[rt]) >= 0) {
      m[head] = m[lf];
      head = lf;
      pshift -= 1;
    } else {
      m[head] = m[rt];
      head = rt;
      pshift -= 2;
    }
  }

  m[head] = val;
}

private static <C extends Comparable<? super C>> void trinkle(C[] m, int p,
    int pshift, int head, boolean isTrusty) {

  C val = m[head];

  while (p != 1) {
    int stepson = head - LP[pshift];

    if (m[stepson].compareTo(val) <= 0)
      break; // current node is greater than head. Sift.

    if (!isTrusty && pshift > 1) {
      int rt = head - 1;
      int lf = head - 1 - LP[pshift - 2];
      if (m[rt].compareTo(m[stepson]) >= 0
          || m[lf].compareTo(m[stepson]) >= 0)
        break;
    }

    m[head] = m[stepson];

    head = stepson;
    int trail = Integer.numberOfTrailingZeros(p & ~1);
    p >>>= trail;
    pshift += trail;
    isTrusty = false;
  }

  if (!isTrusty) {
    m[head] = val;
    sift(m, pshift, head);
  }
}

/* insert some basic static void main here...
   my Java's too rusty to do it from the top of my head
*/

(note: some comments removed for effect and to make it shorter; source taken from the wikipedia page linked above)

Could you please add the language you used for this to the post?

“tradeoff between readability and performance”—I need to remember that.

The F# "I hate functional programming" :
let numbers = System.Console.ReadLine().Split(',')
let mutable check = 0
let mutable sorted = ""

while not (sorted.Split(',').Length = numbers.Length) do
    for i in [check..check + 1000] do
        for number in numbers do
            if number = i.ToString() then
                if sorted.Length > 0 then
                    sorted <- sorted + ","
                sorted <- sorted + number
    check <- check + 1000

printfn "%s" sorted

A Cobol subprogram to sort a table of integers, guaranteed to have a higher WTF/minute than any other language.  For performance purposes, the QuickSort algorithm is used:
Identification Division.
Program-ID. QwikSort is recursive.
Environment Division.
Data Division.
Working-Storage Section.
01 QwikSort-Working-Storage.
 05 Swap-Space           Pic X(80) Value spaces.
 05 Pivot         Binary Pic S9(8).
 05 I             Binary Pic S9(8).

Local-Storage Section.
01 QwikSort-Local-Storage.
 05 Lo            Binary Pic S9(8) Value 0.
 05 Hi            Binary Pic S9(8) Value 0.

Linkage Section.

01 The-Table-Area.
 05 The-Table     occurs 0 to 200000 depending on High-Element.
  10 The-Key     Binary Pic S9(8).

01 Low-Element     Binary Pic S9(8).
01 High-Element    Binary Pic S9(8).

Procedure Division using The-Table-Area
                         Low-Element
                         High-Element.

  Compute Lo  = Low-Element
  Compute Hi  = High-Element

  If ( High-Element > Low-Element )
     Perform Select-Pivot

* ----- Loop through table until indices cross
       Perform until Hi < Lo

* -------- Locate an item that should not be in less partition
          Perform varying Lo from Lo by 1
            until (( Lo >= High-Element )
               or  ( The-Key of The-Table ( Lo ) >= Pivot ))
          End-Perform

* -------- Locate an item that should not be in greater partition
          Perform varying Hi from Hi by -1
            until (( Hi <= Low-Element )
               or  ( The-Key of The-Table ( Hi ) <= Pivot ))
          End-Perform

* -------- Exchange the two and keep looking
          If ( Lo <= Hi )
             Perform Swap-Elements
             Compute Lo = Lo + 1
             Compute Hi = Hi - 1
          End-If

    End-Perform

    Perform Qsort-Less-Partition

    Perform Qsort-Greater-Partition

 End-If

 Goback.

*--------------------------------------------------------------*
* Select the pivot using median of three rule.
*--------------------------------------------------------------*
 Select-Pivot.

    Compute Pivot = ( Lo + Hi ) / 2
    Compute Pivot = Function Median (
            The-Key of The-Table ( Lo )
            The-Key of The-Table ( Pivot )
            The-Key of The-Table ( Hi )
         )
    End-Compute

    Exit.

*--------------------------------------------------------------*
* Exchange elements in the wrong partition
*--------------------------------------------------------------*
 Swap-Elements.
    Move The-Table ( Lo ) to Swap-Space
    Move The-Table ( Hi ) to The-Table ( Lo )
    Move Swap-Space       to The-Table ( Hi )
    Exit.

*--------------------------------------------------------------*
* Sort the less sub-partition
*  -- Optimization opportunity for the user: if the partition
*    size is sufficiently small you might want to apply a simple
*    sort like insertion or bubble, or perhaps a bose-nelson
*    network to order the last few and save the overhead of
*    another recursive call.
*--------------------------------------------------------------*
 Qsort-Less-Partition.
    If ( Low-Element < Hi )
       Call 'QwikSort' Using
          The-Table-Area
          Low-Element
          Hi
       End-Call
    End-If
    Exit.

*--------------------------------------------------------------*
* Sort the greater sub-partition
*  -- Optimization opportunity for the user: same as left part.
*--------------------------------------------------------------*
 Qsort-Greater-Partition.
    If ( Lo < High-Element )
       Call 'QwikSort' Using
          The-Table-Area
          Lo
          High-Element
       End-Call
    End-If
    Exit.

 End Program QwikSort.

Is there a reason why it's QwikSort instead of QuickSort? (i.e. length restriction or you can't use the letter u in a name?) Because that would make it even more fun :P

@marinus It's probably a linker restriction.

not enough uppercase later however

It is "QwikSort" instead of "QuickSort" to fit into the eight character length restriction placed on things by older OSes.  "QwikSort" will fit into an MVS PDS or on an old school DOS machine nicely.

The uppercase isn't needed, Cobol does lower case just fine, I'm happy to go bowling, but lets be real, this isn't 1974...

var inp = [1, 4, 7, 2, 5],
    loops = 0,
    trysort;

while(++loops) {
    trysort = new Array(inp.length);

    for(var i = 0, len = inp.length; i < len; i++) {
        trysort[i] = inp[~~(Math.random()*inp.length)];
    }

    if( trysort.join(',') === '1,2,4,5,7' )
        break;
}
alert('done! Only ' + loops + ' iterations! ' + trysort);

http://www.jsfiddle.net/sAFMC/

hard coded in the array tut tut.

Bogosort for the win! \o/

nice. i like it.

Python quicksort using lambda
Something I wrote on my blog:
qsort = lambda seq: [] if not seq else qsort(filter(lambda n: n<=seq[0], seq[1:]))+[seq[0]]+qsort(filter(lambda n: n>seq[0], seq[1:]))

Here's the actual blog post

Nice solution! The shortest known quicksort in Python is only 79 bytes long (cortesy legendary codegolfer Mark Byers): http://news.e-scribe.com/314#581

That's a very esoteric solution. Blew my mind!

Ruby
#get user input from standard input and store it in a variable
var = gets
#make user input into a ruby array in a string
array_string = '[' + var + ']'
#evaluate this ruby array and store the array in a variable
array = eval(array_string)
#convert from strings to integers
#initialize loop variable as 0
i = 0
#loop until the loop variable is no longer small enough
#to be a valid index of the array
until !(i < array.length)
    #convert to a number then ensure it is an integer
    array[i] = array[i].to_f.floor
    #increment i
    i = i + 1
end

sorted = false

#infinite loop
while true
    #if it hasn't been sorted
    if ((!sorted) == true)
        #try to sort it
        #initialize loop variable as 0
        j = 0
        #loop while i is less than or equal to the length of the array
        while (i <= array.length)
            random = rand # get a random number
            #this gets a zero or one
            random = (random + random.round).floor
            #turn random into a boolean
            if random == 0
                random = true
            end
            if random == 1
                random = false
            end
            #don't do anything if this is the last one
            if j == (array.length - 1)
                #do nothing
            else
                if random == true
                    #true means keep these 2 elements in the same order
                end
                if random == false
                    #false means swap with next element
                    #initialize a variable to store the current element
                    swapvar = array[j]
                    #initialize a variable to store the next element
                    swapvar2 = array[j+1]
                    #set the current element to what was the next element
                    array[j] = swapvar2
                    #set the next element to what was in this one
                    array[j+1] = swapvar
                end
            end
            #increment j
            j = j + 1
            #loop kept looping, fixed now
            if j >= array.length
                break
            end
        end
        #now test if it is sorted
        #lets say it is
        sorted = true
        #now see if we are wrong
        #initialise a loop variable to zero
        k = 0
        while (array.length > k)
            #get current value from array and store it in a variable
            current = array[k]
            #get current value from array and store it in a variable
            next_ = array[k + 1]
            if !(array[k +1].nil? == true)#stop errors
                #if sorted correctly
                if next_ < current || next_ == current
                    #sorted stil== true
                else
                    sorted = false #not sorted, try again
                end
            end
            #increment loop variable
            k = k + 1
        end
            #DEBUG
        #p array
    else
        break #break out of infinite loop
    end
end

#it is now sorted in descending order
#we want ascending so lets flip it

#initialise a loop variable to zero
l = 0

final_array = Array.new([])

while (l <= (array.length - 1))
    final_array[array.length - l - 1] = array[l]
    #increment loop variable
    l += 1
end

#now we need to make it into a string
str = ''

#first map each element to a string
#to do this lets extend Array, then use this for our array
class Array
    def map #map each element to a string
        #initialise a loop variable to zero
        @m = 0
        arr = []
        while @m < self.length
            arr += [self[@m].to_s]
            #increment loop variable
            @m = @m + 1
        end
        return arr
    end
end

final_array = Array.new(final_array).map()
#DEBUG
#p final_array

#now add the elements to a string, separated by commas and spaces
#initialise a loop variable to zero
n = 0

while n < array.length
    #increment loop variable
    #add item to string
    str = str + final_array[n]
    #if not last item
    if !((array.length - 1 )== n)
        #add comma
        str += ','
    end
    #if not last item
    if !((array.length - 1 )== n)
        #add space
        str += ' '
    end
    n = n + 1
end

#now print the string
puts str

C++ (4409)
#include <iostream>
#include <cstdlib>
#include <cctype>
#include <string>
#include <sstream>

std::string itostr(int number)
{
   std::stringstream ss;
   ss << number;
   return(ss.str());
}

class CStackLIFO
{
private:
    int* stack;
    size_t len;
public:
    CStackLIFO();
    CStackLIFO(int);
    ~CStackLIFO();
    void init();
    void init(int);
    void push(int);
    int pop();
    int pop(int&);
    void destroy(size_t);
    int get(size_t);
    size_t get_len();
};

void CStackLIFO::init()
{
    len = 0;
    stack = NULL;
}

void CStackLIFO::init(int val)
{
    len = 1;
    stack = new int[len];
    stack[0] = val;
}

CStackLIFO::CStackLIFO()
{
    init();
}

CStackLIFO::CStackLIFO(int val)
{
    init(val);
}

CStackLIFO::~CStackLIFO()
{
    len = 0;
    delete[] stack;
    stack = NULL;
}

void CStackLIFO::push(int val = NULL)
{
    if((stack == NULL) || (len == 0))
    {
        this->init(val);
    }
    else
    {
        int* buf = stack;
        len++;
        stack = new int [len];

        for(size_t i = 0; i < (len - 1); i++)
        {
            stack[i] = buf[i];
        }

        stack[len - 1] = val;
        delete[] buf;
    }
}

int CStackLIFO::pop()
{
    int val;
    int* buf = stack;
    len--;
    stack = new int [len];

    for(size_t i = 0; i < len; i++)
    {
        stack[i] = buf[i];
    }

    val = buf[len];
    delete[] buf;

    return(val);
}

int CStackLIFO::pop(int &out)
{
    if(len <= 0)
        return(false);

    int* buf = stack;
    len--;
    stack = new int [len];

    for(size_t i = 0; i < len; i++)
    {
        stack[i] = buf[i];
    }

    out = buf[len];
    delete[] buf;

    return(true);
}

void CStackLIFO::destroy(size_t idx)
{
    int* buf = stack;
    len--;
    stack = new int [len];
    for(size_t i = 0; i < idx; i++)
    {
        stack[i] = buf[i];
    }
    for(size_t i = idx; i < len; i++)
    {
        stack[i] = buf[i + 1];
    }
    delete[] buf;
}

int CStackLIFO::get(size_t idx)
{
    return(stack[idx]);
}

size_t CStackLIFO::get_len()
{
    return(len);
}

class CSort
{
private:
    void removeWhitespace();
public:
    std::string in;
    void sort();
    void display();
};

void CSort::display()
{
    std::cout << in << std::endl;
    return;
}

void CSort::removeWhitespace()
{
    for(size_t i = 0; i < in.size(); i++)
    {
        if(in[i] == ' ')
        {
            in = in.substr(0, i) + in.substr(i+1);
        }
    }
}

void CSort::sort()
{
    removeWhitespace();

    CStackLIFO nums;
    CStackLIFO s;

    // build stack
    for(size_t i = 0, offset = 0; i < in.size(); i++)
    {
        for(offset = 0; (i + offset) < in.size(); offset++)
        {
            if(!(isdigit(in[i + offset]) ||
                 (in[i + offset] == '-')))
                break;
        }

        if(offset > 0)
        {
            nums.push(atoi(in.substr(i, offset).c_str()));
        }

        i += offset;
    }

    // sort
    for(size_t lowest = 0; 0 < nums.get_len(); lowest = 0)
    {
        for(size_t i = 0; i < nums.get_len(); i++)
        {
            if(nums.get(i) < nums.get(lowest))
                lowest = i;
        }

        s.push(nums.get(lowest));
        nums.destroy(lowest);
    }

    // convert to string
    in = "";
    for(size_t i = 0; i < s.get_len(); i++)
    {
        // Convert num to string
        in += itostr(s.get(i));
        in += ", ";
    }
    if(in.size() > 2)
        in = in.substr(0, in.size() - 2);
}

int main(int argc, char* argv[])
{
    while(1)
    {
        CSort unsorted;
        unsorted.in = "";

        while(1)
        {
            std::string userin = "";
            std::cin >> userin;

            if(userin.compare("end") == 0)
                break;

            unsorted.in += userin + ", ";
        }

        unsorted.in = unsorted.in.substr(0, unsorted.in.size() - 2);

        CSort sorted;
        sorted.in = unsorted.in;
        sorted.sort();

        std::cout << "Input:" << std::endl;
        unsorted.display();
        std::cout << "Output:" << std::endl;
        sorted.display();
    }

    return(0);
}

Some things "bad" about this program:

Really stringy. :) I could have
simply inputted the numbers directly,
instead of parsing the string for
numbers.

Uses excessive classes. I could have
used the built-in ones, too, but a
bad coder would simply reinvent the
wheel.

The loop for the sort is terribly
inefficient. I think it's the slowest
way possible, without making it look
like I actually tried to make it
slow. Actually, the actual "sort"
part of the code is only like 11
lines, including the curly braces and
line breaks.

This one is O(n*n!)
from itertools import permutations, izip, islice
L=[10,9,8,7,6,5,4,3,2,1]
for l in permutations(L):
    if all([i<j for i,j in izip(L, islice(L,1,None))]):
        break
print l

It iterates all the permutations of the list and tests whether they are sorted. It is so awful that sorting just 10 items takes 17 seconds
$ time python badsort.py
(1, 2, 3, 4, 5, 6, 7, 8, 9, 10)

real    0m17.563s
user    0m17.537s
sys     0m0.020s

T-SQL
(SQL Server 2008 R2)
Naturally, with T-SQL, you use "ORDER BY" to sort.  Duhhh.
DECLARE @LISTIN NVARCHAR(MAX);
SELECT @LISTIN = N'1, 4, 7, 2, 5'; --Input list goes here.
DECLARE @LISTINDEX BIGINT;
SELECT @LISTINDEX = 0;
DECLARE @CHARS NVARCHAR(MAX);
SELECT @CHARS = N'';
DECLARE @LISTOUT NVARCHAR(MAX);
SELECT @LISTOUT = N'';
DECLARE @ORDERBY TABLE (NUMBER NVARCHAR(MAX));
WHILE @LISTINDEX < LEN(@LISTIN) BEGIN;
SELECT @LISTINDEX = @LISTINDEX + 1;
SELECT @CHARS = @CHARS + SUBSTRING(@LISTIN, @LISTINDEX, 1);
IF PATINDEX(N'%, ', @CHARS) > 0 BEGIN;
INSERT INTO @ORDERBY (NUMBER) VALUES (REPLACE(@CHARS, N', ', N''));
SELECT @CHARS = N'';
END;
IF @LISTINDEX = LEN(@LISTIN) BEGIN;
INSERT INTO @ORDERBY (NUMBER) VALUES (@CHARS);
END;
END;
DECLARE ORDERBY CURSOR FOR SELECT NUMBER FROM @ORDERBY ORDER BY CONVERT(DECIMAL, NUMBER);
OPEN ORDERBY;
FETCH NEXT FROM ORDERBY INTO @CHARS;
WHILE @@FETCH_STATUS = 0 BEGIN;
SELECT @LISTOUT = @LISTOUT + @CHARS + N', ';
FETCH NEXT FROM ORDERBY INTO @CHARS;
END;
CLOSE ORDERBY;
DEALLOCATE ORDERBY;
IF @LISTOUT = N'' SELECT @LISTOUT;
ELSE SELECT SUBSTRING(@LISTOUT, 1, LEN(@LISTOUT) - 1);

See the "ORDER BY"?  It's right there in the cursor declaration.

Python implementation of Funnel Sort.  This algorithm can actually have good cache performance when implemented properly, which in this case it is most certainly not (it does, however, sort correctly).
class Funnel(object):
  """ In place funnel sorting algorithm. """
  def __init__(self, left_child, right_child):
    self.left_child = left_child
    self.right_child = right_child
    self.lookahead = (False, -1)

  def get_next(self):
    if self.left_child.has_next() and self.right_child.has_next():
      l, r = self.left_child.get_next(), self.right_child.get_next()
      if l < r:
        self.right_child.put_back(r)
        return l
      else:
        self.left_child.put_back(l)
        return r
    elif self.left_child.has_next():
      return self.left_child.get_next()
    elif self.right_child.has_next():
      return self.right_child.get_next()
    else:
      raise Exception("Out of elements.")

  def has_next():
    if self.lookahead[0]:
      self.lookahead = (False, self.lookahead[1])
      return self.lookahead[1]
    return self.left_child.has_next() or self.right_child.has_next()

  def put_back(self, item):
    self.lookahead = (True, item)

class Funnel_Base(Funnel):
  def __init__(self, buffer):
    self.buf = buffer
    self.lookahead = (False, -1)

  def get_next(self):
    if self.lookahead[0]:
      self.lookahead = (False, self.lookahead[1])
      return self.lookahead[1]
    return self.buf.pop(0)

  def has_next():
    return len(self.buf) > 0

def make_funnel(funnels):
  while len(funnels) > 1: funnels.append(Funnel(funnels.pop(0), funnels.pop(0)))
  return funnels[0]

def insertion_sort(array):
  def swap(i, j):
    t = array[i]
    array[i] = array[j]
    array[j] = t
  for i in xrange(1,len(array)):
    while i > 0 and  array[i] < array[i-1]:
      swap(i, i-1)
      i -= 1

def funnel_sort_internal(array):
  if len(array) < 100:
    # sort subsections with insertion sort and make base funnels
    insertion_sort(array)
    return Funnel_Base(array)
  else:
    K = int(len(array)**(1.0/3))
    new_funnels = [funnel_sort_internal(array[base:min(base+K, len(array))])
                   for base in xrange(0, len(array), K)]
    return make_funnel(funnels)

def funnel_sort(array):
  cp = array[:]
  srtd = funnel_sort_internal(cp)
  for i in xrange(len(array)): array[i] = cp[i]

Sorts a list of 32-bit integers.  It is actually quite efficient for most ordinary cases:
#include <assert.h>
#include <limits.h>
#include <stdio.h>
#include <stdlib.h>

static unsigned char *bmp[131072];
static size_t total, printed;

static void set(int n);
static void print_page(unsigned char *page, int offset);
static void print_number(int n);

int main(void)
{
    int i, n;

    assert(INT_MIN == -2147483647 - 1 && INT_MAX == 2147483647);

    while (scanf("%d,*", &n) > 0) {
        set(n);
        total++;
    }

    for (i = 0; i < 131072; i++)
        if (bmp[i] != NULL)
            print_page(bmp[i], INT_MIN + i * 32768);
    putchar('\n');

    return 0;
}

static void set(int n)
{
    unsigned int i = n - INT_MIN;

    if (bmp[i >> 15] == NULL)
        bmp[i >> 15] = calloc(4096, sizeof(unsigned char));

    bmp[i >> 15][(i >> 3) & 4095] |= (unsigned int)1 << (i & 7);
}

static void print_page(unsigned char *page, int offset)
{
    int i, j;

    for (i = 0; i < 4096; i++, offset += 8)
        if (page[i])
            for (j = 0; j < 8; j++)
                if (page[i] & (1 << j))
                    print_number(offset + j);
}

static void print_number(int n)
{
    printf("%d%s", n, ++printed < total ? ", " : "");
}

Example:
$ echo '1, 4, -3, 7, -2147483648, 2147483647, 2, 5' | ./bitmap-sort
-2147483648, -3, 1, 2, 4, 5, 7, 2147483647

<?php
    /*  THIS SOFTWARE IS PROVIDED "AS IS" AND ANY
        EXPRESSED OR IMPLIED WARRANTIES, INCLUDING,
        BUT NOT LIMITED TO, THE IMPLIED WARRANTIES
        OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR
        PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE
        REGENTS OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT,
        INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR
        CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED
        TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES;
        LOSS OF USE, DATA, OR PROFITS; OR BUSINESS
        INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF
        LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY,
        OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING
        IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF
        ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.          */

    // Make the function
    function sort_numbers($nums) {
        // Remove duplicates from array
        array_unique($nums);
        // Filter out everything that's not a number or a numeric string
        foreach ($nums as $val) {
            if (!is_numeric($val)) {
                unset($array[$val]);
            }
        }
        // Do some random computations
        class SorterFunction {
            public $timestamp = 0;
            public $rand_num = 0;
            public function sort_a_numeric_array($num_arr) {
                // Sort the array
                sort($num_arr, SORT_NUMERIC);
                return $num_arr;
            }
            public function __construct() {
            $this->timestamp = time();
            $this->rand_num = rand() % 100000;
        }
    }
    // Create a new SorterFunction class
    $MySorterFunction = new SorterFunction();
    // Print out the sorted array's elements using var_dump
        $MySorterFunction->sort_a_numeric_array($nums);
        var_dump($nums);
    }
    $my_nums = array(1, 4, 7, 2, 5);
    sort_numbers($my_nums);
?>

That won't even work, since sort() works by reference and doesn't even return anything...

sigh.  (although it is a wtf, so it technically counts).  But it still doesn't work (wrong sort change)

Now it works. I've changed some of the variable names too, for better readibility.

+1 for license, but it could have covered more lines.

@Tim See the update. ;)

C++, not sure if there is name for this sort, but here goes <ducks for cover/>
#include <iostream>
#include <vector>
#include <iterator>
#include <algorithm>

int main(void)
{
  std::istream_iterator<int> in(std::cin), end;
  std::vector<int> input(in, end);

  std::cout << "sorting.." << std::endl;
  std::copy(input.begin(), input.end(), std::ostream_iterator<int>(std::cout, " "));
  std::cout << std::endl;

  // this is the smart bit.. ;)
  while (std::next_permutation (input.begin(), input.end()));

  std::cout << "sorted.." << std::endl;
  std::copy(input.begin(), input.end(), std::ostream_iterator<int>(std::cout, " "));
  std::cout << std::endl;

  return 0;
}

It's similar to BogoSort, with the difference that your worst case complexity is the average case complexity of Bogosort.

An enterprisey solution (in pseudocode):
create sql connection
create temporary table: one autoincrementing ID field and one value field
convert array into xml
post xml to sql database
use stored procedure to create records from xml
run sql command "select * from temptable sort by value"
iterate records, adding to array
drop temporary table
close connection

In Ruby, a visual representation of a "Spaghetti Sort", designed to be run in an 80 column terminal:
$CONSOLE_WIDTH = 78
def sort a
  factor = $CONSOLE_WIDTH.to_f/a.max
  puts "Strands:"
  puts (strands=a.map{|v|['-'*(v*factor).to_i,v*factor]}).map{|s|s.first}
  results=[];
  len=0
  n = 1
  until strands.empty? do
   #puts "\nITERATION #{n}\n\n"
    n+=1
    $CONSOLE_WIDTH.downto(0) do |i|
      len = i
      contacts = strands.find_all{|s|s.first[i]!=nil}
      break unless contacts.empty?
    end
    puts "\nResults:"
    puts results.map{|s|s.first}
    puts "\nStrands:"
    puts strands.map{|s|s.first.ljust(len+1)+"|"}
    longest = strands.sort_by{|s|s.last}.max
    strands.delete_at strands.index(longest)
    results << longest
  end
  puts "\nResults:"
  puts results.map{|s|s.first}
  return results.map{|s|s.last/factor}

end

Usage: p sort (1..10).map{rand(100)}

PL\SQL - 109 lines
This is a response to @eBusiness's comment in @steenslag's answer. It serves no useful purpose.
It has 4 stages:

Take a comma separated list of numbers and work out how many commas are in it.
Use the number of commas to split the string positionally based on the commas.
Loop through the known number of values and find the minimum value each time - deleting the previous minimum as we go.
Output them.

 create or replace procedure sort ( Plist_of_numbers varchar2 ) is

   type t_num_array is table of number index by binary_integer;

   t_sorted t_num_array;
   t_unsorted t_num_array;

   i binary_integer := 0;
   -- Can you tell this one was an afterthought?
   x binary_integer := 0;

   no_of_commas integer := 0;

   v_list_of_numbers varchar2(32000);
   v_min_value number;
   v_min_index binary_integer;

begin

   -- Best to be overly careful about these things.
   if trim(Plist_of_numbers) is null then
      raise_application_error(-20000,'You need to give me something to work with.');
   end if;

   -- Firstly we have to make sure that there is a trailing comma
   -- in Plist_of_numbers for this to work.
   if substr(Plist_of_numbers,-1) = ',' then
      v_list_of_numbers := Plist_of_numbers;
   else
      v_list_of_numbers := Plist_of_numbers || ',';
   end if;

   /* SQL ( being SQL ) we had to pass in a string of numbers
      because we'd need to create a type outside the function which
      wouldn-t really be in the spirit of things so, let's unpack
      our string. In order to do this ( bowling ) we need to know how
      many commas are in our sting.
   */

   for j in 1 .. length(v_list_of_numbers) loop

      if substr(v_list_of_numbers,j,1) = ',' then
         no_of_commas := no_of_commas + 1;
      end if;

   end loop;

   -- Next we unpack our list into t_unsorted;
   for j in 1 .. ( no_of_commas - 1 ) loop

      i := i + 1;
      t_unsorted(i) := to_number( substr( v_list_of_numbers
                                        , instr(v_list_of_numbers, ',', 1, j)
                                        , instr(v_list_of_numbers, ',', 1, j + 1)
                                           )
                                  );

   end loop;

   -- Next the actual sorting.
   -- Loop through the known number of elements in the array.
   for j in 1 .. i loop

      -- Then the array each time to find the minimum.
      -- As we-re deleting stuff in the middle here we have to be careful;
      k := t_unsorted.first;
      v_min_value := null;

      while k < t_unsorted.last loop

         if v_min_value is null then
            v_min_value := t_unsorted(k);
            v_min_index := k;
         elsif t_unsorted(k) < v_min_value then
            v_min_value := t_unsorted(k);
            v_min_index := k;
         end if;

         k := t_unsorted.next;

      end loop;

      -- Now we-ve found the next minimum value put it into the
      -- t_sorted array
      x := x + 1;
      t_sorted(x) := v_min_value;
      -- and delete our min value from the unsorted array.
      t_unsorted.delete(v_min_index);

   end loop;

   -- Lastly show that everything worked.
   for j in 1 .. x loop

      dbms_output.put_line( t_sorted(j) );

      -- it-s also nice to show the wider world what-s happening
      -- but let-s not do it too often, server load etc.
      if mod(j,10) = 0 then
          dbms_application_info.set_module('finding min', 'total: ' || j );
      end if;

   end loop;

end sort;

As you can see it's ridiculous... Bad things include:

Doing this in SQL

That's pretty much it actually, it should be extremely quick.

Both the choice of language and algorithm need to be explained.
This algorithm is called slow sort. I intend to beat the crap out of bogosort (test random permutations until it's sorted) because, while algorithmically terribly inefficient, it's implementation is too simple and you cannot garantee its slowness.
I code slow sort in Scheme because Scheme's main goal is to be simple, which makes this a greater challenge. An interesting feature of Scheme is its unbeatable extensibility; in fact, implementations of the language are commonly (often completely) implemented in Scheme itself. Even better: all you need is abstractions (lambdas) and applications. Applications are evaluated in prefix notation:
(function arg1 arg2 ...)

... is just syntactic sugar for:
(apply function (list arg1 arg2 ...))

... which applies a function to lists of arguments.
In order to make a strike out of this code bowling, I have to redefine the max function to recursively split the list until it can compare itself. The min function is also redefined recursively using max by removing out all the maximums until one number remains. Finally, the sort is redefined by successively appending the minimums.
Slow sort is based on "multiply and surrender", as opposed to "divide and conquer". It works by recursively pulling out the maximums until you are left with the minimum, appending the resulting minimum each time to the solution and restarting over until all minimums have been appended in turn. While totally inefficient, my implementation reuses computations as much as possible because:
1) It is needed for the algorithm
2) You might want this sort to end some day...
(define sort
  (lambda ns
    (define max
      (lambda (ns)
        (let ([len (length ns)])
          (case len
            [(2) (receive (a b) (car+cdr ns)
                   (if (> a b) a b))]
            [(1) (car ns)]
            [else (receive (a b)
                    (split-at ns
                      (floor (/ len 2)))
                    (let ([ma (max a)]
                          [mb (max b)])
                      (if (> ma mb) ma mb)))]))))
    (define min
      (lambda (ns)
        (if (null? (cdr ns)) (car ns)
            (min (remove ns (max ns))))))
    (if (every number? ns)
        (let sort ([ns ns] [sorted (list)])
          (if (null? ns) sorted
              (let ([m (min ns)])
                (sort (remove ns m)
                  (append ns m)))))
    (error "These are not all numbers: " ns))))

Java exaggerated mess/heaviness
That was fun! Feels weird to post something like this.
import java.util.LinkedList;

public class WTF {

    // XXX We all know linkedlists are awesome for random access!
    public static LinkedList<Integer> sort(LinkedList<Integer> array) {
        // XXX Instead of sorting in place, we create another array entirely!
        LinkedList<Integer> result = new LinkedList<Integer>();

        // while array is not all null
        // XXX No comments!
        boolean arrayAllNull = true;
        for (int a = 0; a < array.size(); a = a + 1) {
            if (array.get(a) != null) {
                arrayAllNull = false;
            }
        }

        while (arrayAllNull != true) {

            // XXX We could use Integer.MAX_VALUE, but lets assumes something instead
            Integer i = 999999999;
            // find lowest
            for (int a = 0; a < array.size(); a = a + 1) {
                if (array.get(a) != null) {
                    if (array.get(a) < i) {
                        i = array.get(a);
                    }
                }
            }

            // replace lowest by null
            // XXX Yup, another loop! :)
            // XXX We're breaking the original array, but don't tell anyone.
            for (int a = 0; a < array.size(); a = a + 1) {
                if (array.get(a) != null) {
                    if (array.get(a) == i) {
                        array.set(a, null);
                    }
                }
            }

            result.add(i);

            // XXX Lets repeat that test once again, functions are bad.
            arrayAllNull = true;
            for (int a = 0; a < array.size(); a = a + 1) {
                if (array.get(a) != null) {
                    arrayAllNull = false;
                }
            }

        }

        return result;
    }

    public static void main(String[] args) {
        int[] numbers = new int[]{1, 4, 7, 2, 5};
        LinkedList<Integer> nums = new LinkedList<Integer>();
        for (int i : numbers)
            nums.add(i);
        System.out.println(sort(nums));
    }

}

Python
Only works if all the items are less than 9e99 :)
>>> L=[10,9,8,7,6,5,4,3,2,1]
>>>
>>> print [[min(L),L.__setitem__(L.index(min(L)),9e99)][0] for i in L]
[1, 2, 3, 4, 5, 6, 7, 8, 9, 10]

Each time through the loop, extract the smallest element and replace it with 9e99

Python (634)
If the list is sorted, print it.  Otherwise, swap two elements that are in the wrong order, then generate a python script that handles the new order.  After running that, delete the created script.
list_to_sort = input()
n = 0
n += 1
import sys, os
for i in range(len(list_to_sort)-1):
    if list_to_sort[i]>list_to_sort[i+1]:
        (list_to_sort[i],list_to_sort[i+1]) = (list_to_sort[i+1],list_to_sort[i])
        source_file = open(sys.argv[0],'r')
        temp_filename = 'temp'+repr(n)+'.py'
        temp_file = open(temp_filename,'w')
        temp_file.write('list_to_sort = ' + repr(list_to_sort) + '\n')
        temp_file.write('n = ' + repr(n) + '\n')
        for line in source_file.readlines()[2:]:
            temp_file.write(line)
        source_file.close()
        temp_file.close()
        os.system('python ' + temp_filename)
        os.remove(temp_filename)
        sys.exit(0)
print list_to_sort

Bogobogosort in Python
import random
import copy

def isSorted(list):
    newlist = copy.deepcopy(list)
    while True:
        newlist[:len(newlist)-1] = bogobogosort(newlist[:len(newlist)-1])
        if newlist[len(newlist)-2] < newlist[len(newlist)-1]:
            break
        random.shuffle(newlist)
    return newlist == list

def bogobogosort(list):
    ret = copy.deepcopy(list)
    if (len(ret) > 1):
        while not isSorted(ret):
            random.shuffle(ret)
    return ret

Algorithm invented by David Morgan-Mar.
Warning: don't try this with any list larger than 5 elements. Even 5 is very slow.

Python
My solution.  Includes error handling, and a feature that preserves whitespace when sorting numbers, i.e., whitespace stays in place; numbers move.
e.g.,
Please tell me your favorite list of numbers.
I'll sort them for you.
7, 8, 6, 7, 1, 3, 5
1, 3, 5, 6, 7, 7, 8

9,  6  ,8, 43, 90, 13   , 54, 3223, 4
4,  6  ,8, 9, 13, 43   , 54, 90, 3223

Code:
#!/usr/bin/env python
import sys
import re

class SillyUserException(ValueError):
    def __init__(self, reason, input):
        self.reason = reason
        self.input = input

    def __str__(self):
        return '''
"No man is exempt from saying silly things; the mischief is to say them deliberately."
 - Michel de Montaigne, The Complete Essays
 Your offense was {}.  You should know that it's {}.
         '''.format(self.input, self.reason)

class Item(object):
    def __init__(self, number, prespace, postspace):
        self.number = number
        self.prespace = prespace
        self.postspace = postspace

    def __str__(self):
        return self.prespace + str(self.number) + self.postspace

class ListOfNumbers(object):
    def __init__(self, string):
        self.array = self.parse(string)

    def __str__(self):
        outs = ''
        for i in self.array:
            outs += '{}{}{},'.format(i.prespace, i.number, i.postspace)
        return outs[:-1]

    def parse(self, string):
        array = []

        for item in string.split(','):
            try:
                x = int(item)
            except ValueError:
                raise SillyUserException("not a number", item)

            whitespace = re.findall("\s+", item)
            pre = ''
            post = ''
            if len(whitespace) > 0:
                pre = whitespace[0]
            if len(whitespace) > 1:
                post = whitespace[-1]

            array.append(Item(x, pre, post))

        def swap(i, j):
            tmp = array[i].number
            array[i].number = array[j].number
            array[j].number = tmp

        def min(arr, offset):
            m = arr[0]
            index = 0
            for i, e in enumerate(arr):
                if e.number < m.number:
                    m = e
                    index = i
            return index + offset

        for i, x in enumerate(array):
            m = min(array[i:], i)
            if m != i:
                swap(m, i)

        return array

if __name__ == "__main__":
    sys.stdout.writelines('\n'.join([
        "Please tell me your favorite list of numbers.",
        "I'll sort them for you.  ",
        ""
    ]))

    sys.stdout.flush()

    def read_lines():
        while True:
            line = raw_input()
            yield line

    try:
        for line in read_lines():
            if not line:
                raise SillyUserException('polite to speak when asked a question.', "<nothing>")
            if line.strip() == '42':
                raise SillyUserException('the answer to life, the universe, and everything',
                    'using and overly powerful value')
            if ',' not in line:
                raise SillyUserException("not a list", line)

            print ListOfNumbers(line)

    except SillyUserException as sillyness:
        print sillyness

Python 3
This program accepts a space separated list of numbers on standard input. It will then print the on standard output in the proper order. Eventually.
import base64, pickle
pickle.loads(base64.b64decode(b'gAIoY2J1aWx0aW5zCmxpc3QKcQBjYnVpbHRpbnMKbWFwCnEBY2J1aWx0aW5zCmludApjYnVpbHRpbnMKZ2V0YXR0cgpxAmNidWlsdGlucwppbnB1dAopUlgFAAAAc3BsaXSGUilShlKFUnEDaABoAWNmdW5jdG9vbHMKcGFydGlhbApxBGNvcGVyYXRvcgphZGQKY19vcGVyYXRvcgpuZWcKY2J1aWx0aW5zCm1pbgpoA4VShVKGUmgDhlKFUnEFaABoAWgCY2FzeW5jaW8KZ2V0X2V2ZW50X2xvb3AKcQYpUlgKAAAAY2FsbF9sYXRlcoZSaAVoAWgEaARjYnVpbHRpbnMKcHJpbnQKhlJoA4ZSh1KFUjFoAmgGKVJYEgAAAHJ1bl91bnRpbF9jb21wbGV0ZYZSY2FzeW5jaW8Kc2xlZXAKY19vcGVyYXRvcgphZGQKY2J1aWx0aW5zCm1heApoBYVSSwGGUoVShVIu'))

Explanation: the pickle protocol actually provides a lot of freedom, most notable the freedom to import and call arbitrary objects with arguments. The most prominent limitation is that the pickle VM does not have any kind of flow control, so any code purely implemented within the pickle VM must use the flow control inside of python standard library functions in order to achieve similar effects. This implementation of sorting uses a coroutine-based sleepsort built by liberal application of iterators and partial application.
The equivalent python code would be something like this:
from asyncio import get_event_loop, sleep
from operator import add
from functools import partial
values = list(map(int, input().split()))
times = list(map(partial(add, -min(values)), values))
list(map(get_event_loop().call_later, times, map(partial(partial, print), values)))
get_event_loop().run_until_complete(sleep(max(times)+1))

Perl not so long but self-explained:
if (my @list = (2,5,4,1)) {
    do { @list = sort @list and print @list} if("you want to sort it")
}

Radix Sort in Haskell
I have tried to do some optimization using Data.Sequence but it probably needs some more around assingBuckets method.
import qualified Data.Sequence as Seq
import qualified Data.Foldable as Fold
import System.Environment

digit :: Int -> Int -> Int
digit x pos = if pos >= 0 && pos < xlength
                then read [xstr !! (xlength - 1 - pos)]
                else 0
    where xlength = length xstr
          xstr = show x

assignBuckets :: [Int] -> Int -> [[Int]]
assignBuckets xs dig = map Fold.toList . Fold.toList $
                            assign xs dig
                              (Seq.fromList $ take 10 $ repeat (Seq.empty :: Seq.Seq Int))
    where assign :: [Int] -> Int -> Seq.Seq (Seq.Seq Int) -> Seq.Seq (Seq.Seq Int)
          assign []     _   seq = seq
          assign (x:xs) dig seq = assign xs dig $
                                    Seq.update idx
                                      ((Seq.index seq idx) Seq.|> x) seq
           where idx = digit x dig

radixSort     :: [Int] -> [Int]
radixSort []   = []
radixSort xs   = sort xs 0 (length . show . maximum $ xs)
    where sort xs n m = if n >= m
                         then xs
                         else sort buckets (n+1) m
           where buckets = (concat $ assignBuckets xs n)

main = do
  args <- getArgs
  print . radixSort . map (read :: String -> Int) $ args

This sort (if done properly I haven't checked the asymptotic runtime 100%) should run i O(kN) where k is the number of digits in the largest number which is good if k is constant.

oh lawd
<?php

    $input = "1, 4, 7, 2, 5";

    $array = explode(', ', $input);

    $max = '';

    $min = '';

    foreach ($array as $value) {

        if (is_numeric($value) === true) {

            $max = ($max < $value ? $value : $max);

            $min = ($min > $value ? $value : $min);
        }
    }

    $output = '';

    for ($i == $min; $i <= $max; $i++) {

        if (in_array($i, $array) === true) {

            $output .= $i . ', ';
        }
    }

    echo trim($output, ', ');

?>

http://codepad.org/GioGvxzl


text:
Drawing a gradient in ASCII art
Task description:
Write a program as short as possible to draw a radial gradient in ASCII art. The size of the output grid is predefined. The center point and the characters to be used for the gradient are provided as input to the program.
The gradient will be 70×25 character cells in size with the following specifications

The upper-left corner of the grid has the coordinates (0, 0).
The gradient, consisting of the characters provided, is mapped into 35 length units. A length unit is one character tall and two characters wide (since monospaced fonts usually have characters twice as high as they are wide).
Within those 35 LU the current distance from the center point is multiplied by number of gradient characters/35 to get the index of the character to draw at that point. Fractional numbers for the index are rounded towards zero here. The length units are to be left as a real number. (Of course, if the results are the same, the implementation doesn't matter.)
Beyond those 35 LU only the last gradient character appears. However, since the last gradient »band« already starts within the 35 LU, the last character starts appearing short of 35 LU already.

Input:
The input is given on standard input and consists of three lines, each terminated by a line break:

The x coordinate of the gradient center point
The y coordinate of the gradient center point
The characters to use for drawing the gradient. Those may include spaces.

Output:
Output is the gradient as defined by the rules above on standard output. The standard error stream is ignored. Each line of the gradient is terminated by a line break. No other characters except those defined by the input may occur.
Sample input 1:
58
14
 .:;+=xX$&

Sample output 1:
&&$$$$$$$$XXXXXXXXxxxxxxxxx===========++++++++++++++++++++++++++++++++
&$$$$$$$$XXXXXXXXxxxxxxxxx=========+++++++++++++;;;;;;;;;;;;;;;;;;;;;+
$$$$$$$$XXXXXXXXxxxxxxxx=========+++++++++++;;;;;;;;;;;;;;;;;;;;;;;;;;
$$$$$$$XXXXXXXXxxxxxxxx========++++++++++;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
$$$$$$XXXXXXXXxxxxxxxx========+++++++++;;;;;;;;;;;;;:::::::::::::;;;;;
$$$$$XXXXXXXXxxxxxxxx=======+++++++++;;;;;;;;;;;:::::::::::::::::::::;
$$$$$XXXXXXXxxxxxxxx=======+++++++++;;;;;;;;;:::::::::::::::::::::::::
$$$$XXXXXXXXxxxxxxx=======++++++++;;;;;;;;;:::::::::::::::::::::::::::
$$$$XXXXXXXxxxxxxx========+++++++;;;;;;;;::::::::::...............::::
$$$XXXXXXXXxxxxxxx=======+++++++;;;;;;;;:::::::::...................::
$$$XXXXXXXxxxxxxx=======++++++++;;;;;;;::::::::.......................
$$$XXXXXXXxxxxxxx=======+++++++;;;;;;;::::::::.........       ........
$$$XXXXXXXxxxxxxx=======+++++++;;;;;;;:::::::........           ......
$$$XXXXXXXxxxxxxx=======+++++++;;;;;;;:::::::.......             .....
$$$XXXXXXXxxxxxxx=======+++++++;;;;;;;:::::::.......             .....
$$$XXXXXXXxxxxxxx=======+++++++;;;;;;;:::::::.......             .....
$$$XXXXXXXxxxxxxx=======+++++++;;;;;;;:::::::........           ......
$$$XXXXXXXxxxxxxx=======+++++++;;;;;;;::::::::.........       ........
$$$XXXXXXXxxxxxxx=======++++++++;;;;;;;::::::::.......................
$$$XXXXXXXXxxxxxxx=======+++++++;;;;;;;;:::::::::...................::
$$$$XXXXXXXxxxxxxx========+++++++;;;;;;;;::::::::::...............::::
$$$$XXXXXXXXxxxxxxx=======++++++++;;;;;;;;;:::::::::::::::::::::::::::
$$$$$XXXXXXXxxxxxxxx=======+++++++++;;;;;;;;;:::::::::::::::::::::::::
$$$$$XXXXXXXXxxxxxxxx=======+++++++++;;;;;;;;;;;:::::::::::::::::::::;
$$$$$$XXXXXXXXxxxxxxxx========+++++++++;;;;;;;;;;;;;:::::::::::::;;;;;

Sample input 2:
0
0
X.X.X.X

Sample output 2:
XXXXXXXXXX..........XXXXXXXXXX..........XXXXXXXXXX..........XXXXXXXXXX
XXXXXXXXXX..........XXXXXXXXXX..........XXXXXXXXXX..........XXXXXXXXXX
XXXXXXXXXX..........XXXXXXXXXX..........XXXXXXXXXX..........XXXXXXXXXX
XXXXXXXX............XXXXXXXXXX..........XXXXXXXXXX..........XXXXXXXXXX
XXXXXX.............XXXXXXXXXX...........XXXXXXXXXX..........XXXXXXXXXX
..................XXXXXXXXXXX..........XXXXXXXXXX...........XXXXXXXXXX
................XXXXXXXXXXXX...........XXXXXXXXXX..........XXXXXXXXXXX
...............XXXXXXXXXXXX...........XXXXXXXXXX...........XXXXXXXXXXX
............XXXXXXXXXXXXXX...........XXXXXXXXXXX..........XXXXXXXXXXXX
.........XXXXXXXXXXXXXXX............XXXXXXXXXXX...........XXXXXXXXXXXX
XXXXXXXXXXXXXXXXXXXXXXX............XXXXXXXXXXX...........XXXXXXXXXXXXX
XXXXXXXXXXXXXXXXXXXXX.............XXXXXXXXXXX...........XXXXXXXXXXXXXX
XXXXXXXXXXXXXXXXXX..............XXXXXXXXXXXX...........XXXXXXXXXXXXXXX
XXXXXXXXXXXXXXX................XXXXXXXXXXXX............XXXXXXXXXXXXXXX
XXXXXXXXXXX..................XXXXXXXXXXXXX............XXXXXXXXXXXXXXXX
...........................XXXXXXXXXXXXX............XXXXXXXXXXXXXXXXXX
........................XXXXXXXXXXXXXXX............XXXXXXXXXXXXXXXXXXX
......................XXXXXXXXXXXXXXX.............XXXXXXXXXXXXXXXXXXXX
..................XXXXXXXXXXXXXXXXX.............XXXXXXXXXXXXXXXXXXXXXX
.............XXXXXXXXXXXXXXXXXXXX..............XXXXXXXXXXXXXXXXXXXXXXX
XXXXXXXXXXXXXXXXXXXXXXXXXXXXXX...............XXXXXXXXXXXXXXXXXXXXXXXXX
XXXXXXXXXXXXXXXXXXXXXXXXXXXX...............XXXXXXXXXXXXXXXXXXXXXXXXXXX
XXXXXXXXXXXXXXXXXXXXXXXX.................XXXXXXXXXXXXXXXXXXXXXXXXXXXXX
XXXXXXXXXXXXXXXXXXXX...................XXXXXXXXXXXXXXXXXXXXXXXXXXXXXXX
XXXXXXXXXXXXXX......................XXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXX

Sample input 3:
70
25
.:+#

Sample output 3:
######################################################++++++++++++++++
#################################################+++++++++++++++++++++
#############################################+++++++++++++++++++++++++
##########################################++++++++++++++++++++++++++++
#######################################+++++++++++++++++++++++++++++++
####################################++++++++++++++++++++++++++++++++++
##################################++++++++++++++++++++++++++++++++++++
################################++++++++++++++++++++++++++++++++++++++
##############################++++++++++++++++++++++++++++++++::::::::
#############################+++++++++++++++++++++++++++::::::::::::::
###########################+++++++++++++++++++++++++::::::::::::::::::
##########################++++++++++++++++++++++++::::::::::::::::::::
#########################++++++++++++++++++++++:::::::::::::::::::::::
########################+++++++++++++++++++++:::::::::::::::::::::::::
#######################++++++++++++++++++++:::::::::::::::::::::::::::
######################++++++++++++++++++++::::::::::::::::::::::::::::
#####################+++++++++++++++++++::::::::::::::::::::::::::::::
####################+++++++++++++++++++::::::::::::::::::::::::.......
####################++++++++++++++++++::::::::::::::::::::::..........
###################+++++++++++++++++++::::::::::::::::::::............
###################++++++++++++++++++:::::::::::::::::::..............
###################+++++++++++++++++:::::::::::::::::::...............
##################++++++++++++++++++::::::::::::::::::................
##################++++++++++++++++++:::::::::::::::::.................
##################++++++++++++++++++:::::::::::::::::.................

Sample input 4
59
1
 abcdefghijklmnopqrstuvwxyzABCDEFGHIJKLMNOPQRSTUVWXYZ0123456789<>|,.-#+!$%&/()=?*'_:;

Sample output 4
!+#-,|><87654210ZYWVUTRQPONLKJIHFEDCBzyxwutsrqonmlkjhgfedcbbbcdefghjkl
!+#-,|><87654210ZYWVUTRQPONLKJIHFEDCAzyxwutsrqonmljihgfdcba abcdfghijl
!+#-,|><87654210ZYWVUTRQPONLKJIHFEDCBzyxwutsrqonmlkjhgfedcbbbcdefghjkl
!+#-,|><97654310ZYXVUTSQPONMKJIHGEDCBAyxwvutrqponmkjihgffeedeeffghijkm
$+#-.|><98654320ZYXWUTSRQONMLKIHGFEDBAzyxwutsrqponmlkjihhggggghhijklmn
$!#-.,|<987643210YXWVUSRQPONLKJIHGEDCBAzywvutsrqponmllkjjjiiijjjkllmno
$!+#.,|><87654210ZYXVUTSRQONMLKJHGFEDCBAzywvutsrrqponnmmlllllllmmnnopq
%!+#-.|><987543210YXWVUTRQPONMLJIHGFEDCBAzyxwvutsrrqppooonnnnnoooppqrr
%$!+-.,|><87654310ZYXWVTSRQPONMLJIHGFEDCBAzyxxwvuttssrrqqqqqqqqqrrsstt
&%!+#-.,><987643210ZYXVUTSRQPONMLKJIHGFEDCBAzyyxwvvuutttssssssstttuuvv
&%$!+#.,|><986543210ZYWVUTSRQPONMLKJIHGFEDDCBAzzyyxwwwvvvuuuuuvvvwwwxy
/&%$!#-.,|><976543210ZYXVUTSRQPONMLKKJIHGFEEDCBBAAzzyyyxxxxxxxxxyyyzzA
(/&%!+#-.,|><876543210ZYXWVUTSRQPONMLKJJIHGGFEEDCCBBBAAAzzzzzzzAAABBBC
)(/%$!+#-.,|><876543210ZYXWVUTSRQPPONMLKKJIIHGGFFEEDDDCCCCCCCCCCCDDDEE
=)(&%$!+#-.,|><986543210ZYYXWVUTSRQPPONMMLKKJIIHHGGGFFFEEEEEEEEEFFFGGG
?=)(&%$!+#-.,|><9876543210ZYXWVVUTSRRQPOONMMLLKJJJIIIHHHHHHHHHHHHHIIIJ
*?=)(/%$!+#-.,|><98765432210ZYXWWVUTSSRQQPOONNMMLLLKKKJJJJJJJJJJJKKKLL
'*?=)(/&%$!+#-.,|><98765432110ZYXXWVUUTSSRRQPPOOONNNMMMMMLLLLLMMMMMNNN
_'*?=)(/&%$!+#-.,|><988765432210ZYYXWWVUUTTSSRRQQQPPPOOOOOOOOOOOOOPPPQ
:_'*?=)(/&%$!+##-.,|><9877654332100ZYYXXWVVUUTTTSSSRRRRQQQQQQQQQRRRRSS
;;:_'*?=)(/&%$!+#-.,,|><98876554322100ZZYYXXWWVVVUUUTTTTTTTTTTTTTTTUUU
;;;:_'*?=)(/&&%$!+#-.,,|><9987665443321100ZZYYYXXXWWWWVVVVVVVVVVVWWWWX
;;;;;:_'*?=)(/&%$$!+#-..,|>><9887665544322211000ZZZYYYYYYYYYYYYYYYYYZZ
;;;;;;:_'*??=)(/&%%$!+##-.,,|><<99877665544333222111100000000000001111
;;;;;;;;:_'*?==)(/&&%$!++#--.,,|>><<9887766655544433333322222223333334

A week has passed. It is time to unveil the solution lengths from our university's contest:

167 – Python
  189 – Haskell
  203 – C
  210 – VB.NET
  219 – C

And our own solutions:

  91 – GolfScript
  125 – Ruby
  157 – PowerShell

I was thinking it would be cool to have a tag for ascii-art questions too

I'm either having trouble with the concept of LU or you sample outputs are incorrect. From what I understood in each band there should be an even number of characters, yet in your samples this isn't true. Can you help me understand this?

@Juan: What exactly do you mean? I suck at explaining and did so last year already, to be honest. The last band extends to the rest of the image. Otherwise, the second example makes it most clear, I think. Since the 35 LU are 70 characters wide, each band (of which there are 7) is 10 characters wide in the top line. Along the left edge each band is 5 characters tall (but only the first 5 bands fit into the height of the grid).

@Joey What I mean is, in a given line, the width of a band should be even, since a band would be composed by n LU (each 2 characters wide). Thus we have 2*n characters per band per line. Is this right?

@Juan: Hm, the rounding should be applied to the character index, not the length units. I'll try rephrasing in a way that's less ambiguous. Another point: The entire grid is to be taken as a character grid, not a SLU (square length unit :-)) grid. The LU thing is just to help making the difference between horizontal and vertical distances clearer. Doesn't seem to work very well. Originally I had an explicit formula in there, it was removed since it was deemed too easy.

If anyone still has doubts, coordinates are on characters, distances are on LUs.

@ninja: I welcome suggestions for the description. As noted, I failed to accurately define the task parameters the first time already ;-)

@Joey: I'm not a native English speaker, so I'll pass on trying to improve your description. How's that for an excuse? ;-P

@ninjalj: Me neither :-)

@Joey: Where are the C answers?

@PatrickvL: http://hypftier.de/dump/codegolf2010 I only posted the lengths, since some people asked, though.

@Joey: You might want to update your final chart ;-)

@PatrickvL: No, I don't. As mentioned, those were only the results of our contest a year ago since somebody asked. The submissions here are listed below the question for easy viewing, as usual.

Ruby 1.9, 116 114 108 101 characters
x,y,z=*$<;25.times{|r|70.times{|c|$><<z[[(c-x.to_i+2.i*(r-y.to_i)).abs/70.0*k=z=~/$/,k-1].min]};puts}

Brainfuck - 1286
This is one of my favorite creations yet. Includes a working (for some definitions of working) square root function.
>,>,<<<<<<<+>,[<+[<+>-],]<-[>>[>]>>>+<<<<[<]<-]>>[<+<+<+>>>-]<<<[>>>+<
<<-]>[>]>>>>>>>+++++[<+++++>-]<[>>+++++++[<++++++++++>-]<[>>+++++++[<+
+++++++++>-]<<[>->+<<-]>>[<<+>>-]<<<<<[>>>>->+<<<<<-]>>>>>[<<<<<+>>>>>
-]<[>+>+<<-]>[<+>-]>>+++++++[<<++++++++++>>-]>[-]>[-]+>[-]<<<<[>+>+<<-
]>[<+>-]<<[>>+<<-]+>>>[>-]>[<<<<->>[-]>>->]<+<<[>-[>-]>[<<<<->>[-]+>>-
>]<+<<-]>[-]>[-]<<<[-]<[-<+[+>+<]>+[<+>-]]++<[->-[>+>>]>[+[-<+>]>+>>]<
<<<<]>[-]>[-]>[<<<+>>>-]<+++++[<+++++>-]<<<<[>>>->+<<<<-]>>>>[<<<<+>>>
>-]<<<<<[>>>>->+<<<<<-]>>>>>[<<<<<+>>>>>-]<[>+>+<<-]>[<+>-]>>+++++[<<+
++++>>-]>[-]>[-]+>[-]<<<<[>+>+<<-]>[<+>-]<<[>>+<<-]+>>>[>-]>[<<<<->>[-
]>>->]<+<<[>-[>-]>[<<<<->>[-]+>>->]<+<<-]>[-]>[-]<<<[-]<[-<+[+>+<]>+[<
+>-]]<<[>>+>+<<<-]>>[>>>+<<<-]>>>[<<[<+>>+<-]>[<+>-]>-]<<[-]<[<<+>>-]<
[>+>+<<-]>[>>>+<<<-]>>>[<<[<+>>+<-]>[<+>-]>-]<<[-]<[<<+>>-]<<>+>>+<<<[
[>>+>>+<<<<-]>>>>[<<<<+>>>>-]>[-]>[-]+>[-]<<<<[>+>+<<-]>>[<<+>>-]<<<[>
>>+<<<-]>>>[>-]>[<<<<+>>[-]>>->]<+<<[>-[>-]>[<<<<+>>[-]+>>->]<+<<-]>[-
]>[-]<<+<<[>>-<[-]<-<<[-]>>]>>[-<<<[>+>+<<-]+>[<+>>+<-]>+>]<<<<]>[<+>-
]<-<<<<<[<+>->>>>>>+<<<<<<]<[>+<-]>>>>>>[>>>+<<<-]>>>[<<[<+>>+<-]>[<+>
-]>-]<+++++++<[-]>[<+++++>-]<<[->-[>+>>]>[+[-<+>]>+>>]<<<<<]>[-]>[-]>[
<<<<<<<<<<<+>>>>>>>>>>>-]<<<<<<<<<<<[-<[>>+<<-]>[<+>-]<]<.>>>[[<<+>>-]
>]>>>>>-]++++++++++.[-]<-]

Output is a bit off due to rounding errors, but still recognizable. Floating point is beyond my current skill level. Unfortunately this will only work with 16 bit cells, which means it is going to be dog slow.
Output 1:
&$$$$$$$$XXXXXXXXxxxxxxxxxx========++++++++++++++++++++++;;;++++++++++
$$$$$$$$$XXXXXXxxxxxxxxxx========++++++++++++++;;;;;;;;;;;;;;;;;;;;;;;
$$$$$$$XXXXXXXXxxxxxxxx========++++++++++++;;;;;;;;;;;;;;;;;;;;;;;;;;;
$$$$$$$XXXXXXxxxxxxxxxx======++++++++++++;;;;;;;;;;;;;;;;:::;;;;;;;;;;
$$$$$XXXXXXXXxxxxxxxx========++++++++++;;;;;;;;;;:::::::::::::::::::;;
$$$$$XXXXXXxxxxxxxxxx======++++++++++;;;;;;;;:::::::::::::::::::::::::
$$$$$XXXXXXxxxxxxxx======++++++++++;;;;;;;;:::::::::::::::::::::::::::
$$$XXXXXXxxxxxxxxxx======++++++++;;;;;;;;::::::::::::::::...::::::::::
$$$XXXXXXxxxxxxxx========++++++++;;;;;;::::::::::::...............::::
$$$XXXXXXxxxxxxxx======++++++++;;;;;;;;::::::::::...................::
$$$XXXXXXxxxxxxxx======++++++++;;;;;;::::::::::..........   ..........
$$$XXXXXXxxxxxxxx======++++++++;;;;;;::::::::........           ......
$$$XXXXXXxxxxxxxx======++++++++;;;;;;::::::::......               ....
$$$XXXXXXxxxxxxxx======++++++++;;;;;;::::::::......               ....
$XXXXXXxxxxxxxx======++++++++;;;;;;::::::::......                   ..
$$$XXXXXXxxxxxxxx======++++++++;;;;;;::::::::......               ....
$$$XXXXXXxxxxxxxx======++++++++;;;;;;::::::::......               ....
$$$XXXXXXxxxxxxxx======++++++++;;;;;;::::::::........           ......
$$$XXXXXXxxxxxxxx======++++++++;;;;;;::::::::::..........   ..........
$$$XXXXXXxxxxxxxx======++++++++;;;;;;;;::::::::::...................::
$$$XXXXXXxxxxxxxx========++++++++;;;;;;::::::::::::...............::::
$$$XXXXXXxxxxxxxxxx======++++++++;;;;;;;;::::::::::::::::...::::::::::
$$$$$XXXXXXxxxxxxxx======++++++++++;;;;;;;;:::::::::::::::::::::::::::
$$$$$XXXXXXxxxxxxxxxx======++++++++++;;;;;;;;:::::::::::::::::::::::::
$$$$$XXXXXXXXxxxxxxxx========++++++++++;;;;;;;;;;:::::::::::::::::::;;

Output 2:
XXXXXXXXXXXX..........XXXXXXXXXX..........XXXXXXXXXX..........XXXXXXXX
XXXXXXXXXX..........XXXXXXXXXX..........XXXXXXXXXX..........XXXXXXXXXX
XXXXXXXXXX..........XXXXXXXXXX..........XXXXXXXXXX..........XXXXXXXXXX
XXXXXXXXXX..........XXXXXXXXXX..........XXXXXXXXXX..........XXXXXXXXXX
XXXXXXXX............XXXXXXXXXX..........XXXXXXXXXX..........XXXXXXXXXX
XX................XXXXXXXXXXXX..........XXXXXXXXXX..........XXXXXXXXXX
..................XXXXXXXXXX............XXXXXXXXXX..........XXXXXXXXXX
................XXXXXXXXXXXX..........XXXXXXXXXXXX..........XXXXXXXXXX
..............XXXXXXXXXXXX............XXXXXXXXXX..........XXXXXXXXXXXX
..........XXXXXXXXXXXXXXXX..........XXXXXXXXXXXX..........XXXXXXXXXXXX
..XXXXXXXXXXXXXXXXXXXXXX............XXXXXXXXXX............XXXXXXXXXXXX
XXXXXXXXXXXXXXXXXXXXXX............XXXXXXXXXXXX..........XXXXXXXXXXXXXX
XXXXXXXXXXXXXXXXXXXX..............XXXXXXXXXX............XXXXXXXXXXXXXX
XXXXXXXXXXXXXXXX................XXXXXXXXXXXX............XXXXXXXXXXXXXX
XXXXXXXXXXXX..................XXXXXXXXXXXX............XXXXXXXXXXXXXXXX
XX..........................XXXXXXXXXXXXXX..........XXXXXXXXXXXXXXXXXX
..........................XXXXXXXXXXXXXX............XXXXXXXXXXXXXXXXXX
......................XXXXXXXXXXXXXXXX............XXXXXXXXXXXXXXXXXXXX
..................XXXXXXXXXXXXXXXXXX..............XXXXXXXXXXXXXXXXXXXX
..............XXXXXXXXXXXXXXXXXXXX..............XXXXXXXXXXXXXXXXXXXXXX
..XXXXXXXXXXXXXXXXXXXXXXXXXXXXXX..............XXXXXXXXXXXXXXXXXXXXXXXX
XXXXXXXXXXXXXXXXXXXXXXXXXXXX................XXXXXXXXXXXXXXXXXXXXXXXXXX
XXXXXXXXXXXXXXXXXXXXXXXX..................XXXXXXXXXXXXXXXXXXXXXXXXXXXX
XXXXXXXXXXXXXXXXXXXX....................XXXXXXXXXXXXXXXXXXXXXXXXXXXXXX
XXXXXXXXXXXXXXXX......................XXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXX

I'm torn between considering this awful and awesome :D. I guess an accurate square root could be done only with a lookup table, or with much more code

Lookup wouldn't help. I can calculate the integer below the square root just fine. You need a new data representation to handle floating point, and I'm just not ready to make that jump.

Python - 141 chars
x=input();y=input();z=raw_input();w=len(z)
for i in range(-y,25-y):print"".join(z[min(w-1,int((i*i*4+j*j)**.5*w/70))]for j in range(-x,70-x))

Delphi, 200 (and 185)
Since I like ascii-art here a Delphi version of this code golf:
uses Math;var G:string;X,Y,l,i,j:Int16;begin ReadLn(X,Y);ReadLn(G);l:=Length(G);for j:=-y to 24-y do for i:=-x to 70-x do if i=70-x then WriteLn else Write(g[Min(l,1+Trunc(l*sqrt(i*i/4+j*j)/35))])end.

Not very impressive character-wise, as I had to use the Math unit to link in the Min() function. Also, ReadLn() somehow doesn't read integers and strings in one call, so that's quite expensive too. The newline needs a lot of characters too. Also, Delphi needs quite a lot of whitespace around it's keywords. Not very proud of this one.
Anyway, the output of sample 4 gives me :
!+#-,|><87654210ZYWVUTRQPONLKJIHFEDCBzyxwutsrqonmlkjhgfedcbbbcdefghjkl
!+#-,|><87654210ZYWVUTRQPONLKJIHFEDCAzyxwutsrqonmljihgfdcba abcdfghijl
!+#-,|><87654210ZYWVUTRQPONLKJIHFEDCBzyxwutsrqonmlkjhgfedcbbbcdefghjkl
!+#-,|><97654310ZYXVUTSQPONMKJIHGEDCBAyxwvutrqponmkjihgffeedeeffghijkm
$+#-.|><98654320ZYXWUTSRQONMLKIHGFEDBAzyxwutsrqponmlkjihhggggghhijklmn
$!#-.,|<987643210YXWVUSRQPONLKJIHGEDCBAzywvutsrqponmllkjjjiiijjjkllmno
$!+#.,|><87654210ZYXVUTSRQONMLKJHGFEDCBAzywvutsrrqponnmmlllllllmmnnopq
%!+#-.|><987543210YXWVUTRQPONMLJIHGFEDCBAzyxwvutsrrqppooonnnnnoooppqrr
%$!+-.,|><87654310ZYXWVTSRQPONMLJIHGFEDCBAzyxxwvuttssrrqqqqqqqqqrrsstt
&%!+#-.,><987643210ZYXVUTSRQPONMLKJIHGFEDCBAzyyxwvvuutttssssssstttuuvv
&%$!+#.,|><986543210ZYWVUTSRQPONMLKJIHGFEDDCBAzzyyxwwwvvvuuuuuvvvwwwxy
/&%$!#-.,|><976543210ZYXVUTSRQPONMLKKJIHGFEEDCBBAAzzyyyxxxxxxxxxyyyzzA
(/&%!+#-.,|><876543210ZYXWVUTSRQPONMLKJJIHGGFEEDCCBBBAAAzzzzzzzAAABBBC
)(/%$!+#-.,|><876543210ZYXWVUTSRQPPONMLKKJIIHGGFFEEDDDCCCCCCCCCCCDDDEE
=)(&%$!+#-.,|><986543210ZYYXWVUTSRQPPONMMLKKJIIHHGGGFFFEEEEEEEEEFFFGGG
?=)(&%$!+#-.,|><9876543210ZYXWVVUTSRRQPOONMMLLKJJJIIIHHHHHHHHHHHHHIIIJ
*?=)(/%$!+#-.,|><98765432210ZYXWWVUTSSRQQPOONNMMLLLKKKJJJJJJJJJJJKKKLL
'*?=)(/&%$!+#-.,|><98765432110ZYXXWVUUTSSRRQPPOOONNNMMMMMLLLLLMMMMMNNN
_'*?=)(/&%$!+#-.,|><988765432210ZYYXWWVUUTTSSRRQQQPPPOOOOOOOOOOOOOPPPQ
:_'*?=)(/&%$!+##-.,|><9877654332100ZYYXXWVVUUTTTSSSRRRRQQQQQQQQQRRRRSS
;;:_'*?=)(/&%$!+#-.,,|><98876554322100ZZYYXXWWVVVUUUTTTTTTTTTTTTTTTUUU
;;;:_'*?=)(/&&%$!+#-.,,|><9987665443321100ZZYYYXXXWWWWVVVVVVVVVVVWWWWX
;;;;;:_'*?=)(/&%$$!+#-..,|>><9887665544322211000ZZZYYYYYYYYYYYYYYYYYZZ
;;;;;;:_'*??=)(/&%%$!+##-.,,|><<99877665544333222111100000000000001111
;;;;;;;;:_'*?==)(/&&%$!++#--.,,|>><<9887766655544433333322222223333334

If you would accept indented output, this version is a bit shorter by changing the newline into an indent that leads to a 80-character wrap (simulating a newline on standard 80x25 consoles) :
uses Math;var G:string;X,Y,l,i,j:Int16;begin ReadLn(X,Y);ReadLn(G);l:=Length(G);for j:=-y to 24-y do for i:=-x to 70-x do Write(g[Min(l,1+Trunc(l*sqrt(i*i/4+j*j)/35))]:11*Ord(i=-x))end.

(this saves 15 characters, for a total of 185 characters).
It's output for "0 0 X.X.X.X" is :
          XXXXXXXXXX..........XXXXXXXXXX..........XXXXXXXXXX..........XXXXXXXXXX
          XXXXXXXXXX..........XXXXXXXXXX..........XXXXXXXXXX..........XXXXXXXXXX
          XXXXXXXXXX..........XXXXXXXXXX..........XXXXXXXXXX..........XXXXXXXXXX
          XXXXXXXX............XXXXXXXXXX..........XXXXXXXXXX..........XXXXXXXXXX
          XXXXXX.............XXXXXXXXXX...........XXXXXXXXXX..........XXXXXXXXXX
          ..................XXXXXXXXXXX..........XXXXXXXXXX...........XXXXXXXXXX
          ................XXXXXXXXXXXX...........XXXXXXXXXX..........XXXXXXXXXXX
          ...............XXXXXXXXXXXX...........XXXXXXXXXX...........XXXXXXXXXXX
          ............XXXXXXXXXXXXXX...........XXXXXXXXXXX..........XXXXXXXXXXXX
          .........XXXXXXXXXXXXXXX............XXXXXXXXXXX...........XXXXXXXXXXXX
          XXXXXXXXXXXXXXXXXXXXXXX............XXXXXXXXXXX...........XXXXXXXXXXXXX
          XXXXXXXXXXXXXXXXXXXXX.............XXXXXXXXXXX...........XXXXXXXXXXXXXX
          XXXXXXXXXXXXXXXXXX..............XXXXXXXXXXXX...........XXXXXXXXXXXXXXX
          XXXXXXXXXXXXXXX................XXXXXXXXXXXX............XXXXXXXXXXXXXXX
          XXXXXXXXXXX..................XXXXXXXXXXXXX............XXXXXXXXXXXXXXXX
          ...........................XXXXXXXXXXXXX............XXXXXXXXXXXXXXXXXX
          ........................XXXXXXXXXXXXXXX............XXXXXXXXXXXXXXXXXXX
          ......................XXXXXXXXXXXXXXX.............XXXXXXXXXXXXXXXXXXXX
          ..................XXXXXXXXXXXXXXXXX.............XXXXXXXXXXXXXXXXXXXXXX
          .............XXXXXXXXXXXXXXXXXXXX..............XXXXXXXXXXXXXXXXXXXXXXX
          XXXXXXXXXXXXXXXXXXXXXXXXXXXXXX...............XXXXXXXXXXXXXXXXXXXXXXXXX
          XXXXXXXXXXXXXXXXXXXXXXXXXXXX...............XXXXXXXXXXXXXXXXXXXXXXXXXXX
          XXXXXXXXXXXXXXXXXXXXXXXX.................XXXXXXXXXXXXXXXXXXXXXXXXXXXXX
          XXXXXXXXXXXXXXXXXXXX...................XXXXXXXXXXXXXXXXXXXXXXXXXXXXXXX
          XXXXXXXXXXXXXX......................XXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXX

(Can you see the indent?! ;-) )

APL (74)
{L←⍴⊃C Y X⎕IO←⍞⎕⎕0⋄⎕←{C[⊃⌊L⌊35÷⍨L×.5*⍨+/2*⍨1 2÷⍨⍵-Y X]}¨⍳⍵}25 70

The reason it's wrapped in a function is that the modification to ⎕IO doesn't apply to the rest of the system.
Explanation:

L←⍴⊃C Y X⎕IO←⍞⎕⎕0: Set ⎕IO to 0 (making arrays 0-based instead of 1-based), set X to ⎕ (first line read), set Y to ⎕ (second line read), set C to ⍞ (third line read, with no formatting), and set L to the length (⍴) of C.
25 70: the dimensions of the matrix.
¨⍳⍵: for each element in the matrix where each element is its own coordinates...
⍵-Y X: difference between the current point and the center point
1 2÷⍨: divide the X coordinate by 2 (because a char is half as wide as it is tall)
.5*⍨+/2*⍨: take the square root of the sum of the squares
35÷⍨: divide by 35
⌊L⌊: take the minimum of the amount of characters and the current value and round it down
,/: The values are still wrapped in a list (of only one element), and this will create spacing in the output, so 'free' the values from their lists.
C[...]: use the value we found as an index into the character list
⎕←: we now have a matrix where each element (x,y) is the character for (x,y), so output the matrix.

Perl 5.10, 103 chars
$x=<>;$y=<>;@C=<>=~/./g;for$j(-$y..24-$y){print+(map$C[@C/35*sqrt$_**2/4+$j**2]//$C[-1],-$x..69-$x),$/}

Thanks to @J B for the nice trick at http://codegolf.stackexchange.com/questions/678/decipher-a-vigenere-ciphertext/709#709

Also thanks to @gnibbler for his "substraction precalculated in range" trick.

You got an empty line before the output. So currently this is counted as invalid.

@Joey: fixed ...

Still fails a test case of mine, here, though. I added it to the question (Sample 4). Somehow the zeroes in the output get replaced by a semicolon.

@Joey: should work now, though I don't have a Perl 5.10 handy to test.

Tested with Perl 5.12 here and works apart from a stray X where an Y should be. Chosen to ignore now for the sake of my sanity. (We actually had a bunch of test cases for all tasks we used in the contest so we could automatically test submissions for passing).

@Joey: that can be fixed at the cost of 2 chars by rearranging operations like this: sqrt($_**2/4+$j**2)*@C/35

Well, that doesn't change the ranking ;-)

Perl, 120 chars
$x,$y=<>,<>;@C=split'',<>;for$j(0..24){print+(map$C[($c=$#C/35*sqrt(($x/2-$_/2)**2+($y-$j)**2))<$#C?$c:$#C-1],0..69),$/}

fails on the first and third examples. abs is there for a reason.

Squaring removes the sign anyway, I don't see how abs would change anything

D'oh! You're completely right. What's failing on my system is  $x,$y=<>,<>;.

Windows PowerShell, 157
Nothing noteworthy. Beaten to death already:
$x,$y,$c=@($input)
$l=$c.Length
$c+=(""+$c[-1])*90
0..24|%{$r=$_
-join(0..69|%{$c[[math]::truncate([math]::sqrt(($x-$_)*($x-$_)+4*($y-$r)*($y-$r))*$l/70)]})}

C, 176
Here a translation of my Delphi solution to C, saving 24 characters :
X,Y,l,i,j,t;char G[99];main(){scanf("%d\n%d\n",&X,&Y);gets(G);l=strlen(G);for(j=-Y;j<25-Y;j++)for(i=-X-1;i<70-X;)t=floor(l*sqrt(i*i++/4+j*j)/35),putchar(!i+X?10:G[t<l?t:l-1]);}

You can test this code here : http://www.ideone.com/oTvHt

You can put the declaration of the int variables in the argument list of main() I guess and save a semicolon that way.

171 bytes

Common Lisp, 173 characters
(let*((c(read))(v(read))(g(read-line))(l(length g)))(dotimes(y 25)(dotimes(x 70)(princ(elt g(min(floor(*(sqrt(+(expt(/(- c x)2)2)(expt(- v y)2)))l)35)(1- l)))))(princ #\
)))

The only real trick I use here is using
#\[actual newline]

as a newline character literal

C# 311
Thought I'd make a long program to make the others feel better:
using System;class P{static void Main(){Func<string>r=Console.ReadLine;int x=int.Parse(r()),y=int.Parse(r());var c=r();for(int j=0;j<25;j++){for(int i=0;i<70;i++){var l=c.Length;Console.Write(c[(int)Math.Min(l*Math.Sqrt(Math.Pow(Math.Abs(x-i)/2.0,2)+Math.Pow(Math.Abs(y-j),2))/35,l-1)]);}Console.Write("\n");}}}

Input is taken from the console, one line at a time (two lines for the coordinates and one for the gradient chars).
Thanks to Joey for the tips.
Sample 1: http://ideone.com/X0jIZ
Sample 2: http://ideone.com/RvICt

@Joey Right. I fixed it and realized why trying this in C# was a pretty bad idea. It was fun though. :-)

@Joey you're right, neither the class nor the method need to be marked as public

@Joey if we use int instead of float, the expressions x-i and y-j become of type int. Due to this, the `int Math.Abs(int value) will be called instead of the float one, leading to some loss of precision. I've tried it and got som e rough edges: http://ideone.com/wQcMT

@Joey Right, Abs does not affect precision, but it returns an int, which, when divided by 2 will lose precision, as opposed to a float.

Sorry, I forgot a modification that will work the way you want (costs two characters, but the ints will save more ;)). Oh, and *.5 costs only one char.

@Joey the using C is a nice trick to keep in mind, but in this case it adds a bit to the char count. I also tried using M=System.Math, and it's the same.

@Joey yep, right about the ints. Saved 4 more chars.

You can put the declaration of i and j before the loops, too. Which saves two ints.

scala 223 (204 without App-Wrapper)
object C extends App{
import math._
def r=readInt
val p=r
val q=r
val m=readLine
(1 to 70)map(x=>(0 to 25)map(y=>{
printf("%c[%d;%dH%s",27,y,x,m(({
val a=abs(p-x)
val b=abs(q-y)
sqrt(a*a+2*b*b)
}*(m.size-1)/74).toInt))}
))}

Having cols and rows (70, 25) set dynamically would allow for screenfilling gradients.

source: Stack Exchange

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

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

sort: votes