Sfida

Il tuo compito in questa domanda è di scrivere un programma o una funzione con nome che accetta un numero intero positivo n(maggiore di 0) come input tramite STDIN, ARGV o argomenti di funzione e genera un array tramite STDOUT o valore restituito dalla funzione.

Sembra abbastanza semplice? Ora ecco le regole

• L'array conterrà solo numeri interi da 1an
• Ogni numero intero da 1a ndeve essere ripetuto xvolte in cui xè il valore di ciascun numero intero.

Per esempio:

Ingresso:

5

Produzione:

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

L'array può essere ordinato o meno.

Questo è code-golf, quindi il vincitore è il codice più breve in byte.

indennità

Moltiplica il tuo punteggio 0.5se non ci sono due numeri interi adiacenti nell'array di output uguali.

Ad esempio n = 5, una di queste configurazioni sarebbe

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

APL, 4 caratteri

/⍨⍳⎕

Come funziona:

⎕legge l'input dell'utente. Per quanto riguarda l'output, APL per impostazione predefinita stampa il risultato da ogni riga.

⍳nè il numero intero compreso tra 1 e n. Esempio:⍳3←→ 1 2 3

/significa replicare . Ogni elemento dall'argomento destro viene ripetuto tutte le volte specificato dal suo elemento corrispondente dall'argomento sinistro. Esempio:2 0 3/'ABC'←→ 'AACCC'

⍨è l' operatore pendolare . Quando si verifica a destra di una funzione, modifica il suo comportamento, quindi scambia gli argomenti ( A f⍨ B ←→ B f A, quindi "permuta") o fornisce lo stesso argomento su entrambi i lati ( f⍨ A ←→ A f A, un "selfie"). Quest'ultima forma viene utilizzata in questa soluzione.

Bonus:

6-∊⌽⍳¨⍳⎕(8 caratteri, grazie @ phil-h )

⍳5(Iota Five) è 1 2 3 4 5.

⍳¨ ⍳5(iota ogni iota cinque) è (,1)(1 2)(1 2 3)(1 2 3 4)(1 2 3 4 5)un vettore di vettori. Ogni ( ¨) è un operatore, prende una funzione a sinistra e la applica a ciascun elemento dell'array a destra.

⌽inverte l'array, quindi otteniamo (1 2 3 4 5)(1 2 3 4)(1 2 3)(1 2)(,1).

∊è arruolato (aka appiattito ). Attraversa ricorsivamente l'argomento e restituisce gli scalari semplici come vettore.

Rubino (ricorsivo), 41 byte * 0,5 = 20,5

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

O usando un lambda (come raccomandato da histocrat e Ventero): 34 byte * 0,5 = 17

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

(chiama usando r[argument])

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

smrhQhdUQ

Con l'aiuto di @FryAmTheEggman

Provalo online.

Spiegazione

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

dov'è Ql'input.

Haskell, 31 caratteri = 15,5 punti

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

27 personaggi senza il bonus

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

Battuto da Proud Haskeller

C, 22 = 44 byte * 0,5

La funzione haccetta due parametri. La prima è una intspecifica n . Il secondo è un int*buffer di output.

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

Programma di test

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

Provalo online.

Prevede input su stdin. Algoritmo scoperto in modo indipendente. Grazie @ Sp3000 per avermi aiutato a inserire l'ultima Q lì dentro: P Inoltre, ironia? XD

