465 배열

24

여기 도전이 있습니다. 범위 내의 모든 정수를 출력하는 코드를 작성하십시오. 쉬운 것처럼 들리지만 여기 까다로운 부분이 있습니다. 가장 낮은 숫자부터 시작하여 가장 높은 숫자로 시작합니다. 그런 다음 아직 배열에없는 가장 낮은 숫자입니다. 그런 다음 아직 포함되지 않은 가장 높은 값입니다.

예:

시작으로 1에서 5까지를 가져갑니다

숫자는 [1, 2, 3, 4, 5]입니다.

우리는 첫 번째를 취합니다 [1]. 나머지 숫자는 [2, 3, 4, 5]입니다. 마지막으로 새로운 배열은 [1, 5]입니다. 나머지 숫자는 [2, 3, 4]입니다. 먼저 새로운 배열은 [1, 5, 2]입니다. 나머지 숫자는 [3, 4]입니다. 마지막으로 새로운 배열은 [1, 5, 2, 4]입니다. 나머지 숫자는 [3]입니다. 먼저 새로운 배열은 [1, 5, 2, 4, 3]입니다. 남은 숫자가 없습니다. 끝났습니다. 출력 [1, 5, 2, 4, 3]

규칙 :

  • 이것은 코드 골프입니다. 모든 언어에서 가장 적은 바이트로 작성하십시오.
  • 표준 허점이 없습니다.
  • 온라인 통역사와 연결 하시겠습니까? (예 : https://tio.run/ )
  • 두 개의 입력, 모두 정수 범위의 하한 및 범위의 상한
  • 출력의 데이터 유형이 무엇인지 상관하지 않지만 올바른 순서로 숫자를 표시해야합니다.

예

낮음 : 4 높음 : 6 결과 : 4 6 5

낮음 : 1 높음 : 5 결과 : 15 5 3

낮음 : -1 높음 : 1 결과 : -110

낮음 : -1 높음 : 2 결과 : -110 2

낮음 : -50 높음 : 50 결과 : -50 50-49 49-48 48-47 47-46 46-45 45-44 44-43 43-42 42-41 41-40 40-39 39-38 38-37 37-36 36-35 35-34 34-33 33-32 32-31 31-30 30-29 29-28 28-27 27-26 26-25 25-24 24-23 23-22 22-21 21- 20 20-19 19-18 18-17 17-16 16-15 15-14 14-14 13-12 12-11 11-11 10 10-9 9-8 8-7 7-6 6-5 5-4 4 4 -3 3 -2 -1 10

행복한 골프!

code-golf 
— 패러데이
소스
2
거의 복제 (이것은 병합하기 전에 후반을 되돌려 야한다는 차이점입니다).
— 피터 테일러
입력이 항상 로우 엔드, 하이 엔드 순서로되어 있습니까?
— Sumner
1
@ Sumner18 예. 여기의 커뮤니티는 입력 유효성 검사와 맞지 않아 역순 입력을 요구하지 않았으므로 항상 낮을 것으로 가정 할 수 있습니다.
— AJFaraday
1
@ Sumner18 이러한 문제가 일반적으로 발생하는 방식은 유효하지 않은 입력이 처리되는 방식을 신경 쓰지 않는 것입니다. 코드는 유효한 입력을 처리하는 방법에 의해서만 성공한 것으로 판단됩니다 (즉, 둘 다 정수, 첫 번째는 두 번째보다 낮음)
— AJFaraday
1
@AJFaraday : 당신은 (! 즉, X = Y)이, 내가이 댓글을 놓친 항상 엄격 Y보다 낮은 것이다 X를 나타내는 주요 포스트에 메모를 추가해야합니다)
— digEmAll

답변:

15

R , 38 37 36 바이트

function(a,b)rbind(a:b,b:a)[a:b-a+1]

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

  • @ user2390246 덕분에 -1 바이트
  • @Kirill L 덕분에 -1 바이트

R이 행렬을 열 단위로 저장한다는 사실을 악용

— digEmAll
소스
사용하는 rbind것이 내 접근법보다 훨씬 낫지 만 [seq(a:b)]대신을 사용하여 1 바이트를 절약 할 수 있습니다 unique.
— user2390246
맞습니다, 저는 a <b (never equal)라고 지정된 의견을 놓쳤습니다.seq(a:b)
— digEmAll
@digEmAll 내 솔루션은 본질적으로 퍼즐에 대한 문자 그대로의 해석이었습니다. 인상적입니다.
— Sumner
1
— Kirill L.
8

