반복되는 숫자로 배열 만들기


19

도전

이 질문의 과제는 nSTDIN, ARGV 또는 함수 인수를 통해 입력 으로 양의 정수 (0보다 큰 정수 )를 사용하고 STDOUT 또는 함수 반환 값을 통해 배열을 출력하는 명명 된 함수 또는 프로그램을 작성하는 것입니다.

충분히 간단하게 들리나요? 이제 여기 규칙이 있습니다

  • 배열은 1~ 사이의 정수만 포함 합니다n
  • 각 정수 1로는 n반복되어야 xx각각의 정수 값이다.

예를 들면 다음과 같습니다.

입력:

5

산출:

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

배열은 정렬되거나 정렬되지 않을 수 있습니다.

이것은 이므로 우승자는 바이트 단위의 가장 짧은 코드입니다.

보너스

0.5출력 배열에서 인접한 두 정수가 동일하지 않으면 점수에 곱하십시오 .

예를 들어 n = 5, 이러한 구성 중 하나는

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

답변:


6

APL, 4 자

/⍨⍳⎕

작동 방식 :

사용자 입력을 읽습니다. 출력과 관련하여 APL은 기본적으로 모든 줄의 결과를 인쇄합니다.

⍳n1에서 1 사이의 정수입니다 n. 예:⍳3←→ 1 2 3

/replicate를 의미 합니다 . 오른쪽 인수의 각 요소는 왼쪽 인수의 해당 요소에 지정된 횟수만큼 반복됩니다. 예:2 0 3/'ABC'←→ 'AACCC'

는 IS 통근 연산자 . 함수의 오른쪽에서 발생하면 해당 동작을 수정하므로 인수를 교환하거나 ( A f⍨ B ←→ B f A"통근") 양쪽에서 동일한 인수를 제공합니다 ( f⍨ A ←→ A f A"selfie"). 후자의 형태가이 솔루션에 사용됩니다.


보너스:

6-∊⌽⍳¨⍳⎕(8 자, @ phil-h 감사합니다 )

⍳5(iota five)는 1 2 3 4 5입니다.

⍳¨ ⍳5(각각 iota 5)는 (,1)(1 2)(1 2 3)(1 2 3 4)(1 2 3 4 5)벡터로 구성된 벡터입니다. ( ¨)은 연산자이며 왼쪽에서 기능을 수행하여 오른쪽의 배열에서 각 항목에 적용합니다.

배열을 반대로하여을 얻습니다 (1 2 3 4 5)(1 2 3 4)(1 2 3)(1 2)(,1).

이다 입대 (일명 평평 ). 재귀 적으로 인수를 순회하고 간단한 스칼라를 벡터로 반환합니다.


4 자식은 어떻습니까? /⍨⍳n
ngn

당신이 원하는대로, 선생님, 나는 텍스트를 업데이트했습니다. 그러나 분명히 당신의 반대는 기능에 싸여 있지 않은 다른 솔루션에 적용되어야합니까?
ngn

3
Dyalog APL은 "Classic"과 "Unicode"의 두 가지 맛이 있습니다. Classic 버전은 유니 코드 표준이 나타나기 전부터 수십 년 동안 존재 해 왔으며 APL 문자 집합에 문자 별 사용자 지정 바이트 인코딩을 사용합니다. 사용을 권장하지는 않지만 여전히 지원됩니다. 저는 이것을 변명으로 사용하고 싶습니다. 더 넓게, 골프에서 우리는 바이트가 아닌 문자를 세어야한다고 생각합니다. 유니 코드에서 가장 낮은 코드 포인트가 영어 중심 ASCII가 차지한다는 사실은 오늘날 중요하지 않은 역사적 사고입니다. 흥미롭게도 APL은 ASCII가 나오기 전에 고안되었습니다.
ngn

3
@ngn counts chars는 대답이 일반적으로 알파벳 수프 디코드가되기 때문에 좋은 생각이 아닙니다 . 인코딩이 존재하기 때문에 APL 문자는 바이트로 계산됩니다. 이것은이 사이트에서 잘 확립되어 있습니다. 이것은 질문하기 전에 존재했던 모든 바이트 인코딩에서 작동합니다.
FryAmTheEggman

