Défi

Votre tâche dans cette question consiste à écrire un programme ou une fonction nommée qui prend un entier positif n(supérieur à 0) en entrée via STDIN, ARGV ou des arguments de fonction et génère un tableau via STDOUT ou une valeur renvoyée par la fonction.

Cela semble assez simple? Voici maintenant les règles

• Le tableau ne contiendra que des entiers de 1àn
• Chaque entier de 1à ndoit être répété xfois où xest la valeur de chaque entier.

Par exemple:

Contribution:

5

Production:

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

Le tableau peut être trié ou non.

Il s'agit de code-golf, donc le gagnant est le code le plus court en octets.

Prime

Multipliez votre score par 0.5s'il n'y a pas deux entiers adjacents dans votre tableau de sortie identiques.

Par exemple pour n = 5, une telle configuration serait

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

APL, 4 caractères

/⍨⍳⎕

Comment ça fonctionne:

⎕lit l'entrée utilisateur. Quant à la sortie, APL imprime par défaut le résultat de chaque ligne.

⍳nest les entiers de 1 à n. Exemple:⍳3←→ 1 2 3

/signifie répliquer . Chaque élément de l'argument de droite est répété autant de fois que spécifié par son élément correspondant de l'argument de gauche. Exemple:2 0 3/'ABC'←→ 'AACCC'

⍨est l' opérateur de navette . Quand il se produit à droite d'une fonction, il modifie son comportement, il échange donc les arguments ( A f⍨ B ←→ B f A, donc "commute") ou fournit le même argument des deux côtés ( f⍨ A ←→ A f A, un "selfie"). Cette dernière forme est utilisée dans cette solution.

Prime:

6-∊⌽⍳¨⍳⎕(8 caractères, merci @ phil-h )

⍳5(iota cinq) est 1 2 3 4 5.

⍳¨ ⍳5(iota chaque iota cinq) est (,1)(1 2)(1 2 3)(1 2 3 4)(1 2 3 4 5), un vecteur de vecteurs. Each ( ¨) est un opérateur, il prend une fonction à gauche et l'applique à chaque élément du tableau à droite.

⌽inverse le tableau, donc nous obtenons (1 2 3 4 5)(1 2 3 4)(1 2 3)(1 2)(,1).

∊est enrôler (alias aplatir ). Traverse récursivement l'argument et en retourne les scalaires simples comme vecteur.

Ruby (récursif), 41 octets * 0,5 = 20,5

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

Ou en utilisant un lambda (comme recommandé par histocrat et Ventero): 34 octets * 0,5 = 17

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

(appel en utilisant r[argument])

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

smrhQhdUQ

Avec l'aide de @FryAmTheEggman

Essayez-le en ligne.

Explication

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

où Qest l'entrée.

Haskell, 31 caractères = 15,5 points

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

27 personnages sans bonus

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

Battu par Proud Haskeller

C, 22 = 44 octets * 0,5

La fonction hprend deux paramètres. Le premier est un nint spécifiant . Le second est un qui est le tampon de sortie.int*

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

Programme de 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

Essayez-le en ligne.

Attend une entrée sur stdin. Algorithme découvert indépendamment. Merci @ Sp3000 de m'avoir aidé à coller le dernier Q: P Aussi, ironie? XD

Explication:

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

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

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

Il s'agit d'un programme complet de STDIN à STDOUT. Il concatène des suffixes croissants du1 ... n plage, ce qui garantit qu'il n'y a pas deux nombres adjacents identiques.

Testez-le ici.

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

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

Emprunté sans vergogne à l'idée de VisualMelon

Haskell, 34 octets * 0,5 = 17

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

C'est la première fois que j'utilise Haskell pour jouer au golf. Appelez avec g <number>.

Bash + coreutils, 28/2 = 14

Voler sans vergogne l'idée de pgy et jouer au golf:

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

Pure bash (sans coreutils), 30/2 = 15

Eval, évasion et enfer d'expansion:

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

GolfScript (14 octets * 0,5 = score 7)

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

Démo en ligne

Je pense que cela est probablement similaire à certaines réponses existantes en ce qu'il construit le tableau concat( [n], [n-1, n], [n-2, n-1, n], ..., [1, 2, ..., n] )

Malheureusement, je n'ai pas pu jouer au golf sans doute plus élégant:

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

qui place l'entrée xdans un tableau puis l'applique deux fois {,{x\-}/}%, qui mappe chaque élément d'un tableau avec un décompte de ce nombre d'éléments x.

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

