Meydan okuma

Bu sorudaki göreviniz pozitif bir tamsayı alan bir program veya adlandırılmış bir işlev yazmaktır n STDIN, ARGV veya işlev bağımsız değişkenleri aracılığıyla girdi olarak (0'dan büyük) alan ve STDOUT veya işlev döndürülen değeri aracılığıyla bir dizi çıkaran yazmaktır.

Kulağa yeterince basit geliyor mu? İşte kurallar

• Dizi yalnızca gelen tamsayılar içerecektir 1içinn
• Each tamsayı 1Ortaya ntekrarlanmalıdır xkez xher tamsayı değeridir.

Örneğin:

Giriş:

5

Çıktı:

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

Dizi sıralanabilir veya sıralanmayabilir.

Bu kod golf yani kazanan byte en kısa kod.

Bonus

0.5Çıktı dizinizdeki iki bitişik tamsayı aynı değilse puanınızı çarpın .

Örneğin n = 5, böyle bir yapılandırma

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

APL, 4 karakter

/⍨⍳⎕

Nasıl çalışır:

⎕kullanıcı girişini okur. Çıktıya gelince, APL varsayılan olarak sonucu her satırdan yazdırır.

⍳n1 ile 1 arasında bir tamsayıdır n. Misal:⍳3←→ 1 2 3

/çoğaltma anlamına gelir . Sağ argümandaki her öğe, sol argümandaki karşılık gelen öğeyle belirtildiği kadar çok tekrarlanır. Misal:2 0 3/'ABC'←→ 'AACCC'

⍨olduğunu gidip operatörü . Bir işlevin sağında gerçekleştiğinde, davranışını değiştirir, böylece ya argümanları değiştirir ( A f⍨ B ←→ B f Adolayısıyla "gidip gelme") ya da her iki tarafta da aynı argümanı sağlar ( f⍨ A ←→ A f Abir "selfie"). İkinci form, bu çözeltide kullanılır.

Bonus:

6-∊⌽⍳¨⍳⎕(8 karakter, teşekkürler @ phil-h )

⍳5(iota beş) 'dir 1 2 3 4 5.

⍳¨ ⍳5(iota her iota beş) (,1)(1 2)(1 2 3)(1 2 3 4)(1 2 3 4 5)bir vektörler vektörüdür. Her ( ¨) bir operatördür, soldaki bir işlevi alır ve sağdaki diziden her öğeye uygular.

⌽diziyi tersine çevirir, böylece elde ederiz (1 2 3 4 5)(1 2 3 4)(1 2 3)(1 2)(,1).

∊olduğu Enlist (aka düzleştirmek ). Argümanı tekrar tekrar dolaşır ve basit skalerleri bir vektör olarak döndürür.

Yakut (özyinelemeli), 41 bayt * 0.5 = 20.5

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

Veya bir lambda kullanarak (histokrat ve Ventero tarafından önerildiği gibi): 34 bayt * 0.5 = 17

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

(kullanarak arayın r[argument])

Pyth , 9 bayt * 0.5 = 4.5

smrhQhdUQ

@FryAmTheEggman yardımıyla

Çevrimiçi deneyin.

açıklama

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

Qgiriş nerede .

Haskell, 31 karakter = 15.5 puan

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

Bonus olmadan 27 karakter

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

Proud Haskeller tarafından dövüldü

C, 22 = 44 bayt * 0.5

Fonksiyon hiki parametre alır. Birincisi intbelirleyici bir n . İkincisi, int*çıktı tamponu olan bir tanesidir.

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

Test programı

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

Çevrimiçi deneyin.

Stdin üzerinde girdi bekliyor. Bağımsız keşfedilen algoritma. Oradaki son Q'yu yapıştırmama yardımcı olduğu için @ Sp3000'e teşekkürler: P Ayrıca, ironi? XD

Açıklama:

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

CJam, 12 15 bayt * 0.5 = 7.5

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

Bu tam STDIN-STDOUT programıdır. Artan soneklerini birleştirir.1 ... nİki bitişik sayının aynı olmamasını sağlayan aralığın .

Burada test edin.

Python 2, 53 bayt * 0.5 = 26.5

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

Utanmazca ödünç @ VisualMelon'un fikri

Haskell, 34 bayt * 0.5 = 17

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

Haskell'i golf için ilk kez kullandım. İle arayın g <number>.

Bash + coreutils, 28/2 = 14

Utanmazca pgy'nin fikrini çalmak ve golf oynamak :

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

Saf bash (çekirdek yok), 30/2 = 15

Cehennemi değerlendirin, kaçın ve genişletin:

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

GolfScript (14 bayt * 0,5 = puan 7)

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

Çevrimiçi demo

Bence bu, diziyi oluşturması nedeniyle bazı mevcut cevaplara benzer. concat( [n], [n-1, n], [n-2, n-1, n], ..., [1, 2, ..., n] )

Ne yazık ki tartışmasız daha zarif golf daha koyamadım:

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

bu da girdiyi xbir diziye yerleştirir ve ardından bir dizideki {,{x\-}/}%her öğeyi o öğenin geri sayımıyla eşleştiren iki kez uygulanır x.

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

Basit iş C #, umarım neibouring numaralar bonus alır. Stdin'den bir int okur, stdout'a örnek gibi bir dizi yazar.

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

Daha okunabilir:

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

Örnek çıktı:

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

JavaScript, ES6, 41 bayt

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

Bu fgibi çağrılabilen bir işlev oluşturur f(6)ve gerekli diziyi döndürür.

Bu, her yinelemenin ideğerli bir öğe dizisi oluşturduğu ive f(i-1)durma koşulu ile döndürülen bir diziyi birleştirdiği yinelemeli bir yaklaşım kullanır i==0.

En son Firefox'ta çalışır.

Haskell, 14 = 28 bayt / 2

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

örnek çıktı:

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

Bonus olmadan 24 bayt:

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

Haxe , 53 bayt

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

L (6) ile çalışır; dizi kavraması nedeniyle.
Çevrimiçi test 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}