1
@ngn : 보너스 답변을 설명해 주시겠습니까? 5 4 3 2 1 5 4 3 2 5 4 3 5 4 5 또는 6에서 각각 1 2 3 4 5 1 2 3 4 1 2 3 1 2 1을 뺀 값을 통해 수행 할 수 있기 때문에 멀지 않은 느낌 초기 답변에서.
Phil H

11

루비 (재귀), 41 바이트 * 0.5 = 20.5

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

또는 람다 사용 (히스 토크 라트 및 Ventero에서 권장) : 34 바이트 * 0.5 = 17

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

(를 사용하여 전화 r[argument])


2
정말 멋진 솔루션입니다. 메소드 ( n=->x,i=1{...n[x,i+1]...) 대신 람다로하고 일부를 사용하여 바이트를 절약 할 수 있습니다 [*i..n].
histocrat

1
논리를 r=->n,i=n{i>0?[*i..n]+r[n,i-1]:[]}
뒤집


8

하스켈, 31 자 = 15.5 점

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

보너스없이 27 자

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

Proud Haskeller에 의해 구타


첫 번째 해결책이 올바르지 않습니다. 가능한 수정 사항은 다음과 같습니다g n = [y|x<-[n,n-1..1],y<-[x..n]]
karakfa

@karakfa 죄송합니다 : - 수정을위한 / 감사
존 드보락

내 Haskell의 답변은 당신보다 약간 낮습니다
자랑스런 Haskeller

솔루션을 홍보하기 위해 솔루션에서 연결해야합니까?
존 드보락

@JanDvorak 실제로, 싶습니다 ...
자랑스러운 haskeller

7

C, 22 = 44 바이트 * 0.5

이 함수 h는 두 가지 매개 변수를 사용합니다. 첫 번째는 n을int 지정하는 것 입니다. 두 번째는 출력 버퍼입니다.int*

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

테스트 프로그램

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

나는 그것을 얻지 못한다. 설명 해주십시오?
bacchusbeale

@bacchusbeale Ok. n부터 0까지 내림차순 시퀀스를 재귀 적으로 씁니다. 더 짧은 시퀀스는 더 깊은 재귀 수준에서 더 빨리 기록됩니다. 인수 n이 0이면 n이 거짓이므로 재귀가없고 배열의 끝을 표시하는 0 만 작성됩니다.
feersum

7

Pyth - 15 10 * .5 = 5

smr-QdhQUQ

온라인으로 사용해보십시오.

stdin에 대한 입력을 예상합니다. 독립적으로 발견 된 알고리즘. 거기에 마지막 Q를 넣는 데 도움을 주신 @ Sp3000에게 감사드립니다 : P 또한, 아이러니? XD

설명:

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

2
좋은 해결책. Pyth 코드 골프 를 얻지 못하는 상황이 있습니까? :)
Alex A.

2
@ 알렉스는, 기반 골프 언어 (Golfscript, CJam) 캔 크림을, 그 수 또한 잃게 라이브러리 물건 (에 스택 문제의 특성에 따라 기침 bash는 기침 ))
FryAmTheEggman


6

파이썬 2, 53 바이트 * 0.5 = 26.5

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

@VisualMelon의 아이디어를 뻔뻔스럽게 빌렸다


6

하스켈, 34 바이트 * 0.5 = 17

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

하스켈을 처음으로 골프에 사용한 것은 이번이 처음입니다. 로 전화하십시오 g <number>.



5

GolfScript (14 바이트 * 0.5 = 점수 7)

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

온라인 데모

나는 이것이 아마도 배열을 구축한다는 점에서 기존의 대답과 비슷하다고 생각합니다. concat( [n], [n-1, n], [n-2, n-1, n], ..., [1, 2, ..., n] )

슬프게도 더 이상 더 우아하게 골프를 칠 수 없었습니다.

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

입력 x을 배열에 넣은 다음 두 번 적용 {,{x\-}/}%하여 배열의 각 요소를에서 여러 요소의 카운트 다운에 매핑합니다 x.


5

C #-81 (161 바이트 * 0.5)

C #의 간단한 직업으로 희망없는 수의 보너스를 얻습니다. stdin에서 int를 읽고 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+"]");}}

더 읽기 쉬운 :

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

출력 예 :

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

