Cho một số N, xuất ra dấu của N:

• Nếu N dương, đầu ra 1
• Nếu N âm, đầu ra -1
• Nếu N bằng 0, đầu ra 0

N sẽ là một số nguyên trong phạm vi số nguyên có thể biểu thị trong ngôn ngữ bạn đã chọn.

Võng mạc , 9 byte

[1-9].*
1

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

Thay thế một chữ số khác không và mọi thứ sau nó bằng 1. Điều này để lại một tiềm năng hàng đầu -nguyên vẹn và thay đổi tất cả các số ngoại trừ 0chính nó thành giá trị tuyệt đối 1.

C (GCC), 24 23 22 18 byte

Cảm ơn @aross và @Steadybox vì đã tiết kiệm một byte!

f(n){n=!!n|n>>31;}

Không được bảo đảm để hoạt động trên tất cả các hệ thống hoặc trình biên dịch, hoạt động trên TIO .

Toán học, 4 byte

Clip

Làm thế nào về việc không sử dụng tích hợp Signvà vẫn ghi được 4 byte? ;)

Clipvới một clip đối số (hoặc kẹp) giá trị đầu vào giữa -1và 1. Vì các đầu vào sẽ chỉ là số nguyên, điều này giống như sử dụng Sign.

COW, 225 213 201 byte

oomMOOmoOmoOmoOmoOMoOMoOmOomOomOoMoOMMMmoOMMMMOOMOomOo
mOoMOomoOmoOmoomOomOoMMMmoOmoOmoOMMMMOOOOOmoOMOoMOomOo
mOomOoMoOMMMmoOMMMMOOMOomOomOoMoOmoOmoOmoomoOmoomOomOo
mOomoomoOMOOmoOmoOmoOMOoMMMOOOmooMMMOOM

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

Cách mà mã này hoạt động là nó xác định dấu bằng cách xen kẽ cộng và trừ các số lớn hơn và xem cái nào là số cuối cùng hoạt động. Cho bất kỳ số nguyên khác không, đầu tiên trừ 1, sau đó cộng 2, sau đó trừ 3, v.v ... và cuối cùng bạn sẽ đạt 0. Theo dõi trạng thái của bạn bằng cách xen kẽ thêm và trừ 2 vào một giá trị bắt đầu từ 0. Đối với thí dụ:

-5  - 1  = -6  (current state: 0 + 2 = 2)
-6  + 2  = -4  (current state: 2 - 2 = 0)
-4  - 3  = -7  (current state: 0 + 2 = 2)
-7  + 4  = -3  (current state: 2 - 2 = 0)
-3  - 5  = -8  (current state: 0 + 2 = 2)
-8  + 6  = -2  (current state: 2 - 2 = 0)
-2  - 7  = -9  (current state: 0 + 2 = 2)
-9  + 8  = -1  (current state: 2 - 2 = 0)
-1  - 9  = -10 (current state: 0 + 2 = 2)
-10 + 10 =  0  (current state: 2 - 2 = 0)
value is now at 0.  state - 1 = 0 - 1 = -1
sign of original number is -1

Khi bạn hoàn thành, trừ 1 từ trạng thái của bạn và bạn nhận được dấu, tích cực hoặc tiêu cực. Nếu số ban đầu là 0, thì đừng bận tâm đến việc này và chỉ cần in 0.

Giải thích chi tiết:

oom                                        ;Read an integer into [0]
MOO                                        ;Loop while [0] is non-empty
    moOmoOmoOmoOMoOMoOmOomOomOo            ;    Decrement [4] twice
    MoOMMMmoOMMM                           ;    Increment [1], then copy [1] to [2]
    MOO                                    ;    Loop while [2] is non-empty
        MOomOomOoMOomoOmoO                 ;        Decrement [0] and [2]
    moo                                    ;    End loop now that [2] is empty
    mOomOoMMMmoOmoOmoOMMM                  ;    Navigate to [0], and copy to [3]
    MOO                                    ;    Perform the next steps only if [3] is non-zero
        OOOmoOMOoMOomOomOomOoMoOMMMmoOMMM  ;        Clear [3], increment [4] twice, increment [1], and copy it to [2]
        MOO                                ;        Loop while [2] is non-empty
            MOomOomOoMoOmoOmoO             ;            Decrement [2] and increment [0]
        moo                                ;        End loop now that [2] is empty
    moO                                    ;        Navigate back to [3]
    moo                                    ;    End the condition
    mOomOomOo                              ;    Navigate back to [0]
