... Các số thông thường (hoặc số thứ tự) là các từ đại diện cho vị trí hoặc thứ hạng theo thứ tự liên tiếp.

Từ Wikipedia .

Nhiệm vụ của bạn là, sử dụng 2 chương trình riêng biệt (trong đó có thể được tạo từ 2 ngôn ngữ khác nhau), để xuất chuỗi thứ tự từ đầu đến nth. Bạn sẽ xuất ra từ đầy đủ secondtrái ngược với 2nd.

Thách thức của số thứ tự đã được đưa ra trước đây, đặc biệt là trong mục này . Trong thử thách này, các chức vụ chỉ đơn thuần là một phương tiện để tạo điều kiện cho các điều kiện độc đáo chi tiết dưới đây.

Phần 1

Bạn phải tạo một chương trình mà khi đưa ra đầu vào nphải xuất bất cứ thứ gì .
nsẽ luôn là số nguyên dương, khác không không lớn hơn 999.

Đầu ra hợp lệ bao gồm nhưng không giới hạn ở :

• Bất kỳ đầu ra nào cho stdout/ stderr/ etc
• Tạo tập tin / thư mục / vv
• Một giao diện đồ họa hoặc hình ảnh của bất kỳ loại nào

Bất cứ điều gì đi.

Phần 2

Bạn phải tạo một chương trình sử dụng đầu ra của chương trình của phần 1 để xuất một chuỗi các số thứ tự, bắt đầu từ 1 (đầu tiên), cho đến bất cứ thứ gì nđược phân tích cú pháp trong phần 1.

Điều kiện chung:

• Tổng số byte cho phần 2 không được vượt quá tổng số byte cho phần 1 (nhỏ hơn hoặc bằng).

Điều kiện đầu ra:

• Không phân biệt chữ hoa chữ thường.
• Đầu ra phải chỉ chứa chuỗi thứ tự (chỉ các ký tự aZ) và khoảng trắng (dòng mới được phép).
• Có thể xuất ra bất kỳ nguồn nào, miễn là nó có thể nhìn thấy trong hoặc sau khi thực hiện.
• Chương trình không cần kết thúc miễn là đầu ra của nó là chính xác.
• Đầu ra không bắt buộc phải có bất kỳ ngữ pháp nào, nhưng có thể tùy ý bao gồm nó (dấu gạch ngang, dấu phẩy, "ands", v.v.). nine hundred ninety ninthcũng được chấp nhận như nine hundred and ninety-ninth.

Đầu ra mẫu

Trong trường hợp nlà 8

FIRST SECOND THIRD FOURTH FIFTH SIXTH SEVENTH EIGHTH

Chấm điểm

Hệ thống phân cấp của các điều kiện thắng là:

1. Số byte thấp nhất trong phần 1
2. Số byte thấp nhất trong phần 2

Entry #1 | Part 1 = 32 bytes, Part 2 = 22 bytes
Entry #2 | Part 1 = 31 bytes, part 2 = 30 bytes

Entry #2 wins - Part 1 contains 31 bytes vs 32 bytes

---

Entry #1 | Part 1 = 21 bytes, Part 2 = 33 bytes
Entry #2 | Part 1 = 80 bytes, Part 2 = 70 bytes

Entry #2 wins - Entry #1 disqualified (Part 2 contains more bytes than Part 1)

---

Entry #1 | Part 1 = 50 bytes, Part 2 = 49 bytes
Entry #2 | Part 1 = 50 bytes, Part 2 = 50 bytes

Entry #1 wins - Part 1 is equal, Part 2 contains 49 bytes vs 50 bytes

Sledgehammer 0.5.1 / Sledgehammer 0.5.1, 10 byte

Chương trình 1 (10 byte):

⣘⢷⠾⣃⢖⣎⢅⡨⠱⢳

Giải nén vào chức năng Ngôn ngữ Wolfram này:

{Range[#1], "Ordinal"} &

Chương trình 2 (7 byte):

⡾⡁⢚⣷⣬⠤⣾

Giải nén vào chức năng Ngôn ngữ Wolfram này:

StringRiffle[IntegerName @@ #1, " "] &

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

R (có englishgói), 16 byte / 16 byte

 Phần 1, 16 byte

f=function(n)1:n

Phần 2, 16 byte

english::ordinal

Yêu cầu englishgói (không được cài đặt trên TIO, không may).

english::ordinal(f(22))đầu ra first second third fourth fifth sixth seventh eighth ninth tenth eleventh twelfth thirteenth fourteenth fifteenth sixteenth seventeenth eighteenth nineteenth twentieth twenty first twenty second.

Tất nhiên, phần 1 có thể được thực hiện ngắn hơn nhiều (3 byte seq:), nhưng điều đó sẽ đi ngược lại ràng buộc mà phần 2 phải không dài hơn phần 1.

Ngôn ngữ Wolfram (Mathicala) (cả hai phần), 18 byte / 15 byte

-5 / -1 nhờ lirtosiast

Phần 1, 18 byte

Range@#|"Ordinal"&

Phần 2, 15 byte

IntegerName@@#&

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

Hai hàm xuất ra thông qua giá trị trả về.

Python 3 (phần 1 & phần 2)

Thật không may, Nodebox rất dài dòng ... không có nhiều chỗ để chơi gôn.

Phần 1 76 byte

for  i  in  range  (  1 ,  int  (  input  (  ) ) + 1 ) : print ( i ,end=" ")

Phần 2 (Sử dụng thư viện NodeBox ) 76 byte

import en.number as n
for i in input().split():print(n.ordinal(n.spoken(i)))

JavaScript (Node.js), 47 byte / 47 byte

Hai hàm trong cùng môi trường Node.js, được gọi như thế g(f(n)). Sử dụng gói npm từ-to-words .

Phần 1, 47 byte (40 byte + 7 khoảng trắng)

n=>H=>{for(i=0;i<n;)console.log(H(++i))}       

Phần 2, 47 byte

F=>F(require("number-to-words").toWordsOrdinal)

Hãy thử nó trên Runkit!

JavaScript (Node.js), 48 byte / 43 byte

Phần 1, 48 byte

n=>[n,require("number-to-words").toWordsOrdinal]

Phần 2, 43 byte

([n,F])=>{for(i=0;i<n;)console.log(F(++i))}

Hãy thử nó trên Runkit!

Perl 5.10 / Lisp thông thường, 34/26 byte

Vì vậy, Common Lisp formatcó điều này như là một tích hợp, bởi vì tất nhiên nó có.

Chương trình 1 (34 byte)

say"(format t\"~:r \"$_)"for 1..<>

Perl làm tất cả các lần lặp. Mã Lisp chung tương đương ( (dotimes(i(read)) ...)) dài hơn Perl golfer nhiều ... for 1..<>. Perl xuất ra một loạt các mã Lisp thông thường.

Chương trình 2 (26 byte)

(loop(eval(read nil nil)))

Đó là REPL, trừ P. Nó đọc đầu vào tiêu chuẩn và, tốt, thực thi nó. Không chấm dứt, nhưng các quy tắc nói rõ ràng là tốt.