Tôi đảo ngược mã nguồn, bạn phủ nhận đầu ra!


39

Nhiệm vụ của bạn, nếu bạn muốn chấp nhận nó, là viết một chương trình xuất ra một số khác không (có thể là số nguyên hoặc số float). Phần khó khăn là nếu tôi đảo ngược mã nguồn của bạn, đầu ra phải là số nguyên ban đầu bị phủ định.

Quy tắc

  • Bạn phải xây dựng một chương trình đầy đủ . Đó là, đầu ra của bạn phải được in thành STDOUT.

  • Cả hai số phải ở cơ sở 10 (xuất ra chúng trong bất kỳ cơ sở nào khác hoặc với ký hiệu khoa học đều bị cấm).

  • Xuất ra các số có dấu cách / dấu cách hàng đầu được cho phép.

  • Đây là mã golf, vì vậy mã ngắn nhất (nguyên bản) trong mỗi ngôn ngữ sẽ thắng!

  • Lỗ hổng mặc định áp dụng.

Thí dụ

Giả sử mã nguồn của bạn là ABCvà đầu ra tương ứng của nó là 4. Nếu tôi viết CBAthay thế và chạy nó, đầu ra phải được -4.


6
Nếu chúng ta có thể đảo ngược ở mức bit thay vì mức byte thì một byte -(0x45 = 0b00101101) hoạt động trong Jelly - -mang lại -1 vì nó xác định nghĩa đen -1, trong khi (0xB4 = 0b10110100) mang lại 1 vì nó không thực hiện logic của đầu vào ngầm bằng không. (Tất nhiên cũng hoạt động tốt: p)
Jonathan Allan

@TwilightSparkle "Có đầu vào trống không sử dụng" có nghĩa là chúng ta có thể dựa vào các chức năng đầu vào ngay lập tức đạt EOF không?
Borka223

1
@ Borka223 Không, bạn có thể không.
Đánh giá cao hoạt động

@JoKing Sao chép. Tôi sẽ loại bỏ điều đó.
Đánh giá cao hoạt động

Câu trả lời:



28

JavaScript (V8) , 19 byte

print(1)//)1-(tnirp

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


gần giống với ...

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

Print(1)//)1-(tnirP

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

(cảm ơn @someone đã chỉ ra)


vẫn còn khá nhiều trong ...

Lua , 19 byte

print(1)--)1-(tnirp

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


nhưng ngắn hơn trong ...

Python 2 , 15 byte

print 1#1-tnirp

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


Thậm chí ngắn hơn trong PHP, bởi vì nó có công cụ in ma thuật này: <?=...

PHP , 12 byte

<?=1;#;1-=?<

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


Thậm chí ngắn hơn trong Ruby, bởi vì bạn có thể inspectthay vì in

Ruby , 8 byte

p 1#1- p

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


Ngoài ra C # Tương tác , Print(1)//)-1(tnirP. ( Dùng thử trực tuyến! )
đại từ của tôi là monicareinstate

Đối với C #, chương trình ngắn nhất có khả năng cũng là chương trình tầm thường:class A{static void Main(){System.Console.Write(1);}}//}};)1-(etirW.elosnoC.metsyS{)(niaM diov citats{A ssalc
LegionMammal978

Không phải là ngôn ngữ lập trình, nhưng bạn có thể làm 1<!--!<1-(9 byte) với HTML, sẽ là -1<!--!<1khi đảo ngược. Nó thực hiện chính xác như câu trả lời của bạn.
Ismael Miguel

Hầu như giống nhau ở Lua:print(1)--)1-(tnirp
val nói Phục hồi lại



12

/// , 4 byte

9/9-

Đầu ra 9.

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

Đảo ngược:

-9/9

Đầu ra -9.

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

Tất cả mọi thứ trước khi /được in, trong khi phần còn lại bị bỏ qua (không thực sự sử dụng dấu gạch chéo nhiều vì vậy tôi không biết chính xác điều gì xảy ra, nhưng nó không tạo ra bất cứ điều gì).


2
+1 để sử dụng Dấu gạch chéo. Các /bắt đầu quá trình mô hình đọc, và do đó, các nhân vật sau khi được readed vào mô hình, không xuất ra.
Đánh giá cao hoạt động

2
Tôi nghĩ ra /\-//1-và nghĩ rằng mình thật thông minh. : D
Tanner Swett


10

Khoảng trắng , 21 byte

S S S T N
T   N
S T N
N
N
T   S N
T   N
T   T   S S 

Chữ cái S(dấu cách), T(tab) và N(dòng mới) được thêm vào dưới dạng chỉ tô sáng.

Đầu ra 1/ -1.

Hãy thử trực tuyến hoặc thử đảo ngược trực tuyến (chỉ có khoảng trắng, tab và dòng mới).

Giải trình:

Sử dụng chương trình Thoát được xây dựng là một bảng màu ngắn NNN.
Chương trình thường xuyên sẽ:

SSSTN  # Push 1 to the stack
TNST   # Pop and print the top of the stack as number
NNN    # Exit the program, making everything after it no-ops

Chương trình đảo ngược sẽ:

SSTTN  # Push -1 to the stack
TNST   # Pop and print the top of the stack as number
NNN    # Exit the program, making everything after it no-ops

Giải thích thêm về việc đẩy một số:

  • Đầu tiên S: Kích hoạt thao tác ngăn xếp
  • Thứ hai S: Đẩy một số vào ngăn xếp
  • Shoặc T: Tích cực / tiêu cực tương ứng
  • Một số S/ Ttheo sau là một dấu N: số ở dạng nhị phân, ở đâu S=0T=1

Tức là SSTTSTSNđẩy -10.


7

T-SQL, 16 byte

--Forwards:
PRINT 4--4-TNIRP

--Backwards:
PRINT-4--4 TNIRP

Đã chọn 4 vì 1 bị lạm dụng :)


