Вызов

Ваша задача в этом вопросе - написать программу или именованную функцию, которая принимает положительное целое число 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«селфи»). Последняя форма используется в этом решении.

Бонус:

6-∊⌽⍳¨⍳⎕(8 символов, спасибо @ phil-h )

⍳5(йота пять) есть 1 2 3 4 5.

⍳¨ ⍳5(йота каждая йота пять) - (,1)(1 2)(1 2 3)(1 2 3 4)(1 2 3 4 5)это вектор векторов. Each ( ¨) является оператором, он берет функцию слева и применяет ее к каждому элементу из массива справа.

⌽переворачивает массив, поэтому мы получаем (1 2 3 4 5)(1 2 3 4)(1 2 3)(1 2)(,1).

∊это подключить (он же плоский ). Рекурсивно обходит аргумент и возвращает из него простые скаляры как вектор.

Рубин (рекурсивный), 41 байт * 0,5 = 20,5

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

Или используя лямбду (в соответствии с рекомендациями гистократа и Вентеро): 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]]

Избит Гордым Хаскеллером

С, 22 = 44 байта * 0,5

Функция hпринимает два параметра. Первым является intзадающим п . Вторым является 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);
}

Пиф - 15 10 * .5 = 5

smr-QdhQUQ

Попробуйте онлайн.

Ожидает ввода на стандартный ввод. Самостоятельно открытый алгоритм. Спасибо @ 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, escape и ад расширения:

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 (161 байт * 0,5)

Простая работа в C #, мы надеемся получить бонус не-neibouring-numbers. Читает int из stdin, записывает массив как пример в 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];

Работает с л (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)

Опираясь на рекурсивный подход оптимизатора , мы можем создавать нисходящие трассы уменьшающейся длины, например[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существует только для хранения значения , iа gрекурсивно.

T-SQL, 176 * 0,5 = 88

Поскольку вы, похоже, скучали по T-SQL @Optimizer, здесь он во всей его многословной славе :).

Пара опций функции: функция Scalar и Inline Table Valued. Функция Scalar использует циклы while для рекурсии и возвращает строку чисел, где функция Inline Table Valued использует рекурсивный 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) Редактировать: и комментарий Джеймса Вебстера

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

Есть небезопасная версия, которую я беззастенчиво взял из ответа 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;}

Bash с seq, expr и xargs = 59/2 = 29,5

Сохраните его и запустите с номером в качестве первого аргумента.

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

C #, 116 115 + 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 @Optimizer

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]

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 байта

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.5x. Любые предложения приветствуются!

Вызывается с помощью 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 [])