Desafío

Su tarea en esta pregunta es escribir un programa o una función con nombre que tome un entero positivo n(mayor que 0) como entrada a través de STDIN, ARGV o argumentos de función y genere una matriz a través de STDOUT o el valor devuelto por la función.

¿Suena bastante simple? Ahora estas son las reglas

• La matriz solo contendrá enteros de 1an
• Cada entero de 1a ndebe repetirse xveces donde xes el valor de cada entero.

Por ejemplo:

Entrada:

5

Salida:

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

La matriz puede o no estar ordenada.

Este es el código de golf, por lo que el ganador es el código más corto en bytes.

Prima

Multiplique su puntaje por 0.5si no hay dos enteros adyacentes en su matriz de salida iguales.

Por ejemplo n = 5, una de esas configuraciones sería

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

APL, 4 caracteres

/⍨⍳⎕

Cómo funciona:

⎕lee la entrada del usuario. En cuanto a la salida, APL imprime por defecto el resultado de cada línea.

⍳nson los enteros de 1 a n. Ejemplo:⍳3←→ 1 2 3

/significa replicar . Cada elemento del argumento derecho se repite tantas veces como lo especifique su elemento correspondiente del argumento izquierdo. Ejemplo:2 0 3/'ABC'←→ 'AACCC'

⍨es el operador de viaje . Cuando aparece a la derecha de una función, modifica su comportamiento, por lo que intercambia los argumentos (por lo A f⍨ B ←→ B f Atanto, "conmuta") o proporciona el mismo argumento en ambos lados ( f⍨ A ←→ A f Auna "selfie"). La última forma se usa en esta solución.

Prima:

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

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

⍳¨ ⍳5(iota cada iota cinco) es (,1)(1 2)(1 2 3)(1 2 3 4)(1 2 3 4 5)un vector de vectores. Cada ( ¨) es un operador, toma una función a la izquierda y la aplica a cada elemento de la matriz a la derecha.

⌽invierte la matriz, así que obtenemos (1 2 3 4 5)(1 2 3 4)(1 2 3)(1 2)(,1).

∊es alistarse (también conocido como aplanar ). Atraviesa recursivamente el argumento y le devuelve los escalares simples como un vector.

Ruby (recursivo), 41 bytes * 0.5 = 20.5

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

O usando una lambda (según lo recomendado por histocrat y Ventero): 34 bytes * 0.5 = 17

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

(llamar usando r[argument])

Pyth , 9 bytes * 0.5 = 4.5

smrhQhdUQ

Con la ayuda de @FryAmTheEggman

Pruébalo en línea.

Explicación

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

donde Qesta la entrada

Haskell, 31 caracteres = 15.5 puntaje

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

27 personajes sin el bono

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

Golpeado por el orgulloso Haskeller

C, 22 = 44 bytes * 0.5

La función htoma dos parámetros. El primero es un nint especificador . El segundo es unint* que es el búfer de salida.

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

Programa de prueba

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

Pruébalo en línea.

Espera entrada en stdin. Algoritmo descubierto independientemente. Gracias @ Sp3000 por ayudarme a pegar la última Q allí: P ¿También, ironía? XD

Explicación:

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 es un programa completo de STDIN a STDOUT. Concatena sufijos crecientes de la1 ... n rango, lo que garantiza que no haya dos números adyacentes idénticos.

Pruébalo aquí.

Python 2, 53 bytes * 0.5 = 26.5

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

La idea de @ VisualMelon tomó prestada descaradamente

Haskell, 34 bytes * 0.5 = 17

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

Es la primera vez que uso Haskell para jugar al golf. Llamada con g <number>.

Bash + coreutils, 28/2 = 14

Robando descaradamente la idea de @ pgy y jugando al golf:

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

Golpe puro (sin coreutils), 30/2 = 15

Eva, escape y expansión del infierno:

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

GolfScript (14 bytes * 0.5 = puntaje 7)

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

Demostración en línea

Creo que esto es probablemente similar a algunas respuestas existentes, ya que acumula la matriz concat( [n], [n-1, n], [n-2, n-1, n], ..., [1, 2, ..., n] )

Lamentablemente, no pude jugar más al golf, posiblemente el más elegante:

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

