Виклик

Ваше завдання в цьому запитанні - написати програму або іменовану функцію, яка приймає додаткове ціле число 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(йота кожна йота п'ять) - (,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).

∊є Enlist (ака вирівнюватися ). Рекурсивно перетинає аргумент і повертає з нього прості скаляри як вектор.

Ruby (рекурсивна), 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вхід.

Хаскелл, 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вказуючий п . Другий - це 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

Спробуйте в Інтернеті.

Очікує введення на stdin. Самостійно виявлений алгоритм. Спасибі @ Sp3000 за те, що ти допомагаєш мені вкласти останній Q: 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

Чистий баш (без ядер), 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 (161 байт * 0,5)

Проста робота в C #, сподіваємось, отримує бонус за неприлеглі числа. Читає 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]

Хакс , 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)

Спираючись на рекурсивний підхід оптимізатора , ми можемо будувати низхідні пробіги зменшення довжини, наприклад[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 використовує 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 приклад

Математика, 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;}

Безголівки:

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 "feersum", але я не на 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]

Безумовно

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