Desafio

Sua tarefa nesta pergunta é escrever um programa ou uma função nomeada que recebe um número inteiro positivo n(maior que 0) como entrada via STDIN, ARGV ou argumentos de função e gera uma matriz via STDOUT ou valor retornado pela função.

Parece bastante simples? Agora, aqui estão as regras

• A matriz conterá apenas números inteiros de 1an
• Cada número inteiro de 1a ndeve ser repetido xvezes onde xé o valor de cada número inteiro.

Por exemplo:

Entrada:

5

Resultado:

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

A matriz pode ou não ser classificada.

Isso é código-golfe, então vencedor é o código mais curto em bytes.

Bônus

Multiplique sua pontuação 0.5se não houver dois números inteiros adjacentes em sua matriz de saída.

Por exemplo n = 5, uma dessas configurações seria

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

APL, 4 caracteres

/⍨⍳⎕

Como funciona:

⎕lê a entrada do usuário. Quanto à saída, a APL, por padrão, imprime o resultado de cada linha.

⍳né o número inteiro de 1 a n. Exemplo:⍳3←→ 1 2 3

/significa replicar . Cada elemento do argumento da direita é repetido quantas vezes for especificado pelo elemento correspondente do argumento da esquerda. Exemplo:2 0 3/'ABC'←→ 'AACCC'

⍨é o operador de comutação . Quando ocorre à direita de uma função, ela modifica seu comportamento, de modo que troca os argumentos ( A f⍨ B ←→ B f Aportanto, "comuta") ou fornece o mesmo argumento dos dois lados ( f⍨ A ←→ A f Auma "selfie"). A última forma é usada nesta solução.

Bônus:

6-∊⌽⍳¨⍳⎕(8 caracteres, obrigado @ phil-h )

⍳5(Iota cinco) é 1 2 3 4 5.

⍳¨ ⍳5(iota cada iota cinco) é (,1)(1 2)(1 2 3)(1 2 3 4)(1 2 3 4 5)um vetor de vetores. Cada ( ¨) é um operador, pega uma função à esquerda e aplica-a a cada item da matriz à direita.

⌽inverte a matriz, então obtemos (1 2 3 4 5)(1 2 3 4)(1 2 3)(1 2)(,1).

∊é se alistar (também conhecido como achatar ). Atravessa recursivamente o argumento e retorna os escalares simples como um vetor.

Ruby (recursivo), 41 bytes * 0,5 = 20,5

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

Ou usando um lambda (conforme recomendado pelo histocrat e Ventero): 34 bytes * 0,5 = 17

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

(ligue usando r[argument])

Pitão , 9 bytes * 0,5 = 4,5

smrhQhdUQ

Com a ajuda de @FryAmTheEggman

Experimente online.

Explicação

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

Onde Qestá a entrada.

Haskell, 31 caracteres = 15,5 pontos

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

27 caracteres sem o bônus

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

Batido por orgulhoso Haskeller

C, 22 = 44 bytes * 0,5

A função haceita dois parâmetros. O primeiro é um nint especificado . O segundo é um que é o buffer de saída.int*

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

Programa de teste

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

Pitão - 15 10 * 0,5 = 5

smr-QdhQUQ

Experimente online.

Espera entrada no stdin. Algoritmo descoberto independentemente. Obrigado @ Sp3000 por me ajudar a colocar o último Q lá dentro: P Além disso, ironia? XD

Explicação:

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

Este é o programa completo STDIN para STDOUT. Concatena os sufixos crescentes do 1 ... nintervalo, o que garante que dois números adjacentes não sejam idênticos.

Teste aqui.

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

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

Emprestado descaradamente a ideia do @Melmel

Haskell, 34 bytes * 0,5 = 17

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

Foi a primeira vez que usei Haskell para jogar golfe. Ligue com g <number>.

Bash + coreutils, 28/2 = 14

Roubando descaradamente a idéia e o golfe de @ pgy :

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

Festança pura (sem coreutils), 30/2 = 15

Eval, inferno de fuga e expansão:

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

GolfScript (14 bytes * 0,5 = pontuação 7)

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

Demonstração online

Eu acho que isso provavelmente é semelhante a algumas respostas existentes, na medida em que cria a matriz concat( [n], [n-1, n], [n-2, n-1, n], ..., [1, 2, ..., n] )

