Một chuỗi phản đối là một số loại dữ liệu thử nghiệm tự mô tả được sử dụng trong kiểm tra phần mềm. Không chắc nó thực sự được phát minh bởi James Bach , nhưng tôi biết nó từ đó.

Ý tưởng như sau: dữ liệu thử nghiệm chứa nhiều dấu hoa thị ( *). Số ở phía trước dấu hoa thị cho bạn biết thời gian kiểm tra dữ liệu tại thời điểm đó. Nếu bạn cần biết một vị trí trong dữ liệu thử nghiệm không phải là dấu hoa thị, hãy tìm dấu hoa thị cuối cùng, nhìn vào số trước đó và thêm số chữ số theo sau.

Trình tự bắt đầu như thế này:

2*4*6*8*11*14*17*20*23*
             ^

Như bạn có thể thấy, dấu hoa thị được đánh dấu nằm ở vị trí 14.

Nếu một tập tin xảy ra bị cắt ngắn như sau

[...]2045*20

sau đó bạn có thể rút ra rằng có giới hạn 2047 ký tự ở đâu đó (2045 trong đó dấu hoa thị cộng với 2 cho 2và 0).

Nhiệm vụ của bạn là tạo ra chương trình ngắn nhất (đây là code-golf ) tạo ra (std :: out hoặc file hoặc bất cứ thứ gì) một chuỗi thử nghiệm dài tùy ý có định dạng đó. Độ dài trong các ký tự được đưa ra làm đối số. Chương trình sẽ hỗ trợ tối đa 2 GB dữ liệu thử nghiệm (giá trị đầu vào 2147483647 ký tự).

Vị trí "nguy hiểm" trong tệp 2 GB:

8*11*
98*102*
998*1003*
9998*10004*
99998*100005*
999995*1000003*
9999995*10000004*
99999995*100000005*
999999995*1000000006*

Điều này sẽ trả lời câu hỏi của @Leaky Nun nếu có quyết định đưa ra từ 995 * 999 * đến 995 * 1000 * hoặc tương tự: không.

Phần cuối của tệp 2 GB có giá trị đầu vào 2147483647 là:

2147483640*2147483

Haskell, 60 58 byte

Là một chức năng, chúng tôi nhận được:

f=length.show
iterate(\n->1+n+(f$n+1+f n))2>>=(++"*").show

Chương trình đầy đủ, 72 70 byte

Điều này tạo ra một chuỗi ngược vô hạn thành STDOUT:

f=length.show
main=putStr$iterate(\n->1+n+(f$n+1+f n))2>>=(++"*").show

Nhập chiều dài cần thêm 20 byte:

main=interact(\j->take(read j)$iterate(\n->1+n+(f$n+1+f n))2>>=(++"*").show)

Điều này hoạt động tối đa với kích thước RAM của bạn, vì Haskell mặc định các loại tích phân số thành Integer.

Pyth, 25 17 15 14 byte

<uu++GlN\*k)Qk

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

Chiều dài được thực hiện thông qua STDIN.

Python 2, 74 72 66 64 61 byte

f=lambda n,i=2:"%d*"%i+f(n,len(`i+2`)-~i)[:n-2]if i<n*2else""

Lấy một số nguyên n và xuất ra một chuỗi có độ dài n.

phiên bản chương trình, 69 byte:

s,n,i="",input(),2
while i<2*n:s+="%d*"%i;i+=len(`i+2`)+1
print s[:n]

Lấy một số nguyên n từ stdin và in một chuỗi có độ dài n.

Phiên bản thay thế ngắn hơn, nhưng hầu như chỉ hoạt động:

n,i=input(),2
while i<2*n:print("%d*"%i)[:n-i],;i+=len(str(i+2))+1

PowerShell v5, 97 byte

param($n)$l=1;for($i=0;$i-lt$n){$i+="$i*".length;if("$i".Length-gt$l){$i++;$l++};ac .\o "$i*" -n}

Lấy đầu vào làm đối số dòng lệnh $n, đặt trình trợ giúp $lmà chúng ta sử dụng để theo dõi độ dài số nguyên của chúng tôi. Sau đó, chúng tôi lặp từ 0lên đến $n. Mỗi lần lặp, chúng ta tăng $itheo .lengthchuỗi được hình thành từ $ivà dấu hoa thị. Sau đó, nếu .lengthcác $ithay đổi (ví dụ, chúng tôi di chuyển từ 2 chữ số 3 chữ số), chúng tôi tăng cả helper $lbiến ength và $i(vào tài khoản cho các chữ số bổ sung). Sau đó chúng tôi sử dụng add-contentlệnh để chắp thêm "$i*"vào tệp .\otrong thư mục hiện tại, với -noNewLine.

