挑战

这个问题的任务是编写一个程序或一个命名函数，该程序或命名函数采用一个正整数n（大于0）作为通过STDIN，ARGV或函数参数的输入，并通过STDOUT或函数返回值输出一个数组。

听起来足够简单？现在这是规则

• 该数组将仅包含从1到的整数n
• 从1到的每个整数n应重复x一次，其中x是每个整数的值。

例如：

输入：

5

输出：

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

数组可以排序也可以不排序。

这是代码高尔夫球，因此获胜者是最短的代码（以字节为单位）。

奖金

0.5如果输出数组中没有两个相邻的整数相同，则将您的分数乘以。

例如n = 5，一种这样的配置是

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

APL，4个字符

/⍨⍳⎕

怎么运行的：

⎕读取用户输入。对于输出，默认情况下，APL从每一行打印结果。

⍳n是从1到的整数n。例：⍳3←→ 1 2 3

/意味着复制。右自变量中的每个元素重复的次数与左自变量中其相应元素指定的次数相同。例：2 0 3/'ABC'←→ 'AACCC'

⍨是通勤者。当它出现在函数右侧时，它会修改其行为，因此它要么交换参数（A f⍨ B ←→ B f A，因此称为“通勤”），要么在两侧都提供相同的参数（f⍨ A ←→ A f A称为“ selfie”）。在该解决方案中使用后一种形式。

奖金：

6-∊⌽⍳¨⍳⎕（8个字符，谢谢@ phil-h）

⍳5（五点钟）是1 2 3 4 5。

⍳¨ ⍳5（每个iota五个iota）是(,1)(1 2)(1 2 3)(1 2 3 4)(1 2 3 4 5)向量的向量。 每个（¨）是运算符，它接受左侧的一个函数并将其应用于右侧数组中的每个项目。

⌽反转数组，因此得到(1 2 3 4 5)(1 2 3 4)(1 2 3)(1 2)(,1)。

∊被征募（又名扁平化）。递归遍历参数，并从中返回简单标量作为向量。

Ruby（递归），41个字节* 0.5 = 20.5

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

或使用lambda（如histocrat和Ventero所建议）：34个字节* 0.5 = 17

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

（使用致电r[argument]）

Pyth，9个字节* 0.5 = 4.5

smrhQhdUQ

在@FryAmTheEggman的帮助下

在线尝试。

说明

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

Q输入在哪里。

Haskell，31个字符= 15.5分

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

没有奖金的27个字符

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

被骄傲的哈斯克勒殴打

C，22 = 44字节* 0.5

该函数h有两个参数。第一个是int指定n。第二个是an int*，它是输出缓冲区。

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

测试程序

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

Pyth - 15 10 * 0.5 = 5

smr-QdhQUQ

在线尝试。

期望在stdin上输入。独立发现的算法。感谢@ Sp3000帮助我在其中加入最后一个问题：P另外，具有讽刺意味吗？XD

说明：

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

CJam，12 15字节* 0.5 = 7.5

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

这是完整的STDIN到STDOUT程序。它串联了1 ... n范围的后缀，以确保没有两个相邻的数字相同。

在这里测试。

Python 2，53字节* 0.5 = 26.5

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

无耻地借用@VisualMelon的想法

Haskell，34个字节* 0.5 = 17

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

这是我第一次使用Haskell打高尔夫球。致电g <number>。

Bash + coreutils，28/2 = 14

无耻地偷@pgy的想法并打高尔夫球：

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

纯bash（无coreutils），30/2 = 15

评估，逃生和扩展地狱：

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

GolfScript（14个字节* 0.5 =得分7）

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

在线演示

我认为这可能与一些现有答案相似，因为它可以建立数组 concat( [n], [n-1, n], [n-2, n-1, n], ..., [1, 2, ..., n] )

可悲的是，我再也无法打高尔夫了。

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

它将输入x放入数组中，然后两次进行应用{,{x\-}/}%，它将数组中的每个元素映射到从中倒数的元素的倒数x。