1
Nếu bạn tò mò, một câu trả lời cho MySQL sẽ là select 1#1-tceles(17 byte). Bạn có thể kiểm tra kết quả trên sqlfiddle.com/#!9/9eecb/107825 .
Ismael Miguel

7

Japt , 2 byte

Bất kỳ số nguyên chữ số duy nhất >0có thể được sử dụng ở vị trí của 2như lon A-G, H, I, Jhoặc L( 10-16, 32, 64, -1& 100, tương ứng).

n2

Kiểm tra nó | Đảo ngược

Các nphương pháp khi áp dụng cho một số nguyên, trừ rằng số nguyên từ đối số được truyền cho nó, mặc định là 0. Khi chạy về phía trước, nphương thức đang được chạy trên đầu vào ẩn đầu tiên, cũng mặc định là 0.

Ngoài ra, gphương thức có thể được sử dụng thay cho n, phương thức này cho dấu hiệu của kết quả trừ đi đối số của nó khỏi số nguyên mà nó được áp dụng.


7

Haskell không có ý kiến, 41 byte

Chuyển tiếp in 1+ dòng mới:

main=print$!1
niam=main
"1-"!$rtStup=niam

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

Các bản in đảo ngược -1không có dòng mới (có thể được thêm vào với chi phí là 2 byte):

main=putStr$!"-1"
niam=main
1!$tnirp=niam

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

  • Dòng đầu tiên của mỗi chương trình in số.
    • Đối với -1đầu ra chuỗi được sử dụng để tránh dấu ngoặc đơn.
    • Sử dụng $!(ứng dụng nghiêm ngặt) thay vì khoảng trắng cho phép đường đảo ngược là định nghĩa hợp lệ của toán tử !$(chỉ $không làm được vì định nghĩa lại sẽ phá vỡ việc sử dụng).
  • Đường giữa đảm bảo niamđược xác định cho dòng cuối cùng.
  • Dòng cuối cùng là một định nghĩa của một toán tử !$, không được sử dụng nhưng cần phân tích cú pháp và đánh máy chính xác.

7

PHP , 15 13 byte

Một phiên bản PHP mà không lạm dụng bình luận. ohcelà một hằng số không xác định, vì vậy nó sẽ bằng giá trị chuỗi của tên của nó. Kết quả là, điều này sẽ cố gắng in +1-'ohce'hoặc -1+'ohce'khi đảo ngược. Vì 'ohce'là một giá trị không phải là số, nên 0 sẽ được sử dụng thay thế trong các phép toán số học và chỉ 1hoặc -1sẽ được in.