나는 더 짧은 C # 솔루션을 찾으려고 노력하고 있지만 그것을 얻을 수없는 것 같습니다 ... 잘 끝났습니다
Brandon

1
@ MarkKnol System.Console은 정적이므로 변수에 할당 할 수 없지만 C # 6 또는 그 다음에있는 모든 것에서 는 이 기능에 대해 어떻게 생각하는지 확실하지 않을 수 있습니다 using System.Console;( using System;이 경우 지불하지 않음). 이 이유로 정확하게 많은 오래된 골프 질문에 영향을 미칩니다;)
VisualMelon

1
@IchabodClay 그것은 더 나 빠지고 using C=System.Console3 바이트를 절약하며 아마도 @MarkKnol이 의미하는 것 (죄송합니다!), 부끄러운 태만입니다.
VisualMelon

1
또한 규칙에 따라 완전한 프로그램을 작성하는 대신 메소드 자체를 가질 수 있습니다. 뭔가 ... 이것 . (공백이있는 114 바이트 및 이와 같은 제거. 보너스가있는 57 바이트)
Ichabod Clay

1
실제로 @IchabodClay; 나는 완전한 프로그램을 함수에 제출하는 것을 선호한다. 정당한 이유는 없다. IO는 단지 재미의 일부처럼 보인다 (argv도 사용하지 않는 경향이있다). 이러한 멍청한 제약없이 더 나은 점수를 매기는 답변을 자유롭게 게시하십시오!
VisualMelon

4

자바 스크립트, ES6, 41 바이트

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

이렇게하면 f호출 할 수 있는 함수 가 만들어 f(6)지고 필요한 배열이 반환됩니다.

이것은 재귀 적 접근 방식을 사용하는데, 여기서 각 반복은 i모든 값을 갖는 요소 의 배열을 만들고 중지 조건이 i로 반환 된 배열을 연결합니다 .f(i-1)i==0

최신 Firefox에서 작동합니다.


4

하스켈, 14 = 28 바이트 / 2

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

출력 예 :

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

보너스없이 24 바이트 :

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

=<<공백을 피할 수 있습니까? 나는 그것이 가능하다고 생각하지만, 당신이 그것을 아직 고려하지 않았다면 놀랄 것입니다.
John Dvorak

@JanDvorak 내가 사용 =<<했으면 람다에 대한 괄호가 필요하다
자랑스런 Haskeller

정확히 람다에 괄호가 필요할 때 혼란 스럽습니다. 람다 헤더는 고정 도와 동일 >>=합니까?
John Dvorak

@ JanDvorak 그들은 고정이 없습니다; 나는 얼마나 정확이 규칙은 모르겠지만, 사업자 (섹션을 무시) 할 수없는 경우 람다에만 나타날 수 있습니다 후 (, [, =, ,, 어떤 사업자 등 후
자랑 haskeller

I guess neither lambdas nor operators can appear as patterns? let \x->y = (2+) in (x,y) seems kinda impossible.
John Dvorak


3

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

you can lose 1 (0.5, technically) byte(s) by condensing For Z=1 To to For Z=1To
Taylor Scott

you can also condense Next:Next to Next x,Z
Taylor Scott

2

R, 44 *.5 = 22

f=function(n){r=0;for(i in 1:n)r=c(r,n:i);r}

A quick 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

What ? No TSQL ?
Optimizer

@Optimizer maybe later:)
MickyT

2

JavaScript, ES6, 66 bytes * 0.5 = 33

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

Building on Optimizer's recursive approach, we can build descending runs of decreasing length, like [4,3,2,1, 4,3,2, 4,3, 4].

Instead of making same-value subarrays with Array(i).fill(i), we make undefined-filled subarrays of the appropriate length with Array(n).fill() and then change the values to a descending run using .map((v,x)=>i-x). Also, we define and recurse over an inner function g; the outer function f exists only to store the value of i while g recurses.


2

T-SQL, 176 * 0.5 = 88

Since you seemed to miss the T-SQL @Optimizer, here it is in all it's verbose glory :).

A couple of function options, a Scalar and a Inline Table Valued function. The Scalar function uses while loops to recurse and returns a string of numbers, where the Inline Table Valued function uses a recursive CTE for a sequence and returns a table. Of course these will never be competitive, so I haven't spent a lot of time golfing.

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

Called as follows

SELECT * FROM dbo.F(5)

SQLFiddle example

Scalar Function, 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

Called as follows

SELECT dbo.G(5)

SQLFiddle example



2

perl ,26 bytes

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

1
Please post your score. Also, since this is code golf, you can save bytes by removing the extra spaces and the definition of $n.
Alex A.

This doesn't run for me under Perl 6.
Alex A.

@Alex , what is the error , works under 5.10
michael501

Unable to parse postcircumfix:sym<{ }>, couldn't find final '}' at line 3. Tried it on ideone.com.
Alex A.

