Bạn đã thu thập dữ liệu từ Bộ điều khiển thiết bị thu thập nâng cao ™ trong một thời gian dài. Bạn kiểm tra nhật ký và đến nỗi kinh hoàng bạn phát hiện ra rằng có điều gì đó đã sai lầm khủng khiếp: dữ liệu chỉ chứa các bit cuối cùng của các con số!

May mắn thay, bạn biết giá trị bắt đầu và giá trị đó không bao giờ thay đổi nhanh chóng. Điều đó có nghĩa là bạn có thể phục hồi phần còn lại bằng cách chỉ cần tìm khoảng cách từ đầu.

Thử thách

Bạn sẽ viết một chương trình hoặc một hàm để tính toán số lượng giá trị đã thay đổi, đưa ra một mô-đun Nvà một danh sách các giá trị trung gian modulo N.

Sự thay đổi giữa mỗi cặp số luôn nhỏ hơnN/2 , do đó sẽ chỉ có một câu trả lời hợp lệ cho mỗi trường hợp kiểm tra.

Bạn sẽ được cung cấp dưới dạng đầu vào số nguyên N> 2 và danh sách các giá trị, theo định dạng bạn chọn. Đầu vào có thể được cung cấp thông qua STDIN hoặc dòng đối số hoặc đối số chức năng.

Bạn sẽ xuất một số nguyên duy nhất, số tiền giá trị ban đầu đã thay đổi. Đầu ra có thể được in ra STDOUT hoặc trả lại.

Quy tắc

• Chương trình của bạn phải làm việc cho bất kỳ khoảng cách và mô đun nhỏ hơn 2^20.
• Bạn có thể cho rằng:
  • Nlà ít nhất 3.
  • Danh sách có ít nhất 2 giá trị.
  • Tất cả các giá trị trong danh sách ít nhất là 0 và nhỏ hơn N.
  • Tất cả các thay đổi trong số ít hơn N/2.
• Bất cứ điều gì khác là một đầu vào không hợp lệ, và chương trình của bạn có thể làm bất cứ điều gì nó muốn.
• Các lỗ hổng tiêu chuẩn, bất kỳ thư viện không chuẩn và các hàm tích hợp cho mục đích chính xác này đều bị cấm.
• Đây là môn đánh gôn , vì vậy chương trình ngắn nhất tính bằng byte sẽ thắng.

Ví dụ trường hợp kiểm tra

Đầu vào:

3
0 1 2 2 0 1 0 2 1 2 0 1 2 1 1

Đầu ra:

4

Giải thích (với giá trị mẫu):

Value mod 3: 0 1 2 2 0 1 0 2 1 2 0 1 2 1 1
Value:       0 1 2 2 3 4 3 2 1 2 3 4 5 4 4

Đầu vào:

10
5 2 8 9 5

Đầu ra:

-10

Giải thích (với giá trị mẫu):

Value mod 10:  5  2  8  9  5
Value:        15 12  8  9  5

Đầu vào không hợp lệ:

2
0 0 0 0 0

(mô đun quá nhỏ)

6
2 5 4 2

(thay đổi quá lớn giữa 2 và 5)

TI-BASIC, 15 byte