;echo+1-ohce;

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

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


Thật khéo léo. Tốt đẹp!
admBorkBork

1
Man, thật buồn khi tôi đã đến câu trả lời giống như bạn, trễ 3 tiếng :( Hãy thông báo cho tôi.
Ismael Miguel




6

Khối , 7 6 5 byte

@)O(@

Dùng thử ở đây
Đảo ngược

Giải trình

Lập thể

  @
) O ( @
  .

Bỏ kiểm soát luồng điều khiển, chúng tôi thực hiện )O(@ , tăng, xuất, giảm và thoát.

Đảo ngược và lập phương:

  @
( O ) @
  .

Không kiểm soát luồng điều khiển, chúng tôi thực hiện (O)@, sẽ giảm, đầu ra, tăng và thoát.

Phiên bản trước

@O(.)O@

Dùng thử ở đây
Đảo ngược

Không phải là ngắn, nhưng thẩm mỹ.


tốt đẹp, cách để đặt nó trên một kích thước 1 khối!
Giuseppe

3
@)O(@cho 5 byte và khôi phục tính đối xứng :)
MickyT

5

Bùa mê , 4 byte

1@Z1

Hãy thử trực tuyến! Hãy thử nó đảo ngược!

Tôi không thể tìm ra cách sử dụng lại 1lệnh, thậm chí với chi phí là một hoặc hai byte.

1@ɩ cũng hoạt động, nhưng là cùng số byte.


Tại sao đầu vào? Câu hỏi cho biết chương trình của bạn phải không có đầu vào.
Đánh giá cao hoạt động

@TwilightSparkle Tôi đã đọc sai và đã sửa nó
Draco18s

Vâng, tôi hiểu rồi. Tài giỏi.
Đánh giá cao hoạt động


5

Mèo xếp chồng -mn , 4 byte

:-:_

Hãy thử trực tuyến! Trong phần chân trang tôi đã bao gồm tất cả các giải pháp 4 byte khác. (Mèo xếp chồng bỏ qua mọi thứ sau khi cho ăn đầu tiên.)

Hãy thử ngược lại!

Giải trình

Các -nlượt cờ trên đầu ra số (và đầu vào, nhưng chúng tôi không có bất kỳ), và những -mlá cờ thường chỉ là một tiện nghi chơi golf cho phép bạn tránh được những phần không cần thiết của mã nguồn. Điều này là do mọi chương trình Stack Mèo cần phải có đối xứng gương. Với -mcờ bạn chỉ cho nó nửa đầu (cộng với ký tự trung tâm). Vì vậy, chương trình thực tế ở đây là:

:-:_:-:

Như bạn có thể thấy trong liên kết TIO đầu tiên, có rất nhiều giải pháp 4 byte, nhưng tôi đã chọn giải pháp này vì đơn giản. Stack Mèo dựa trên stack và chương trình này chỉ sử dụng stack ban đầu. Vì chúng ta không có bất kỳ đầu vào nào, nó chứa một -1(một điểm đánh dấu EOF) trên một giếng số vô hạn. Ba lệnh trong chương trình có ý nghĩa như sau:

:   Swap the top two stack elements.
-   Negate the top stack element (i.e. multiply by -1).
_   Pop a. Peek b. Push b-a.

Vì vậy, đây là cách chương trình sửa đổi ngăn xếp (trạng thái và lệnh được đặt so le để chỉ ra cách mỗi lệnh thay đổi ngăn xếp từ trạng thái này sang trạng thái tiếp theo):

   :   -   :   _   :   -   :

-1   0   0  -1   1   0   0   1
 0  -1  -1   0   0   1   1   0
 0   0   0   0   0   0   0   0
 …   …   …   …   …   …   …   …

Hóa ra, lệnh duy nhất thực sự làm bất cứ điều gì ở đây là _biến điểm đánh dấu EOF của chúng ta thành a 1. Đầu ra ở cuối chương trình là ẩn và dấu EOF là tùy chọn, vì vậy điều này chỉ in ra những gì 1chúng ta nhận được.

Bây giờ nếu chúng ta đảo ngược mã nguồn, do phản chiếu ngầm, chương trình thực tế sẽ trở thành:

_:-:-:_

Điều này làm một cái gì đó rất khác nhau:

   _   :   -   :   -   :   _