Lưu ý

• Yêu cầu v5, vì -noNewLinetham số cuối cùng đã được thêm vào trong phiên bản đó.
• PowerShell sẽ tự động chuyển đổi từ [int]sang [double](không, tôi không biết lý do tại sao nó không chuyển sang [long]), do đó, điều này sẽ xử lý chính xác đầu vào lên đến và lớn hơn 2147483648, mà không gặp vấn đề gì. Về mặt lý thuyết, nó sẽ xử lý đầu vào ở đâu đó xung quanh 1.79769313486232E+308(giá trị tối đa [double]) trước khi phàn nàn, nhưng tôi hy vọng đĩa sẽ lấp đầy trước khi điều đó xảy ra. ;-)
• Do kiểm tra điều kiện vòng lặp, điều này sẽ xuất ra tệp tối thiểu chiều dài đầu vào. Ví dụ, đối với đầu vào 10này sẽ xuất ra 2*4*6*8*11*, vì 11là $igiá trị đầu tiên lớn hơn đầu vào.

PowerShell v2 +, cũng 97 byte (không cạnh tranh)

param($n)$l=1;-join(&{for($i=0;$i-lt$n){$i+="$i*".length;if("$i".Length-gt$l){$i++;$l++};"$i*"}})

Thay vì gửi đến một tệp, điều này gói gọn các vòng lặp lặp và sau đó -joinghép chúng lại thành một chuỗi. Điều này cho phép nó hoạt động cho các phiên bản sớm hơn v5. Tuy nhiên, vì .NET định nghĩa a [string]với hàm tạo như thế String(char c,Int32 length), phiên bản này không thỏa mãn yêu cầu đầu vào tối đa, vì chuỗi đầu ra sẽ tràn và barf.

Ngoài ra, bạn có thể không muốn có chuỗi ~ 2GB trôi nổi trong đường ống của mình. Chỉ cần nói.

Python 3, 126 114 99 byte

def f(x,s=''):
 i=t=2
 while len(s)<x:i+=len(str(t+i))-len(str(t));s+=str(t)+'*';t+=i
 print(s[:x])

Một hàm lấy đầu vào thông qua đối số đếm ký tự để cắt ngắn chuỗi và in ra STDOUT.

Làm thế nào nó hoạt động

Sự khác biệt giữa các số trong chuỗi ban đầu là 2. Mỗi khi một thứ tự cường độ được thông qua, sự khác biệt này được tăng thêm 1; điều này có thể đạt được bằng cách lấy chênh lệch giữa số chữ số của số hiện tại và số chữ số của số hiện tại được thêm vào chênh lệch, chỉ bằng 1 khi được yêu cầu. Hàm chỉ đơn giản là các vòng lặp trong khi độ dài của chuỗi nhỏ hơn đầu vào, nối vào chuỗi và cập nhật sự khác biệt và số lượng theo yêu cầu, sau đó cắt ngắn trước khi in.

Hãy thử nó trên Ideone

Phiên bản đầu ra vô hạn, 69 byte

s=i=2
while 1:i+=len(str(s+i))-len(str(s));print(end=str(s)+'*');s+=i

R, 92 byte

    N=nchar;f=function(n){z=0;y="";while(z<n){z=z+N(z+N(z)+1)+1;y=paste0(y,z,"*")};strtrim(y,n)}

Ví dụ đầu ra:

f (103) [1] "2 * 4 * 6 * 8 * 11 * 14 * 17 * 20 * 23 * 26 * 29 * 32 * 35 * 38 * 41 * 44 * 47 * 50 * 53 * 56 * 59 * 62 * 65 * 68 * 71 * 74 * 77 * 80 * 83 * 86 * 89 * 92 * 95 * 98 * 102 * 1 "

Thạch , 22 19 18 byte

2µṾL+®‘¹©=¡=µ³#j”*

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

Tìm các nsố đầu tiên trong chuỗi sau đó tham gia danh sách bằng dấu hoa thị. Điều này sẽ luôn dài hơn mức ncho phép của OP trong các bình luận.

Chương trình cập nhật có chọn lọc thanh ghi với số hiện tại trong chuỗi trong #vòng lặp với ¹©=¡. Tôi đã hy vọng điều này có thể ngắn hơn, bằng cách đặt ©sau lần thứ hai µchẳng hạn, nhưng tiếc là điều đó không hiệu quả và tôi không thể tìm ra điều gì ngắn hơn.