que pone la entrada xen una matriz y luego se aplica dos veces {,{x\-}/}%, que asigna cada elemento de una matriz a una cuenta regresiva de esa cantidad de elementos x.

C # - 81 (161bytes * 0.5)

Trabajo simple en C #, es de esperar que obtenga el bono de números sin neibouring. Lee un int desde stdin, escribe una matriz como el ejemplo en 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+"]");}}

Más legible:

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

Ejemplos de salida:

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

Esto crea una función fque se puede llamar como f(6)y devuelve la matriz requerida.

Esto utiliza un enfoque recursivo, donde cada iteración crea una matriz de ielementos todos valorados iy concatena una matriz devuelta f(i-1)con la condición de detención de i==0.

Funciona en la última versión de Firefox.

Haskell, 14 = 28 bytes / 2

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

salida de ejemplo:

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

24 bytes sin el bono:

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

Funciona con l (6); debido a la comprensión de la matriz.
Prueba en línea 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}

Una prueba rápida

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

Partiendo del enfoque recursivo de Optimizer , podemos construir series descendentes de longitud decreciente, como [4,3,2,1, 4,3,2, 4,3, 4].

En lugar de Array(i).fill(i)hacer undefinedsubconjuntos del mismo valor con , hacemos subconjuntos llenos de la longitud apropiada con Array(n).fill()y luego cambiamos los valores a una ejecución descendente usando .map((v,x)=>i-x). Además, definimos y recurrimos sobre una función interna g; la función externa fexiste solo para almacenar el valor de iwhile grecurses.

T-SQL, 176 * 0.5 = 88

Como parecía perderse el T-SQL @Optimizer, aquí está en toda su gloria detallada :).

Un par de opciones de funciones, una función escalar y una tabla de valores en línea. La función escalar usa bucles while para recurrir y devuelve una cadena de números, donde la función Valor de tabla en línea usa un CTE recursivo para una secuencia y devuelve una tabla. Por supuesto, estos nunca serán competitivos, por lo que no he pasado mucho tiempo jugando al golf.

Función de valor de tabla en línea, 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

Llamado de la siguiente manera

SELECT * FROM dbo.F(5)

Ejemplo de SQLFiddle

Función 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

Llamado de la siguiente manera

SELECT dbo.G(5)

Ejemplo de SQLFiddle

Mathematica, 34 * 0.5 = 17

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

perl, 26 bytes

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

JavaScript (legible), 131 bytes

Soy nuevo en Code Golf, así que este no es el mejor

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 legible), 87 bytes

Minified 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=>>

Lo anterior apenas supera la versión sin bono de 13 bytes:

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

C #, 114 99 * 0.5 = 49.5 bytes

(Con un poco de ayuda de la respuesta de VisualMelon) Editar: y el comentario 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;}

Sin golf:

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

Hay una versión insegura que tomé descaradamente de la respuesta C de feersum, pero no estoy 100% seguro de que se ajuste a las reglas, ya que debe asignar la memoria antes de llamar al método.

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

Llamado de la siguiente manera:

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 }

Según la sugerencia de VisualMelon (¡gracias!), El código inseguro se puede volver a crear con un código seguro que reduce aún más el tamaño. Todavía plantea la pregunta de si la creación de la matriz de resultados finales se puede realizar fuera del 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 con seq, expr y xargs = 59/2 = 29.5

Guárdelo y ejecute con el número como primer argumento.

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

C #, 116115 + 33 = 148 bytes

No es el código más corto, pero ... funciona de todos modos: 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();}

Requiere esto en la parte superior del archivo (33 bytes):

using System.Collections.Generic;

Versión sin 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)

Editar eliminar; thx @Optimizer

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

Prueba en la consola FireFox / FireBug

Q(9)

Salida

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

Sin golf

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}

Bastante contento con este ... Es aproximadamente una cuarta parte del tamaño de mi original.

f(4) devoluciones:

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

Vieja respuesta:

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

Esta es mi primera oportunidad en el código de golf ... Todavía quiero obtener ese bono de 0.5x. Cualquier sugerencia es bienvenida!

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

¡Gracias a VisualMelon por hacer el trabajo duro! Pensé que trataría de exprimirlo lo más posible.

(114 bytes * 0.5 = 57, si insiste en usar .ToArray () para devolver int [])