Đây là thử thách. Viết một số mã để xuất tất cả các số nguyên trong một phạm vi. Nghe có vẻ dễ, nhưng đây là phần khó khăn. Nó sẽ bắt đầu với số thấp nhất, sau đó cao nhất. Sau đó, số thấp nhất chưa có trong mảng. Sau đó, mức cao nhất chưa có trong đó.

Thí dụ:

Hãy bắt đầu từ 1 đến 5

Các số là [1, 2, 3, 4, 5].

Chúng tôi lấy đầu tiên, vì vậy [1]. Các số còn lại là [2, 3, 4, 5]. Chúng tôi lấy mảng cuối cùng, mới là [1, 5]. Các số còn lại là [2, 3, 4]. Chúng tôi lấy mảng đầu tiên, mới là [1, 5, 2]. Các số còn lại là [3, 4]. Chúng tôi lấy mảng cuối cùng, mới là [1, 5, 2, 4]. Số còn lại là [3]. Chúng tôi lấy mảng đầu tiên, mới là [1, 5, 2, 4, 3]. Không còn số nào, chúng tôi đã hoàn thành. Đầu ra [1, 5, 2, 4, 3]

Quy tắc:

• Đây là mã golf, viết nó bằng ít byte nhất, bất kỳ ngôn ngữ nào.
• Không có sơ hở tiêu chuẩn.
• Liên kết đến một thông dịch viên trực tuyến, xin vui lòng? (Ví dụ: https://tio.run/ )
• Hai đầu vào, cả hai số nguyên. Kết thúc thấp của phạm vi, và cao cấp của phạm vi.
• Tôi không quan tâm kiểu dữ liệu của đầu ra là gì, nhưng nó phải hiển thị các số theo đúng thứ tự.

Ví dụ

Thấp: 4 Cao: 6 Kết quả: 4 6 5

Thấp: 1 Cao: 5 Kết quả: 1 5 2 4 3

Thấp: -1 Cao: 1 Kết quả: -1 1 0

Thấp: -1 cao: 2 Kết quả: -1 2 0 1

Thấp: -50 Cao: 50 Kết quả: -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 -13 13 -12 12 -11 11 -10 10 -9 9 -8 8 -7 7 -6 6 -5 5 -4 4 -3 3 -2 2 -1 1 0

Chúc bạn chơi golf vui vẻ!

R , 38 37 36 byte

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

Hãy thử trực tuyến!

• -1 byte nhờ @ user2390246
• -1 byte nhờ @Kirill L

Khai thác thực tế rằng R lưu trữ ma trận cột khôn ngoan

Haskell , 30 byte

a%b=a:take(b-a)(b:(a+1)%(b-1))

Hãy thử trực tuyến!

R , 65 64 61 60 byte

-1 byte nhờ Robert S.

-4 thêm nhờ vào digEmAll

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

Hãy thử trực tuyến!

Haskell , 39 byte

a#b|a>b=a:b#(a-1)|a<b=a:b#(a+1)|1>0=[a]

Hãy thử trực tuyến!

Python 2 , 44 byte

f=lambda a,b:[a]*(a==b)or[a]+f(b,a-cmp(a,b))

Hãy thử trực tuyến!

PowerShell , 59 48 byte

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

Hãy thử trực tuyến!

(Có vẻ dài ...)

Đưa đầu vào $avà $b, xây dựng phạm vi 0 .. ($b-$a), lưu trữ vào $zđó, sau đó lặp qua phạm vi đó. Việc lặp qua phạm vi đó chỉ được sử dụng như một bộ đếm để đảm bảo chúng ta có đủ số lần lặp. Mỗi lần lặp, chúng tôi đặt $avà $btrên đường ống có phép cộng / trừ. Cung cấp cho chúng tôi một cái gì đó như 1,5,2,4,3,3,4,2,5,1vì vậy chúng tôi cần phải lát vào đó từ 0đến$b-$a (ví dụ: số đếm) của mảng ban đầu để chúng ta chỉ còn lại các yếu tố thích hợp. Đó là còn lại trên đường ống và đầu ra là ẩn.

-11 byte nhờ mazzy.

05AB1E , 6 byte

ŸDvć,R

Hãy thử trực tuyến!

Giải trình

Ÿ        # 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

Japt , 14 byte

òV
íUs w)c vUl

Hãy thử trực tuyến!

Stax , 7 byte

É╓ÅìΔà▲

Chạy và gỡ lỗi nó

R , 51 byte

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

Hãy thử trực tuyến!

Giải thích: Đối với một chuỗi x:yđộ dài N, tạo ma trận hai nhân N bao gồm chuỗi x: y ở hàng trên cùng và y: x ở hàng dưới cùng matrix(c(z,rev(z)),2,,T). Nếu chúng ta chọn các Nphần tử đầu tiên của ma trận [seq(z)], chúng sẽ được chọn theo cột, đưa ra đầu ra cần thiết.

Vượt trội bởi digEmAll

cQuents , 19 byte

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

Hãy thử trực tuyến!

Lưu ý rằng nó không hoạt động trên TIO ngay bây giờ vì trình thông dịch của TIO không cập nhật.

Giải trình

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

Haskell, 39 byte

f(a:b)=a:f(reverse b)
f x=x
a#b=f[a..b]

Hãy thử trực tuyến!

C # (Trình biên dịch tương tác Visual C #) , 46 byte

a=>b=>{for(;a<=b;Write(a+(b>a++?b--+"":"")));}

Đã lưu 4 byte nhờ dana!

Hãy thử trực tuyến!

C # (Trình biên dịch tương tác Visual C #) , 65 byte

void z(int a,int b){if(a<=b){Write(a+(b>a?b+"":""));z(a+1,b-1);}}