Travail simple en C #, avec un peu de chance, le bonus sans chiffres Lit un int dans stdin, écrit un tableau comme l'exemple dans 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+"]");}}

Plus lisible:

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

Exemples de sortie:

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

JavaScript, ES6, 41 octets

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

Cela crée une fonction fqui peut être appelée comme f(6)et renvoie le tableau requis.

Cela utilise une approche récursive, où chaque itération crée un tableau d' iéléments tous valorisés iet concatène un tableau renvoyé par f(i-1)avec la condition d'arrêt de i==0.

Fonctionne sur le dernier Firefox.

Haskell, 14 = 28 octets / 2

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

exemple de sortie:

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

24 octets sans bonus:

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

Haxe , 53 octets

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

Fonctionne avec l (6); en raison de la compréhension du tableau.
Test en ligne 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 rapide

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

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

En s'appuyant sur l'approche récursive d'Optimizer , nous pouvons créer des séries descendantes de longueur décroissante, comme [4,3,2,1, 4,3,2, 4,3, 4].

Au lieu de créer des sous- tableaux de même valeur avec Array(i).fill(i), nous undefinedcréons des sous-tableaux remplis de la longueur appropriée avec Array(n).fill(), puis modifions les valeurs en une exécution décroissante à l'aide de .map((v,x)=>i-x). En outre, nous définissons et récurrons sur une fonction intérieure g; la fonction externe fn'existe que pour stocker la valeur de iwhile grécursive.

T-SQL, 176 * 0,5 = 88

Puisque vous avez semblé manquer le T-SQL @Optimizer, le voici dans toute sa splendeur verbeuse :).

Deux options de fonction, une fonction scalaire et une valeur de table en ligne. La fonction Scalar utilise des boucles while pour récurrer et renvoie une chaîne de nombres, où la fonction Valeurs de table en ligne utilise un CTE récursif pour une séquence et renvoie une table. Bien sûr, ceux-ci ne seront jamais compétitifs, donc je n'ai pas passé beaucoup de temps à jouer au golf.

Fonction de valeur de table en ligne, 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

Appelé comme suit

SELECT * FROM dbo.F(5)

Exemple SQLFiddle

Fonction scalaire, 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

Appelé comme suit

SELECT dbo.G(5)

Exemple SQLFiddle

Mathematica, 34 * 0,5 = 17

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

perl, 26 octets

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

JavaScript (lisible), 131 octets

Je suis nouveau sur Code Golf donc ce n'est pas le meilleur

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 (moins lisible), 87 octets

Minifié à l'aide de 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 octets * 0,5 = 12,5

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

Ce qui précède bat à peine la version sans bonus à 13 octets:

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

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

(Avec un peu d'aide de la réponse de VisualMelon) Edit: et le commentaire 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;}

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

Il y a une version dangereuse que j'ai prise sans vergogne de la réponse C de feersum, mais je ne suis pas sûr à 100% qu'elle correspond aux règles puisque vous devez allouer la mémoire avant d'appeler la méthode.

C # (dangereux), 82 * 0,5 = 41 octets

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

Appelé comme suit:

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 }

Selon la suggestion de VisualMelon (merci!), Le code dangereux peut être recréé avec un code sûr qui réduit encore plus la taille! Se pose toujours la question de savoir si la création du tableau de résultats final peut être effectuée en dehors de la méthode.

C #, 72 * 0,5 = 36 octets

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

Bash avec seq, expr et xargs = 59/2 = 29,5

Enregistrez-le et exécutez avec le nombre comme premier argument.

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

C #, 116 115 + 33 = 148 octets

Pas le code le plus court, mais ... ça marche quand même: 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();}

Nécessite cela en haut du fichier (33 octets):

using System.Collections.Generic;

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

Modifier supprimer; thx @Optimizer

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

Test dans la console FireFox / FireBug

Q(9)

Production

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

Non 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 octets

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

Assez content avec celui-ci ... Il fait environ un quart de la taille de mon original.

f(4) Retour:

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

Ancienne réponse:

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

C'est mon premier tir au golf de code ... Je veux toujours obtenir ce bonus de 0,5x. Toutes les suggestions sont les bienvenues!

Appelé avec f (n).

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

Merci à VisualMelon pour avoir travaillé dur! Je pensais que j'essaierais de le presser autant que possible.

(114 octets * 0,5 = 57, si vous insistez pour utiliser .ToArray () pour retourner int [])