นี่คือความท้าทาย เขียนโค้ดเพื่อเอาท์พุทจำนวนเต็มทั้งหมดในช่วง ฟังดูง่าย แต่นี่เป็นส่วนที่ยุ่งยาก มันจะเริ่มต้นด้วยจำนวนต่ำสุดจากนั้นสูงที่สุด ดังนั้นจำนวนต่ำสุดที่ยังไม่ได้อยู่ในอาร์เรย์ จากนั้นสูงสุดซึ่งยังไม่ได้อยู่ในนั้น

ตัวอย่าง:

ให้ใช้เวลา 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 ผลลัพธ์: 1 5 2 4 3

ต่ำ: -1 สูง: 1 ผล: -1 1 0

ต่ำ: -1 สูง: 2 ผลลัพธ์: -1 2 0 1

ต่ำ: -50 สูง: 50 ผล: -50 50 -49 49 -48 48 -47 47 -46 46 -45 45 -44 44 -43 43 -42 42 -41 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 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 11 -10 10 -9 9 -8 8 -7 7 -6 6 -5 5 -4 4 4 -3 3 -2 2 -1 1 0 0

มีความสุขในการเล่นกอล์ฟ!

R , 38 37 36 ไบต์

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

ลองออนไลน์!

• -1 ไบต์ต้องขอบคุณ @ user2390246
• -1 ไบต์ขอบคุณ @Kirill L.

การใช้ประโยชน์จากความจริงที่ว่า R เก็บเมทริกซ์คอลัมน์ไว้

Haskellขนาด 30 ไบต์

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

ลองออนไลน์!

R , 65 64 61 60 ไบต์

-1 ไบต์ขอบคุณ Robert S.

-4 ขอบคุณเพิ่มเติม digEmAll

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

ลองออนไลน์!

Haskell , 39 ไบต์

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

ลองออนไลน์!

Python 2 , 44 ไบต์

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

ลองออนไลน์!

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(เช่นการนับ) ของอาร์เรย์เดิมดังนั้นเราจึงเหลือองค์ประกอบที่เหมาะสมเท่านั้น ที่เหลืออยู่บนไปป์ไลน์และเอาท์พุทเป็นนัย

-11 ไบต์ขอบคุณที่มาซี่

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

Japt , 14 ไบต์

òV
íUs w)c vUl

ลองออนไลน์!

Stax , 7 ไบต์

É╓ÅìΔà▲

เรียกใช้และแก้ไขข้อบกพร่อง

R , 51 ไบต์

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

ลองออนไลน์!

คำอธิบาย: สำหรับลำดับx:yของความยาวNสร้างเมทริกซ์สองโดย-N ซึ่งประกอบด้วยลำดับที่ x: Y ในแถวบนสุดและ Y: x matrix(c(z,rev(z)),2,,T)ในแถวด้านล่าง หากเราเลือกNองค์ประกอบแรกของเมทริกซ์[seq(z)]พวกมันจะถูกเลือกโดยคอลัมน์เพื่อให้ได้ผลลัพธ์ที่ต้องการ

โดดเด่นด้วย digEmAll

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

Haskell, 39 ไบต์

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

ลองออนไลน์!

C # (Visual C # Interactive คอมไพเลอร์) , 46 ไบต์

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

บันทึก 4 ไบต์ด้วย dana!

ลองออนไลน์!

C # (Visual C # Interactive Compiler) , 65 ไบต์

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

ลองออนไลน์!

JVM bytecode (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;}}

Ungolfed (และทำความสะอาดเล็กน้อย)

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

b.a(num1,num2)ฟังก์ชั่นแบบสแตนด์อโลนจะต้องมีการเรียกจากชวา

คำอธิบาย

รหัสนี้ใช้พารามิเตอร์วิธีการเป็นตัวแปรเช่นเดียวกับบูลีนในท้องถิ่น # 3 ตัดสินใจว่าจะส่งออกจำนวนใด การวนซ้ำแต่ละรอบไม่ว่าจะทางซ้ายหรือขวาคือเอาท์พุทและจำนวนนั้นจะเพิ่มขึ้นสำหรับด้านซ้ายหรือลดลงสำหรับด้านขวา วนซ้ำจะดำเนินต่อไปจนกว่าทั้งสองหมายเลขจะเท่ากันดังนั้นจึงส่งออกหมายเลขนั้น

... ฉันมีความรู้สึกที่แตกต่างกันฉันอย่างหนาแน่นอาวุธนับไบต์

ภาษา Wolfram (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]

ouput:

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

APL (dzaima / APL)ขนาด 21 ไบต์

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

ลองออนไลน์!

Japtap, 7 ไบต์

รับอินพุตเป็นอาร์เรย์

rõ
ÊÆÔv

ลองใช้หรือเรียกใช้กรณีทดสอบทั้งหมด

         :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 ไบต์

&:t"1&)P

ลองออนไลน์!

คำอธิบาย

&:      % 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 ไบต์

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

ลองออนไลน์!

Forth (gforth) , 52 ไบต์

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

ลองออนไลน์!

คำอธิบาย

วนซ้ำตั้งแต่ 0 ถึง (สิ้นสุด - เริ่ม) วาง End และ Start ที่ด้านบนสุดของสแต็ก

การทำซ้ำแต่ละครั้ง:

• เอาท์พุทจำนวนปัจจุบัน
• เพิ่ม (หรือลบ) 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

Julia 0.7 , 29 ไบต์

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

ลองออนไลน์!

Haskell ขนาด 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)เพื่อย่นลำดับความยาวให้ถูกต้อง (ซึ่งอาจเป็นลำดับที่ไม่มีที่สิ้นสุดของการเพิ่มและลดจำนวน)

Brachylogขนาด 15 ไบต์

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

อินพุตเป็นรายการ 2 องค์ประกอบ [แท้จริงสวัสดี] โปรดทราบว่าขีดเส้นใต้จะใช้สำหรับจำนวนลบ ลองออนไลน์!

คำอธิบาย

⟦₂               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 ไบต์

↨_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]

เหตุผลที่ว่าทำไมงานนี้เป็นเพราะความจริงที่ว่าองค์ประกอบทั้งหมดในการส่งออกควรจะไม่ซ้ำกันดังนั้นผู้ประกอบการองค์ประกอบที่ไม่ซ้ำกันจะกรองครึ่งหลังของอาร์เรย์ที่ผลิตออกที่ถูกต้อง

Perl 5 -ln , 37 ไบต์

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

ลองออนไลน์!

Java (JDK) , 52 ไบต์

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

ลองออนไลน์!

ทำความสะอาด , 48 ไบต์

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

ลองออนไลน์!

Ruby , 37 36 33 ไบต์

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

ลองออนไลน์!

เวอร์ชันแบบเรียกซ้ำพร้อม 3 ไบต์ที่บันทึกโดย G B

Ruby , 38 ไบต์

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

ลองออนไลน์!

รุ่นที่ไม่ใช่แบบเรียกซ้ำ

Cubix, 16 ไบต์

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

ลองที่นี่

Cubified

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

คำอธิบาย

โดยพื้นฐานแล้วสิ่งนี้จะย้ายทั้งสองขอบเขตเข้าหากันทีละก้าวจนกว่าพวกเขาจะพบกัน ทุกครั้งที่ผ่านลูปเราจะsทำการ จำกัด ขอบเขตOใช้งานสร้างความแตกต่างและเพิ่ม)หรือลดระดับโดย(ยึดตามเครื่องหมาย

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.