moo                                        ;End loop once [0] is empty.
moO                                        ;Navigate to [1]. If [1] is 0, then input was 0.  Otherwise, [4] contains (sign of [0] + 1)
MOO                                        ;Perform the next steps only if [1] is non-zero
    moOmoOmoOMOoMMMOOO                     ;    Navigate to [4], copy it to the register, and clear [4].
moo                                        ;End condition
MMMOOM                                     ;If the register contains something (which is true iff the condition ran), paste it and print it.  Otherwise, no-op and print 0.

Tôi vẫn đang thử nghiệm chơi golf (bạn sẽ bị sốc khi phát hiện ra rằng chơi golf trong COW khá khó khăn), vì vậy điều này có thể sẽ giảm thêm một vài byte trong tương lai.

Khối , 10 byte

(W0^I?>O2@

Kiểm tra nó trực tuyến!

Mã này được gói vào mạng khối sau:

    ( W
    0 ^
I ? > O 2 @ . .
. . . . . . . .
    . .
    . .

Đoạn mã sau đó được chạy với IP (con trỏ lệnh) bắt đầu từ Ihướng về phía đông. Inhập một số nguyên đã ký từ STDIN, đẩy nó lên ngăn xếp.

Lệnh tiếp theo là ?, thay đổi hướng của IP tùy thuộc vào dấu hiệu của mục trên cùng. Nếu đầu vào là 0, nó tiếp tục di chuyển theo cùng một hướng, chạy qua đoạn mã sau:

• >- Trỏ IP về phía đông. (Không-op vì chúng ta đã đi về hướng đông.)
• O - Xuất mục trên cùng dưới dạng số nguyên.
• 2- Đẩy 2 vào ngăn xếp. Đây thực tế là một no-op, bởi vì ...
• @ - Chấm dứt chương trình.

Nếu đầu vào là âm, IP rẽ trái tại ?; bởi vì đây là một khối lập phương, IP di chuyển lên 0hàng thứ hai, hướng về phía đông. 0đẩy một chữ 0, sau đó mã này được chạy:

• ^ - Chỉ IP phía bắc.
• W - "Sidestep" một điểm IP ở bên trái.
• ( - Giảm các mục hàng đầu.

Hiện tại -1, ĐKDV và IP bao bọc khối lập phương thông qua một loạt các no-op .cho đến khi nó chạm tới >. Điều này chạy cùng mã đầu ra được đề cập ở trên, xuất ra -1.

Nếu đầu vào là dương, điều tương tự cũng xảy ra với đầu vào âm, với một ngoại lệ: IP quay sang phải thay vì trái ở bên trái ?và quấn quanh khối tới 2, đẩy một chữ 2. Điều này sau đó giảm xuống 1 và gửi đến đầu ra.

JavaScript (ES6), 9 byte

Math.sign

Nói thẳng ra.

Không dựng ngắn nhất là 13 byte:

n=>n>0|-(n<0)

Nhờ @Neil, điều này có thể được chơi bằng một byte, nhưng với chi phí chỉ hoạt động trên các số nguyên 32 bit:

n=>n>0|n>>31

Hoặc bạn có thể làm

n=>n>0?1:!n-1

có vẻ như chơi gôn hơn, nhưng tôi không biết làm thế nào.

APL (Dyalog APL) , 1 byte

Làm việc cho số phức quá, trở về 1∠ q :

×

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

Không có tích hợp sẵn đó, cho các số nguyên (theo OP):

¯1⌈1⌊⊢

¯1⌈ lớn nhất của âm và

1⌊ nhỏ nhất của một và

⊢ tranh luận

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

... và nói chung:

>∘0-<∘0

>∘0 nhiều hơn không

- dấu trừ

<∘0 ít hơn không

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

> <> , 9 8 byte

Cảm ơn Sp3000 vì đã tiết kiệm một byte.

'i$-%n/

Có một không thể in được 0x01trước /.

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

Giải trình

Đây là một cổng của câu trả lời Labyrinth dựa trên mã ký tự của tôi .

'     Push the entire program (except ' itself) onto the stack, which ends 
      with [... 1 47].
i     Read the first character of the input.
$-    Subtract the 47.
%     Take the 1 modulo this value.
n     Output the result as an integer.
0x01  Unknown command, terminates the program.

Vim, 22 byte

xVp:s/-/-1^M:s/[1-9]/1^M

Đã lưu một byte nhờ @DJMcMayhem !

Đây ^Mlà một dòng mới.

Như @ nmjcman101 đã chỉ ra trong các bình luận, một regex duy nhất có thể được sử dụng ( :s/\v(-)=[^0].*/\11^M, 20 byte), nhưng vì điều này về cơ bản giống như câu trả lời của Retina, tôi sẽ sử dụng phương pháp của riêng mình.

Giải trình:

xVp                        Delete everything except the first character. If the number is negative, this leaves a -, a positive leaves any number between 1 and 9, and 0 leaves 0.
   :s/-/-1^M               Replace a - with a -1
            :s/[1-9]/1^M   Replace any number between 1 and 9 with 1.

Đây là một gif của nó đang chạy với một số âm (phiên bản cũ):

Đây là nó đang chạy với 0:

Chạy với tích cực:

///, 52 36 byte

/a/\/1\/\///2a3a4a5a6a7a8a9a10a11/1/

Ung dung, giải thích:

/2/1/
/3/1/
/4/1/
/5/1/
/6/1/
/7/1/
/8/1/
/9/1/
/10/1/
/11/1/

Về cơ bản, đây là một triển khai MapReduce, tức là có hai giai đoạn:

• Thay thế tất cả các lần xuất hiện của các chữ số 2- 9bởi 1, ví dụ 1230405->1110101
• Giảm cặp 11hoặc 10để 1lặp đi lặp lại, ví dụ: 1110101->1

Nếu có một -ở phía trước ban đầu, nó sẽ vẫn còn và đầu ra sẽ được -1. Một đơn 0không bao giờ được thay thế, do đó dẫn đến chính nó.

Cập nhật: Lưu thêm 16 byte bằng răng cưa //1/với a, nhờ Martin Ender.

Dùng thử trực tuyến, với các trường hợp thử nghiệm

Python 2 , 17 byte

lambda n:cmp(n,0)

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

Mê cung , 10 byte

?:+:)%:(%!

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

Giải trình

Ngữ nghĩa dòng điều khiển của Labyrinth thực sự cung cấp cho bạn một cách "miễn phí" để xác định dấu hiệu của một số, bởi vì đường dẫn được chọn ở ngã ba đường phụ thuộc vào việc dấu đó là âm, bằng 0 hay dương. Tuy nhiên, cho đến nay tôi vẫn chưa thể điều chỉnh chương trình có các mối nối thành ít hơn 12 byte (mặc dù có thể là có thể).

Thay vào đó, đây là một giải pháp dạng đóng, không yêu cầu bất kỳ chi nhánh nào:

Code    Comment             Example -5      Example 0       Example 5
?       Read input.         [-5]            [0]             [5]
:+      Double.             [-10]           [0]             [10]
:)      Copy, increment.    [-10 -9]        [0 1]           [10 11]
%       Modulo.             [-1]            [0]             [10]
:(      Copy, decrement.    [-1 -2]         [0 -1]          [10 9]
%       Modulo.             [-1]            [0]             [1]
!       Print.              []              []              []

Con trỏ lệnh sau đó chạm vào ngõ cụt, quay lại và chấm dứt khi %bây giờ cố gắng chia cho 0.

Nhân đôi đầu vào là cần thiết để làm cho công việc này hoạt động với đầu vào 1và -1, nếu không, một trong hai thao tác modulo sẽ thử chia cho 0.

PHP, 16 byte

Sử dụng toán tử tàu vũ trụ mới.

<?=$argv[1]<=>0;

Brain-Flak 74 42 40 byte

Đã lưu 2 byte nhờ 1000000000

{([({}<([()])>)]<>(())){({}())<>}}{}({})

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

Giải trình:

{                                }       # if 0 do nothing
   (          )                          # push:                           
    {}<     >                            # the input, after 
       (    )                            # pushing:
        [  ]                             # negative:
         ()                              # 1

 (                    )                  # Then push:
  [            ]                         # the negative of the input
                <>                       # on the other stack with:
                   ()                    # a 1 
                  (  )                   # pushed under it

                       {        }        # while 1: 
                        ({}())           # increment this stack and...
                              <>         # switch stacks

                                 {}      # pop the top (the counter or 0 from input)
                                   (  )  # push:
                                    {}   # the top (this is a no-op, or pushes a 0)

J , 1 byte

*

Hãy thử trực tuyến (với các trường hợp thử nghiệm)!

C, 24 20 19 18 byte

Tôi lạm dụng hai khai thác C để đánh golf này xuống; Đây là trong C (GCC).

f(a){a=a>0?:-!!a;}

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

Lịch sử sửa đổi:

1) f(a){return(a>0)-(a<0);}// 24 byte

2) f(a){a=(a>0)-(a<0);}// 20 byte