-1   1   0   0   1  -1   0  -1
 0   0   1   1   0   0  -1  -1
 0   0   0   0   0   0   0   0
 …   …   …   …   …   …   …   …

Lần này dưới cùng của ngăn xếp vẫn còn là một -1vì vậy nó đóng vai trò là điểm đánh dấu EOF và chỉ có-1 trên đầu trang của nó được in.

...

Bây giờ với tất cả những gì đã nói, vì Stack Mèo có mối quan hệ độc đáo với mã đảo ngược, tôi cảm thấy rằng việc sử dụng -mlà một chút gian lận. Thông thường chỉ có nghĩa là lưu byte bằng cách bỏ qua phần thừa của mã nguồn, nhưng ở đây nó thực sự làm cho thách thức dễ dàng hơn rất nhiều và thậm chí toàn bộ chương trình ngắn hơn. Điều này là do việc đảo ngược một chương trình đầy đủ sẽ chỉ thay đổi chương trình nếu nó chứa bất kỳ chương trình nào <>[], điều đó cũng có nghĩa là chương trình kết thúc bằng cách sử dụng nhiều ngăn xếp (Stack Mèo thực sự có một băng ngăn xếp, trong đó tất cả trừ một chương trình ban đầu chỉ được lấp đầy với số không để bắt đầu). Hơn nữa, đảo ngược nó sau đó chỉ hoán đổi các cặp <>[]cặp, điều này vẫn làm cho việc thực hiện đối xứng. Cách duy nhất để phá vỡ tính đối xứng đó là sử dụng Icái nào -]hoặc-[hoặc không có gì tùy thuộc vào dấu hiệu của đỉnh ngăn xếp. Vì thế...


Mèo xếp chồng -n , 11 byte

*|]I*:*I[|*

Hãy thử trực tuyến! Chân trang một lần nữa bao gồm tất cả các lựa chọn thay thế khác ở cùng một số byte. Một số đầu ra 1 / -1 và một số đầu ra 2 / -2 như được chỉ định sau mỗi chương trình. Tôi chọn cái này để giải thích ngẫu nhiên là một trong những cái đầu ra 2.

Hãy thử ngược lại!

Giải trình

Như tôi đã nói, cái này dài hơn một chút. Ngay cả khi chúng tôi đã sử dụng-m ký hiệu cho điều này, nó sẽ có trọng lượng 6 byte thay vì 4 ở trên.

Các lệnh được sử dụng lần này:

*   Toggle the least significant bit of the top of the stack.
|   Reverse the longest non-zero of prefix on this stack.
[]  Move one stack to the left/right and take the top of the current stack with you.
I   If the top of the stack is positive, -], if it's negative, -[, otherwise do nothing.
:   Swap the top two stack elements.

Chương trình đầu tiên chỉ sử dụng hai ngăn xếp. Đó là một chút lộn xộn để làm trong nghệ thuật ASCII, nhưng tôi sẽ cố gắng hết sức. Dấu ngoặc vuông cho biết ngăn xếp đầu băng nào được bật và tôi sẽ đặt các lệnh giữa mỗi cặp trạng thái ngăn xếp.

  [-1]
…   0   0   …
    0   0
    …   …

      *

  [-2]
…   0   0   …
    0   0
    …   …

      | (does nothing)
      ]

      [-2]
…   0   0   …
    0   0
    …   …

      I

   [2]
…   0   0   …
    0   0
    …   …

      *

   [3]
…   0   0   …
    0   0
    …   …

      :

   [0]
…   3   0   …
    0   0
    …   …

      *

   [1]
…   3   0   …
    0   0
    …   …

      I

      [-1]