Hãy thử trực tuyến!

Mã byte JVM (OpenJDK asmtools JASM), 449 byte

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

Ungolfed (và hơi sạch hơn)

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

Hàm độc lập, cần được gọi từ Java như b.a(num1,num2) .

Giải trình

Mã này sử dụng các tham số phương thức làm biến, cũng như boolean ở địa phương # 3 quyết định số nào sẽ xuất. Mỗi vòng lặp lặp lại bên trái hoặc bên phải là đầu ra và số đó được tăng cho bên trái hoặc giảm cho bên phải. Vòng lặp tiếp tục cho đến khi cả hai số bằng nhau, thì số đó là đầu ra.

... Tôi có một cảm giác khác biệt Tôi đang ồ ạt về số lượng byte

Ngôn ngữ Wolfram (Mathicala) , 56 54 byte

Đây là lần đầu tiên tôi chơi golf!

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

Hãy thử trực tuyến!

Đã lưu 2 byte bằng cách sử dụng ký hiệu infix.

Giải trình:

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)

Ngoài ra, chúng ta có thể sử dụng Take[...,b-a+1]cho cùng một kết quả.

Các xét nghiệm:

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

Ouput:

{4, 6, 5}
{1, 5, 2, 4, 3}
{-1, 1, 0}
{-1, 2, 0, 1}

APL (dzaima / APL) , 21 byte

⌈⊢+.5×-+∘(⌽ׯ1*)∘⍳1+-

Hãy thử trực tuyến!

Japt, 7 byte

Đưa đầu vào như một mảng.

rõ
ÊÆÔv

Hãy thử nó hoặc chạy tất cả các trường hợp thử nghiệm

         :Implicit input of array U=[low,high]
r        :Reduce by
 õ       :  Inclusive, reversed range (giving the range [high,low])
\n       :Reassign to U
Ê        :Length
 Æ       :Map the range [0,Ê)
  Ô      :  Reverse U
   v     :  Remove the first element

MATL , 8 byte

&:t"1&)P

Hãy thử trực tuyến!

Giải trình

&:      % Take two inputs (implicit). Two-input range
t       % Duplicate
"       % For each
  1&)   %   Push first element, then an array with the rest
  P     %   Reverse array
        % End (implicit). Display (implicit)

JavaScript, 40 byte

l=>g=h=>h>l?[l++,h--,...g(h)]:h<l?[]:[l]

Dùng thử trực tuyến!

Forth (gforth) , 52 byte

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

Hãy thử trực tuyến!

Giải trình

Lặp lại từ 0 đến (Kết thúc - Bắt đầu). Đặt Kết thúc và Bắt đầu trên đầu ngăn xếp.

Mỗi lần lặp:

• Xuất số hiện tại
• Thêm (hoặc trừ) 1 từ số hiện tại
• Chuyển số hiện tại với số khác

Giải thích mã

: 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

Julia 0,7 , 29 byte

f(a,b)=[a:b b:-1:a]'[1:1+b-a]

Hãy thử trực tuyến!

Haskell, 30 byte

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

Sử dụng: 3%7 cho `[3,7,4,6,5]

Đối với các đầu vào l, h, hàm gọi đệ quy với các đầu vào l+1, h-1và thêm l,hvào việc cầu xin. Thay vì bất kỳ điều kiện tạm dừng nào, mã sử dụng take(h-l)để rút ngắn chuỗi theo đúng độ dài (nếu không sẽ là một chuỗi vô hạn của các số tăng và giảm).

Brachylog , 15 byte

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

Đầu vào là danh sách 2 yếu tố [lo, hi]. Lưu ý rằng dấu gạch dưới được sử dụng cho số âm.Hãy thử trực tuyến!

Giải trình

⟦₂               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]

MathGolf , 6 byte

↨_x^─▀

Hãy thử trực tuyến!

Giải thích với (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]

Lý do tại sao điều này hoạt động là do thực tế là tất cả các phần tử trong đầu ra phải là duy nhất, do đó toán tử phần tử duy nhất sẽ lọc ra nửa sau của mảng, tạo ra đầu ra chính xác.

Perl 5 -ln , 37 byte

@.=$_..<>;say shift@.,$/,pop@.while@.

Hãy thử trực tuyến!

Java (JDK) , 52 byte

(l,h,o)->{for(int i=0;l<=h;i^=1)o.add(i<1?l++:h--);}

Hãy thử trực tuyến!

Sạch , 48 byte

import StdEnv
$a b|a<>b=[a: $b(a+sign(b-a))]=[a]

Hãy thử trực tuyến!

Ruby , 37 36 33 byte

f=->a,b{a>b ?[]:[a,b]|f[a+1,b-1]}

Hãy thử trực tuyến!

Phiên bản đệ quy với 3 byte được lưu bởi G B.

Ruby , 38 byte

->a,b{d=*c=a..b;c.map{d.reverse!.pop}}

Hãy thử trực tuyến!

Phiên bản không đệ quy.

Hình khối, 16 byte

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

Hãy thử nó ở đây

Tạo khối

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

Giải trình

Về cơ bản, điều này di chuyển hai giới hạn gần nhau hơn một bước cho đến khi họ gặp nhau. Mỗi lần qua vòng lặp, chúng tôi swap các giới hạn, Othông số, lấy sự khác biệt và tăng dần theo )hoặc giảm (dựa trên dấu hiệu.

Bình thường, 10 8 byte

{.iF_B}F

Hãy thử nó ở đây

Giải trình

{.iF_B}F
      }FQ  Generate the range between the (implicit) inputs.
 .iF_B     Interleave it with its reverse.
{          Deduplicate.