3) f(a){a=a>0?:-1+!a;}// 19 byte

4) f(a){a=a>0?:-!!a;}// 18 byte

Bản sửa đổi 1: Nỗ lực đầu tiên. Logic đơn giản

Bản sửa đổi 2: Lạm dụng lỗi bộ nhớ / ngăn xếp trong GCC, theo như tôi có thể nói, một hàm không trả về sẽ trả về biến đặt cuối cùng trong một số trường hợp nhất định.

Sửa đổi 3: Lạm dụng hành vi ternary trong đó kết quả không xác định sẽ trả về kết quả có điều kiện (đó là lý do tại sao lợi nhuận thực sự trên ternary của tôi là không)

Bản sửa đổi 4: Trừ một bool cast ( !!) khỏi sự thay thế có điều kiện ternary để niltham chiếu trong phiên bản 2.

Ruby, 10 byte

->x{x<=>0}

Perl, 9 byte

Yêu cầu -Ekhông có chi phí thêm.

say<><=>0

Sử dụng

perl -E 'say<><=>0' <<< -9999
-1
perl -E 'say<><=>0' <<< 9999
1
perl -E 'say<><=>0' <<< -0
0

Tôi hài lòng với người điều khiển cá!

Mèo xếp chồng , 6 + 4 = 10 byte