R , 65 64 61 60 바이트

Robert S 덕분에 -1 바이트

digEmAll 덕분에 -4 더 

x=scan();z=x:x[2];while(sum(z|1)){cat(z[1],"");z=rev(z[-1])}

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

— 섬너 18
소스
당신은 대체 할 수 length(z)와 함께 sum(z|1):)에 저장 1 바이트
— 로버트 S.
나는 그것이 어떻게 작동하는지 이해하지 못하지만 그렇게 생각합니다. sum (z | 1)은 항상 1 이상으로 평가되는 것처럼 보이므로 while 루프가 끝없이 반복됩니다. 하지만 분명히 아닙니다
— Sumner18
4
z는 벡터입니다. 해당 벡터의 각 요소는 |1로 표시됩니다. 항상 1과 같습니다. 합계를 취하면 TRUEs로 채워진 벡터가 있으므로 결과는 벡터의 길이와 같습니다. 벡터가 비어 있으면 아무것도 아닙니다 . |따라서 출력 벡터는 logical(0)입니다. 이 합계를 가져 오면
— OganM
5

PowerShell , 59 48 바이트

param($a,$b)(($z=0..($b-$a))|%{$a+$_;$b-$_})[$z]

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

(길게 보인다 ...)

입력을 받아 $a하고 $b, 범위를 구성 0 .. ($b-$a)으로 그 점포를 $z, 그 범위에 걸쳐 루프. 그 범위를 반복하는 것은 우리가 충분한 반복을 얻도록 카운터로 사용됩니다. 반복 할 때마다, 우리는 넣어 $a및 $b추가 / 뺄셈과 파이프 라인에. 그것은 우리에게 원래 배열의 최대 (즉, 카운트) 까지 1,5,2,4,3,3,4,2,5,1슬라이스해야 하므로 우리는 적절한 요소 만 남습니다. 그것은 파이프 라인에 남아 있으며 출력은 암시 적입니다.0$b-$a

mazzy 덕분에 -11 바이트

— AdmBorkBork
소스
— mazzy
@mazzy 아, 나는 그 $b-$a트릭을 좋아한다 -그것은 영리하다!
— AdmBorkBork
5

05AB1E , 6 바이트

ŸDvć,R

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

설명

Ÿ        # push range [min ... max]
 D       # duplicate
  v      # for each element in the copy
   ć,    # extract and print the head of the original list
     R   # and then reverse it
