Herausforderung

Ihre Aufgabe in dieser Frage ist es, ein Programm oder eine benannte Funktion zu schreiben, die eine positive Ganzzahl n(größer als 0) als Eingabe über STDIN-, ARGV- oder Funktionsargumente und ein Array über STDOUT- oder Funktionsrückgabewert ausgibt.

Hört sich einfach an? Hier sind die Regeln

• Das Array enthält nur Ganzzahlen von 1bisn
• Jede Ganzzahl von 1bis nsollte wiederholt werden x, wobei xder Wert jeder Ganzzahl ist.

Beispielsweise:

Eingang:

5

Ausgabe:

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

Das Array kann sortiert sein oder nicht.

Dies ist Code-Golf, also ist der Gewinner der kürzeste Code in Bytes.

Bonus

Multiplizieren Sie Ihre Punktzahl mit, 0.5wenn keine zwei benachbarten Ganzzahlen in Ihrem Ausgabearray gleich sind.

Zum Beispiel n = 5wäre eine solche Konfiguration

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

APL, 4 Zeichen

/⍨⍳⎕

Wie es funktioniert:

⎕liest Benutzereingaben. Wie bei der Ausgabe druckt APL standardmäßig das Ergebnis aus jeder Zeile.

⍳nist die ganze Zahl von 1 bis n. Beispiel:⍳3←→ 1 2 3

/bedeutet replizieren . Jedes Element aus dem rechten Argument wird so oft wiederholt, wie durch das entsprechende Element aus dem linken Argument angegeben. Beispiel:2 0 3/'ABC'←→ 'AACCC'

⍨ist der Pendler . Wenn sie rechts von einer Funktion auftritt, ändert sie ihr Verhalten, sodass sie entweder die Argumente austauscht ( A f⍨ B ←→ B f Adaher "pendelt") oder auf beiden Seiten dasselbe Argument bereitstellt ( f⍨ A ←→ A f Aein "Selfie"). Die letztere Form wird in dieser Lösung verwendet.

Bonus:

6-∊⌽⍳¨⍳⎕(8 Zeichen, danke @ phil-h )

⍳5(iota fünf) ist 1 2 3 4 5.

⍳¨ ⍳5(iota jedes iota fünf) ist (,1)(1 2)(1 2 3)(1 2 3 4)(1 2 3 4 5)ein Vektor von Vektoren. Jedes ( ¨) ist ein Operator. Es übernimmt eine Funktion auf der linken Seite und wendet sie auf jedes Element des Arrays auf der rechten Seite an.

⌽Kehrt das Array um, so erhalten wir (1 2 3 4 5)(1 2 3 4)(1 2 3)(1 2)(,1).

∊ist einschreiben (aka Abflachen ). Durchläuft das Argument rekursiv und gibt die einfachen Skalare als Vektor zurück.

Ruby (rekursiv), 41 Bytes * 0,5 = 20,5

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

Oder mit einem Lambda (wie von Histokrat und Ventero empfohlen): 34 Bytes * 0,5 = 17

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

(anrufen mit r[argument])

Pyth , 9 Bytes * 0,5 = 4,5

smrhQhdUQ

Mit Hilfe von @FryAmTheEggman

Probieren Sie es online aus.

Erläuterung

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

wo Qist der eingang.

Haskell, 31 Zeichen = 15,5 Punkte

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

27 Zeichen ohne den Bonus

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

Geschlagen von Proud Haskeller

C, 22 = 44 Bytes * 0,5

Die Funktion hakzeptiert zwei Parameter. Das erste ist ein intspezifizierendes n . Der zweite int*ist der Ausgabepuffer.

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

Testprogramm

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

Probieren Sie es online aus.

Erwartet die Eingabe von stdin. Unabhängig entdeckter Algorithmus. Danke @ Sp3000, dass du mir geholfen hast, die letzten Fragen zu beantworten: P Auch Ironie? XD

Erläuterung:

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

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

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

Dies ist das vollständige STDIN-zu-STDOUT-Programm. Es verkettet zunehmende Suffixe des 1 ... nBereichs, wodurch sichergestellt wird, dass keine zwei benachbarten Zahlen identisch sind.

Teste es hier.

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

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

Schamlos entlehnt @ VisualMelons Idee

Haskell, 34 Bytes * 0,5 = 17

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

Das ist das erste Mal, dass ich Haskell zum Golfen benutze. Mit anrufen g <number>.

Bash + Coreutils, 28/2 = 14

Schamlos die Idee von @ pgy stehlen und Golf spielen:

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

Pure Bash (keine Coreutils), 30/2 = 15

Eval, Flucht und Expansionshölle:

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

GolfScript (14 Bytes * 0,5 = 7 Punkte)

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

Online-Demo

Ich denke, dies ähnelt wahrscheinlich einigen vorhandenen Antworten, da es das Array aufbaut concat( [n], [n-1, n], [n-2, n-1, n], ..., [1, 2, ..., n] )

Umso eleganter konnte ich leider nicht mehr golfen:

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

Das setzt die Eingabe xin ein Array und wird dann zweimal angewendet {,{x\-}/}%. Dabei wird jedes Element in einem Array einem Countdown von so vielen Elementen von zugeordnet x.

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