_[:I!:

+4 byte cho các ​ -nmcờ. ndành cho I / O số và vì Stack Mèo yêu cầu các chương trình phải thực tế, nên mngầm phản ánh mã nguồn để cung cấp nguồn ban đầu

_[:I!:!I:]_

Hãy thử trực tuyến! Về cơ bản với tất cả các môn đánh gôn Stack Mèo tốt, điều này được tìm thấy bởi lực lượng vũ phu, đánh bại mọi nỗ lực thủ công bằng một cú sút xa và không thể dễ dàng kết hợp vào một chương trình lớn hơn.

Thêm một Dcờ nếu bạn muốn xem theo dõi chương trình từng bước, tức là chạy với -nmDvà kiểm tra STDERR / gỡ lỗi.

Mèo Stack sử dụng một cuộn băng ngăn xếp được lấp đầy bằng các số 0 ở phía dưới. Khi bắt đầu chương trình, tất cả đầu vào được đẩy lên ngăn xếp đầu vào, với một -1ở chân đế để tách đầu vào khỏi các số 0 ẩn. Vào cuối chương trình, ngăn xếp hiện tại là đầu ra, ngoại trừ một cơ sở -1nếu có.

Các lệnh có liên quan ở đây là:

_           Perform subtraction [... y x] -> [... y y-x], where x is top of stack
[           Move left one stack, taking top of stack with you
]           Move right one stack, taking top of stack with you
:           Swap top two of stack
I           Perform [ if top is negative, ] if positive or don't move if zero. Then
                negate the top of stack.
!           Bitwise negate top of stack (n -> -n-1)

Lưu ý rằng tất cả các lệnh này là không thể đảo ngược, với nghịch đảo của nó là gương của lệnh. Đây là tiền đề của Stack Mèo - tất cả các chương trình chấm dứt không cần thiết đều có độ dài lẻ, vì các chương trình có độ dài tự hủy.

Chúng tôi bắt đầu với

               v
               n
              -1
...  0    0    0    0    0  ...

_trừ, tạo đỉnh -1-nvà [di chuyển kết quả sang trái một ngăn xếp:

           v
       -1-n   -1
...  0    0    0    0    0  ...

:hoán đổi hai đầu và Ikhông làm gì cả, vì đỉnh của ngăn xếp bây giờ bằng không. !sau đó bitwise phủ định số 0 trên cùng thành a -1và :hoán đổi hai đỉnh trên. !sau đó bitwise phủ định đỉnh, quay -1-ntrở lại nmột lần nữa:

          v
          n
         -1   -1
...  0    0    0    0    0  ...

Bây giờ chúng tôi phân nhánh dựa trên I, được áp dụng cho bản gốc của chúng tôi n:

• Nếu nlà âm, chúng ta di chuyển sang trái một ngăn xếp và kết thúc -nbằng số không ẩn. :hoán đổi, đặt số 0 lên trên và ]di chuyển số 0 lên trên cùng mà -1chúng ta vừa chuyển đi. _sau đó trừ đi, để lại ngăn xếp cuối cùng như thế [-1 -1], và chỉ có một -1đầu ra là do cơ sở -1bị bỏ qua.

• Nếu nbằng không, chúng ta không di chuyển và :hoán đổi, đặt -1lên hàng đầu. ]sau đó di chuyển bên trái này -1lên trên cùng bên phải -1và _trừ đi, để lại ngăn xếp cuối cùng như thế [-1 0], xuất ra số 0 và bỏ qua cơ sở -1.

