Wyzwanie

Twoim zadaniem w tym pytaniu jest napisanie programu lub funkcji o nazwie, która przyjmuje dodatnią liczbę całkowitą n(większą niż 0) jako dane wejściowe za pośrednictwem argumentów STDIN, ARGV lub funkcji i wysyła tablicę za pośrednictwem STDOUT lub zwracanej wartości funkcji.

Brzmi dość prosto? Oto zasady

• Tablica będzie zawierać tylko liczby całkowite od 1don
• Każdą liczbę całkowitą od 1do nnależy powtórzyć xrazy, gdzie xjest wartością każdej liczby całkowitej.

Na przykład:

Wejście:

5

Wynik:

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

Tablica może być sortowana lub nie.

To jest code-golf, więc zwycięzca jest najkrótszym kodem w bajtach.

Premia

Pomnóż swój wynik przez, 0.5jeśli nie ma dwóch sąsiadujących liczb całkowitych w tablicy wyjściowej.

Na przykład dla n = 5jednej takiej konfiguracji byłaby

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

APL, 4 znaki

/⍨⍳⎕

Jak to działa:

⎕odczytuje dane wprowadzone przez użytkownika. Jeśli chodzi o dane wyjściowe, APL domyślnie drukuje wynik z każdej linii.

⍳nto liczby całkowite od 1 do n. Przykład:⍳3←→ 1 2 3

/oznacza replikację . Każdy element z prawego argumentu jest powtarzany tyle razy, ile jest określony przez odpowiedni element z lewego argumentu. Przykład:2 0 3/'ABC'←→ 'AACCC'

⍨jest operatorem dojeżdżającym do pracy . Kiedy pojawia się na prawo od funkcji, modyfikuje swoje zachowanie, więc albo zamienia argumenty ( A f⍨ B ←→ B f Astąd „dojazdy”), albo podaje ten sam argument po obu stronach ( f⍨ A ←→ A f A„selfie”). W tym rozwiązaniu używana jest druga forma.

Premia:

6-∊⌽⍳¨⍳⎕(8 znaków, dzięki @ phil-h )

⍳5(iota five) jest 1 2 3 4 5.

⍳¨ ⍳5(iota każdy iota pięć) to (,1)(1 2)(1 2 3)(1 2 3 4)(1 2 3 4 5)wektor wektorów. Każda ( ¨) jest operatorem, bierze funkcję po lewej stronie i stosuje ją do każdego elementu z tablicy po prawej stronie.

⌽odwraca tablicę, więc otrzymujemy (1 2 3 4 5)(1 2 3 4)(1 2 3)(1 2)(,1).

∊jest zaciągnięty (aka spłaszczony ). Rekurencyjnie przechodzi przez argument i zwraca z niego proste skalary jako wektor.

Rubinowy (rekurencyjny), 41 bajtów * 0,5 = 20,5

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

Lub używając lambda (jak zalecają histocrat i Ventero): 34 bajty * 0,5 = 17

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

(zadzwoń za pomocą r[argument] )

Pyth , 9 bajtów * 0,5 = 4,5

smrhQhdUQ

Z pomocą @FryAmTheEggman

Wypróbuj online.

Wyjaśnienie

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

gdzie Qjest wejście.

Haskell, 31 znaków = 15,5 wynik

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

27 znaków bez bonusu

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

Pobity przez Dumnego Haskellera

C, 22 = 44 bajty * 0,5

Funkcja hprzyjmuje dwa parametry. Pierwszy jest intokreślające n . Drugi to int*bufor wyjściowy.

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

Program testowy

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

Pyth - 15 10 * .5 = 5

smr-QdhQUQ

Wypróbuj online.

Oczekuje wejścia na standardowe wejście. Niezależnie odkryty algorytm. Dzięki @ Sp3000 za pomoc w naklejeniu tam ostatniego Q: P Co za ironia? XD

Wyjaśnienie:

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

CJam, 12 15 bajtów * 0,5 = 7,5

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

Jest to pełny program STDIN-to-STDOUT. Łączy w sobie rosnące przyrostki 1 ... nzakresu, co zapewnia, że ​​żadne dwie sąsiednie liczby nie są identyczne.

Sprawdź to tutaj.

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

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

Bezwstydnie pożyczył pomysł @ VisualMelon

Haskell, 34 bajty * 0,5 = 17

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

Po raz pierwszy użyłem Haskell do gry w golfa. Zadzwoń z g <number>.

Bash + coreutils, 28/2 = 14

Bezwstydnie kradnie pomysł @ pgy i gra w golfa:

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

Pure Bash (bez coreutils), 30/2 = 15

Piekło ewolucji, ucieczki i ekspansji:

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

GolfScript (14 bajtów * 0,5 = wynik 7)

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

Demo online

Myślę, że jest to prawdopodobnie podobne do niektórych istniejących odpowiedzi, ponieważ tworzy tablicę concat( [n], [n-1, n], [n-2, n-1, n], ..., [1, 2, ..., n] )

Niestety nie byłem już w stanie grać w golfa, prawdopodobnie bardziej elegancki:

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

który umieszcza dane wejściowe xw tablicy, a następnie stosuje się dwukrotnie {,{x\-}/}%, co mapuje każdy element w tablicy na odliczanie tylu elementów x.

