Sau khi @ MartinBüttner đạt được chính xác 10.000 danh tiếng , giờ đây chúng tôi có ba hàng 10k người dùng đầy đủ trên trang người dùng ! Bây giờ, vì tất cả chúng ta đều là lập trình viên ở đây, chúng tôi muốn tự động hóa mọi thứ thay vì thực hiện chúng một cách thủ công. Thử thách của bạn là viết một chương trình để tự động chúc mừng người dùng 10k mới.

Đặc điểm kỹ thuật

Đầu vào

Đầu vào sẽ là ncác dòng của các số được phân tách bằng dấu cách. (Nếu bạn muốn, bạn cũng có thể lấy một danh sách các số được phân tách bằng dấu phẩy, nếu điều đó làm cho mã của bạn ngắn hơn.) Ví dụ:

10 20 30 40 50
15 25 35 45 55
20 30 40 50 60

Hoặc là:

10 20 30 40 50,15 25 35 45 55,20 30 40 50 60

Mỗi danh sách các số đại diện cho một danh sách các giá trị danh tiếng của người dùng trong một ngày.

Đầu ra

Đầu ra sẽ có cùng số lượng ndòng (hoặc danh sách được phân tách bằng dấu phẩy có cùng độ dài). Mỗi mục / danh sách sẽ là:

• :D nếu có một người dùng có danh tiếng chỉ trở thành> = 10.000.
  • Nhiều :Ds được phân tách bằng dấu cách nếu có nhiều người dùng đã gặp hoặc vượt qua số lượng 10.000 rep. Ví dụ: :D :D :Dcho 3 người dùng 10k mới.
• :( và sau đó tạm dừng đầu ra thêm nếu đầu vào không rõ ràng hoặc không thể (thêm về điều này trong phần tiếp theo).
• Không có gì nếu cả hai điều kiện này đều không đúng.

Sự mơ hồ

Có thể là đầu vào mơ hồ. Đối với mục đích của thử thách này, chúng tôi giả định rằng:

• Giới hạn danh tiếng là 200 mỗi ngày, bỏ qua chấp nhận và tiền thưởng và tương tự cho các thách thức.
• Người dùng có thể không mất danh tiếng (một lần nữa vì đơn giản và cho thử thách).

Đầu vào được coi là mơ hồ khi không thể xác định giá trị danh tiếng nào tương ứng với người dùng nào. Ví dụ: trong đầu vào 10 20,30 40, bạn không thể biết người dùng 10 rep trở thành người dùng 30 rep hay người dùng 40 rep.

Đầu vào được coi là không thể khi người dùng từ một ngày không thể trở thành người dùng từ ngày hôm sau. Ví dụ, trong đầu vào 10 20,310 320, tình huống này rõ ràng là không thể vì người dùng không thể có được 300 danh tiếng trong một ngày. Người dùng mất danh tiếng cũng là không thể.

Trường hợp cạnh

• Các giá trị danh tiếng ban đầu có thể bắt đầu ở bất cứ điều gì (tức là người dùng có thể bắt đầu với danh tiếng 1337).
• Không có đầu ra cho mục hàng / danh sách đầu tiên.
• Đầu vào sẽ luôn có giá trị cú pháp, nghĩa là các giá trị danh tiếng sẽ luôn là số nguyên dương, sẽ luôn có cùng một lượng giá trị danh tiếng cho mỗi mục / danh sách, v.v.
• Các giá trị danh tiếng không được sắp xếp; chúng có thể theo thứ tự bất kỳ.

Các trường hợp thử nghiệm

Đầu vào: 9900,10000
Đầu ra::D

Đầu vào: 9900 9950 9910,10100 9950 9910,10300 10150 10110
Đầu ra::D,:D :D

Đầu vào: 10 20 30,42 10 20,10 242 20,442 42 10,0 0 0,442 42 10
Đầu ra:,,,:(

Đầu vào: 10 20,15 25,15 25
Đầu ra:,,

Đầu vào: 9999 9998 9997,10000 9998 9997,10000 10000 9997,10300 10000 10000
Đầu ra::D,:D,:(

Đầu vào: 100,90,80,70
Đầu ra::(

Đầu vào: 10000 10000 10000 9999,10000 10000 10000 10000,10010 10020 10030 10040
Đầu ra::D,:(

Đầu vào: 9999 9998 9997 9996,10196 10197 10198 10199,10399 10199 10197 10196
Đầu ra::D :D :D :D,

Ruby, 209 byte

Chỉnh sửa: Tôi đã chuyển sang Ruby, rút ​​ngắn khoảng 30%. Xem lịch sử chỉnh sửa cho phiên bản Mathicala gốc. Tôi cho rằng các khoản tiết kiệm chính đến từ Ruby permutationkhông bỏ qua các vị trí đã chuyển đổi của các yếu tố giống hệt nhau (mà tôi phải lừa Mathicala).

Điều này sử dụng định dạng phân tách dòng mới.

gets.split('
').map{|s|s.split.map &:to_i}.each_cons(2){|a,b|a.permutation.map{|q|q.zip(b).map{|x,y|y-x}}.reject{|d|d.any?{|x|x<0||x>200}}.size!=1?abort(':('):(puts':D '*(a.count{|d|d<1e4}-b.count{|d|d<1e4}))}

Ý chính là đây:

• Nhận tất cả các cặp ngày liên tiếp.
• Nhận tất cả các hoán vị của ngày trước, và trừ từng trong số này từ ngày hiện tại.
• Bỏ tất cả các kết quả có chứa chênh lệch âm hoặc lớn hơn 200.
• Nếu số lượng hoán vị còn lại không phải là 1, đầu ra :(.
• Nếu không, đầu ra nhiều :Dnhư có người dùng 10k mới.
• Vào cuối, thả tất cả các ngày sau khi đầu tiên :(.

Ít golf hơn:

gets.split("\n").map{|s|
  s.split.map &:to_i
}.each_cons(2){|a,b|
  a.permutation.map{|q|
    q.zip(b).map{|x,y|
      y-x
    }
  }.reject{|d|
    d.any?{|x|
      x<0||x>200
    }
  }.size!=1 ? abort(':(') : (puts ':D '*(a.count{|d|d<1e4}-b.count{|d|d<1e4}))
}

Tôi nghĩ đó là một chuỗi các điều tra viên xinh đẹp. :)

PS: Có lạ không khi tôi là người đầu tiên gửi câu trả lời cho điều này?

Haskell, 254 249 244 232 228

import Data.List
t=m(9999<)
p(a:b:r)=(a,b,r)%(filter(all(`elem`[0..200]))$nub$m(zipWith(-)b)$permutations a)
p _=""
(a,b,r)%(_:[])=(concat$m(const":D ")$t b\\t a)++'\n':p(b:r)
_%_=":("
m=map
main=interact$p.m(m read.words).lines

Một lời giải thích nhỏ: Thuật toán này rất giống với thuật toán được MartinBüttner sử dụng, ngoại trừ thuật toán nubmà tôi đã dành một số suy nghĩ. Lưu ý rằng một sự khác biệt danh sách được sử dụng để tìm ra có bao nhiêu giá trị danh tiếng hơn 10000 hoặc lớn hơn vào ngày n + 1 so với ngày n : t b\\t a.

Tôi cũng đồng ý với MartinBüttner về việc giải thích các thông số kỹ thuật và rằng một số ví dụ ở trên là sai, thậm chí đến mức ví dụ # 2 là sai (nên là :().