Wise là một ngôn ngữ bitwise đơn giản mà tôi đã thiết kế một thời gian trước. Nó dựa trên các hoạt động bitwise của Python . Nó có một số hoạt động hầu hết trong số này là giống hoặc rất giống với biểu tượng tương đương trong Python.

• : Nhân đôi đỉnh của ngăn xếp

• ? Xoay đỉnh của ngăn xếp xuống dưới cùng

• ! Xoay dưới cùng của ngăn xếp lên trên cùng

• [ ] vòng lặp trong khi đỉnh của ngăn xếp không bằng không

• ~không phải đỉnh của ngăn xếp ( -(n+1))

• -phủ định đỉnh của ngăn xếp ( -n)

• >bẻ khóa đỉnh của ngăn xếp một lần sang phải ( n//2)

• <bẻ khóa đỉnh của ngăn xếp một lần sang trái ( n*2)

• ^xor hai mục trên cùng của ngăn xếp ( Giống như Python )

• |hoặc hai mục trên cùng của ngăn xếp ( Giống như Python )

• &và hai mục trên cùng của ngăn xếp ( Giống như Python )

Tạo một số nguyên trong Wise khá đơn giản, bạn có thể tạo số 0 bằng ::^và tăng nó lên ~-để bạn tạo số 0 và tăng nó lên rất nhiều lần. Tuy nhiên nếu chúng ta loại bỏ những -thứ trở nên thú vị hơn một chút.

Chúng tôi vẫn có thể thực hiện mọi số bằng cách sử dụng các hoạt động còn lại. Ví dụ ở đây là 3

~<<~

TIO

Điều này hoạt động vì ~biến zero, một chuỗi 0bit vô hạn , thành chuỗi âm, chuỗi 1bit vô hạn , mỗi bit <nối thêm một 0bit vào cuối, khi chúng ta thực hiện xong, chúng ~biến mỗi chuỗi thành một chuỗi 0s theo sau là hai 1s hoặc như hầu hết mọi người gọi nó là 3.

Bài tập

Viết chương trình khi được cung cấp một số nguyên dương sẽ tạo ra chương trình Wise sẽ tạo ra số nmà không có bất kỳ -nguồn nào trong nguồn của nó (nguồn của đầu ra, bạn có thể sử dụng -trong nguồn của riêng mình). Bạn có thể cho rằng đã có một số 0 trên đỉnh của ngăn xếp.

Đây là code-golf chứ không phải meta-golf, vì vậy bạn nên đặt mục tiêu giảm thiểu mã nguồn tạo không nhất thiết là đầu ra.

Ví dụ đầu ra

Danh sách này không đầy đủ, chúng chỉ đơn giản là đầu ra có thể

1  -> ~<~
2  -> ~<~<
3  -> ~<<~
4  -> ~<~<<
5  -> ~<~:<<|
6  -> ~<<~<
7  -> ~<<<~
8  -> ~<~<<<
9  -> ~<~:<<<|
10 -> ~<~:<<|<
11 -> ~<<~:><<<|
12 -> ~<<~<<
13 -> ~<<~:<<<|>
14 -> ~<<<~<
15 -> ~<<<<~
16 -> ~<~<<<<

Japt , 10 byte

¤d0'<1"~<~

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

Ý tưởng cơ bản: lấy biểu diễn nhị phân của số và ánh xạ 0tới <và 1tới ~<~. Đầu ra cho 1-10:

 1: ~<~
 2: ~<~<
 3: ~<~~<~
 4: ~<~<<
 5: ~<~<~<~
 6: ~<~~<~<
 7: ~<~~<~~<~
 8: ~<~<<<
 9: ~<~<<~<~
10: ~<~<~<~<

JavaScript (ES6), 34 33 byte

f=n=>n?f(n&1?~n:n/2)+'<~'[n&1]:''

<input type=number oninput=o.textContent=f(this.value)><pre id=o>

Hoạt động với mọi số nguyên 32 bit.

Haskell , 38 byte

Tôi cảm thấy như PPCG đang thực sự cải thiện Haskell của mình. Mèo trắng vuốt ve.

f n=mapM(["<","~<~"]<$f)[1..n]!!n>>=id

fmất một Intvà trả về a String.

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

(Nhân tiện, tôi đang đề cập đến điều đó <$f. Nó cứu một nhân vật \_->.)

Trong Functorví dụ cho (->) a(các hàm từ loại a), chúng ta có : x <$ f = fmap (const x) f = const x . f = const x. Hạn chế duy nhất là fvà cuối cùng const xphải sử dụng cùng một loại nguồn a. Ví dụ là hoàn toàn lười biếng vì vậy điều này thậm chí không bao giờ đánh giá f.

Ngoài ra, cùng chiều dài nhưng ít tệ hơn ( (l!!)là một hàm ẩn danh):

(l!!)
l=(++)<$>"":tail l<*>["<","~<~"]

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

Cả hai đều sử dụng cùng một đại diện như câu trả lời Japt của @ETHproductions, mặc dù đặc biệt là câu đầu tiên có thể đưa ra một số câu thừa <vào lúc đầu.

Cái đầu tiên tính toán tất cả các kết hợp n "<"và "~<~"chuỗi, sau đó lập chỉ mục vào danh sách kết quả.

Cái thứ hai tính toán đệ quy một danh sách vô hạn được hình thành bằng cách bắt đầu ""và sau đó xây dựng các phần tử mới bằng cách nối thêm "<"và "~<~"chuỗi cho từng phần tử đã có trong danh sách (thực ra nó cũng ngắn hơn một chút để cho phép ""biến thành "<".)

Ruby , 118 116 109 107 105 91 byte

Đã lưu 2 byte nhờ cyoce!

->n{o={0=>""}
o.dup.map{|c,k|["~~c","<c*2"].map{|t|o[eval t[1..9]]=k+t[0]}}until o[n]
o[n]}

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

Đây là một hàm lấy số nguyên làm đầu vào và trả về chuỗi đại diện cho số nguyên đó trong Wise. Bạn có thể tìm thấy một phiên bản chưa được chỉnh sửa ở đây , thử nghiệm chương trình này trên tất cả các số nguyên từ 1 trở lên.

Ý tưởng cơ bản là ghi lại một "nhóm" hằng số. Sau đó, với mỗi "bước", hằng số được thêm vào nhóm cho từng chức năng có thể. Tôi đã chọn các hàm ~, <và >, mà tôi tin là đủ để đại diện cho mọi số. (Ít nhất, mỗi số dưới 10.000.)

Python2, 54 52 51 byte.

lambda x:'<'.join('>~<~'*int(i)for i in bin(x)[2:])

Cảm ơn Wheat Wizard đã lưu 2 byte và Ørjan Johansen cho một byte! Điều này sử dụng cùng một ý tưởng như câu trả lời Japt của ETHproduction, nhưng với các chuỗi thay thế khác nhau (nghĩa là sử dụng biểu diễn nhị phân)

05AB1E , 11 byte

bS'<…~<~‚èJ

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

Tương tự như câu trả lời Japt của ETHproductions.

Đã lưu 4 byte nhờ @Adnan!

Python 2 , 123 110 byte

def w(x):a=map(int,bin(x)[2:]);return x%2*("~<~:<"+"<".join(":"*e for e in a[-2::-1])+"|"*sum(a))or w(x/2)+"<"

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

Cũng như một lambda

w=lambda x:x%2*("~<~:<"+"<".join(":"*int(e)for e in bin(x)[-2:2:-1])+"|"*sum(map(int,bin(x)[2:])))or w(x/2)+"<"

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

Có thể ngắn hơn nhưng đây là giải pháp của tôi. Nó nhận biểu diễn nhị phân và biến nó thành mã.

Japt , 23 byte

?Uu ?ß~U +'~:ßU/2 +'<:P

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

Thạch, 11 10 byte

Bị“~<~“<”F

Đây là phiên bản được chuyển của câu trả lời Japt của ETHproductions. Nói về ETHproductions, họ đã tiết kiệm cho tôi một byte!