…   3   0   …
    0   0
    …   …

      [

  [-1]
…   3   0   …
    0   0
    …   …

      |

  [ 3]
…  -1   0   …
    0   0
    …   …

      *

  [ 2]
…  -1   0   …
    0   0
    …   …

Bây giờ -1hoạt động như một điểm đánh dấu EOF và2 được in.

Các chương trình khác là như vậy cho đến khi [. Nó vẫn gần như giống nhau cho đến lần thứ hai I. Về mặt kỹ thuật, chúng tôi sẽ ở trên một ngăn xếp khác nhau, nhưng không có giá trị nào trên chúng, tất cả đều không thể phân biệt được. Nhưng sau đó, sự khác biệt giữa I[I]kết thúc quan trọng:

    *|[I*:*I

      [-1]
…   3   0   0   …
    0   0   0
    …   …   …

        ]

          [-1]
…   3   0   0   …
    0   0   0
    …   …   …

        | (does nothing)
        *

          [-2]
…   3   0   0   …
    0   0   0
    …   …   …

Và lần này, chúng ta không có điểm đánh dấu EOF, nhưng chương trình vẫn xuất ra -2.


4

Zsh , 12 byte

<<<2 # 2-<<<

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

Chuyển tiếp cơ bản, bình luận, phương pháp đảo ngược.


Nếu I / O ít hạn chế hơn, thì có thể có giải pháp 11 byte thú vị hơn nhờ Zsh hỗ trợ mã trả về âm:

return -127

Đảo ngược, 721- nruterthoát với mã 127(không tìm thấy lệnh). exit -127không thể được sử dụng, nó sẽ được chuyển sang a u8. Hãy thử trực tuyến!


4

CJam , 3 byte

W;1

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

Chúng hoạt động như thế nào

Phiên bản bình thường:

W    e# Push -1
;    e# Delete
1    e# Push 1
     e# Implicit display

Phiên bản ngược: bạn có được ý tưởng.


4

MATL , 3 byte

Nqv

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

Chúng hoạt động như thế nào

Bình thường:

N   % Push number of elements in the stack: 0
q   % Subtract 1: gives -1
v   % Concatenate stack contents vertically: leaves -1 as is
    % Implicit display stack contents

Đảo ngược:

v   % Concatenate stack contents vertically: gives the empty array, []
q   % Subtract 1: leaves [] as is
N   % Push number of elements in the stack: 1
    % Implicit display. [] is not displayed


4

Lục giác , 5 byte

1!@!(

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

Bất kỳ chương trình hợp lệ phải:

  • Có lệnh chấm dứt ( @hoặc: ). Cái sau chỉ khác với cái trước khi có lệnh di chuyển con trỏ bộ nhớ. Ngoài ra lệnh này không được ở byte đầu tiên hoặc byte cuối cùng.
  • Có một lệnh đầu ra. ( !,; cũng có thể nhưng có thể sẽ mất nhiều byte hơn)
  • Có một lệnh thao tác bộ nhớ.

Do đó, một chương trình 2 byte rõ ràng là không thể. Không thể có chương trình 3 byte vì byte thứ hai phải là lệnh kết thúc và byte đầu tiên không phải là lệnh thao tác nhân bản / IP, do đó chỉ có thể thực hiện 1 byte.

Tôi nghĩ rằng một chương trình 4 byte là không thể. Một chương trình như vậy phải có dạng a@bcvới lưới lục giác

 Forward:       | Backward:
                | 
  c b           |   a @
 @ a .          |  b c .
  . .           |   . .

Do đó aphải là một lệnh chuyển hướng IP. Tuy nhiên, không thể tạo cả số dương và số âm chỉ với 1 lệnh thao tác bộ nhớ.


+1 cho bằng chứng về sự tối ưu trong một câu trả lời tầm thường khác
Jo King



3

Java 5 hoặc 6, 127 67 byte

enum A{A;{System.out.print(9);}}//}};)9-(tnirp.tuo.metsyS{;A{A mune

Đầu ra 9/-9.

Không có trình biên dịch trực tuyến, vì Java 5 hoặc 6 không có sẵn ở bất cứ đâu.

Tuy nhiên, bạn có thể thử tương đương 127 byte Java 8 này:
Thử trực tuyến hoặc thử đảo ngược trực tuyến .

Giải trình:

enum A{                              // Create an enum
 A;                                  //  With a mandatory value
 {                                   //  And in a separate instance code-block:
  System.out.print(9);}}             //   Print 9 to STDOUT
//}};)9-(tnirp.tuo.metsyS{;A{A mune  // Comment and thus a no-op

Java 5 và 6 có một lỗi cho phép bạn tạo một khối mã bên trong enum để làm một cái gì đó, mặc dù thiếu phương thức chính bắt buộc của chương trình. Điều này sẽ dẫn đến một lỗi:

java.lang.NoSuchMethodError:
ngoại lệ chính trong luồng "chính"

Nhưng vẫn sẽ xuất ra những gì chúng ta muốn STDOUT trước, vì vậy chúng ta có thể bỏ qua điều đó .


3

Golang , 109 byte

package main;import "fmt";func main(){fmt.Println(1)}//})1(nltnirP.tmf{)(niam cnuf;"tmf" tropmi;niam egakcap

Và nó ngược lại:

package main;import "fmt";func main(){fmt.Println(-1)}//})1(nltnirP.tmf{)(niam cnuf;"tmf" tropmi;niam egakcap

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


2
Tôi không biết Go, nhưng có vẻ như bạn có thể xóa một vài byte. Có Printlnthể Print, và import "fmt";không cần không gian : import"fmt";. :)
Kevin Cruijssen


3

Võng mạc , 6 byte

-`<
-

In 1.

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



-
<`-

In -1.

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

Giải trình: 1

-`<
-

Điều này ... không làm gì cả. Do sự `, đây là thay một từ <để -(với cấu hình -, mà không làm gì), nhưng đầu vào là trống rỗng, vì vậy sản lượng rỗng là tốt.


Và giai đoạn thứ hai này khớp với biểu thức chính trống so với đầu vào trống và đếm số lượng kết quả khớp, chính xác là 1. Đầu ra là ẩn.

Giải trình: -1


-

Lần này chúng ta thay thế regex trống bằng -. Điều này thực sự biến đầu vào trống thành một -.

<`-

Ở đây, cấu hình thực sự làm một cái gì đó: <in đầu vào của giai đoạn trước khi thực hiện giai đoạn, vì vậy chúng tôi in -. Sau đó -đếm các dấu gạch nối trong đầu vào của giai đoạn một lần nữa 1. Do đầu ra ngầm định, điều này sẽ in 1sau -, cung cấp cho chúng tôi -1theo yêu cầu.


3

TEX(MathJax), 4byte

1%1-

Kết quảPhía trước:1% 1-1Lạc hậu:-1% 1-1


3

Brainfuck , 156 byte

+++++++++++++++++++++++++++++++++++++++++++++.+++++++++++++++++++++++++++++++++++++++++++++++++<+++++++++++++++++++++++++++++++++++++++++++++++++.++++++++++

Hãy thử trực tuyến! / Chuyển tiếp / xác minh lùi trong Bash

In -1về phía trước và\n1 lùi.

Mặc dù gần như không đáng kể, tôi tin rằng đây là giải pháp tối ưu cho đầu ra cố định cụ thể này.

Bằng chứng:

  • Chương trình không thể có [hoặc] .

    Do đó chương trình phải có hình thức <A> . <B> . <C>.

  • Mỗi ,có thể được thay thế bằng một số lượng đủ <mà không tăng số lượng +hoặc -.

  • Mỗi + chỉ hữu ích trong cả chương trình tiến hoặc lùi, không bao giờ cả hai.

    Bằng chứng: +trong phần A rõ ràng chỉ hữu ích trong chương trình chuyển tiếp, và+ trong phần C rõ ràng chỉ hữu ích trong chương trình lùi.

    Suy ra shift(P)= số lượng <trong P - số lượng >trong P. Xem xét chương trình <B> = <D> + <E>, +ở giữa là hữu ích trong chương trình chuyển tiếp shift(E) = 0, tương tự, nó hữu ích trong chương trình lạc hậu shift(D) = 0. Tuy nhiên, nếu shift(D) = shift(E) = 0sau đó chương trình được Bthực hiện tiến hoặc lùi sẽ thêm một giá trị cố định vào ô hiện tại trước khi in lần thứ hai, điều này không thể xảy ra vì ord('1') - ord('\n') != ord('1') - ord('-').

Do đó, chương trình cần ít nhất ord('-')+ord('1')+ord('\n')+ord('1') = 153 +s, 2 .s và ít nhất a < >hoặc ,bởi vì shift(B) != 0.

Khi sử dụng trang web của chúng tôi, bạn xác nhận rằng bạn đã đọc và hiểu Chính sách cookieChính sách bảo mật của chúng tôi.
Licensed under cc by-sa 3.0 with attribution required.