Hızlı bir 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 bayt * 0.5 = 33

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

Optimizer'ın özyinelemeli yaklaşımını temel alarak , azalan uzunlukta azalan çalışmalar yapabiliriz, örneğin[4,3,2,1, 4,3,2, 4,3, 4] .

İle aynı değerde alt diziler Array(i).fill(i)yapmak undefinedyerine, uygun uzunlukta doldurulmuş alt diziler yaparız Array(n).fill()ve ardından değerleri kullanarak azalan bir çalışma olarak değiştiririz .map((v,x)=>i-x). Ayrıca, bir iç işlevi tanımlar ve bunlara yöneliriz g; dış işlev fyalnızca iwhile gtekrarlarının değerini saklamak için vardır.

T-SQL, 176 * 0.5 = 88

T-SQL @Optimizer'ı özlediğiniz gibi göründüğünden, burada tüm ihtişamıyla :).

Birkaç işlev seçeneği, bir Skaler ve Satıriçi Tablo Değerli işlevi. Skaler işlevi, döngülemek için while döngülerini kullanır ve Satır İçi Tablo Değerli işlevinin bir dizi için özyinelemeli bir CTE kullandığı ve bir tablo döndürdüğü bir sayı dizesi döndürür. Tabii ki bunlar asla rekabetçi olmayacak, bu yüzden golf oynamak için çok fazla zaman harcamadım.

Satır İçi Tablo Değerli İşlev, 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

Aşağıdaki gibi adlandırılır

SELECT * FROM dbo.F(5)

SQLFiddle örneği

Skaler Fonksiyon, 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

Aşağıdaki gibi adlandırılır

SELECT dbo.G(5)

SQLFiddle örneği

Mathematica, 34 * 0.5 = 17

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

perl, 26 bayt

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

JavaScript (okunabilir), 131 bayt

Code Golf'te yeniyim, bu yüzden bu en iyisi değil

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 (daha az okunabilir), 87 bayt

Jscompress.com kullanılarak küçültülmüş

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 bayt * 0.5 = 12.5

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

Yukarıdakiler, bonus olmayan sürümü 13 baytta zorlukla yenmektedir:

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

C #, 114 99 * 0.5 = 49.5 bayt

(VisualMelon'un cevabından biraz yardım alarak) Edit: ve James Webster'ın yorumu

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

Utanmazca feersum'un C cevabından aldığım güvensiz bir sürüm var, ancak yöntemi çağırmadan önce belleği ayırmanız gerektiğinden, kurallara uyduğundan% 100 emin değilim.

C # (güvenli değil), 82 * 0,5 = 41 bayt

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

Aşağıdaki gibi adlandırılır:

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 }

VisualMelon'un önerisine göre (teşekkürler!), Güvensiz kod, boyutu daha da azaltan güvenli kod ile yeniden yapılabilir! Son sonuç dizisinin oluşturulmasının yöntemin dışında yapılmasına izin verilip verilmediğini hala soruyor.

C #, 72 * 0.5 = 36 bayt

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

Sıra, ifade ve xargs ile bas = 59/2 = 29.5

Kaydedin ve ilk argüman olarak numara ile çalıştırın.

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

C #, 116115 + 33 = 148 bayt

En kısa kod değil, ama ... yine de çalışıyor: 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();}

Dosyanın üstünde bunu gerektirir (33 bayt):

using System.Collections.Generic;

Golfsiz sürüm:

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)

Düzenle kaldır; thx @Optimizer

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

FireFox / FireBug konsolunda test

Q(9)

Çıktı

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

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

Bundan oldukça memnunum ... Orijinalimin dörtte biri kadar.

f(4) İadeler:

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

Eski cevap:

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

Bu benim kod golf attığım ilk atışım ... Hala 0.5x bonus almak istiyorum. Herhangi bir öneri bekliyoruz!

F (n) ile çağrılır.

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

Zor işi yaptığı için VisualMelon'a teşekkürler! Mümkün olduğunca sıkıştırmaya çalışacağımı düşündüm.

(114 bayt * 0,5 = 57, int [] döndürmek için .ToArray () yöntemini kullanmakta ısrar ederseniz)