Infelizmente, não pude jogar mais o discutivelmente mais elegante:

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

que coloca a entrada xem uma matriz e depois se aplica duas vezes {,{x\-}/}%, que mapeia cada elemento em uma matriz para uma contagem regressiva de muitos elementos x.

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

Trabalho simples em C #, espero que receba o bônus de números sem neibouring. Lê um int a partir de stdin, grava uma matriz como o exemplo em 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+"]");}}

Mais legível:

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

Saída de exemplos:

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

JavaScript, ES6, 41 bytes

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

Isso cria uma função fque pode ser chamada como f(6)e retorna a matriz necessária.

Isso usa uma abordagem recursiva, em que cada iteração cria uma matriz de ielementos todos com valor ie concatena uma matriz retornada f(i-1)com a condição de parada de i==0.

Funciona no Firefox mais recente.

Haskell, 14 = 28 bytes / 2

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

saída de exemplo:

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

24 bytes sem o bônus:

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

Trabalha com l (6); por causa da compreensão do array.
Teste 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}

Um teste rápido

> 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 bytes * 0,5 = 33

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

Construindo em abordagem recursiva do Optimizer , podemos criar execuções descendentes de comprimento decrescente, como [4,3,2,1, 4,3,2, 4,3, 4].

Em vez de criar sub-matrizes de mesmo valor Array(i).fill(i), criamos undefinedsub-matrizes preenchidas com o comprimento apropriado Array(n).fill()e, em seguida, alteramos os valores para uma execução descendente usando .map((v,x)=>i-x). Além disso, definimos e recorremos a uma função interna g; a função externa fexiste apenas para armazenar o valor de iwhile se grepete.

T-SQL, 176 * 0,5 = 88

Desde que você pareceu sentir falta do T-SQL @Optimizer, aqui está toda a sua glória detalhada :).

Algumas opções de função, uma escalar e uma função com valor de tabela embutida. A função Escalar usa os loops while para recuperar e retornar uma sequência de números, onde a função Valor da Tabela Inline usa um CTE recursivo para uma sequência e retorna uma tabela. É claro que isso nunca será competitivo, por isso não passei muito tempo jogando golfe.

Função com valor de tabela embutida, 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

Chamado da seguinte forma

SELECT * FROM dbo.F(5)

Exemplo de SQLFiddle

Função Escalar, 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

Chamado da seguinte forma

SELECT dbo.G(5)

Exemplo de SQLFiddle

Mathematica, 34 * 0,5 = 17

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

perl, 26 bytes

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

JavaScript (legível), 131 bytes

Eu sou novo no Code Golf, então isso não é o melhor

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 (menos legível), 87 bytes

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

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

O exemplo acima mal bate a versão sem bônus em 13 bytes:

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

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

(Com uma pequena ajuda da resposta do VisualMelon) Editar: e o comentário de 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;
}

Existe uma versão insegura que tirei descaradamente da resposta C do feersum, mas não tenho 100% de certeza de que ela se encaixa nas regras, pois você precisa alocar a memória antes de chamar o método.

C # (não seguro), 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;}

Chamado da seguinte forma:

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 }

De acordo com a sugestão do VisualMelon (obrigado!), O código não seguro pode ser refeito com um código seguro, o que reduz ainda mais o tamanho! Ainda coloca a questão se a criação da matriz de resultados finais pode ser feita fora do método.

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 com seq, expr e xargs = 59/2 = 29,5

Salve-o e execute com o número como o primeiro argumento.

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

C #, 116 115 + 33 = 148 bytes

Não é o código mais curto, mas ... funciona de qualquer maneira: 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();}

Requer isso na parte superior do arquivo (33 bytes):

using System.Collections.Generic;

Versão sem golfe:

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)

Editar remover; thx @Optimizer

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

Teste no console do FireFox / FireBug

Q(9)

Resultado

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

Muito feliz com este ... É cerca de um quarto do tamanho do meu original.

f(4) retorna:

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

Resposta antiga:

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

This is my first shot at code golf...I still want to get that 0.5x bonus. Any suggestions are welcomed!

Called with f(n).

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

Thanks to VisualMelon for doing the hard work! I thought I'd try to squeeze it down as much as possible.

(114 bytes * 0.5 = 57, if you insist on using .ToArray() to return int[])