n=e=$Input;
a=0;
w=While[{m=Modulo[$e];Not[m[1]];}];
w=w[{f=For[4];f=f[@x];f=f[{Print[$e];q=Equal[$x];i=If[{q[1];}];i=i[{k=Times[$e];}];Do[$i];i=If[{q[2];}];i=i[{k=Add[$e];}];Do[$i];i=If[{q[3];}];i=i[{k=Subtract[$e];}];Do[$i];i=If[{q[4];}];i=i[{k=Divide[$e];}];Do[$i];e=k[a=Increment[$a]];}];Do[$f];}];
Do[$w];
Hãy thử trực tuyến!
Đó là khoảng thời gian tôi sử dụng lại Rutger. Thật không may, nó có thể không phải là ngôn ngữ tốt nhất cho nhiệm vụ, vì nó không có hình thức nào eval, buộc tôi phải sử dụng bốn câu lệnh if
Làm thế nào nó hoạt động
Cách thức hoạt động của Ruthger
Một lời giới thiệu ngắn gọn về cách ngôn ngữ hoạt động: Mọi thứ đều là một nhiệm vụ hoặc một chức năng và mỗi chức năng đều có chính xác một đối số. Đối với các hoạt động yêu cầu nhiều hơn một đối số (ví dụ: phép nhân), cuộc gọi đầu tiên trả về một hàm một phần , khi được gọi lại với đối số thứ hai, sẽ trả về kết quả mong đợi. Ví dụ:
left = Times[5];
Print[left[6]];
sẽ in ra 30: Dùng thử trực tuyến! . Mặc dù thông thường, nó dài hơn so với thay thế thông thường, đôi khi nó có thể lưu byte, nếu một hàm được gọi lặp lại với một đối số không đổi và một đối số thay đổi, ví dụ như khi in ra các bảng lần.
Quy tắc một đối số này áp dụng cho mọi thứ không phải là hằng hoặc biến, bao gồm các vòng lặp và các điều kiện. Tuy nhiên, các vòng lặp và điều kiện ( For, Each, While,DoWhile , Ifvà IfElse) là doable , có nghĩa là để thực sự chạy chúng, các Dochức năng phải được gọi (xem dòng cuối cùng trong câu trả lời). Một lần nữa, điều này có thể lưu byte khi liên tục chạy cùng một vòng lặp hoặc cho phép bạn chạy mã tùy ý giữa định nghĩa và chạy vòng lặp.
Cuối cùng, có ba cách để chỉ các biến, tất cả đều được sử dụng trong chương trình này. Đầu tiên là tham chiếu trực tiếp , trong đó tên biến được thêm tiền tố bằng $ký hiệu. Điều này truy cập trực tiếp vào giá trị của biến và trả về nó. Thứ hai là tham chiếu chức năng , không có ký tự tiền tố. Điều này cho phép mã phân biệt giữa các hàm (có khả năng một phần) được gán cho các biến và các biến thực tế có chứa một giá trị cụ thể. Cuối cùng, tham chiếu gián tiếp , có tiền tố là một @ký hiệu, tạo ra một biến (nếu nó chưa tồn tại) và trả về đối tượng biến trong một phạm vi nhất định. Điều này cho phép bạn tạo một biến vòng lặp (ví dụ: itrong for i in range(...)).
Giải pháp thực tế hoạt động như thế nào
Đây là mã không được mã hóa:
n = elem = $Input;
var = 0;
while = While[{
mod = Modulo[$elem];
Not[mod[1]];
}];
while = while[{
for = For[4];
for = for[@index];
for = for[{
Print[$elem];
equal = Equal[$index];
if = If[{ equal[1]; }];
if = if[{ func = Times[$elem]; }];
Do[$if];
if = If[{ equal[2];}];
if = if[{ func = Add[$elem];}];
Do[$if];
if = If[{ equal[3];}];
if = if[{ func = Subtract[$elem];}];
Do[$if];
if=If[{ equal[4];}];
if=if[{ func = Divide[$elem];}];
Do[$if];
elem = func[var = Increment[$var]];
}];
Do[$for];
}];
Do[$while];
Hãy thử trực tuyến!
Như bạn có thể thấy, nó bắt đầu bằng cách gán ba biến n , evà a, trong đó đại diện cho đầu vào, yếu tố thay đổi trong trình tự, và số thay đổi cho mỗi phần tử mới tương ứng. Sau đó chúng ta tạo một vòng lặp while:
w=While[{m=Modulo[$e];Not[m[1]];}];
Các dấu ngoặc ( {và }) xác định một khối mã, trong đó câu lệnh cuối cùng trong khối là điều kiện cho vòng lặp while. Trong trường hợp này, chúng tôi bắt đầu bằng cách xác định hàm modulo một phần, sẽ lấy trong đối số thứ hai mvà trả về e % m. Sau đó chúng ta gọi hàm này một phần với1 như là đối số thứ hai của nó, trở lại 0cho số nguyên và số nguyên khác không cho số float. Sau đó, chúng tôi tính toán logic không phải của điều này, ánh xạ0 → 1 và n → 0 , n ≠ 0.
Tiếp theo chúng ta đến với sự quái dị tuyệt đối bao gồm cơ thể của vòng lặp while:
w=w[{f=For[4];f=f[@x];f=f[{Print[$e];q=Equal[$x];i=If[{q[1];}];i=i[{k=Times[$e];}];Do[$i];i=If[{q[2];}];i=i[{k=Add[$e];}];Do[$i];i=If[{q[3];}];i=i[{k=Subtract[$e];}];Do[$i];i=If[{q[4];}];i=i[{k=Divide[$e];}];Do[$i];e=k[a=Increment[$a]];}];Do[$f];}];
Phần chính của vòng lặp này là một vòng lặp for, lặp đi lặp lại 4lần mỗi lần lặp của vòng lặp while, có một biến lặp xvà bao gồm:
Print[$e];
q=Equal[$x];
i=If[{q[1];}];i=i[{k=Times[$e] ;}];Do[$i];
i=If[{q[2];}];i=i[{k=Add[$e] ;}];Do[$i];
i=If[{q[3];}];i=i[{k=Subtract[$e] ;}];Do[$i];
i=If[{q[4];}];i=i[{k=Divide[$e] ;}];Do[$i];
e=k[a=Increment[$a]];
Câu lệnh đầu tiên in ra mỗi lần lặp của chuỗi trước khi sửa đổi nó. Sau đó, chúng ta tạo một hàm một phần để kiểm tra sự bằng nhau với biến vòng lặp xvà gặp bốn câu lệnh if. Mỗi kiểm tra tuyên bố nếu xbằng 1, 2, 3 hoặc 4 tương ứng, và sau đó chuyển nhượng kcho mỗi chức năng trong *, +, -và /, sau đó làm cho nó thành một chức năng một phần với enhư là đối số của nó. Cuối cùng, chúng ta gán eđể kchạy với atư cách là đối số thứ hai và tăng dần a.