@Alex , try this : C:\Windows\system32>perl -e "$n=5;for(1..$n){print qq($_ )x$_;};" 1 2 2 3 3 3 4 4 4 4 5 5 5 5 5
michael501

2

JavaScript(readable), 131 bytes

I'm new to Code Golf so this isn't the best

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(less readable), 87 bytes

Minified using 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}

2

TECO, 25 bytes * 0.5 = 12.5

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

The above barely beats the non-bonus version at 13 bytes:

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

2

C#, 114 99 * 0.5 = 49.5 bytes

(With a little help from VisualMelon's answer) Edit: and James Webster's comment

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

There is an unsafe version that I shamelessly took from feersum's C answer, but I'm not 100% sure it fits within the rules since you have to allocate the memory before calling the method.

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

Called as follows:

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 }

Per VisualMelon's suggestion (thanks!), the unsafe code can be re-made with safe code which reduces the size even further! Still poses the question if the creation of the final result array is allowed to be done outside of the method.

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

Nice work! For the per-allocated version, it's much cheaper to go safe and pass it the int[] straight off void A(int n,int[]p){int z=0,m=n,i;while(m-->0)for(i=m;i++<n;)p[z++]=i;} - I would agree it's probably a bit iffy, regarding the rules ;)
VisualMelon

You shouldn't need to create a local pointer for the unsafe version, which cuts a good 8bytes out. Also, I might be missing the point, but should the last line of the unsafe calling code be System.Runtime.InteropServices.Marshal.Copy(new IntPtr(stuff), stuffArray, 0, length); ?
VisualMelon

@VisualMelon That's what I get for not rechecking the names of variables after I rename them. Thanks for the heads up :D. Edited the answer to account for the shorter version in your comment.
Ichabod Clay

You can chop a little off the safe version by inlining the length var a=new int[(int)((n/2f)*(n+1))]; I think that takes it down to 109
James Webster

One more off by rewriting the calc as: (n*(n+1)/2)
James Webster


1

C#, 116 115 + 33 = 148 bytes

Not the shortest code, but... it works anyway :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();}

Requires this at the top of the file (33 bytes):

using System.Collections.Generic;

Un-golfed version:

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

1

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

1
23 * 0.5 is 11.5, not 10.5.
ProgramFOX

@ProgramFOX good catch. Are you going to edit, or should I? Not a great reason to downvote IMO.
John Dvorak

@JanDvorak Just edited it. And I didn't downvote, I upvoted it even before I saw the mistake.
ProgramFOX

Now that the mistake has been fixed, should the bonus solution be moved to the bottom?
John Dvorak

-1 Byte: f=.-[:;<@|.@i."0@>:@i., making the scores equal!
Bolce Bussiere

1

JavaScript (ES6) 29 (58 * 0.5)

Edit remove ; thx @Optimizer

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

Test in FireFox/FireBug console

Q(9)

Output

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

1

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}

Pretty happy with this one...It's about a quarter the size of my original.

f(4) returns:

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

Old answer:

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


You must be pretty new to JavaScript it self :) . (1) Remove brackets around argument d, (2) a=b=c=[] in for declaration part, (3) c[a].map(e=>a) (4) b.push(...c)
Optimizer

I made a shorter version before reading your comment, which I'll put in my post. My experience with JS is mostly limited to DOM/style manipulation for simple web apps...and I've hardly used any of the new ES6 features until today.
binormal

1

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

당사 사이트를 사용함과 동시에 당사의 쿠키 정책개인정보 보호정책을 읽고 이해하였음을 인정하는 것으로 간주합니다.
Licensed under cc by-sa 3.0 with attribution required.