Spiegazione:

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%~}`

Questo è il programma completo da STDIN a STDOUT. Concatena i suffissi crescenti 1 ... ndell'intervallo, garantendo che non vi siano due numeri adiacenti identici.

Provalo qui.

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

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

Preso spudoratamente in prestito l'idea di VisualMelon

Haskell, 34 byte * 0,5 = 17

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

È la prima volta che uso Haskell per giocare a golf. Chiama con g <number>.

Bash + coreutils, 28/2 = 14

Rubare senza vergogna l'idea di @ pgy e il golf:

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

Bash puro (no coreutils), 30/2 = 15

Inferno di eval, fuga ed espansione:

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

GolfScript (14 byte * 0,5 = punteggio 7)

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

Demo online

Penso che questo sia probabilmente simile ad alcune risposte esistenti in quanto crea l'array concat( [n], [n-1, n], [n-2, n-1, n], ..., [1, 2, ..., n] )

Purtroppo non sono stato in grado di giocare a golf ulteriormente discutibilmente più elegante:

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

che inserisce l'input xin un array e quindi si applica due volte {,{x\-}/}%, che mappa ogni elemento di un array su un conto alla rovescia di tanti elementi da x.

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

Semplice lavoro in C #, si spera che ottenga il bonus senza numeri. Legge un int da stdin, scrive un array come nell'esempio su 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+"]");}}

Più leggibile:

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

Esempi di output:

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

Questo crea una funzione fche può essere chiamata come f(6)e restituisce l'array richiesto.

Questo utilizza un approccio ricorsivo, in cui ogni iterazione crea una matrice di ielementi tutti valutati ie concatena una matrice restituita f(i-1)con condizione di arresto di i==0.

Funziona con l'ultimo Firefox.

Haskell, 14 = 28 byte / 2

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

esempio di output:

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

24 byte senza il bonus:

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

Funziona con l (6); a causa della comprensione dell'array.
Test 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}

Un test veloce

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

Sulla approccio ricorsivo di Optimizer , possiamo costruire piste discendenti di lunghezza decrescente, come [4,3,2,1, 4,3,2, 4,3, 4].

Invece di Array(i).fill(i)creare undefinedsubarrays dello stesso valore con , eseguiamo subarrays riempiti della lunghezza appropriata con Array(n).fill()e poi cambiamo i valori in una corsa discendente usando .map((v,x)=>i-x). Inoltre, definiamo e ricorriamo a una funzione interiore g; la funzione esterna fesiste solo per memorizzare il valore di iwhile grecruit.

T-SQL, 176 * 0,5 = 88

Dal momento che sembravi mancare il T-SQL @Optimizer, qui è in tutto il suo splendore verboso :).

Un paio di opzioni di funzione, una funzione scalare e una tabella in linea valutata. La funzione scalare utilizza i cicli while per ricorrere e restituisce una stringa di numeri, in cui la funzione Inline Table Valued utilizza un CTE ricorsivo per una sequenza e restituisce una tabella. Naturalmente questi non saranno mai competitivi, quindi non ho trascorso molto tempo a giocare a golf.

Inline Table Valued Function, 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

Chiamato come segue

SELECT * FROM dbo.F(5)

Esempio SQLFiddle

Funzione scalare, 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

Chiamato come segue

SELECT dbo.G(5)

Esempio SQLFiddle

Mathematica, 34 * 0,5 = 17

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

perl, 26 byte

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

JavaScript (leggibile), 131 byte

Sono nuovo di Code Golf, quindi questo non è il migliore

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 (meno leggibile), 87 byte

Minimizzato usando 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=>>

Quanto sopra batte a malapena la versione non bonus a 13 byte:

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

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

(Con un piccolo aiuto dalla risposta di VisualMelon) Modifica: e il commento di 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;}

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

Esiste una versione non sicura che ho preso spudoratamente dalla risposta C di feersum, ma non sono sicuro al 100% che rientri nelle regole poiché devi allocare la memoria prima di chiamare il metodo.

C # (non sicuro), 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;}

Chiamato come segue:

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 }

Come suggerito da VisualMelon (grazie!), Il codice non sicuro può essere rifatto con un codice sicuro che ne riduce ulteriormente le dimensioni! Pone ancora la domanda se la creazione dell'array dei risultati finali può essere eseguita al di fuori del metodo.

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 con seq, expr e xargs = 59/2 = 29.5

Salvalo ed eseguilo con il numero come primo argomento.

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

C #, 116 115 + 33 = 148 byte

Non è il codice più breve, ma ... funziona comunque: 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();}

Richiede questo nella parte superiore del file (33 byte):

using System.Collections.Generic;

Versione senza golf:

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)

Modifica rimuovi; thx @Optimizer

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

Test nella console FireFox / FireBug

Q(9)

Produzione

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

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

Abbastanza felice con questo ... Ha circa un quarto delle dimensioni del mio originale.

f(4) ritorna:

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

Vecchia risposta:

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

Questo è il mio primo colpo al code golf ... Voglio ancora ottenere quel bonus di 0,5x. Tutti i suggerimenti sono i benvenuti!

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

Grazie a VisualMelon per fare il duro lavoro! Ho pensato di provare a comprimerlo il più possibile.

(114 byte * 0,5 = 57, se si insiste sull'uso di .ToArray () per restituire int [])