C # - 81 (161 bajtów * 0,5)

Prosta praca w C #, mam nadzieję, że dostanie premię za brak liczb. Czyta int ze standardowego wejścia, wypisuje tablicę podobną do przykładu na standardowe wyjście.

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

Bardziej czytelny:

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

Przykłady wyników:

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

JavaScript, ES6, 41 bajtów

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

Tworzy to funkcję, fktórą można wywołać jak f(6)i zwraca wymaganą tablicę.

Wykorzystuje to podejście rekurencyjne, w którym każda iteracja tworzy tablicę ielementów o wszystkich wartościach ii łączy tablicę zwróconą przez f(i-1)warunek zatrzymaniai==0 .

Działa na najnowszym Firefoksie.

Haskell, 14 = 28 bajtów / 2

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

przykładowe dane wyjściowe:

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

24 bajty bez premii:

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

Haxe , 53 bajty

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

Współpracuje z l (6); z powodu zrozumienia tablicy.
Przetestuj online 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}

Szybki 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

JavaScript, ES6, 66 bajtów * 0,5 = 33

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

Opierając się na rekurencyjnym podejściu Optimizer , możemy budować malejące odcinki o malejącej długości [4,3,2,1, 4,3,2, 4,3, 4].

Zamiast tworzyć podrzędne tablice o tej samej wartości Array(i).fill(i), wykonujemy undefinedpodrzędne tablice o odpowiedniej długości za pomocą, Array(n).fill()a następnie zmieniamy wartości na przebieg malejący za pomocą .map((v,x)=>i-x). Ponadto definiujemy i powtarzamy funkcję wewnętrzną g; funkcja zewnętrzna fistnieje tylko do przechowywania wartości iwhile grecurses.

T-SQL, 176 * 0,5 = 88

Ponieważ wydawało się, że brakuje T-SQL @Optimizer, oto cała jego pełna chwała :).

Kilka opcji funkcji, funkcja Skalarna i Inline Table Valued. Funkcja Scalar używa pętli while do rekurencji i zwraca ciąg liczb, przy czym funkcja Inline Table Valued wykorzystuje rekurencyjną CTE dla sekwencji i zwraca tabelę. Oczywiście nigdy nie będą one konkurencyjne, więc nie spędziłem dużo czasu na grze w golfa.

Funkcja ceniona w tabeli wbudowanej, 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

Nazywany w następujący sposób

SELECT * FROM dbo.F(5)

SQLFiddlePrzykład

Funkcja skalarna, 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

Nazywany w następujący sposób

SELECT dbo.G(5)

Przykład SQLFiddle

Mathematica, 34 * 0,5 = 17

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

perl, 26 bajtów

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

JavaScript (czytelny), 131 bajtów

Jestem nowy w Code Golf, więc to nie jest najlepsze

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 (mniej czytelny), 87 bajtów

Zminimalizowane za pomocą 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 bajtów * 0,5 = 12,5

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

Powyższe ledwo pokonuje wersję bez premii przy 13 bajtach:

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

C #, 114 99 * 0,5 = 49,5 bajtów

(Z niewielką pomocą odpowiedzi VisualMelon) Edytuj: i komentarz Jamesa Webstera

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

Nie golfowany:

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

Istnieje niebezpieczna wersja, którą bezwstydnie wziąłem z odpowiedzi Feersum C, ale nie jestem w 100% pewien, że pasuje ona do reguł, ponieważ musisz przydzielić pamięć przed wywołaniem metody.

C # (niebezpieczne), 82 * 0,5 = 41 bajtów

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

Nazywany w następujący sposób:

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 }

Zgodnie z sugestią VisualMelon (dzięki!) Niebezpieczny kod można ponownie utworzyć za pomocą bezpiecznego kodu, który jeszcze bardziej zmniejsza rozmiar! Nadal pojawia się pytanie, czy tworzenie końcowej tablicy wyników może być wykonane poza metodą.

C #, 72 * 0,5 = 36 bajtów

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

Bash z seq, expr i xargs = 59/2 = 29,5

Zapisz go i uruchom z numerem jako pierwszym argumentem.

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

C #, 116 115 + 33 = 148 bajtów

Nie najkrótszy kod, ale ... i tak działa: 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();}

Wymaga tego na górze pliku (33 bajty):

using System.Collections.Generic;

Wersja bez gry w golfa:

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)

Edytuj usuń; dzięki @Optimizer

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

Przetestuj w konsoli FireFox / FireBug

Q(9)

Wynik

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

Nie golfił

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 bajtów

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

Całkiem zadowolony z tego ... To mniej więcej jedna czwarta wielkości mojego oryginału.

f(4) zwroty:

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

Stara odpowiedź:

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

To jest moja pierwsza szansa na kod golfa ... Nadal chcę otrzymać ten bonus 0,5x. Wszelkie sugestie są mile widziane!

Wywoływany za pomocą f (n).

C #, 108 bajtów * 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;}

Dzięki VisualMelon za ciężką pracę! Pomyślałem, że spróbuję to ściśnąć tak mocno, jak to możliwe.

(114 bajtów * 0,5 = 57, jeśli nalegasz na użycie .ToArray () do zwrócenia int [])