Mục tiêu : Cho một số nguyên dương n:

• Nếu nlà số lẻ, hãy xuất danh sách các nsố gần nhất 0theo thứ tự tăng dần
• Nếu nlà chẵn, xuất giá trị Falsey.

Các trường hợp thử nghiệm :

5 -> [-2,-1,0,1,2]
4 -> false (or any Falsey value)
1 -> [0]

Thực hiện tham khảo

function update(){
  var num = +document.getElementById("yield").value;
  if(num){
    var out = document.getElementById("output");
    if(num % 2 == 1){
      // base is balanced
      var baseArr = [];
      for(var i=0;i<num;i++){
        baseArr.push(i-Math.floor(num/2));
      }
      out.innerHTML = baseArr.join(" ");
    } else {
      out.innerHTML = "false";
    }
  } else {
    out.innerHTML = "<i>enter input</i>";
  }
}

setInterval(update,1);

* {
  font-family: "Constantia", "Consolas", monospace;
}

[type="number"] {
  width: 10px;
  width: 2em;
}

#output {
  font-family: "Consolas", monospace;
}

Input: <input type="number" id="yield" value="3"> is <span id="output"><i>enter input</i></span>

Bình thường, 10 byte

*-R/Q2Q%Q2

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

Làm thế nào nó hoạt động

            (implicit) Store the input in Q.
   /Q2      Calculate Q/2 (integer division).
 -R   Q     Subtract that value (-R) from each element in [0, ..., Q-1] (Q).
*      %Q2  Repeat the resulting array Q%2 times.

APL, 16 15 13 byte

Cảm ơn @Dennis cho -2 byte!

⌊(⍳⊢×2|⊢)-÷∘2

Đây là một tàu đơn nguyên cung cấp một mảng trống cho đầu vào chẵn. Dưới đây là sơ đồ:

┌────┴─────┐   
⌊ ┌────────┼─┐ 
┌─┴─┐      - ∘ 
⍳ ┌─┼───┐   ┌┴┐
  ⊢ × ┌─┼─┐ ÷ 2
      2 | ⊢    

Đầu tiên, ⊢×2|⊢đưa ra lần đầu vào mod 2 của nó; nghĩa là, tỷ lệ cược sẽ tự cung cấp và evens cho 0. Chúng tôi sử dụng ⍳để tạo danh sách các số từ 1 đến đó ( ⍳0đưa ra mảng trống), và sau đó chúng tôi trừ đi một nửa đầu vào và sàn.

Toán học, 32 30 24 byte

OddQ@#&&Range@#-(#+1)/2&

Thủ thuật đánh gôn bằng mã: Đối số cuối cùng Andkhông nhất thiết phải là một boolean.

PowerShell, 50 52 byte

param($a)$b=$a/2-.5;(0,((0-$b)..$b-join' '))[($a%2)]

Ôi. Câu trả lời khá dài dòng. Lấy đầu vào $a, sau đó đặt một biến mới $blà "sàn" của $a/2. Tạo một phạm vi số mới từ (0-$b)đến $b, sau đó joinlà phạm vi có khoảng trắng và có đó là phần tử thứ hai của mảng hai phần tử (phần tử đầu tiên là 0). Sau đó sử dụng $a%2để lập chỉ mục vào mảng đó cho đầu ra.

Phiên bản thay thế sử dụng luồng if / other "truyền thống" hơn, ở mức 54 byte:

param($a)$b=$a/2-.5;if($a%2){(0-$b)..$b-join' ';exit}0

_{Chỉnh sửa - Cần thêm một số logic để xuất giá trị falsey nếu đầu vào chẵn}

Haskell, 37 36 31 byte

g n=take(n*mod n 2)[-div n 2..]

Mất cân bằng được chỉ định bởi danh sách trống. Ví dụ sử dụng: g 7-> [-3,-2,-1,0,1,2,3].

@xnor tìm thấy 5 byte. Cảm ơn!

JavaScript (ES6), 44 43 42 41 byte