— 에미 냐
소스
인터리브를 사용하는 비 반복적 Ÿ2ä`R.ι. 그러나 이것은 훨씬 낫습니다.
— 매직 문어 항아리
1
@MagicOctopusUrn : 반복적이지 않은 솔루션을 먼저 시도했지만 알지 못했기 때문에 더 나빴습니다 .ι.)
— Emigna
내가 생각했던 것과 비슷하게, 나에게서 명백한 +1. 나는 @MagicOctopusUrn을 통해 당신의 대안 7 바이 터를 좋아합니다. :)
— Kevin Cruijssen
1
@ KristianWilliams : 나를 위해 일하는 것 같습니다 .
— Emigna
1
@KevinCruijssen : 어쨌든보다 직관적 인 느낌으로 대신 페어로 전환했습니다. :)
— Emigna
4

R , 51 바이트

function(x,y,z=x:y)matrix(c(z,rev(z)),2,,T)[seq(z)]

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

설명 : x:y길이 시퀀스 의 N경우 맨 위 행의 시퀀스 x : y와 맨 아래 행의 y : x로 구성된 2xN 행렬을 작성하십시오 matrix(c(z,rev(z)),2,,T). N행렬 의 첫 번째 요소를 선택하면 [seq(z)]열별로 선택되어 필요한 출력을 제공합니다.

digEmAll에 의해 아웃 고프

— 사용자
소스
1
난 그냥 30초하기 전에 매우 유사한 접근 방식을 게시 : D
— digEmAll
@digEmAll 네,하지만 당신은 훨씬 좋습니다!
— user2390246
4

cQuents , 19 바이트

#|B-A+1&A+k-1,B-k+1

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

TIO 인터프리터가 최신 상태가 아니기 때문에 현재 TIO에서는 작동하지 않습니다.

설명

#|B-A+1&A+k-1,B-k+1
                      A is the first input, B is the second input
#|B-A+1               n = B - A + 1
       &              Print the first n terms of the sequence
                      k starts at 1 and increments whenever we return to the first term
        A+k-1,         Terms alternate between A + k - 1 and
              B-k+1     B - k + 1
                       increment k
— 스티븐
소스
4

JVM 바이트 코드 (OpenJDK asmtools JASM), 449 바이트

enum b{const #1=Method java/io/PrintStream.print:(I)V;static Method a:(II)V stack 2 locals 4{getstatic java/lang/System.out:"Ljava/io/PrintStream;";astore 3;ldc 0;istore 2;l:iload 2;ldc 1;if_icmpeq t;aload 3;iload 0;invokevirtual #1;iinc 0,1;iinc 2,1;goto c;t:aload 3;iload 1;invokevirtual #1;iinc 1,-1;iinc 2,-1;c:aload 3;ldc 32;i2c;invokevirtual java/io/PrintStream.print:(C)V;iload 0;iload 1;if_icmpne l;aload 3;iload 0;invokevirtual #1;return;}}

언 골프 (약간 더 깨끗함)

 enum b {    
    public static Method "a":(II)V stack 5 locals 4 {
        getstatic "java/lang/System"."out":"Ljava/io/PrintStream;";
        astore 3;
        ldc 0;
        istore 2;
    loop:
        iload 2;
        ldc 1;
        if_icmpeq true;
    false:
        aload 3;
        iload 0;
        invokevirtual "java/io/PrintStream"."print":"(I)V";
        iinc 0,1;
        iinc 2,1;
        goto cond;
    true:
        aload 3;
        iload 1;
        invokevirtual "java/io/PrintStream"."print":"(I)V";
        iinc 1,-1;
        iinc 2,-1;
        goto cond;
    cond:
        iload 0;
        iload 1;
        if_icmpne loop;
        aload 3;
        iload 0;
        invokevirtual "java/io/PrintStream"."print":"(I)V";
        return;
    }
}

독립형 함수는 Java에서로 호출해야합니다 b.a(num1,num2).

설명

이 코드는 메소드 매개 변수를 변수로 사용하고 출력 할 숫자를 결정하는 로컬 # 3의 부울을 사용합니다. 왼쪽 또는 오른쪽의 각 루프 반복이 출력되고 해당 숫자는 왼쪽에 대해 증가하거나 오른쪽에 대해 감소합니다. 두 숫자가 같을 때까지 루프가 계속되고 그 숫자가 출력됩니다.

... 나는 바이트 수에서 엄청나게 뚜렷한 느낌을 가지고 있습니다.

— 고양이 새끼
소스
4

Wolfram Language (Mathematica) , 56 54 바이트

이것은 나의 첫 번째 골프입니다!

f[a_,b_]:=(c=a~Range~b;Drop[c~Riffle~Reverse@c,a-b-1])

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

접두사 표기법을 사용하여 2 바이트를 저장했습니다.

설명:

f[a_,b_]:=                                   \function of two variables
c=a~Range~b;                                 \list of integers from a to b 
                           Reverse@c         \same list in reverse
                  c~Riffle~Reverse@c         \interleave the two lists
             Drop[c~Riffle~Reverse@c,a-b-1]  \drop last |a-b-1| elements (note a-b-1 < 0)

또는 Take[...,b-a+1]동일한 결과에 사용할 수 있습니다.

테스트 :

f[4, 6]
f[1, 5]
f[-1, 1]
f[-1, 2]

출력 :

{4, 6, 5}
{1, 5, 2, 4, 3}
{-1, 1, 0}
{-1, 2, 0, 1}
— 카이
소스
"온라인으로 시도"링크는 403을 반환합니다. "죄송합니다.이 항목에 액세스 할 수있는 권한이 없습니다."
— Rohit Namjoshi
@RohitNamjoshi 링크를 업데이트했습니다
— Kai
TIO에서는 실제 코드 상자 위와 아래의 텍스트 상자에 머리글과 바닥 글 코드를 배치 할 수 있습니다. 이렇게하면 코드가 더 깔끔해 보이고 PPCG 응답 포맷터 (esc-sg)를 활용할 수 있습니다. 온라인으로 사용해보십시오!
— 조왕
@ JoKing 감사합니다, 나는 전에 그것을 사용한 적이 없다!
— 카이
3

4 번째 (2 번째) , 52 바이트

: f 2dup - 1+ 0 do dup . i 2 mod 2* 1- - swap loop ;

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

설명

0에서 (끝-시작)으로 반복합니다. 스택 위에 끝과 시작을 놓습니다.

각 반복 :

  • 현재 번호를 출력
  • 현재 숫자에서 1을 더하거나 빼기
  • 현재 번호를 다른 번호로 전환

코드 설명

: f           \ start new word definition
  2dup -      \ get the size of the range (total number of integers)
  1+ 0        \ add 1 to the size because forth loops are [Inclusive, Exclusive) 
  do          \ start counted loop from 0 to size+1
    dup .     \ output the current top of the stack
    i 2 mod   \ get the index of the loop modulus 2
    2* 1-     \ convert from 0,1 to -1,1
    -         \ subtract result from top of stack (adds 1 to lower bound and subtracts 1 from upper)
    swap      \ swap the top two stack numbers 
  loop        \ end the counted loop
;             \ end the word definition
— 반박
소스
3

하스켈, 30 바이트

l%h=l:take(h-l)(h:(l+1)%(h-1))

사용법 : 3%7`[3,7,4,6,5]

