Thử thách

Nhiệm vụ của bạn trong câu hỏi này là viết một chương trình hoặc một hàm được đặt tên lấy một số nguyên dương n(lớn hơn 0) làm đầu vào thông qua STDIN, ARGV hoặc các đối số hàm và xuất ra một mảng thông qua STDOUT hoặc hàm trả về giá trị.

Nghe có vẻ đơn giản? Bây giờ đây là các quy tắc

• Mảng sẽ chỉ chứa các số nguyên từ 1đếnn
• Mỗi số nguyên từ 1đến nphải được lặp lại xlần trong đó xlà giá trị của mỗi số nguyên.

Ví dụ:

Đầu vào:

5

Đầu ra:

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

Các mảng có thể hoặc không thể được sắp xếp.

Đây là mã golf, vì vậy người chiến thắng là mã ngắn nhất tính bằng byte.

Tiền thưởng

Nhân số điểm của bạn với 0.5nếu không có hai số nguyên liền kề trong mảng đầu ra của bạn giống nhau.

Ví dụ n = 5, một cấu hình như vậy sẽ là

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

APL, 4 ký tự

/⍨⍳⎕

Làm thế nào nó hoạt động:

⎕đọc đầu vào của người dùng. Đối với đầu ra, APL theo mặc định in kết quả từ mỗi dòng.

⍳nlà các số nguyên từ 1 đến n. Thí dụ:⍳3←→ 1 2 3

/có nghĩa là nhân rộng . Mỗi phần tử từ đối số bên phải được lặp lại nhiều lần như được chỉ định bởi phần tử tương ứng của nó từ đối số bên trái. Thí dụ:2 0 3/'ABC'←→ 'AACCC'

⍨là toán tử đi lại . Khi nó xuất hiện ở bên phải của hàm, nó sẽ sửa đổi hành vi của nó, do đó, nó hoán đổi các đối số ( A f⍨ B ←→ B f Ado đó "đi lại") hoặc cung cấp cùng một đối số ở cả hai bên ( f⍨ A ←→ A f A, "selfie"). Các hình thức sau được sử dụng trong giải pháp này.

Tiền thưởng:

6-∊⌽⍳¨⍳⎕(8 ký tự, cảm ơn @ phil-h )

⍳5(iota năm) là 1 2 3 4 5.

⍳¨ ⍳5(iota mỗi iota năm) là (,1)(1 2)(1 2 3)(1 2 3 4)(1 2 3 4 5), một vectơ của vectơ. Mỗi ( ¨) là một toán tử, nó lấy một hàm ở bên trái và áp dụng nó cho từng mục từ mảng bên phải.

⌽đảo ngược mảng, vì vậy chúng tôi nhận được (1 2 3 4 5)(1 2 3 4)(1 2 3)(1 2)(,1).

∊là tranh thủ (aka flatten ). Đệ quy đi qua đối số và trả về các vô hướng đơn giản từ nó dưới dạng một vectơ.

Ruby (đệ quy), 41 byte * 0,5 = 20,5

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

Hoặc sử dụng lambda (theo khuyến nghị của histocrat và Ventero): 34 byte * 0.5 = 17

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

(sử dụng cuộc gọi r[argument])

Bình thường , 9 byte * 0,5 = 4,5

smrhQhdUQ

Với sự giúp đỡ từ @FryAmTheEggman

Hãy thử trực tuyến.

Giải trình

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

nơi Qlà đầu vào.

Haskell, 31 ký tự = 15,5 điểm

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

27 ký tự không có tiền thưởng

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

Bị đánh đập bởi Proud Haskeller

C, 22 = 44 byte * 0,5

Hàm hcó hai tham số. Đầu tiên là một intchỉ định n . Thứ hai là một int*bộ đệm đầu ra.

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

Chương trình kiểm tra

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

Bình - 15 10 * .5 = 5

smr-QdhQUQ

Hãy thử trực tuyến.

Mong đợi đầu vào trên stdin. Thuật toán độc lập phát hiện ra. Cảm ơn @ Sp3000 vì đã giúp tôi dán Q cuối cùng vào đó: P Ngoài ra, thật trớ trêu? XD

Giải trình:

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

CJam, 12 15 byte * 0,5 = 7,5

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

Đây là chương trình STDIN-to-STDOUT đầy đủ. Nó kết hợp các hậu tố tăng dần của 1 ... nphạm vi, điều này đảm bảo rằng không có hai số liền kề nào giống hệt nhau.

Kiểm tra nó ở đây.

Python 2, 53 byte * 0,5 = 26,5

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

Không biết xấu hổ mượn ý tưởng của @ VisualMelon

Haskell, 34 byte * 0,5 = 17

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

Đó là lần đầu tiên tôi từng sử dụng Haskell để chơi gôn. Gọi với g <number>.

Bash + coreutils, 28/2 = 14

Ăn cắp ý tưởng và chơi golf của pgy :

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

Bash tinh khiết (không có coreutils), 30/2 = 15

Eval, thoát và mở rộng địa ngục:

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

GolfScript (14 byte * 0,5 = điểm 7)

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

Bản demo trực tuyến

Tôi nghĩ rằng điều này có thể tương tự như một số câu trả lời hiện có ở chỗ nó xây dựng mảng concat( [n], [n-1, n], [n-2, n-1, n], ..., [1, 2, ..., n] )

Đáng buồn thay, tôi đã không thể chơi golf thêm nữa thanh lịch hơn:

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

trong đó đặt đầu xvào thành một mảng và sau đó áp dụng hai lần {,{x\-}/}%, ánh xạ từng phần tử trong một mảng thành đếm ngược của nhiều phần tử đó x.

