19
\$\begingroup\$

Challenge

Your task in this question is to write a program or a named function which takes a positive integer n (greater than 0) as input via STDIN, ARGV or function arguments and outputs an array via STDOUT or function returned value.

Sounds simple enough ? Now here are the rules

  • The array will only contain integers from 1 to n
  • Each integer from 1 to n should be repeated x times where x is the value of each integer.

For example:

Input:

5

Output:

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

The array may or may not be sorted.

This is so winner is shortest code in bytes.

Bonus

Multiply your score by 0.5 if no two adjacent integers in your output array are same.

For example for n = 5, one such configuration would be

[5, 4, 5, 4, 3, 4, 5, 2, 5, 3, 1, 2, 3, 4, 5]
\$\endgroup\$

46 Answers 46

6
\$\begingroup\$

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 commute operator. When it occurs to the right of a function, it modifies its behaviour, so it either swaps the arguments (A f⍨ B ←→ B f A, hence "commute") or provides the same argument on both sides (f⍨ A ←→ A f A, a "selfie"). The latter form is used in this solution.


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.

\$\endgroup\$
  • \$\begingroup\$ How about a 4-character expression? /⍨⍳n \$\endgroup\$ – ngn Dec 20 '14 at 9:31
  • \$\begingroup\$ As you wish, sir, I've updated the text. But surely your objection must apply to other solutions that are not wrapped in functions? \$\endgroup\$ – ngn Dec 20 '14 at 11:17
  • 3
    \$\begingroup\$ Dyalog APL comes in two flavours: "Classic" and "Unicode". The Classic version has existed for decades, since before the Unicode standard appeared, and uses a custom byte-per-character encoding for the APL character set. It is still supported, though its use is discouraged. So, I'd like to use this as an excuse. More broadly, I think in golfing we should be counting characters, not bytes. The fact that the lowest code points in Unicode are occupied by the English-centric ASCII is a historical accident that shouldn't matter today. Interestingly, APL was conceived before ASCII came out. \$\endgroup\$ – ngn Dec 20 '14 at 13:01
  • 3
    \$\begingroup\$ @ngn counting chars is not a good idea, as answers will generally become alphabet soup decodes. APL chars are counted as bytes because that encoding exists; this is well established on this site. This works with any byte encoding that existed prior to the question's asking. \$\endgroup\$ – FryAmTheEggman Dec 20 '14 at 17:37
  • 1
    \$\begingroup\$ @ngn: Can you explain your bonus answer? Because it can be done via: 5 4 3 2 1 5 4 3 2 5 4 3 5 4 5 or 6 minus each of 1 2 3 4 5 1 2 3 4 1 2 3 1 2 1, which feels like it is not far from your initial answer. \$\endgroup\$ – Phil H Dec 22 '14 at 11:20
11
\$\begingroup\$

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])

\$\endgroup\$
  • 2
    \$\begingroup\$ That's a really cool solution. You can save some bytes by making it a lambda instead of a method (n=->x,i=1{...n[x,i+1]...) and a few more with [*i..n]. \$\endgroup\$ – histocrat Dec 19 '14 at 18:47
  • 1
    \$\begingroup\$ By inverting the logic, you can drop the whitespace in the ternary: r=->n,i=n{i>0?[*i..n]+r[n,i-1]:[]} \$\endgroup\$ – Ventero Dec 20 '14 at 10:39
11
\$\begingroup\$

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.

\$\endgroup\$
  • 5
    \$\begingroup\$ Shouldn't have helped you :D \$\endgroup\$ – FryAmTheEggman Dec 19 '14 at 19:06
8
\$\begingroup\$

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

\$\endgroup\$
  • \$\begingroup\$ your first solution is not correct. A possible fix is g n = [y|x<-[n,n-1..1],y<-[x..n]] \$\endgroup\$ – karakfa Dec 19 '14 at 20:43
  • \$\begingroup\$ @karakfa oops :-/ and thanks for the fix \$\endgroup\$ – John Dvorak Dec 20 '14 at 1:08
  • \$\begingroup\$ My Haskell answer is just a tad lower than yours \$\endgroup\$ – proud haskeller Dec 20 '14 at 23:31
  • \$\begingroup\$ Should I link to it from my solution, to promote it? \$\endgroup\$ – John Dvorak Dec 21 '14 at 11:03
  • \$\begingroup\$ @JanDvorak I would like to, actually... \$\endgroup\$ – proud haskeller Dec 23 '14 at 7:45
7
\$\begingroup\$

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);
}
\$\endgroup\$
  • \$\begingroup\$ I don't get it. Please explain? \$\endgroup\$ – bacchusbeale Dec 31 '14 at 9:34
  • \$\begingroup\$ @bacchusbeale Ok.. It recursively writes descending sequences from n to 0. Shorter sequences are written sooner, at a deeper level of recursion. If the argument n is 0, then n is falsey so there is no recursion, and only a 0 is written, which serves to mark the end of the array. \$\endgroup\$ – feersum Dec 31 '14 at 15:02
