Ruby (recursive), 41 bytes * 0.5 = 20.5

def n(n,i=1);i>n ?[]:n(n,i+1)+[*i..n];end

Or using a lambda (as recommended by histocrat and Ventero): 34 bytes * 0.5 = 17

r=->n,i=n{i>0?[*i..n]+r[n,i-1]:[]}

(call using r[argument])

Pyth, 9 bytes * 0.5 = 4.5

smrhQhdUQ

With help from @FryAmTheEggman

Try it online.

Explanation

s             reduce + on list
 m            map
  rhQhd       lambda d: reversed(range(d+1, Q+1)), over
       UQ     range(Q)

where Q is the input.

Pyth - 15 10 * .5 = 5

smr-QdhQUQ

Try it online.

Expects input on stdin. Independently discovered algorithm. Thanks @Sp3000 for helping me stick the last Q in there :P Also, irony? XD

Explanation:

Q=eval(input())       : implicit
s                     : The sum of...
 m      UQ            : map(...,range(Q))
  r-QdhQ              : range(Q-d,Q+1)

Haskell, 31 characters = 15.5 score

f n=[y|x<-[n,n-1..1],y<-[x..n]]

27 characters without the bonus

f n=[x|x<-[1..n],_<-[1..x]]

Beaten by Proud Haskeller

C, 22 = 44 bytes * 0.5

The function h takes two parameters. The first is an int specifying n. The second is an int* which is the output buffer.

h(n,o)int*o;{for(n&&h(~-n,o+=n);*--o=n--;);}

Test program

main(){
int wow[999],*i;
memset(wow,0,sizeof(wow));
h(6, wow);
for(i=wow;*i;i++)printf("%d ", *i);
}

CJam, 12 15 bytes * 0.5 = 7.5

li_,f{),f-W%~}`

This is full STDIN-to-STDOUT program. It concatenates increasing suffixes of the 1 ... n range, which ensures that no two adjacent numbers are identical.

Test it here.

Python 2, 53 bytes * 0.5 = 26.5

i=n=input()
x=[]
while i:x+=range(i,n+1);i-=1
print x

Shamelessly borrowed @VisualMelon's idea

Bash + coreutils, 28/2 = 14

Shamelessly stealing @pgy's idea and golfing:

seq -f"seq %g $1" $1 -1 1|sh

Pure bash (no coreutils), 30/2 = 15

Eval, escape and expansion hell:

eval eval echo \\{{$1..1}..$1}

GolfScript (14 bytes * 0.5 = score 7)

 ~:x,{~x),>~}%`

Online demo

I think this is probably similar to some existing answers in that it builds up the array concat( [n], [n-1, n], [n-2, n-1, n], ..., [1, 2, ..., n] )

Sadly I wasn't able to golf any further the arguably more elegant:

~:x]{{,{x\-}/}%}2*`

which puts the input x into an array and then twice applies {,{x\-}/}%, which maps each element in an array to a count down of that many elements from x.

C# - 81 (161bytes * 0.5)

Simple job in C#, hopefully gets the no-neibouring-numbers bonus. Reads an int from stdin, writes out an array like the example to stdout.

class P{static void Main(){int n=int.Parse(System.Console.ReadLine()),m=n-1,i;var R="["+n;for(;m-->0;)for(i=m;i++<n;)R+=", "+i;System.Console.WriteLine(R+"]");}}

More readable:

class P
{
    static void Main()
    {
        int n=int.Parse(System.Console.ReadLine()),m=n-1,i;
        var R="["+n;
        for(;m-->0;)
            for(i=m;i++<n;)
                R+=", "+i;
        System.Console.WriteLine(R+"]");
    }
}

Examples output:

n = 5
[5, 4, 5, 3, 4, 5, 2, 3, 4, 5, 1, 2, 3, 4, 5]

Haskell, 34 bytes * 0.5 = 17

0%n=[]
i%n=[i..n]++(i-1)%n
g n=n%n

That's the first time I've ever used Haskell for golfing. Call with g <number>.

APL, 4 characters

/⍨⍳⎕

How it works:

⎕ reads user input. As for output, APL by default prints the result from every line.

⍳n is the integers from 1 to n. Example: ⍳3←→ 1 2 3

/ means replicate. Each element from the right argument is repeated as many times as specified by its corresponding element from the left argument. Example: 2 0 3/'ABC'←→ 'AACCC'

⍨ is the switch operator. When it occurs to the right of a function invoked with a single argument, the switch operator provides it as both left and right argument, so f⍨ A ←→ A f A. (It can also swap arguments: A f⍨ B ←→ B f⍨ A, hence "switch", but that's irrelevant to this solution.)

So, /⍨ is a (derived) function and ⍳ is a function. A "train" of two functions in isolation forms a so-called atop. An atop with a single argument is equivalent to composition: (f g)A ←→ f g A, so g is applied to A, then f is applied to the result.

Bonus:

6-∊⌽⍳¨⍳⎕ (8 characters, thanks @phil-h)

⍳5 (iota five) is 1 2 3 4 5.

⍳¨ ⍳5 (iota each iota five) is (,1)(1 2)(1 2 3)(1 2 3 4)(1 2 3 4 5), a vector of vectors. Each (¨) is an operator, it takes a function on the left and applies it to each item from the array on the right.

⌽ reverses the array, so we get (1 2 3 4 5)(1 2 3 4)(1 2 3)(1 2)(,1).

∊ is enlist (a.k.a. flatten). Recursively traverses the argument and returns the simple scalars from it as a vector.

JavaScript, ES6, 41 bytes

f=i=>[...Array(i).fill(i),...i?f(--i):[]]

This creates a function f which can be called like f(6) and it returns the required array.

This uses a recursive approach, where each iteration creates an array of i elements all valued i and concatenates an array returned by f(i-1) with stopping condition of i==0.

Works on latest Firefox.

Haskell, 14 = 28 bytes / 2

f n=n:[1..n-1]>>= \r->[r..n]

example output:

>f 5
[5,1,2,3,4,5,2,3,4,5,3,4,5,4,5]

24 bytes without the bonus:

f n=[1..n]>>= \r->[r..n]

vba, 76*0.5=38

Sub i(q)
For Z=1 To q:For x=q To Z Step -1:Debug.?x;",";:Next:Next
End Sub

JavaScript, ES6, 66 bytes * 0.5 = 33

f=i=>(g=n=>[...Array(n).fill().map((v,x)=>i-x),...n?g(n-1):[]])(i)

Building on Optimizer's recursive approach, we can build descending runs of decreasing length, like [4,3,2,1, 4,3,2, 4,3, 4].

Instead of making same-value subarrays with Array(i).fill(i), we make undefined-filled subarrays of the appropriate length with Array(n).fill() and then change the values to a descending run using .map((v,x)=>i-x). Also, we define and recurse over an inner function g; the outer function f exists only to store the value of i while g recurses.

T-SQL, 176 * 0.5 = 88

Since you seemed to miss the T-SQL @Optimizer, here it is in all it's verbose glory :).

A couple of function options, a Scalar and a Inline Table Valued function. The Scalar function uses while loops to recurse and returns a string of numbers, where the Inline Table Valued function uses a recursive CTE for a sequence and returns a table. Of course these will never be competitive, so I haven't spent a lot of time golfing.

Inline Table Valued Function, 176 * .5

CREATE FUNCTION F(@ INT)RETURNS TABLE RETURN WITH R AS(SELECT @ N UNION ALL SELECT N-1FROM R WHERE N>0)SELECT B.N FROM R CROSS APPLY(SELECT TOP(R.N)N FROM R A ORDER BY N DESC)B

Called as follows

SELECT * FROM dbo.F(5)

SQLFiddle example

Scalar Function, 220 * .5

CREATE FUNCTION G(@ INT)RETURNS VARCHAR(MAX)AS BEGIN DECLARE @S VARCHAR(MAX),@N INT=1,@I INT,@C INT WHILE @N<=@ BEGIN SELECT @I=@N,@C=@ WHILE @C>=@I BEGIN SELECT @S=CONCAT(@S+',',@C),@C-=1 END SET @N+=1 END RETURN @S END

Called as follows

SELECT dbo.G(5)

SQLFiddle example

Mathematica, 34 * 0.5 = 17

f=Join@@Table[x,{y,#},{x,#,y,-1}]&

perl ,26 bytes

for(1..$n){print"$_ "x$_;}

JavaScript(readable), 131 bytes

I'm new to Code Golf so this isn't the best

function f(n) {
    var arr = [];
    for(var i = 1; i <= n; i++) {
        for(var j = 0; j < i; j++) {
            arr.push(i);
        }
    }
    return arr;
}

JavaScript(less readable), 87 bytes

Minified using jscompress.com

function f(e){var t=[];for(var n=1;n<=e;n++){for(var r=0;r<n;r++){t.push(n)}}return t}

C#, 114 99 * 0.5 = 49.5 bytes

(With a little help from VisualMelon's answer) Edit: and James Webster's comment

int[]A(int n){int m=n,i,c=0;var a=new int[n*(n+1)/2];while(m-->0)for(i=m;i++<n;)a[c++]=i;return a;}

Ungolfed:

int[] FooBar(int n)
{
    int altCounter = n, i, arrayCounter = 0;
    var returnArray = new int[n * (n + 1) / 2];
    while(m-->0)
        for(i = altCounter; i++ < n; )
            returnArray[arrayCounter++]=i;
    return returnArray;
}

There is an unsafe version that I shamelessly took from feersum's C answer, but I'm not 100% sure it fits within the rules since you have to allocate the memory before calling the method.

unsafe void A(int n,int*p){int*z=p;int m=n,i;while(m-->0)for(i=m;i++<n;)z++[0]=i;}

int n = 5, length = (int)((n / 2f) * (n + 1));
int* stuff = stackalloc int[length];
int[] stuffArray = new int[length];
A(n, stuff);
System.Runtime.InteropServices.Marshal.Copy(new IntPtr(stuffArray), stuffArray, 0, stuffArray.Length);
//stuffArray == { 5, 4, 5, 3, 4, 5, 2, 3, 4, 5, 1, 2, 3, 4, 5 }

Per VisualMelon's suggestion (thanks!), the unsafe code can be re-made with safe code which reduces the size even further! Still poses the question if the creation of the final result array is allowed to be done outside of the method.

C#, 72 * 0.5 = 36 bytes

void A(int n,int[]p){int z=0,m=n,i;while(m-->0)for(i=m;i++<n;)p[z++]=i;}

R, 44 *.5 = 22

f=function(n){r=0;for(i in 1:n)r=c(r,n:i);r}

A quick test

> f(1)
[1] 1
> f(2)
[1] 2 1 2
> f(3)
[1] 3 2 1 3 2 3
> f(4)
 [1] 4 3 2 1 4 3 2 4 3 4

Bash with seq, expr and xargs = 59 / 2 = 29.5

Save it and run with the number as the first argument.

seq $1|xargs -n1 seq|xargs -n1 expr $1 + 1 -|sed 1d;echo $1

C#, 116 115 + 33 = 148 bytes

Not the shortest code, but... it works anyway :P

int[]l(int m){List<int>i=new List<int>();for(int j=1;j<=m;j++){for(int x=0;x<j;x++){i.Add(j);}}return i.ToArray();}

Requires this at the top of the file (33 bytes):

using System.Collections.Generic;

Un-golfed version:

int[] RepatedNumberList(int m)
{
    List<int> intList = new List<int>();
    for (int j = 1; j <= m; j++)
    {
        for (int x = 0; x < j; x++)
        {
            intList.Add(j);
        }
    }
    return initList.ToArray();
}

J, 23 * 0.5 = 11.5

   f=.-;@(<@|.@i."0@>:@i.)
   f 5
5 4 5 3 4 5 2 3 4 5 1 2 3 4 5

J, 11

   f=.#~@i.@>:
   f 5
1 2 2 3 3 3 4 4 4 4 5 5 5 5 5

Haxe, 54 bytes

function l(v) return[for(i in 0...v)for(j in 0...i)i];

Works with l(6); because of array comprehension.
Test online http://try.haxe.org/#741f9

JavaScript (ES6) 29 (58 * 0.5)

Edit remove ; thx @Optimizer

Q=o=>(m=>{for(n=o,r=[];n>m||++m<(n=o);)r.push(n--)})(0)||r

Test in FireFox/FireBug console

Q(9)

Output

[9, 8, 7, 6, 5, 4, 3, 2, 1, 9, 8, 7, 6, 5, 4, 3, 2, 9, 8, 7, 6, 5, 4, 3, 9, 8, 7, 6, 5, 4, 9, 8, 7, 6, 5, 9, 8, 7, 6, 9, 8, 7, 9, 8, 9]

Ungolfed

Q=o=>{
  for(m=0,r=[];m<o;++m)
    for(n=o;n>m;)
      r.push(n--);
  return r
}

ECMAScript6, 67 * 0.5 = 33.5 bytes

f=n=>{a=[],b=0;while(c=n+b,n--){while(c-b)a.push(c--);b++}return a}

Pretty happy with this one...It's about a quarter the size of my original.

f(4) returns:

[ 4, 3, 2, 1, 4, 3, 2, 4, 3, 4 ]

Old answer:

f=i=>{a=b=Array;while(i)a=a.concat(b.apply(null,b(i)).map(e=>i)),i--;return a}

This is my first shot at code golf...I still want to get that 0.5x bonus. Any suggestions are welcomed!

Called with f(n).

TECO, 25 bytes * 0.5 = 12.5

a\+1%a%b<qauc-1%b<-1%c=>>

The above barely beats the non-bonus version at 13 bytes:

a\%a<%b<qb=>>

Java (adjacent equals ok): 276 bytes

public class a{public static int[]b(final int c){final int d=(c+1)*c/2;final int[]e=new int[d];int f=1;int g=0;for(int i=0;i<d;i++){if(g==f){f++;g=0;;}
e[i]=f;g++;}
return e;}
public static void main(String[]args){final int q=new java.util.Scanner(System.in).nextInt();b(q);}}

Java (adjacent equals not ok): 442 * 0.5 = 221 bytes

public class a{private static int h=1;public static int[]j(final int k){final int[]l=new int[k+1];for(int i=1;i<=k;i++){l[i]=i;}
final int m=(k+1)*k/2;final int[]n=new int[m];for(int i=1;i<n.length;i++){n[i]=o(l,k);}
n[0]=k;return n;}
private static int o(final int[]p,final int q){if(h>q){h=1;}
while(p[h]==0){h++;}
p[h]=p[h]-1;return h++;}
public static void main(String[]args){final int q=new java.util.Scanner(System.in).nextInt();j(q);}}