C # - 81 (161byte * 0,5)

Công việc đơn giản trong C #, hy vọng sẽ nhận được phần thưởng không có số lượng lớn. Đọc một int từ stdin, viết ra một mảng như ví dụ cho thiết bị xuất chuẩn.

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

Dễ đọc hơn:

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

Ví dụ đầu ra:

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

JavaScript, ES6, 41 byte

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

Điều này tạo ra một hàm fcó thể được gọi như thế f(6)và nó trả về mảng cần thiết.

Điều này sử dụng một cách tiếp cận đệ quy, trong đó mỗi lần lặp tạo ra một mảng các iphần tử đều có giá trị ivà nối một mảng được trả về bằng f(i-1)điều kiện dừng của i==0.

Hoạt động trên Firefox mới nhất.

Haskell, 14 = 28 byte / 2

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

đầu ra ví dụ:

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

24 byte không có tiền thưởng:

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

Haxe , 53 byte

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

Hoạt động với l (6); vì hiểu mảng.
Kiểm tra trực tuyến 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}

Một bài kiểm tra nhanh

> 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 byte * 0,5 = 33

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

Xây dựng phương pháp đệ quy của Trình tối ưu hóa , chúng ta có thể xây dựng các bước giảm dần theo chiều dài giảm dần, như thế nào [4,3,2,1, 4,3,2, 4,3, 4].

Thay vì thực hiện các tập hợp con có cùng giá trị với Array(i).fill(i), chúng tôi thực hiện undefinedcác tập hợp con có độ dài phù hợp với Array(n).fill()và sau đó thay đổi các giá trị thành một lần chạy giảm dần bằng cách sử dụng .map((v,x)=>i-x). Ngoài ra, chúng tôi xác định và tái diễn trên một chức năng bên trong g; hàm ngoài fchỉ tồn tại để lưu trữ giá trị itrong khi gđệ quy.

T-SQL, 176 * 0,5 = 88

Vì bạn dường như bỏ lỡ T-SQL @Optimizer, nên đây là vinh quang dài dòng :).

Một vài tùy chọn chức năng, hàm vô hướng và hàm nội tuyến có giá trị. Hàm vô hướng sử dụng các vòng lặp while để lặp lại và trả về một chuỗi số, trong đó hàm Inline Table Valued sử dụng CTE đệ quy cho một chuỗi và trả về một bảng. Tất nhiên những thứ này sẽ không bao giờ cạnh tranh được, vì vậy tôi đã không dành nhiều thời gian để chơi gôn.

Hàm nội tuyến có giá trị, 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

Được gọi như sau

SELECT * FROM dbo.F(5)

Ví dụ SQLFiddle

Hàm vô hướng, 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

Được gọi như sau

SELECT dbo.G(5)

Ví dụ SQLFiddle

Toán học, 34 * 0,5 = 17

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

perl, 26 byte

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

JavaScript (có thể đọc được), 131 byte

Tôi chưa quen với Code Golf nên đây không phải là tốt nhất

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 (ít đọc hơn), 87 byte

Giảm thiểu bằng cách sử dụng 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 byte * 0,5 = 12,5

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

Ở trên hầu như không vượt qua phiên bản không thưởng ở mức 13 byte:

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

C #, 114 99 * 0,5 = 49,5 byte

(Với một chút trợ giúp từ câu trả lời của VisualMelon) Chỉnh sửa: và nhận xét của 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;}

Ung dung:

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

Có một phiên bản không an toàn mà tôi xấu hổ lấy từ câu trả lời C của frageum, nhưng tôi không chắc chắn 100% nó phù hợp với các quy tắc vì bạn phải phân bổ bộ nhớ trước khi gọi phương thức.

C # (không an toàn), 82 * 0,5 = 41 byte

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

Được gọi như sau:

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 }

Theo đề xuất của VisualMelon (cảm ơn!), Mã không an toàn có thể được tạo lại bằng mã an toàn làm giảm kích thước hơn nữa! Vẫn đặt ra câu hỏi nếu việc tạo mảng kết quả cuối cùng được phép thực hiện ngoài phương thức.

C #, 72 * 0,5 = 36 byte

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

Bash với seq, expr và xargs = 59/2 = 29,5

Lưu nó và chạy với số là đối số đầu tiên.

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

C #, 116 115 + 33 = 148 byte

Không phải mã ngắn nhất, nhưng ... dù sao nó cũng hoạt động: 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();}

Yêu cầu điều này ở đầu tệp (33 byte):

using System.Collections.Generic;

Phiên bản chưa chơi gôn:

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)

Chỉnh sửa xóa; thx @Optimizer

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

Thử nghiệm trong bảng điều khiển FireFox / FireBug

Q(9)

Đầu ra

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

Bị đánh cắp

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 byte

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

Khá hài lòng với cái này ... Nó chỉ bằng một phần tư kích thước ban đầu của tôi.

f(4) trả về:

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

Câu trả lời cũ:

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

Đây là lần đầu tiên tôi chơi golf mã ... Tôi vẫn muốn nhận được 0,5x tiền thưởng đó. Mọi góp ý đều được hoan nghênh!

Được gọi với f (n).

C #, 108 byte * 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;}

Cảm ơn VisualMelon đã làm công việc khó khăn! Tôi nghĩ tôi sẽ cố gắng ép nó xuống hết mức có thể.

(114 byte * 0,5 = 57, nếu bạn khăng khăng sử dụng .ToArray () để trả về int [])