Input N
sum(N/πtan⁻¹(tan(ΔList(πAns/N

Lấy danh sách từ Ansvà mô đun từ Input.

                       πAns/N    ; Normalize the list to [0,π)
                 ΔList(          ; Take differences, which are in the range (-π,π)
       tan⁻¹(tan(                ; Modulo, but shorter. Now elements are in (-π/2,π/2)
    N/π                          ; Multiply by N/π. These are displacements at each step.
sum(                             ; Add up all the displacements

Python 2, 53 byte

lambda n,l:sum((b-a+n/2)%n-n/2for a,b in zip(l,l[1:]))

Siêu thẳng về phía trước trả lời. Tôi tự hỏi nếu có một cách ngắn hơn.

Toán học, 30 byte

Tr@Mod[Differences@#2,#,-#/2]&

Đây là một hàm ẩn danh có hai đối số. Ví dụ sử dụng:

Tr@Mod[Differences@#2,#,-#/2]&[3, {0, 1, 2, 2, 0, 1, 0, 2, 1, 2, 0, 1, 2, 1, 1}]
(* 4 *)
Tr@Mod[Differences@#2,#,-#/2]&[10, {5, 2, 8, 9, 5}]
(* -10 *)

Này hoạt động bằng cách lấy Differencesgiữa các yếu tố liên tiếp, bao bì của họ để phạm vi -n/2đến +n/2với Modvà thông số bù đắp nó, sau đó đưa tổng số với Tr(ma trận dấu vết, cộng các yếu tố đường chéo).

Lưu ý rằng ngay cả không được phép, nó chỉ có 43 byte!

f[n_, l_] := Total[Mod[Differences[l], n, -n/2]]

J, 24 byte

[+/@(]-(>-:)~*[)[|2-~/\]

Sử dụng:

   f=:[+/@(]-(>-:)~*[)[|2-~/\]

   3 f 0 1 2 2 0 1 0 2 1 2 0 1 2 1 1
4

   10 f 5 2 8 9 5
_10

Sẽ cố gắng để chơi golf nhiều hơn và thêm một số lời giải thích sau đó.

Hãy thử trực tuyến tại đây.

Bình thường, 20 19 byte

sm-J/Q2%+-FdJQ.:vw2

Lấy trộm .:_2từ Jakube, ý tưởng từ Mauris.

R, 38 byte

function(n,v)sum((diff(v)+n/2)%%n-n/2)

Điều này tạo ra một hàm không tên chấp nhận một số nguyên và một vectơ làm đầu vào và trả về một số nguyên duy nhất. Để gọi nó, đặt tên cho nó, vd f=function(n,v)....

Ungolfed + giải thích:

f <- function(n, v) {
    # Compute the differences between sequential elements of v
    d <- diff(v)

    # Add n/2 to the differences and get the result modulo n
    m <- (d + n/2) %% n

    # Subtract n/2 then sum the vector
    sum(m - n/2)
}

Ví dụ:

> f(3, c(0, 1, 2, 2, 0, 1, 0, 2, 1, 2, 0, 1, 2, 1, 1))
[1] 4

> f(10, c(5, 2, 8, 9, 5))
[1] -10

MatLab, 33 byte

@(x,y)sum(mod(diff(y)+x/2,x)-x/2)

Tôi xin lỗi, đây là câu trả lời đầu tiên của tôi trên trang web này. Nhập giá trị này vào MatLab sau đó sử dụng đầu vào ans(modulus_value, [intermediate_values])sẽ trả về giá trị được yêu cầu, trong đó 'modulus_value' là giá trị mô-đun và 'trung gian_values' là danh sách các giá trị trung gian được phân tách bằng dấu cách hoặc dấu phẩy.

Thí dụ:

ans(3, [0 1 2 2 0 1 0 2 1 2 0 1 2 1 1])

Các chức năng ẩn danh lợi dụng MatLab của mod, diffvà sumcác chức năng để tính toán các câu trả lời. Đầu tiên, sự khác biệt giữa mỗi giá trị trung gian được tính toán. Kết quả sau đó được bù bởi mô đun chia cho hai, dẫn đến một tập hợp các giá trị chênh lệch được ràng buộc bởi [-modulus / 2 mô đun / 2]. Kết quả sau đó được bù và tổng hợp lại.

Tôi nghĩ rằng điều này có thể được đánh gôn nhiều hơn, tôi sẽ quay lại sớm với một bản cập nhật. Đặc biệt cảm ơn @ 2012rcampion cho ý tưởng.

Chỉnh sửa:unwrap Chức năng của Matlab gần như hoạt động ở đây, nhưng thật khó để chơi gôn. Đoạn mã sau trả về một mảng trong đó giá trị cuối cùng là số tiền giá trị đầu tiên đã thay đổi: @(x,y)unwrap(y/x*2*pi)/2/pi*x-y(1)

Các giá trị trung gian được chia tỷ lệ theo phạm vi [-pi pi], sau đó "không được bao bọc" sao cho không có giá trị liên tiếp nào lớn hơn pi. Các giá trị này sau đó được thu nhỏ lại và dịch chuyển, dẫn đến một khoảng cách từ giá trị bắt đầu.

Thú vị, nhưng không thực tế cho thử thách này: D

Bình thường, 29 byte

+sm**._K-Fdvz>y.aKvz.:Q2-eQhQ

Dùng thử trực tuyến: Trình biên dịch / thực thi Pyth

CJam, 27 byte

0q~:_2ewf{~\m1$2/:I+\,=I-+}

Kiểm tra nó ở đây.

Pip , 39 byte

Qn$+({a>n/2?a-na<-n/2?a+na}Mg@>1-g@<-1)

Yêu cầu danh sách dữ liệu dưới dạng đối số dòng lệnh và mô đun trên STDIN. Nếu quá nhiều, tôi có một phiên bản có hai đối số dòng lệnh để có thêm 5 byte.

Giải trình:

                                         g is list of cmdline args (implicit)
Qn                                       Read n from stdin
                            g@>1         All but the first of the cmdline args
                                -g@<-1   ...minus all but the last of the cmdline args
                                         (i.e. a list of the differences of adjacent items)
     {                    }M             ...to which, map the following function:
      a>n/2?a-n                            If diff is too big, subtract n;
               a<-n/2?a+n                  else if too small, add n;
                         a                 else return unchanged
  $+(                                 )  Sum; print (implicit)

Và chỉ để chứng minh rằng điểm số không cạnh tranh này phản ánh nhiều hơn về kỹ năng chơi gôn của tôi so với ngôn ngữ của tôi, đây là một cổng của giải pháp Python của Mauris trong 30 byte :

Qn$+({(n/2-$-a)%n-n/2}MgZg@>1)

Thạch , không cạnh tranh

6 byte Câu trả lời này không cạnh tranh, vì thử thách trước khi tạo ra Jelly.

Iæ%H}S

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

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

Iæ%H}S    Main link. Left input: A (list). Right input: N (integer).

I         Compute the increments (deltas of consecutive elements) of A.
   H}     Halve the right input (N).
 æ%       Mod the increments into (-N/2, N/2].
     S    Take the sum of all results.