7
\$\begingroup\$

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)
\$\endgroup\$
  • 2
    \$\begingroup\$ Nice solution. Is there ever a situation in which Pyth wouldn't win code golf? :) \$\endgroup\$ – Alex A. Dec 19 '14 at 19:02
  • 2
    \$\begingroup\$ @Alex Depending on the nature of the problem, stack based golfing languages (Golfscript, CJam) can cream it, it can also lose to library stuff (cough bash cough) ;) \$\endgroup\$ – FryAmTheEggman Dec 19 '14 at 19:03
6
\$\begingroup\$

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.

\$\endgroup\$
6
\$\begingroup\$

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

\$\endgroup\$
6
\$\begingroup\$

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>.

\$\endgroup\$
5
\$\begingroup\$

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}
\$\endgroup\$
5
\$\begingroup\$

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.

\$\endgroup\$
5
\$\begingroup\$

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]
\$\endgroup\$
  • \$\begingroup\$ I'm really trying to figure out a shorter C# solution but I just can't seem to get it... well done \$\endgroup\$ – Brandon Dec 19 '14 at 19:42
  • 1
    \$\begingroup\$ @MarkKnol System.Console is static, you can't assign it to a variable, but in C# 6 or whatever is next, you will be able to do using System.Console; (using System; doesn't pay in this instance), not sure how I feel about this feature, will affect a lot of old golf questions for this reason precisely ;) \$\endgroup\$ – VisualMelon Dec 20 '14 at 15:57
  • 1
    \$\begingroup\$ @IchabodClay it gets worse, using C=System.Console saves 3 bytes, and is probably what @MarkKnol meant (sorry!), shameful negligence on my part. \$\endgroup\$ – VisualMelon Dec 21 '14 at 22:13
  • 1
    \$\begingroup\$ Also, according to the rules, you could just have the method itself instead of creating a complete program. Something like... this. (114 bytes with whitespaces and such removed. 57 bytes with bonus.) \$\endgroup\$ – Ichabod Clay Dec 21 '14 at 22:28
  • 1
    \$\begingroup\$ @IchabodClay indeed; I prefer submitting full programs to functions, no good reason, IO just seems like part of the fun (I don't tend to use argv, either). Feel free to post a better scoring answer without these daft constraints! \$\endgroup\$ – VisualMelon Dec 21 '14 at 22:53
4
\$\begingroup\$

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.

\$\endgroup\$
4
\$\begingroup\$

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]
\$\endgroup\$
  • \$\begingroup\$ could =<< help avoid the whitespace? I feel like it could, but I'd be surprised if you hadn't already considered that. \$\endgroup\$ – John Dvorak Dec 20 '14 at 16:53
  • \$\begingroup\$ @JanDvorak If I would have used =<< I would need parentheses for the lambda \$\endgroup\$ – proud haskeller Dec 20 '14 at 16:55
  • \$\begingroup\$ I'm confused on when exactly lambdas need parentheses. Does the lambda header have the same fixity as >>=? \$\endgroup\$ – John Dvorak Dec 20 '14 at 17:01
  • \$\begingroup\$ @JanDvorak They have no fixity; I'm not sure how accurate this rule is, but lambdas can only appear where operators can't (disregarding sections): after (, [, =, ,, after any operators, and the like \$\endgroup\$ – proud haskeller Dec 20 '14 at 17:13
  • \$\begingroup\$ I guess neither lambdas nor operators can appear as patterns? let \x->y = (2+) in (x,y) seems kinda impossible. \$\endgroup\$ – John Dvorak Dec 20 '14 at 17:37
4
\$\begingroup\$

Haxe, 53 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

\$\endgroup\$
3
\$\begingroup\$

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
\$\endgroup\$
  • \$\begingroup\$ you can lose 1 (0.5, technically) byte(s) by condensing For Z=1 To to For Z=1To \$\endgroup\$ – Taylor Scott Mar 25 '17 at 20:55
  • \$\begingroup\$ you can also condense Next:Next to Next x,Z \$\endgroup\$ – Taylor Scott Nov 1 '17 at 12:04
2
\$\begingroup\$

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
\$\endgroup\$
  • \$\begingroup\$ What ? No TSQL ? \$\endgroup\$ – Optimizer Dec 19 '14 at 19:32
  • \$\begingroup\$ @Optimizer maybe later:) \$\endgroup\$ – MickyT Dec 19 '14 at 19:34
2
\$\begingroup\$

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.

\$\endgroup\$
2
\$\begingroup\$

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

\$\endgroup\$
2
\$\begingroup\$

Mathematica, 34 * 0.5 = 17

f=Join@@Table[x,{y,#},{x,#,y,-1}]&
\$\endgroup\$
2
\$\begingroup\$

perl ,26 bytes

for(1..$n){print"$_ "x$_;}
\$\endgroup\$
  • 1
    \$\begingroup\$ Please post your score. Also, since this is code golf, you can save bytes by removing the extra spaces and the definition of $n. \$\endgroup\$ – Alex A. Dec 19 '14 at 19:01
  • \$\begingroup\$ This doesn't run for me under Perl 6. \$\endgroup\$ – Alex A. Dec 19 '14 at 19:09
  • \$\begingroup\$ @Alex , what is the error , works under 5.10 \$\endgroup\$ – michael501 Dec 19 '14 at 19:13
  • \$\begingroup\$ Unable to parse postcircumfix:sym<{ }>, couldn't find final '}' at line 3. Tried it on ideone.com. \$\endgroup\$ – Alex A. Dec 19 '14 at 19:14
  • \$\begingroup\$ @Alex , try this : C:\Windows\system32>perl -e "$n=5;for(1..$n){print qq($_ )x$_;};" 1 2 2 3 3 3 4 4 4 4 5 5 5 5 5 \$\endgroup\$ – michael501 Dec 19 '14 at 19:20
2
\$\begingroup\$

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}
\$\endgroup\$
2
\$\begingroup\$

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=>>
\$\endgroup\$
2
\$\begingroup\$

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.

C# (unsafe), 82 * 0.5 = 41 bytes

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;}