C＃-81（161bytes * 0.5）

使用C＃进行简单的工作，有望获得无编号的奖金。从stdin读取一个int，将类似于示例的数组写到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+"]");}}

更具可读性：

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+"]");
    }
}

示例输出：

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

JavaScript，ES6、41个字节

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

这将创建一个f可以像这样调用的函数，f(6)并返回所需的数组。

这使用了一种递归方法，其中每次迭代都会创建一个i元素数组，所有元素都被赋值，i并连接一个由f(i-1)终止条件为的数组i==0。

适用于最新的Firefox。

Haskell，14 = 28字节/ 2

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

示例输出：

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

24个字节，没有奖金：

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

Haxe，53个字节

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

适用于l（6）; 由于数组理解。
在线测试http://try.haxe.org/#741f9

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

R，44 * .5 = 22

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

快速测试

> 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

JavaScript，ES6、66字节* 0.5 = 33

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

基于Optimizer的递归方法，我们可以构建长度递减的降序运行，例如[4,3,2,1, 4,3,2, 4,3, 4]。

与其使用制作相同值的子数组Array(i).fill(i)，undefined不如使用制作适当长度的填充子数组Array(n).fill()，然后使用来将值更改为降序运算.map((v,x)=>i-x)。此外，我们定义并递归内部函数g；外部函数f仅用于存储iwhile g递归的值。

T-SQL，176 * 0.5 = 88

由于您似乎错过了T-SQL @Optimizer，因此这就是冗长的荣耀:)。

几个函数选项，一个标量和一个内联表值函数。标量函数使用while循环来递归并返回数字字符串，其中“内联表值”函数对序列使用递归CTE并返回表。当然，这些永远不会有竞争力，所以我没有花很多时间打高尔夫球。

内联表值函数，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

称为如下

SELECT * FROM dbo.F(5)

SQLFiddle示例

标量函数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

称为如下

SELECT dbo.G(5)

SQLFiddle示例

Mathematica，34 * 0.5 = 17

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

perl，26个字节

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

JavaScript（可读），131字节

我是Code Golf的新手，所以这不是最好的

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（不可读），87字节

使用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}

TECO，25字节* 0.5 = 12.5

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

以上仅以13个字节击败了非奖励版本：

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

C＃，114 99 * 0.5 = 49.5字节

（在VisualMelon的回答中有一点帮助）编辑：和James Webster的评论

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

取消高尔夫：

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

我从feersum的C答案中无耻地提取了一个不安全的版本，但是我不确定100％地确定它是否符合规则，因为您必须在调用方法之前分配内存。

C＃（不安全），82 * 0.5 = 41个字节

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 }

根据VisualMelon的建议（谢谢！），可以使用安全代码来重新编写不安全的代码，从而进一步减小了大小！仍然提出一个问题，是否允许在方法之外完成最终结果数组的创建。

C＃，72 * 0.5 = 36个字节

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

带有seq，expr和xargs的Bash = 59/2 = 29.5

保存它并以数字作为第一个参数运行。

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

C＃，116115 + 33 = 148字节

不是最短的代码，但是...仍然可以工作：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();}

要求在文件顶部（33字节）：

using System.Collections.Generic;

非高尔夫版本：

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

JavaScript（ES6）29（58 * 0.5）

编辑删除; thx @优化器

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

在FireFox / FireBug控制台中测试

Q(9)

输出量

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

不打高尔夫球

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字节

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

对此感到非常满意……大约是我原来作品的四分之一。

f(4) 返回：

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

旧答案：

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

这是我第一次打代码高尔夫……我仍然想获得那0.5倍的奖金。任何建议都欢迎！

用f（n）调用。

C＃，108字节* 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;}

感谢VisualMelon的辛勤工作！我以为我会尽量缩小它。

（114字节* 0.5 = 57，如果您坚持使用.ToArray（）返回int []）