^{gạch bỏ 44 vẫn là 44 thường xuyên (}

n=>[...Array(n&1&&n--)].map((x,i)=>i-n/2)

Đối với các đầu vào lẻ, trả về một mảng số nguyên có độ dài x, tập trung tại 0; cho chẵn, trả về 0. Tôi nghĩ rằng điều này là ngắn như nó có thể nhận được. (Đã lưu một vài byte nhờ @ edc65 và @ nɟuɐɯɹɐ ן oɯ!)

Thay thế ES6: (42 byte, nhờ @intrepidcoder)

x=>x%2&&[for(y of Array(x--).keys())y-x/2]

Đề nghị chào mừng!

Chồn 0,10 , 18 byte

nd2%?.d2:~r[dN1+].

Giải trình

n          Take input as integer (k)
d2%?.      Duplicate k and stop if it's even
d2:~       Duplicate k, then divide by 2 and negate to get first number
r          Put k on top
[    ].    Loop k times and then stop
 dN1+      Duplicate, output as integer, and increment

J, 12 byte

i:@%~2&!*2&|

Đây là một động từ đơn âm trả về 0(falsy) cho các số chẵn. Dùng thử trực tuyến với J.js .

Chạy thử nghiệm

   (i:@%~2&!*2&|) 3
_1 0 1
   (i:@%~2&!*2&|) 2
0

Làm thế nào nó hoạt động

              Right argument: y
         2&|  Take y modulo 2.
     2&!      Calculate y C 2 = y(y-1)/2.
        *     Multiply the results.
   %~         Divide the product by y.
              This yields (y-1)*(y%2)/2 = (y-1)/2 (y even) | 0 (y odd).
  @           Take the result and...
i:              apply the bilateral index generator z -> (-z ... z).

DUP , 31 byte

[a:a;2/b:[b;_[$b;<][$1+]#][0]?]

Try it here.

Lambda ẩn danh. Sử dụng:

5[a:a;2/b:[b;_[$b;<][$1+]#][0]?]!

Giải trình

[                             ] {lambda}
 a:                             {store input to a}
   a;2/                         {divmod a by 2}
       b:                       {store quotient to b, top of stack is now remainder}
         [               ][ ]?  {conditional}
          b;_                   {if remainder is 1, get b and negate it}
             [    ][   ]#         {while loop}
              $b;<                {while top of stack is less than b}
                    $1+           {duplicate and increment}
                           0    {otherwise, leave falsy value}

Python 2, 34 32 byte

Ngay bây giờ tôi không chắc mình có thể xuất bất cứ thứ gì tôi muốn hay không nếu nó không cân bằng, vì vậy hiện tại điều này chỉ trả về một danh sách trống trong trường hợp cơ sở có thể mất cân bằng. Đây là một hàm lambda ẩn danh, vì vậy hãy đặt tên cho nó để sử dụng nó.

lambda k:k%2*range(-k/2+1,-~k/2)

CJam, 13 12 byte

{_2md@,@f-*}

Đây là một hàm ẩn danh bật một số nguyên từ ngăn xếp và đẩy một mảng chữ số (cơ sở lẻ) hoặc một mảng trống (cơ sở chẵn) đổi lại. Hãy thử trực tuyến trong trình thông dịch CJam .

Làm thế nào nó hoạt động

_          e# Copy the input (N).
 2md       e# Push N/2 and N%2.
    @      e# Rotate N on top of the stack.
     ,     e# Push [0 ... N-1].
      @    e# Rotate N/2 on top of the stack.
       f-  e# Subtract N/2 from each element of [0 ... N-1].
         * e# Repeat the resulting array N%2 times.

Ô, 18

M(.e\2/.@{_}dmrr]p

Bản thử trực tiếp.

Vitsy, 27 25 byte

Tôi sẽ chơi golf này vào ngày mai, nhưng tôi thực sự nên đi ngủ bây giờ.

D2M) [& 1] D1-i *} \ [D2 / NaO2 +]
D Sao y đầu vào.
 2M) [& 1] Nếu đầu vào là chẵn (đầu vào% 2 = 0) tạo ra một ngăn xếp mới
                              và đẩy 1 vào nó.
        D Sao y giá trị hàng đầu - nếu không phải là số chẵn, đây sẽ là đầu vào. Nếu không, nó là một.
         1- Trừ đi một (để cân bằng khoảng 0)
           i * Đảo ngược
             } Chuyển qua một mục trong ngăn xếp - điều này đảm bảo rằng
                              chúng tôi có đầu vào hoặc một trên đầu trang.
              \ [] Lặp lại thời gian nhập.
                D2 / N Sao chép mục trên cùng và in ra.
                    aO Dòng mới (Tôi khá chắc chắn đây là phân tách hợp lệ)
                      2+ Thêm một vào mục trên cùng của ngăn xếp.

TeaScript , 16 byte 18

x%2Þr(xØ)ßl-x/2)