• Nếu nlà dương, chúng ta di chuyển sang phải một ngăn xếp và kết thúc bằng -na -1. :hoán đổi, đặt -1lên trên và ]di chuyển -1bên phải này lên trên một số không ẩn. _sau đó trừ, cho 0 - (-1) = 1và rời khỏi ngăn xếp cuối cùng [1], đó là đầu ra.

TI-Basic, 8 byte

median({1,Ans,~1

Giải pháp thay thế (vui lòng đề xuất thêm):

max(~1,min(Ans,1               8  bytes
0:If Ans:Ans/abs(Ans           9  bytes
(Ans>0)-(Ans<0                 10 bytes

MATL , 6 byte

0>EGg-

Đầu vào có thể là một số hoặc một mảng. Kết quả là số hoặc một mảng với các giá trị tương ứng.

Hãy thử trực tuyến! Hoặc kiểm tra một số trường hợp bằng cách sử dụng đầu vào mảng.

Giải trình

Điều này tránh sử dụng hàm dấu dựng ( ZS).

0>   % Take input implicitly. Push 1 if positive, 0 otherwise
E    % Multiply by 2
Gg   % Push input converted to logical: 1 if nonzero, 0 otherwise
-    % Subtract. Implicitly display

Thạch , 1 byte

Ṡ

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

Dấu hiệu monadic nguyên tử , Ṡ, thực hiện chính xác những gì được quy định cho một đầu vào số nguyên, hoặc là một chương trình đầy đủ hoặc như một liên kết monadic (chức năng chụp một đối số).

Toán học, 4 byte

Sign

Chính xác những gì nó nói trên tin

Octave, 26 24 byte

f=@(x)real(asin(x))/pi*2

Đây là câu trả lời Octave golf-code đầu tiên của tôi , bất kỳ mẹo chơi gôn nào cũng được đánh giá cao!

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

Ý tưởng để lấy asinxuất phát từ câu hỏi mà nó nói output the sign:)

Giải trình

Lưu ý: chia số cho pivà nhân số đó 2tương đương với việc chia toàn bộ số chopi/2

Trường hợp 0:

asin(0)năng suất 0. Lấy phần thực của nó và chia nó bằng cách pi/2làm cho không có sự khác biệt với đầu ra.

Trường hợp positive:

asin(1)năng suất pi/2. asincủa bất kỳ số nào lớn hơn 1sẽ cho pi/2+ số phức. Lấy phần thực của nó cho pi/2và chia nó bằng cách pi/2cho1

Trường hợp negative:

asin(-1)năng suất -pi/2. asincủa bất kỳ số nào nhỏ hơn -1sẽ cho -pi/2+ số phức. Lấy phần thực của nó cho -pi/2và chia nó bằng cách pi/2cho-1

Trên thực tế , 1 byte

s

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

Một trường hợp khác về chính xác những gì nó nói trên hộp thiếc - slà chức năng ký hiệu.

Không có nội dung (4 byte):

;A\+

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

;A\chia giá trị tuyệt đối của đầu vào cho đầu vào. Kết quả này -1cho đầu vào tiêu cực và 1cho đầu vào tích cực. Thật không may, do thực tế xử lý lỗi (nếu có lỗi xảy ra, lệnh bị bỏ qua), 0vì đầu vào để lại hai 0s trên ngăn xếp. +khắc phục điều này bằng cách thêm chúng (gây ra lỗi với bất kỳ thứ gì khác, vì vậy nó bị bỏ qua).

Piet, 188 53 46 41 byte

5bpjhbttttfttatraaearfjearoaearbcatsdcclq

Thông dịch viên trực tuyến có sẵn ở đây.

Mã piet này làm tiêu chuẩn (n>0)-(n<0), vì không có dấu kiểm tra dựng sẵn. Trong thực tế, không có ít hơn so với nội dung, vì vậy một mô tả chính xác hơn về phương pháp này sẽ là (n>0)-(0>n).

Các văn bản trên đại diện cho hình ảnh. Bạn có thể tạo hình ảnh bằng cách dán nó vào hộp văn bản trên trang thông dịch. Để thuận tiện, tôi đã cung cấp hình ảnh bên dưới với kích thước codel là 31 pixel. Lưới ở đó để dễ đọc và không phải là một phần của chương trình. Cũng lưu ý rằng chương trình này không vượt qua bất kỳ codel trắng nào; theo các bảng mã màu xung quanh viền của hình ảnh để theo dòng chương trình.

Giải trình

Instruction    Δ Hue   Δ Lightness   Stack
------------   -----   -----------   --------------------
In (Number)    4       2             n
Duplicate      4       0             n, n
Push [1]       0       1             1, n, n
Duplicate      4       0             1, 1, in, in
Subtract       1       1             0, in, in
Duplicate      4       0             0, 0, in, in
Push [4]       0       1             4, 0, 0, in, in
Push [1]       0       1             1, 4, 0, 0, in, in
Roll           4       1             0, in, in, 0
Greater        3       0             greater, in, 0
Push [3]       0       1             3, greater, in, 0
Push [1]       0       1             1, 3, greater, in, 0
Roll           4       1             in, 0, greater
Greater        3       0             less, greater
Subtract       1       1             sign
Out (Number)   5       1             [Empty]
[Exit]         [N/A]   [N/A]         [Empty]

Để giảm kích thước tệp hơn nữa, tôi thực sự cần phải thay đổi chương trình (gasp) thay vì chỉ nén tệp như tôi đã làm. Tôi muốn xóa một hàng có thể đánh xuống 36. Tôi cũng có thể phát triển trình thông dịch riêng có định dạng đầu vào nhỏ hơn nhiều, vì thực sự thay đổi mã để làm cho nó nhỏ hơn không phải là mã golf.

Các mod nói với tôi rằng kích thước tập tin tổng thể là những gì được tính cho mã Piet. Vì trình thông dịch chấp nhận văn bản là đầu vào hợp lệ và văn bản thô có số byte nhỏ hơn nhiều so với bất kỳ hình ảnh nào, văn bản là lựa chọn rõ ràng. Tôi xin lỗi vì táo tợn về điều này nhưng tôi không đưa ra các quy tắc. Các cuộc thảo luận về điều này làm cho ý kiến ​​của tôi về vấn đề này rõ ràng.

Nếu bạn nghĩ rằng điều đó đi ngược lại với tinh thần của Piet hoặc muốn thảo luận thêm về điều này vì bất kỳ lý do gì, vui lòng xem cuộc thảo luận về meta .

Đẩy , 7 byte

Đây có lẽ là chương trình trông lạ nhất tôi từng viết ...

&?&|/;#

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

Nó sử dụng sign(x) = abs(x) / x, nhưng với một rõ ràng sign(0) = 0để tránh lỗi phân chia bằng không.

          \ Take implicit input
&?   ;    \ If the input is True (not 0):
  &|      \  Push its absolute value
    /     \  Divide
      #   \ Output TOS (the sign)

Điều này hoạt động vì x / abs(x)là 1 khi x dương và -1 khi x âm. Nếu đầu vào là 0, chương trình sẽ nhảy tới lệnh đầu ra.

4 byte (không cạnh tranh)

Vì ngày lễ và có quá nhiều thời gian, tôi đã viết lại hoàn toàn trình thông dịch Pushy. Chương trình trên vẫn hoạt động, nhưng vì 0 / 0bây giờ mặc định là 0, nên sau đây ngắn hơn:

&|/#

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

R, 25 byte

'if'(x<-scan(),x/abs(x),0)

Đưa số thành STDIN. Sau đó kiểm tra xem nó có bằng không, nếu không, trả về giá trị x/|x|nào trong 1số đó -1và xuất ra 0 nếu x=0.

Điều này là không sử dụng nội signdung tất nhiên.

V 14 12 byte

Cảm ơn @DJMcMayhem cho 2 byte. Sử dụng một reg-ex để thực hiện thay thế. Loại niềm vui, bởi vì nó không phải là một tích hợp. Tôi có một chức năng thú vị hơn, nhưng nó không hoạt động theo cách tôi mong đợi.

ͨ-©½0]/±1

Xác minh trường hợp kiểm tra

Điều này chỉ có nghĩa là :%s/\v(-)=[^0].*/\11phù hợp với một hoặc nhiều -theo sau bởi bất cứ điều gì trừ 0, tiếp theo là bất kỳ số lần nào. Nó được thay thế bằng trận đấu đầu tiên (vì vậy a -hoặc không có gì) và a 1. Regex không khớp 0, vì vậy nó vẫn giữ nguyên.

Cách thú vị hơn (21 byte)

é
Àé12|DkJòhé-òó^$/a

Dùng thử

Điều này chấp nhận đầu vào như một đối số chứ không phải trong bộ đệm.

é<CR> Chèn một dòng mới.

Àchạy đối số dưới dạng mã V. a -sẽ di chuyển con trỏ đến dòng trước và bất kỳ số nào sẽ trở thành số đếm cho lệnh tiếp theo

é1chèn (count) 1's

2| di chuyển đến cột thứ hai

D xóa mọi thứ từ cột thứ hai trở đi (chỉ để lại một ký tự)

kJ Tham gia hai dòng với nhau.

òhé-òdịch thành: "chạy hé-cho đến khi phá vỡ". Nếu 1 nằm trên dòng thứ hai, điều này sẽ phá vỡ ngay sau h. Nếu nó ở dòng đầu tiên, nó sẽ chèn một -trước khi phá vỡ.

ó^$/aĐiều này sửa chữa một thực tế rằng -1, 0, 1sẽ để lại một khoảng trống, và thay thế một trống với đăng ký tranh cãi.

C #, 16 15 byte

Giải pháp cải tiến nhờ Neil

n=>n>0?1:n>>31;

Ngoài ra, phương thức tích hợp dài hơn 1 byte:

n=>Math.Sign(n);

Chương trình đầy đủ với các trường hợp thử nghiệm:

using System;

public class P
{
    public static void Main()
    {
        Func<int,int> f =
        n=>n>0?1:n>>31;

        // test cases:
        for (int i=-5; i<= 5; i++)
            Console.WriteLine(i + " -> " + f(i));
    }
}