Einfacher Job in C #, hoffentlich Bonus ohne Neiburger. Liest ein int aus stdin, schreibt ein Array wie im Beispiel nach 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+"]");}}

Besser lesbar:

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

Beispiele Ausgabe:

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

Dadurch wird eine Funktion ferstellt, die wie f(6)folgt aufgerufen werden kann und das erforderliche Array zurückgibt.

Hierbei wird ein rekursiver Ansatz verwendet, bei dem jede Iteration ein Array von iElementen erstellt, die alle Werte haben, iund ein Array verkettet, das f(i-1)mit der Stoppbedingung von zurückgegeben wird i==0.

Funktioniert mit dem neuesten Firefox.

Haskell, 14 = 28 Bytes / 2

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

Beispielausgabe:

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

24 Bytes ohne den Bonus:

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

Haxe , 53 Bytes

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

Arbeitet mit l (6); wegen des Array-Verständnisses.
Testen Sie 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 · 0,5 = 22

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

Ein schneller 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 Byte * 0,5 = 33

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

Aufbauend auf dem rekursiven Ansatz von Optimizer können wir absteigende Läufe mit abnehmender Länge wie erstellen [4,3,2,1, 4,3,2, 4,3, 4].

Anstatt gleichwertige Subarrays mit zu erstellen Array(i).fill(i), erstellen wir mit undefined-gefüllte Subarrays mit der entsprechenden Länge Array(n).fill()und ändern die Werte in einen absteigenden Lauf mit .map((v,x)=>i-x). Wir definieren und wiederholen auch eine innere Funktion g; Die äußere Funktion dient fnur zum Speichern des Werts von iwhile- gRekursionen.

T-SQL, 176 * 0,5 = 88

Da Sie den T-SQL @Optimizer scheinbar verpasst haben, ist er hier in seiner ganzen Ausführlichkeit :).

Einige Funktionsoptionen, eine Skalar- und eine Inline-Tabellenwertfunktion. Die Scalar-Funktion verwendet while-Schleifen zur Rekursion und gibt eine Folge von Zahlen zurück, wobei die Inline-Tabellenwert-Funktion einen rekursiven CTE für eine Sequenz verwendet und eine Tabelle zurückgibt. Natürlich werden diese nicht wettbewerbsfähig sein, deshalb habe ich nicht viel Zeit mit Golfen verbracht.

Inline-Tabellenwertfunktion, 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

Wird wie folgt aufgerufen

SELECT * FROM dbo.F(5)

SQLFiddle- Beispiel

Skalarfunktion, 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

Wird wie folgt aufgerufen

SELECT dbo.G(5)

SQLFiddle- Beispiel

Mathematica, 34 · 0,5 = 17

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

Perl, 26 Bytes

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

JavaScript (lesbar), 131 Byte

Ich bin neu in Code Golf, das ist also nicht das Beste

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 (weniger lesbar), 87 Bytes

Mit jscompress.com minimiert

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 Bytes * 0,5 = 12,5

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

Das Obige schlägt die Nicht-Bonus-Version mit 13 Bytes kaum:

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

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

(Mit ein wenig Hilfe von VisualMelons Antwort) Edit: und James Websters Kommentar

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

Es gibt eine unsichere Version, die ich schamlos aus Feersums C-Antwort entnommen habe, aber ich bin nicht zu 100% sicher, dass sie in die Regeln passt, da Sie den Speicher zuweisen müssen, bevor Sie die Methode aufrufen.

C # (unsicher), 82 * 0,5 = 41 Bytes

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

Wie folgt aufgerufen:

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 }

Gemäß dem Vorschlag von VisualMelon (danke!) Kann der unsichere Code mit sicherem Code neu erstellt werden, wodurch die Größe noch weiter verringert wird! Wirft immer noch die Frage auf, ob die Erstellung des endgültigen Ergebnis-Arrays außerhalb der Methode erfolgen darf.

C #, 72 * 0,5 = 36 Bytes

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

Bash mit seq, expr und xargs = 59/2 = 29.5

Speichern Sie es und führen Sie es mit der Nummer als erstes Argument aus.

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

C #, 116 115 + 33 = 148 Bytes

Nicht der kürzeste Code, aber ... es funktioniert trotzdem: 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();}

Benötigt dies am Anfang der Datei (33 Bytes):

using System.Collections.Generic;

Ungolf-Version:

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)

Bearbeiten entfernen; thx @Optimizer

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

Test in der FireFox / FireBug-Konsole

Q(9)

Ausgabe

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

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

Ziemlich glücklich mit diesem ... Es ist ungefähr ein Viertel der Größe meines Originals.

f(4) kehrt zurück:

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

Alte Antwort:

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

Dies ist mein erster Versuch mit Codegolf ... Ich möchte immer noch den 0,5-fachen Bonus erhalten. Anregungen sind willkommen!

Wird mit f (n) aufgerufen.

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

Vielen Dank an VisualMelon für die harte Arbeit! Ich dachte, ich würde versuchen, es so weit wie möglich zusammenzudrücken.

(114 Byte * 0,5 = 57, wenn Sie darauf bestehen, .ToArray () zu verwenden, um int [] zurückzugeben.)