Called as follows:

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;}
\$\endgroup\$
  • \$\begingroup\$ Nice work! For the per-allocated version, it's much cheaper to go safe and pass it the int[] straight off void A(int n,int[]p){int z=0,m=n,i;while(m-->0)for(i=m;i++<n;)p[z++]=i;} - I would agree it's probably a bit iffy, regarding the rules ;) \$\endgroup\$ – VisualMelon Dec 22 '14 at 21:25
  • \$\begingroup\$ You shouldn't need to create a local pointer for the unsafe version, which cuts a good 8bytes out. Also, I might be missing the point, but should the last line of the unsafe calling code be System.Runtime.InteropServices.Marshal.Copy(new IntPtr(stuff), stuffArray, 0, length); ? \$\endgroup\$ – VisualMelon Dec 22 '14 at 21:47
  • \$\begingroup\$ @VisualMelon That's what I get for not rechecking the names of variables after I rename them. Thanks for the heads up :D. Edited the answer to account for the shorter version in your comment. \$\endgroup\$ – Ichabod Clay Dec 23 '14 at 0:23
  • \$\begingroup\$ You can chop a little off the safe version by inlining the length var a=new int[(int)((n/2f)*(n+1))]; I think that takes it down to 109 \$\endgroup\$ – James Webster Dec 23 '14 at 16:46
  • \$\begingroup\$ One more off by rewriting the calc as: (n*(n+1)/2) \$\endgroup\$ – James Webster Dec 23 '14 at 16:50
1
\$\begingroup\$

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
\$\endgroup\$
1
\$\begingroup\$

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();
}
\$\endgroup\$
1
\$\begingroup\$

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
\$\endgroup\$
  • 1
    \$\begingroup\$ 23 * 0.5 is 11.5, not 10.5. \$\endgroup\$ – ProgramFOX Dec 20 '14 at 10:34
  • \$\begingroup\$ @ProgramFOX good catch. Are you going to edit, or should I? Not a great reason to downvote IMO. \$\endgroup\$ – John Dvorak Dec 20 '14 at 10:35
  • \$\begingroup\$ @JanDvorak Just edited it. And I didn't downvote, I upvoted it even before I saw the mistake. \$\endgroup\$ – ProgramFOX Dec 20 '14 at 10:37
  • \$\begingroup\$ Now that the mistake has been fixed, should the bonus solution be moved to the bottom? \$\endgroup\$ – John Dvorak Dec 20 '14 at 10:40
  • \$\begingroup\$ -1 Byte: f=.-[:;<@|.@i."0@>:@i., making the scores equal! \$\endgroup\$ – Bolce Bussiere Apr 15 '18 at 21:54
1
\$\begingroup\$

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
}
\$\endgroup\$
1
\$\begingroup\$

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).

\$\endgroup\$
  • \$\begingroup\$ You must be pretty new to JavaScript it self :) . (1) Remove brackets around argument d, (2) a=b=c=[] in for declaration part, (3) c[a].map(e=>a) (4) b.push(...c) \$\endgroup\$ – Optimizer Dec 21 '14 at 7:53
  • \$\begingroup\$ I made a shorter version before reading your comment, which I'll put in my post. My experience with JS is mostly limited to DOM/style manipulation for simple web apps...and I've hardly used any of the new ES6 features until today. \$\endgroup\$ – binormal Dec 21 '14 at 9:43
1
\$\begingroup\$

C#, 108 bytes * 0.5 = 54

List<int> f(int n){var r=new List<int>();int m=n-1,i;r.Add(n);for(;m-->0;)for(i=m;i++<n;)r.Add(i);return r;}

Thanks to VisualMelon for doing the hard work! I thought I'd try to squeeze it down as much as possible.

(114 bytes * 0.5 = 57, if you insist on using .ToArray() to return int[])

\$\endgroup\$

Your Answer

By clicking “Post Your Answer”, you agree to our terms of service, privacy policy and cookie policy

Not the answer you're looking for? Browse other questions tagged or ask your own question.