Khá đơn giản. Các ký tự đặc biệt thực sự chỉ là "viết tắt" cho các chuỗi mã dài hơn.

Tôi vẫn chưa tạo permalinks để bạn sẽ phải sao chép dán vào trình thông dịch

Giải trình

x%2 &&    // If x is NOT even return falsy, else...
r(x--)    // Range 0-input. Subtracts one from input
m(#       // Loop through range
  l-      // Current item in loop, minus...
    x/2   // input - 1, divided by two
)

_{Câu trả lời này là không cạnh tranh}

F #, 38 byte

Kết quả falsey là một danh sách trống.

let O n=if n%2<1 then[]else[-n/2..n/2]

, 21 ký tự / 37 byte

ô[…Ѧ(ï&1⅋ï‡)]ć⇀_-ï/2⸩

Try it here (Firefox only).

Đây là câu trả lời 20 char / 35 byte (không cạnh tranh, vì câu trả lời sử dụng các thay đổi được thực hiện sau khi câu hỏi được hỏi):

ô(ï%2⅋ѨĶ(ï‡)ć⇀$-ï/2⸩

Try it here (Firefox only).

Japt, 21 19 byte

Japt là phiên bản rút gọn của Ja vaScri pt .

U%2&&(X=-U/2+K o1-X

Đối với các đầu vào lẻ, trả về một mảng số nguyên có độ dài x, tập trung tại 0; cho chẵn, trả về 0. Bản dịch JS thô:

output(U%2&&(X=-U/2+.5).range(1-X));

nơi x.range(y)tạo ra một danh sách các số nguyên từ xđến y. Kiểm tra nó trực tuyến!

Trong Japt hiện đại, đây chỉ là 11 byte:

u ©Uo-U/2-½

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

R, 30 byte

function(n)(x=(1-n)/2*n%%2):-x

Đại khái, x:-xtrả về số nguyên từ xđến -x, nơi tôi đặt xđể (1-n)/2. Tôi cũng sử dụng yếu tố modulo-2 n%%2trong định nghĩa về xlực xbằng 0 khi ntrong trường hợp chẵn, trong trường hợp đó, 0:0trả về 0(falsey).

Perl, 36 byte

Tôi có một cảm giác điều này có thể được rút ngắn:

$,=$";$n=<>;print$n%2?-$n/2..$n/2:0;

Phạm vi coi các số float là số nguyên, vì vậy, ví dụ 5/2 = 2.5 được chuyển đổi âm thầm thành 2.

(Nếu định dạng không thành vấn đề, thì hãy xóa $,=$";tổng cộng 30 byte).

Powershell, 49 byte

param($a)$b=$a/2-.5;"[$(-$b..$b-join",")]"*($a%2)

Các số chẵn được đánh giá $falsevì chúng cung cấp một đầu ra dòng trống.

("[$(-$b..$b-join",")]"*($a%2))-eq $True ===> False

Số lẻ xuất chuỗi tham chiếu chính xác. Bạn có thể lưu thêm 4 byte (ngay bây giờ 45) bằng cách xóa []chuỗi đầu ra.

PS> .\balanced.ps1 4


PS> .\balanced.ps1 5
[-2,-1,0,1,2]

PS> .\balanced.ps1 0


PS> .\balanced.ps1 1
[0]

PS> 

Powershell, 36 byte

param($a)$b=$a/2-.5;(-$b..$b)*($a%2)

Điều này có cùng kết quả falsey nhưng đưa ra danh sách các số được phân tách bằng dòng mới:

PS> .\balanced-newline.ps1 4

PS> .\balanced-newline.ps1 1
0

PS> .\balanced-newline.ps1 5
-2
-1
0
1
2

PS>

Perl 6, 25 byte

Biểu thức lambda ngắn nhất tôi có thể đưa ra để đưa ra một danh sách thay vì một phạm vi là:

{$_%2&&|((1-$_)/2..$_/2)} # 25

Kiểm tra:

for 0..10 -> $a {
  if {$_%2&&|((1-$_)/2..$_/2)}($a) -> $b {
    say "$a.fmt('%5s')  $b"
  } else {
    say "$a.fmt('%5s')  False"
  }
}

    0  False
    1  0
    2  False
    3  -1 0 1
    4  False
    5  -2 -1 0 1 2
    6  False
    7  -3 -2 -1 0 1 2 3
    8  False
    9  -4 -3 -2 -1 0 1 2 3 4
   10  False

Điều này lợi dụng thực tế là Perl 6 coi số đó 0là một giá trị sai. Nếu đầu ra phải chính xác, Falsebạn có thể thay thế $_%2bằng $_!%%2.

05AB1E , 8 byte (không cạnh tranh)

Ngôn ngữ hoãn thách thức và do đó không cạnh tranh. Mã số:

È#¹;D(ŸR

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

Giải trình:

È#        # If input % 2 == 0, end the program
  ¹       # Push the first input from the register
   ;      # Halve, push input / 2 rounded down
    D     # Duplicate top of the stack
     (    # Negate
      Ÿ   # Inclusive range, pushes [a .. b]
       R  # Reverse the array

Sử dụng mã hóa CP-1252 .

PHP, 50 byte

<?=($n=$argv[1])&1?join(_,range(-$k=$n/2|0,$k)):0;

chương trình, lấy đầu vào từ STDIN, in _danh sách phân cách hoặc 0.

hoặc là

function f($n){return$n&1?range(-$k=$n/2|0,$k):0;}

Hàm lấy đối số, trả về mảng hoặc 0.

Java, 145 byte

public class c{static void c(int n){for(int i=n/2*-1;i<=n/2;i++){if(n%2==0){System.out.print("false");break;}System.out.print(i);}}}

Giải thích: Xin lỗi, tôi biết điều này thực sự dài. Tôi không thấy câu trả lời cho java nên tôi quyết định đặt một câu hỏi. Hãy cho tôi biết nếu tôi cần viết hàm chính (Tôi không chắc đó có phải là chính sách hay không). Về cơ bản, nó chia số cho hai và nhân nó với -1 cho giới hạn dưới và cho giới hạn trên, nó chỉ sử dụng số chia cho hai. Tôi là người mới đối với trang này vì vậy nếu tôi không định dạng bất cứ điều gì đúng thì hãy cho tôi biết. Ngoài ra, tôi biết rằng các câu trả lời có thể được rút ngắn bằng các hàm lambda nhưng tôi không biết cách sử dụng chúng và tôi không chắc liệu Java có hỗ trợ chúng không.

Đây là một phiên bản dễ đọc hơn mà ít chơi gôn hơn:

public class StackOverflow {
static void c(int n){
    for (int i = n/2*-1; i<=n/2; i++){
        if(n%2==0){
            System.out.print("false");
            break;
        }
        System.out.print(" " + i);
    }
}
}

Ruby, 25 byte

->n{n%2>0&&[*(-n/=2)..n]}

Ruby, 27 byte

->n{[*0-n/2..n/2]if n.odd?}

Tạo một hàm lambda ẩn danh sẽ trả về mảng các nsố gần nhất bằng 0 nếu n là số lẻ và trả về nil (giá trị falsey trong ruby) nếu không.

Ruby làm tròn phép chia số nguyên của nó theo hướng vô cực, nhưng 0-n/2ngắn hơn -n/2+1(vì dấu trừ có ở đó) và vì bây giờ n được coi là dương, nên việc làm tròn có lợi cho tôi.

Phiên bản cũ (28 byte)

->n{[*-n/2+1..n/2]if n.odd?}