입력의 l, h경우 함수는 입력과 함께 재귀 적으로 호출 하고 시작에 l+1, h-1추가 l,h합니다. 코드는 정지 조건 대신 take(h-l)시퀀스를 올바른 길이 (단, 숫자가 증가하거나 감소하는 무한 시퀀스)로 단축하는 데 사용 됩니다.

— 자랑스런 Haskeller
소스
3

Brachylog , 15 바이트

⟦₂{∅|b↔↰T&hg,T}

입력은 2 요소 목록입니다 [lo, hi]. 밑줄은 음수에 사용됩니다. 온라인으로 사용해보십시오!

설명

⟦₂               2-argument inclusive range: [1,5] -> [1,2,3,4,5]
  {           }  Call this recursive predicate to calculate the output:
   ∅               Base case: the input is empty list; nothing to do
    |              Otherwise (recursive case):      [1,2,3,4,5]
     b             Behead the input list            [2,3,4,5]
      ↔            Reverse                          [5,4,3,2]
       ↰           Call the predicate recursively   [5,2,4,3]
        T          Label the result T
         &         Also, with the input list,
          h        Take the head                    1
           g       Wrap it in a list                [1]
            ,T     Append T from earlier            [1,5,2,4,3]
— DLosc
소스
3

MathGolf , 6 바이트

↨_x^─▀

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

설명 (1, 5)

↨        inclusive range from a to b    [1, 2, 3, 4, 5]
 _       duplicate TOS                  [1, 2, 3, 4, 5], [1, 2, 3, 4, 5]
  x      reverse int/array/string       [1, 2, 3, 4, 5], [5, 4, 3, 2, 1]
   ^     zip top two elements on stack  [[1, 5], [2, 4], [3, 3], [4, 2], [5, 1]]
    ─    flatten array                  [1, 5, 2, 4, 3, 3, 4, 2, 5, 1]
     ▀   unique elements of string/list [1, 5, 2, 4, 3]

이것이 작동하는 이유는 출력의 모든 요소가 고유해야하기 때문에 고유 한 요소 연산자가 배열의 후반부를 필터링하여 올바른 출력을 생성하기 때문입니다.

— 맥스
소스
2

Cubix, 16 바이트

;w(.II>sO-?@;)^/

여기 사용해보십시오

Cubified

    ; w
    ( .
I I > s O - ? @
; ) ^ / . . . .
    . .
    . .

설명

기본적으로 이것은 두 경계를 한 번에 한 단계 씩 더 가깝게 움직입니다. 루프를 통해 매번 우리 s는 경계를 O바꾸고, 입력하고, 차이를 취하고 , 부호에 따라 증가 )하거나 감소 (합니다.

2

Pyth, 10 8 바이트

{.iF_B}F

여기 사용해보십시오

설명

{.iF_B}F
      }FQ  Generate the range between the (implicit) inputs.
 .iF_B     Interleave it with its reverse.
{          Deduplicate.
당사 사이트를 사용함과 동시에 당사의 쿠키 정책과 개인정보 보호정책을 읽고 이해하였음을 인정하는 것으로 간주합니다.
Licensed under cc by-sa 3.0 with attribution required.