Cấu hình điện tử

Nhiệm vụ của bạn là chấp nhận số nguyên tử của một nguyên tố làm đầu vào và xuất cấu hình electron của nó (ví dụ như 2,8,8,2canxi).

Đầu vào

Số nguyên tử từ 1 đến 118. Bạn có thể giả sử đầu vào hợp lệ. Nguyên tử không tích điện (nó có nhiều electron như proton). Bạn có thể không mong đợi đầu vào được lưu trữ trong một biến và bạn phải viết một chương trình hoàn chỉnh.

Đầu ra

Số lượng electron trong mỗi vỏ electron không trống. Tôi sẽ khá khoan dung với định dạng đầu ra; tất cả những điều sau đây đều được chấp nhận, tức là bạn có thể sử dụng bất kỳ dấu câu hoặc khoảng trắng nào để phân tách các số và dấu ngoặc của bất kỳ loại nào đều được phép. Vui lòng ghi rõ cái nào được sử dụng.

2,8,8,2
2.8.8.2
2, 8, 8, 2,
[2,8,8,2]
2 8 8 2
([2 [8]] [8] 2)

Làm thế nào các điện tử làm việc

Trong các nguyên tử, các electron được sắp xếp thành "vỏ", là mức năng lượng. Mỗi vỏ có một công suất nhất định, số lượng electron tối đa mà nó có khả năng giữ. Vỏ được lấp đầy từ trong ra ngoài, nhưng không đều. Nhiệm vụ của bạn là xác định, cho một số nguyên tử, có bao nhiêu electron trong mỗi vỏ, theo nguồn này .

Lên đến và bao gồm canxi (số nguyên tử 20), vỏ lấp đầy và theo thứ tự; lớp vỏ bên trong đầu tiên được lấp đầy với khả năng của nó là 2, thứ hai đến 8, sau đó là thứ ba đến 8 và cuối cùng là 2. Cấu hình electron của canxi là 2,8,8,2.

Sau canxi, mọi thứ trở nên phức tạp; hơn nữa các electron đi vào lớp vỏ thứ ba, không phải lớp cuối cùng. Để làm cho mọi thứ tồi tệ hơn, vanadi (23) là 2,8,11,2, trong khi crom (24) là 2,8,13,1và mangan (25) là 2,8,13,2.

Tuy nhiên, có một số kiểu nhất quán: một loại khí cao quý và bảy nguyên tố trước nó sẽ luôn có số lượng electron ở lớp vỏ ngoài tăng từ 1 đến 8. Ví dụ:

vàng (79): 2,8,18,32,18,1
thủy ngân (80): 2,8,18,32,18,2
...
astatine (85): 2,8,18,32,18,7
radon (86): 2,8,18,32,18,8

Quy tắc

Sơ hở tiêu chuẩn bị cấm.
Thư viện tồn tại trước thách thức này được cho phép.
Bất kỳ tính năng tích hợp hoặc thư viện nào liên quan đến các nguyên tử, phân tử hoặc hóa học đều bị cấm.
Độ dài mã thấp nhất tính bằng byte thắng.
Trong nguồn được liên kết, cấu hình của các phần tử 103-118 được đánh dấu bằng (?) , Như chúng được dự đoán và các phần tử quá không ổn định để kiểm tra điều này. Đối với thử thách này, giả sử chúng là chính xác.
Bạn có thể mã hóa một phần hoặc tất cả dữ liệu của bạn.
[QUY TẮC MỚI] Vui lòng cung cấp tệp cơ sở64 hoặc xxd cho các tệp của bạn nếu bạn sử dụng các ký tự điều khiển trong đó (như nhiều câu trả lời dường như đang được thực hiện)

Người chiến thắng: Câu trả lời CJam của Dennis với 80 byte !

— cộng đồng
nguồn

14

CJam, 87 83 82 80 byte

0"hTHøìð¼Ä¿håêÛ¾ªÔ¼"256b6b5a/4a8**li<{[33:B_B*65_B*1]=\_B%8=B\#*+}/Bb0-`

Đoạn mã trên chứa các ký tự không thể in được.

Hãy thử trực tuyến trong trình thông dịch CJam . Nếu liên kết không phù hợp với bạn, hãy sao chép từ dán này .

Lý lịch

Để có được cấu hình electron của nguyên tử thứ N , chúng ta bắt đầu với một nguyên tử không có electron và áp dụng các phép biến đổi N cho nó.

Để giảm số byte thực hiện, chúng tôi biểu diễn cấu hình electron của một nguyên tử dưới dạng số nguyên. Mỗi chữ số của số nguyên đó trong cơ sở 33 tương ứng với số lượng electron trong một lớp vỏ nhất định; chữ số có nghĩa ít nhất đại diện cho lớp vỏ bên ngoài.

Ví dụ, cấu hình electron của Molybdenum (42) là [2 8 18 13 1] . Điều này tương ứng với số nguyên 2 × 33 ⁴ + 8 × 33 ³ + 18 × 33 ² + 13 × 33 + 1 = 26,79,370 .

Palladi (48) là trường hợp đặc biệt, chúng tôi coi là [2 8 18 18 0] thay vì [2 8 18 18] .

Biểu diễn thuận tiện này làm giảm các phép biến đổi đã nói ở trên thành số học đơn giản:

R += 1 (thêm một electron vào lớp vỏ bên ngoài)
R += 33 (thêm một electron vào lớp vỏ ngoài thứ hai)
R += 65 (thêm hai electron vào lớp vỏ ngoài thứ hai; loại bỏ một electron khỏi lớp thứ nhất)
R += 1089 (thêm một electron vào lớp vỏ ngoài thứ ba)
R += 2145 (thêm hai electron vào lớp vỏ ngoài thứ ba; loại bỏ một từ lớp thứ hai)
R *= 33, R += 1 (thêm một lớp vỏ mới chứa một điện tử)

Tất cả những gì còn lại là bằng cách nào đó mã hóa biến đổi nào phải được áp dụng để chuyển từ một nguyên tử cụ thể sang nguyên tử tiếp theo. Sự khác biệt của các biểu diễn số nguyên của hai nguyên tử liên tiếp như sau:

[1 1 65 1 1 1 1 1 1 1 2369 1 1 1 1 1 1 1 78401 1 33 33 33 65 1 33 33 33 65 1 1 1 1 1 1 1 2598017 1 33 33 65 33 1 65 33 65 1 1 1 1 1 1 1 1 85745345 1 33 1089 2145 1089 1089 1089 1089 33 2145 1089 1089 1089 1089 1089 33 33 33 33 33 33 33 65 33 1 1 1 1 1 1 1 2830095041 1 33 33 2145 1089 1089 2145 1089 33 2145 1089 1089 1089 1089 1089 65 1 33 33 33 33 33 33 65 1 1 1 1 1 1 1]

Sự khác biệt duy nhất trong mảng này là như sau:

[1 33 65 1089 2145 2369 78401 2598017 85745345 2830095041]

Tất cả trừ 5 đầu tiên tương ứng với các trường hợp khi một vỏ mới được thêm vào; những cái này có thể được bỏ qua kể từ khi nhân 33 và thêm 1 mang lại kết quả tương tự như thêm chênh lệch.

Vì chúng ta phải thêm một lớp vỏ mới khi và chỉ khi nguyên tử hiện tại có chính xác tám electron ở lớp vỏ ngoài của nó (ngoại trừ He (2) ↦ Li (3) , có thể được mã hóa thành thêm 65 ), chúng ta có thể mã hóa những biến đổi đó như thêm 1 và xác định nhu cầu nhân lên khi đang bay.

Vì vậy, nếu chúng ta xác định

X := 0
I := 0
L := [33 1089 65 2145 1]
T := [1 1 3 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 0 0 0 3 1 0 0 0 3 1 1 1 1 1 1 1 1 1 0 0 3 0 1 3 0 3 1 1 1 1 1 1 1 1 1 1 0 2 4 2 2 2 2 0 4 2 2 2 2 2 0 0 0 0 0 0 0 3 0 1 1 1 1 1 1 1 1 1 0 0 4 2 2 4 2 0 4 2 2 2 2 2 3 1 0 0 0 0 0 0 3 1 1 1 1 1 1 1]

cấu hình electron của nguyên tử thứ N có thể được tính như sau:

while(X < N):
    R *= (33 ** (R % 33 == 8))
    R += L[T[X]]
    X += 1

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

" Push 0, the initial value of R; convert the following array into an integer by
  considering it a base 256 number, then back to the array of its digits in base 6.       ";

0"hTHøìð¼Ä¿håêÛ¾ªÔ¼"256b6b

" Replace each 5 in the resulting array by [4 4 4 4 4 4 4 4]. This yields the array T
  from the above section.                                                                 ";

5a/4a8**

" Read an integer N from STDIN and discard all but the first N elements of T.             ";

li<

" For each element Y of the remainder of T, do the following:                             ";

{
    [33:B_B*65_B*1]=\   " Define B := 33, push L, retrieve L[Y] and swap it with R.       ";

    _B%8=B\#*           " Execute R *= 33 ** (R % 33 == 8).                               ";

    +                   " Execute R += L[Y].                                              ";
}/

" Convert R into the array of its digits in base 33, remove eventual zeros (Palladium)
  and replace the resulting array with its string representation.                         ";

Bb0-`

Chạy ví dụ

$ base64 -d > electrons.cjam <<< MCJoVEgM+OzwErzEGL9o5erbvqrUB4YZhrwRIjI1NmI2YjVhLzRhOCoqbGk8e1szMzpCX0IqNjVfQioxXT1cX0IlOD1CXCMqK30vQmIwLWA=
$ cksum electrons.cjam
3709391992 80 electrons.cjam
$ for i in {1..118}; do LANG=en_US cjam electrons.cjam <<< $i; echo; done
[1]
[2]
[2 1]
[2 2]
[2 3]
[2 4]
[2 5]
[2 6]
[2 7]
[2 8]
[2 8 1]
[2 8 2]
[2 8 3]
[2 8 4]
[2 8 5]
[2 8 6]
[2 8 7]
[2 8 8]
[2 8 8 1]
[2 8 8 2]
[2 8 9 2]
[2 8 10 2]
[2 8 11 2]
[2 8 13 1]
[2 8 13 2]
[2 8 14 2]
[2 8 15 2]
[2 8 16 2]
[2 8 18 1]
[2 8 18 2]
[2 8 18 3]
[2 8 18 4]
[2 8 18 5]
[2 8 18 6]
[2 8 18 7]
[2 8 18 8]
[2 8 18 8 1]
[2 8 18 8 2]
[2 8 18 9 2]
[2 8 18 10 2]
[2 8 18 12 1]
[2 8 18 13 1]
[2 8 18 13 2]
[2 8 18 15 1]
[2 8 18 16 1]
[2 8 18 18]
[2 8 18 18 1]
[2 8 18 18 2]
[2 8 18 18 3]
[2 8 18 18 4]
[2 8 18 18 5]
[2 8 18 18 6]
[2 8 18 18 7]
[2 8 18 18 8]
[2 8 18 18 8 1]
[2 8 18 18 8 2]
[2 8 18 18 9 2]
[2 8 18 19 9 2]
[2 8 18 21 8 2]
[2 8 18 22 8 2]
[2 8 18 23 8 2]
[2 8 18 24 8 2]
[2 8 18 25 8 2]
[2 8 18 25 9 2]
[2 8 18 27 8 2]
[2 8 18 28 8 2]
[2 8 18 29 8 2]
[2 8 18 30 8 2]
[2 8 18 31 8 2]
[2 8 18 32 8 2]
[2 8 18 32 9 2]
[2 8 18 32 10 2]
[2 8 18 32 11 2]
[2 8 18 32 12 2]
[2 8 18 32 13 2]
[2 8 18 32 14 2]
[2 8 18 32 15 2]
[2 8 18 32 17 1]
[2 8 18 32 18 1]
[2 8 18 32 18 2]
[2 8 18 32 18 3]
[2 8 18 32 18 4]
[2 8 18 32 18 5]
[2 8 18 32 18 6]
[2 8 18 32 18 7]
[2 8 18 32 18 8]
[2 8 18 32 18 8 1]
[2 8 18 32 18 8 2]
[2 8 18 32 18 9 2]
[2 8 18 32 18 10 2]
[2 8 18 32 20 9 2]
[2 8 18 32 21 9 2]
[2 8 18 32 22 9 2]
[2 8 18 32 24 8 2]
[2 8 18 32 25 8 2]
[2 8 18 32 25 9 2]
[2 8 18 32 27 8 2]
[2 8 18 32 28 8 2]
[2 8 18 32 29 8 2]
[2 8 18 32 30 8 2]
[2 8 18 32 31 8 2]
[2 8 18 32 32 8 2]
[2 8 18 32 32 10 1]
[2 8 18 32 32 10 2]
[2 8 18 32 32 11 2]
[2 8 18 32 32 12 2]
[2 8 18 32 32 13 2]
[2 8 18 32 32 14 2]
[2 8 18 32 32 15 2]
[2 8 18 32 32 16 2]
[2 8 18 32 32 18 1]
[2 8 18 32 32 18 2]
[2 8 18 32 32 18 3]
[2 8 18 32 32 18 4]
[2 8 18 32 32 18 5]
[2 8 18 32 32 18 6]
[2 8 18 32 32 18 7]
[2 8 18 32 32 18 8]

— Dennis
nguồn

1

Một upvote cho số lượng nỗ lực tuyệt đối, thưa ông. ;)

— COTO

6

GolfScript (96 byte)

Đầu ra ở dạng

[2 8 18 18]

Điều này sử dụng một chuỗi ma thuật chứa các ký tự không in được, vì vậy tôi đang đưa ra tập lệnh ở định dạng xxd:

0000000: 7e30 5c27 0193 ca05 528e 6b25 e461 4d12  ~0\'....R.k%.aM.
0000010: 3195 9abf c9a4 bfad 588b d876 5e72 c82a  1.......X..v^r.*
0000020: 2dd3 6e92 4940 e00b 80dc 71f6 fc97 2732  -.n.I@....q...'2
0000030: 3536 6261 7365 2037 6261 7365 3c7b 2731  56base 7base<{'1
0000040: 0a29 0a5c 295c 0a2b 310a 2b29 0a40 2940  .).\)\.+1.+).@)@
0000050: 400a 402b 5c28 3227 6e2f 3d7e 7d2f 5d60  @.@+\(2'n/=~}/]`

Đối với thử nghiệm trực tuyến Tôi đang viết chuỗi ma thuật với các lối thoát:

"\x01\x93\xCA\x05R\x8Ek%\xE4aM\x121\x95\x9A\xBF\xC9\xA4\xBF\xADX\x8B\xD8v^r\xC8*-\xD3n\x92I@\xE0\v\x80\xDCq\xF6\xFC\x97"

nhưng nó tương đương khi bạn không gặp phải vấn đề dán các ký tự vào văn bản trình duyệt.

Cách tiếp cận là xây dựng một máy ảo với 7 hướng dẫn, mỗi hướng dẫn thao tác một danh sách đếm điện tử. Sau đó, đối với phần tử, nchúng ta bắt đầu với một danh sách đếm electron 0và chạy các nhướng dẫn đầu tiên từ danh sách được mã hóa bởi chuỗi ma thuật.

Các hướng dẫn là:

Thêm một vỏ mới với 1 electron: 1
Thêm một electron vào lớp vỏ bên ngoài: )
Thêm một điện tử vào lớp vỏ bên ngoài: \)\
Kết hợp hai lớp vỏ bên ngoài và thêm một electron : +). (Điều này chỉ được sử dụng cho paladi).
Kết hợp hai lớp vỏ ngoài và tạo lớp vỏ mới với 1 electron: +1
Thêm một electron vào lớp vỏ thứ ba trong: @)@@
Thêm một electron vào lớp vỏ thứ ba và di chuyển một lớp từ lớp vỏ thứ hai sang lớp vỏ thứ ba. Điều này chỉ xảy ra khi lớp vỏ bên ngoài có 2 electron, vì vậy nó được thực hiện @+\(2thay vì dài hơn@2+@(@

— Peter Taylor
nguồn

7 hướng dẫn của bạn là gì?

— COTO

Ah. Cảm ơn. Tôi đoán rằng tôi sẽ cần phải chọn một trong những ngôn ngữ golf bí truyền này để giành chiến thắng trong một thử thách golf một trong những ngày này. Tôi đã có một thời gian viết mã nhỏ gọn có thể diễn giải hai hướng dẫn, chứ chưa nói bảy. : P

— COTO

Tôi có cung cấp đầu vào trên STDIN không? (và sau đó nó xuất hiện trên ngăn xếp)?

@professorfish: Vâng. GolfScript tự động đặt đầu vào từ STDIN trên ngăn xếp.

— Dennis

5

Con trăn 2 (46 + 271 = 327)

Mã số:

print open('f').read().decode('zip').split(';')[input()]

Tệp f, chứa rác nhị phân sau (đây là các mã char)

120, 156, 101, 146, 219, 21, 195, 32, 12, 67, 87, 233, 8, 193, 188, 204, 201, 254, 123, 21, 40, 46, 146, 253, 65, 163, 171, 10, 98, 199, 188, 233, 149, 87, 62, 243, 247, 179, 158, 121, 174, 50, 87, 157, 171, 205, 213, 231, 210, 181, 118, 66, 119, 70, 119, 74, 119, 78, 119, 82, 119, 86, 127, 233, 147, 183, 29, 182, 103, 156, 103, 122, 76, 36, 19, 249, 68, 167, 56, 78, 49, 81, 77, 52, 19, 118, 110, 210, 235, 100, 19, 197, 68, 53, 209, 76, 116, 19, 250, 23, 247, 36, 56, 107, 192, 139, 30, 208, 114, 211, 183, 96, 172, 121, 87, 123, 253, 6, 90, 175, 66, 23, 118, 66, 15, 216, 6, 118, 130, 205, 96, 63, 216, 18, 119, 197, 141, 185, 222, 6, 146, 36, 76, 138, 16, 101, 162, 66, 84, 29, 225, 153, 157, 254, 163, 90, 100, 32, 229, 135, 136, 106, 201, 226, 104, 16, 225, 136, 22, 38, 70, 97, 204, 140, 133, 177, 50, 246, 251, 33, 23, 170, 71, 97, 204, 140, 133, 177, 50, 54, 198, 206, 168, 14, 253, 155, 195, 187, 135, 55, 220, 103, 145, 199, 69, 230, 188, 157, 225, 63, 44, 207, 121, 25, 53, 26, 110, 75, 247, 9, 95, 170, 27, 187, 248, 201, 75, 28, 126, 152, 255, 111, 232, 41, 56, 62, 147, 130, 35, 193, 201, 193, 41, 193, 169, 193, 105, 193, 209, 80, 79, 172, 153, 111, 72, 188, 36, 241, 158, 196, 171, 18, 111, 203, 185, 16, 95, 151, 67, 8, 97

Cơ sở64:

eJxlktsVwyAMQ1fpCMG8zMn+exUoLpL9QaOrCmLHvOmVVz7z97Oeea4yV52rzdXn0rV2QndGd0p3
TndSd1Z/6ZO3HbZnnGd6TCQT+USnOE4xUU00E3Zu0utkE8VENdFMdBP6F/ckOGvAix7QctO3YKx5
V3v9BlqvQhd2Qg/YBnaCzWA/2BJ3xY253gaSJEyKEGWiQlQd4Zmd/qNaZCDlh4hqyeJoEOGIFiZG
YcyMhbEy9vshF6pHYcyMhbEyNsbOqA79m8O7hzfcZ5HHRea8neE/LM95GTUabkv3CV+qG7v4yUsc
fpj/b+gpOD6TgiPBycEpwanBacHRUE+smW9IvCTxnsSrEm/LuRBfl0MIYQ==

Theo yêu cầu, đây là một chương trình đầy đủ chứ không phải là một chức năng.

Câu trả lời cũ: Python (Đường cơ sở Naive, 422):

f=lambda n:'eJxlktsVwyAMQ1fpCMG8zMn+exUoLpL9QaOrCmLHvOmVVz7z97Oeea4yV52rzdXn0rV2QndGd0p3TndSd1Z/6ZO3HbZnnGd6TCQT+USnOE4xUU00E3Zu0utkE8VENdFMdBP6F/ckOGvAix7QctO3YKx5V3v9BlqvQhd2Qg/YBnaCzWA/2BJ3xY253gaSJEyKEGWiQlQd4Zmd/qNaZCDlh4hqyeJoEOGIFiZGYcyMhbEy9vshF6pHYcyMhbEyNsbOqA79m8O7hzfcZ5HHRea8neE/LM95GTUabkv3CV+qG7v4yUscfpj/b+gpOD6TgiPBycEpwanBacHRUE+smW9IvCTxnsSrEm/LuRBfl0MIYQ=='.decode('base64').decode('zip').split(';')[n]

Nội dung của zip:

>>>'eJxlktsVwyAMQ1fpCMG8zMn+exUoLpL9QaOrCmLHvOmVVz7z97Oeea4yV52rzdXn0rV2QndGd0p3TndSd1Z/6ZO3HbZnnGd6TCQT+USnOE4xUU00E3Zu0utkE8VENdFMdBP6F/ckOGvAix7QctO3YKx5V3v9BlqvQhd2Qg/YBnaCzWA/2BJ3xY253gaSJEyKEGWiQlQd4Zmd/qNaZCDlh4hqyeJoEOGIFiZGYcyMhbEy9vshF6pHYcyMhbEyNsbOqA79m8O7hzfcZ5HHRea8neE/LM95GTUabkv3CV+qG7v4yUscfpj/b+gpOD6TgiPBycEpwanBacHRUE+smW9IvCTxnsSrEm/LuRBfl0MIYQ=='.decode('base64').decode('zip')
';1;2;2 1;2 2;2 3;2 4;2 5;2 6;2 7;2 8;2 8 1;2 8 2;2 8 3;2 8 4;2 8 5;2 8 6;2 8 7;2 8 8;2 8 8 1;2 8 8 2;2 8 9 2;2 8 10 2;2 8 11 2;2 8 13 1;2 8 13 2;2 8 14 2;2 8 15 2;2 8 16 2;2 8 18 1;2 8 18 2;2 8 18 3;2 8 18 4;2 8 18 5;2 8 18 6;2 8 18 7;2 8 18 8;2 8 18 8 1;2 8 18 8 2;2 8 18 9 2;2 8 18 10 2;2 8 18 12 1;2 8 18 13 1;2 8 18 13 2;2 8 18 15 1;2 8 18 16 1;2 8 18 18;2 8 18 18 1;2 8 18 18 2;2 8 18 18 3;2 8 18 18 4;2 8 18 18 5;2 8 18 18 6;2 8 18 18 7;2 8 18 18 8;2 8 18 18 8 1;2 8 18 18 8 2;2 8 18 18 9 2;2 8 18 19 9 2;2 8 18 21 8 2;2 8 18 22 8 2;2 8 18 23 8 2;2 8 18 24 8 2;2 8 18 25 8 2;2 8 18 25 9 2;2 8 18 27 8 2;2 8 18 28 8 2;2 8 18 29 8 2;2 8 18 30 8 2;2 8 18 31 8 2;2 8 18 32 8 2;2 8 18 32 9 2;2 8 18 32 10 2;2 8 18 32 11 2;2 8 18 32 12 2;2 8 18 32 13 2;2 8 18 32 14 2;2 8 18 32 15 2;2 8 18 32 17 1;2 8 18 32 18 1;2 8 18 32 18 2;2 8 18 32 18 3;2 8 18 32 18 4;2 8 18 32 18 5;2 8 18 32 18 6;2 8 18 32 18 7;2 8 18 32 18 8;2 8 18 32 18 8 1;2 8 18 32 18 8 2;2 8 18 32 18 9 2;2 8 18 32 18 10 2;2 8 18 32 20 9 2;2 8 18 32 21 9 2;2 8 18 32 22 9 2;2 8 18 32 24 8 2;2 8 18 32 25 8 2;2 8 18 32 25 9 2;2 8 18 32 27 8 2;2 8 18 32 28 8 2;2 8 18 32 29 8 2;2 8 18 32 30 8 2;2 8 18 32 31 8 2;2 8 18 32 32 8 2;2 8 18 32 32 10 1;2 8 18 32 32 10 2;2 8 18 32 32 11 2;2 8 18 32 32 12 2;2 8 18 32 32 13 2;2 8 18 32 32 14 2;2 8 18 32 32 15 2;2 8 18 32 32 16 2;2 8 18 32 32 18 1;2 8 18 32 32 18 2;2 8 18 32 32 18 3;2 8 18 32 32 18 4;2 8 18 32 32 18 5;2 8 18 32 32 18 6;2 8 18 32 32 18 7;2 8 18 32 32 18 8'
>>>len(_)
1478

Và một bài kiểm tra nhanh:

map(f, range(119))
Out[48]: 
['',
 '1',
 '2',
 '2 1',
 '2 2',
 '2 3',
 '2 4',
 '2 5',
 '2 6',
 '2 7',
 '2 8',
 '2 8 1',
 '2 8 2',
 '2 8 3',
 '2 8 4',
 '2 8 5',
 '2 8 6',
 '2 8 7',
 '2 8 8',
 '2 8 8 1',
 '2 8 8 2',
 '2 8 9 2',
 '2 8 10 2',
 '2 8 11 2',
 '2 8 13 1',
 '2 8 13 2',
 '2 8 14 2',
 '2 8 15 2',
 '2 8 16 2',
 '2 8 18 1',
 '2 8 18 2',
 '2 8 18 3',
 '2 8 18 4',
 '2 8 18 5',
 '2 8 18 6',
 '2 8 18 7',
 '2 8 18 8',
 '2 8 18 8 1',
 '2 8 18 8 2',
 '2 8 18 9 2',
 '2 8 18 10 2',
 '2 8 18 12 1',
 '2 8 18 13 1',
 '2 8 18 13 2',
 '2 8 18 15 1',
 '2 8 18 16 1',
 '2 8 18 18',
 '2 8 18 18 1',
 '2 8 18 18 2',
 '2 8 18 18 3',
 '2 8 18 18 4',
 '2 8 18 18 5',
 '2 8 18 18 6',
 '2 8 18 18 7',
 '2 8 18 18 8',
 '2 8 18 18 8 1',
 '2 8 18 18 8 2',
 '2 8 18 18 9 2',
 '2 8 18 19 9 2',
 '2 8 18 21 8 2',
 '2 8 18 22 8 2',
 '2 8 18 23 8 2',
 '2 8 18 24 8 2',
 '2 8 18 25 8 2',
 '2 8 18 25 9 2',
 '2 8 18 27 8 2',
 '2 8 18 28 8 2',
 '2 8 18 29 8 2',
 '2 8 18 30 8 2',
 '2 8 18 31 8 2',
 '2 8 18 32 8 2',
 '2 8 18 32 9 2',
 '2 8 18 32 10 2',
 '2 8 18 32 11 2',
 '2 8 18 32 12 2',
 '2 8 18 32 13 2',
 '2 8 18 32 14 2',
 '2 8 18 32 15 2',
 '2 8 18 32 17 1',
 '2 8 18 32 18 1',
 '2 8 18 32 18 2',
 '2 8 18 32 18 3',
 '2 8 18 32 18 4',
 '2 8 18 32 18 5',
 '2 8 18 32 18 6',
 '2 8 18 32 18 7',
 '2 8 18 32 18 8',
 '2 8 18 32 18 8 1',
 '2 8 18 32 18 8 2',
 '2 8 18 32 18 9 2',
 '2 8 18 32 18 10 2',
 '2 8 18 32 20 9 2',
 '2 8 18 32 21 9 2',
 '2 8 18 32 22 9 2',
 '2 8 18 32 24 8 2',
 '2 8 18 32 25 8 2',
 '2 8 18 32 25 9 2',
 '2 8 18 32 27 8 2',
 '2 8 18 32 28 8 2',
 '2 8 18 32 29 8 2',
 '2 8 18 32 30 8 2',
 '2 8 18 32 31 8 2',
 '2 8 18 32 32 8 2',
 '2 8 18 32 32 10 1',
 '2 8 18 32 32 10 2',
 '2 8 18 32 32 11 2',
 '2 8 18 32 32 12 2',
 '2 8 18 32 32 13 2',
 '2 8 18 32 32 14 2',
 '2 8 18 32 32 15 2',
 '2 8 18 32 32 16 2',
 '2 8 18 32 32 18 1',
 '2 8 18 32 32 18 2',
 '2 8 18 32 32 18 3',
 '2 8 18 32 32 18 4',
 '2 8 18 32 32 18 5',
 '2 8 18 32 32 18 6',
 '2 8 18 32 32 18 7',
 '2 8 18 32 32 18 8']

— Đó là
nguồn

Điều này là tốt, nhưng vui lòng làm cho nó trở thành một chương trình hoàn chỉnh (đọc trong đầu vào từ stdin hoặc đối số); đồng thời, bạn có thể sử dụng một tệp bên ngoài để tránh Base64 (nhưng tệp và tên của nó được tính theo chiều dài mã)

Câu trả lời bạn liên kết để bắt đầu với Trừ khi câu hỏi là một ngoại lệ rõ ràng (ngoại lệ chính là những phức tạp được gắn thẻ kolmogorov) , đó là trường hợp ở đây. Toàn bộ ý tưởng của các câu hỏi phức tạp kolmogorov là mã hóa đầu ra theo cách hiệu quả nhất.

— Dennis

Tôi đã bỏ lỡ thẻ phức tạp kolmogorov. Và ở đây tôi đang cố gắng giải mã các mức năng lượng của các lớp con hóa trị khác nhau, và tôi thậm chí không phải là một nhà vật lý. :I

— Sammitch

"Câu trả lời cũ" chỉ hoạt động trong Python2. Tôi chưa kiểm tra cái mới - bạn đã có một cơ sở64 của tệp fđể tôi có thể sao chép nó chưa?

@professorfish Chắc chắn nhất. Cái mới cũng chỉ là python 2 ( printdưới dạng từ khóa chứ không phải là hàm).

— ɐɔıʇǝɥʇuʎs

3

MATLAB - 248 244 241 178 + 44 = 222 byte

Giảm thiểu:

i=1;a=fread(fopen('a'));b=fix(a/7);a=a-7*b+1;d=0*a;for n=1:input(''),A=a(i);if b(i),m=1;i=i+(d(A)+2>b(i));else A=A-[1;0];m=[2;-1];i=i+1;end;d(A)=d(A)+m;end;fprintf('%d ',d(~~d));

Mở rộng:

i = 1;
a = fread( fopen( 'a' ) );
b = fix( a/7 );
a = a-7*b+1;
d = 0*a;
for n = 1:input('')
    A = a(i);
    if b(i)
        m = 1;
        i = i + (d(A)+2 > b(i));
    else
        A = A - [1; 0];
        m = [2; -1];
        i = i + 1;
    end
    d(A) = d(A) + m;
end
fprintf( '%d ', d(~~d) );

Phụ thuộc tệp nhị phân (Tên tệp ' a '):

0e 39 3a 11  4f 03 72 03  3b 12 49 04  5e 12 04 73
04 3c 13 43  88 04 b2 43  04 e3 6d 05  82 3d 14 4b
05 9e 05 b3  44 05 e4 06  14 75 06 3e

Tôi tin rằng đây là một "chương trình hoàn chỉnh" ở chỗ nó có thể được gọi từ dòng lệnh, nó đọc từ stdinvà xuất ra stdout.

Nó sử dụng một loại mã byte hai hướng dẫn để xây dựng các cấu hình electron. Hai hướng dẫn là

inc D until N      (i.e. increment valence D by 1; advance to next instruction when D = N)

và

pulldown D         (i.e. pull down one electron from valence D, thereby decrementing it by 1
                         and incrementing valence D-1 by 2)

Các hướng dẫn được mã hóa trong hai mảng. Đầu tiên lưu trữ các Dđối số trong tất cả các trường hợp. Thứ hai lưu trữ Nđối số hoặc 0để chỉ ra một pulldownhướng dẫn, vì N = 0không bao giờ được sử dụng làm đối số.

Chuỗi hướng dẫn đầy đủ là:

inc 1 until 2
inc 2 until 8
inc 3 until 8
inc 4 until 2
inc 3 until 11
pulldown 4

inc 3 until 16
pulldown 4

inc 4 until 8
inc 5 until 2
inc 4 until 10
pulldown 5

inc 4 until 13
inc 5 until 2
pulldown 5

inc 4 until 16
pulldown 5

inc 5 until 8
inc 6 until 2
inc 5 until 9
inc 4 until 19
pulldown 5

inc 4 until 25
inc 5 until 9
pulldown 5

inc 4 until 32
inc 5 until 15
pulldown 6

inc 5 until 18
inc 6 until 8
inc 7 until 2
inc 6 until 10
pulldown 6

inc 5 until 22
pulldown 6

inc 5 until 25
inc 6 until 9
pulldown 6

inc 5 until 32
pulldown 7

inc 7 until 2
inc 6 until 16
pulldown 7

inc 7 until 8

Điều đáng chú ý là có thể bỏ 28 ký tự nếu chúng ta sử dụng bộ ký tự dành riêng cho MATLAB, nhưng tôi muốn giải pháp của mình có thể được biểu diễn dưới dạng văn bản gốc trên Stack Exchange, mà không cần bất kỳ tham chiếu tệp bên ngoài nào.

Tài liệu tham khảo tập tin bên ngoài nó là.

Đầu ra mẫu

39: 2 8 18 9 2

78: 2 8 18 32 17 1

117: 2 8 18 32 32 18 7

5: 2 3

— COTO
nguồn

Làm thế nào để tôi xây dựng lại "phụ thuộc tệp nhị phân"?

Tệp này là mã 44 byte tôi đã liệt kê, từ trái sang phải, từ trên xuống dưới theo thứ tự thông thường. Tên tệp chỉ đơn giản là "a", không có phần mở rộng. Nó cần phải nằm trong thư mục làm việc khi tập lệnh được chạy. Tôi đã tải lên một bản sao có thể tải xuống tới syonidv.hodginsmedia.com/misc/a

— COTO

2

Perl 5, 235 (234 + 1 cho -E)

Chơi gôn

@a=unpack'C*','ABR3S4sT5tU6';if(($-=<>)~~[unpack'C*',')*,-./9:@NOYZ[\]`g']){$.+=($-~~[46,90]);$p=2+$-/33;$->87|$-~~[57..64]&&($.*=-1);$o[$p]+=$.,$o[$p+1]-=$.}$%=($%=$a[$q]/8)>$-?$-:$%,$o[$a[$q++]&7]+=$%while($--=$%);$,=$";say@o

Lưu ý: một kết xuất hex được cung cấp ở dưới cùng của bài đăng này, vì một số chuỗi ký tự chuỗi chứa các ký tự điều khiển (được nhập thông qua trình soạn thảo hex).

Ungolfed với ý kiến:

$_=<>;
# For each byte, the first 5 bits are the number of spaces to fill at a time, the next 3 bits represent the shell number, minus 1.
# Values: 10 41 42 13 52 33 14 53 34 15 73 54 35 16 74 55 36
# The 1st shell takes 2 electrons
# Then the 2nd shell take 8, then the third takes 8...
@a=unpack'C*','ABR3S4sT5tU6';
# Contains the atomic numbers of abnormal elements
# Values: 18 1d 29 2a 2c 2d 2e 2f 39 3a 40 4e 4f 59 5a 5b 5c 5d 60 67
@b=unpack'C*',')*,-./9:@NOYZ[\]`g';
# if abnormal
if($_~~@b){
    # All abnormals, except element 46 and 90, only displace 1 electron
    $y=1+($_~~[46,90]);
    # Abnormals with atomic number less than 33 involve switches between shells 3 and 4
    # 33-65: 4 and 5
    # 66-98: 5 and 6
    # 99+ : 6 and 7
    $p = (3 + ~~($_/33)) - 1;
    # abnormals in these ranges move electrons from lower to higher
    # abnormals elsewhere do higher to lower
    if($_ >= 88 || $_ ~~ [57..64]){
        $y *= -1;
    }
    # move electrons
    $o[$p] += $y;
    $o[$p+1] -= $y;
}

    # extract max number of electrons to fill shell with
    # >> 3 is equivalent to /8 for integers; $% is always an integer.
    $% = $a[$q] / 8,
    # do not overfill
    $% = $% > $_ ? $_ : $%,
    # add electrons to shell
    $o[ $a[$q++] & 7 ] += $%
# reduce number of electrons left to fill shells with
while($_ -= $%);
# set list separator to space
$, = $";
# print list representing shells
say @o

Bãi rác Hex:

0000000: 4061 3d75 6e70 6163 6b27 432a 272c 2710  @a=unpack'C*','.
0000010: 4142 1352 3314 5334 1573 5435 1674 5536  AB.R3.S4.sT5.tU6
0000020: 273b 6966 2828 242d 3d3c 3e29 7e7e 5b75  ';if(($-=<>)~~[u
0000030: 6e70 6163 6b27 432a 272c 2718 1d29 2a2c  npack'C*','..)*,
0000040: 2d2e 2f39 3a40 4e4f 595a 5b5c 5d60 6727  -./9:@NOYZ[\]`g'
0000050: 5d29 7b24 2e2b 3d28 242d 7e7e 5b34 362c  ]){$.+=($-~~[46,
0000060: 3930 5d29 3b24 703d 322b 242d 2f33 333b  90]);$p=2+$-/33;
0000070: 242d 3e38 377c 242d 7e7e 5b35 372e 2e36  $->87|$-~~[57..6
0000080: 345d 2626 2824 2e2a 3d2d 3129 3b24 6f5b  4]&&($.*=-1);$o[
0000090: 2470 5d2b 3d24 2e2c 246f 5b24 702b 315d  $p]+=$.,$o[$p+1]
00000a0: 2d3d 242e 7d24 253d 2824 253d 2461 5b24  -=$.}$%=($%=$a[$
00000b0: 715d 2f38 293e 242d 3f24 2d3a 2425 2c24  q]/8)>$-?$-:$%,$
00000c0: 6f5b 2461 5b24 712b 2b5d 2637 5d2b 3d24  o[$a[$q++]&7]+=$
00000d0: 2577 6869 6c65 2824 2d2d 3d24 2529 3b24  %while($--=$%);$
00000e0: 2c3d 2422 3b73 6179 406f                 ,=$";say@o

— es1024
nguồn

Làm thế nào để tôi đảo ngược hexdump? (Có thể tốt hơn để thực hiện kết xuất

@professorfish bãi rác xxd có thể đảo ngược được thêm vào

— es1024

2

CJam, 309 289 byte

0000000: 22 cc b5 a3 1a f7 bd 07 1b 26 ce 73 16 55 87 08  "........&.s.U..
0000010: 27 d2 65 54 66 ac c1 38 ff de 95 d8 8a 77 6d 4e  '.eTf..8.....wmN
0000020: 0d 13 df bb b7 c6 8c ae 6b 32 4d b9 f1 7c b9 f1  ........k2M..|..
0000030: bc 68 2d 8a 5c 22 e6 5c 22 e1 d7 c9 80 ba a5 5d  .h-.\".\"......]
0000040: 64 24 47 0b aa 78 c9 13 a5 0a 65 41 08 f3 ee e3  d$G..x....eA....
0000050: 2e 58 92 19 5f 1a 80 fc d9 30 3b 51 99 c7 1b 51  .X.._....0;Q...Q
0000060: ba 0c 8a 3c 7d f0 60 1e d5 1c e7 2f 33 16 c8 1f  ...<}.`..../3...
0000070: e6 df 24 75 d1 51 e6 af 38 b4 f7 b1 63 77 14 8d  ..$u.Q..8...cw..
0000080: d3 69 bc 99 9e a5 98 56 53 e7 71 f7 48 76 7a 24  .i.....VS.q.Hvz$
0000090: a7 dc 5c 22 fc a6 55 05 30 e2 03 d6 a8 ef 1a 9f  ..\"..U.0.......
00000a0: e4 03 c6 a0 5e 60 be 01 2b ca 12 83 d4 64 69 3d  ....^`..+....di=
00000b0: a7 2e cc 59 5e 0c bb 69 b0 19 1d e1 f2 53 e4 1b  ...Y^..i.....S..
00000c0: 6e 6d cc 45 d3 1f cc 3c b7 1b 5f ca c8 d0 94 fe  nm.E...<.._.....
00000d0: 05 ea ae dc 98 9e 9a 47 a6 fa 3a 0e c3 45 ef 31  .......G..:..E.1
00000e0: 61 a0 7c 80 55 9a 5d 7a af 8e 51 e8 5c 79 c4 22  a.|.U.]z..Q.\y."
00000f0: 32 35 36 62 33 38 62 22 24 12 23 20 5c 22 12 21  256b38b"$.# \".!
0000100: 08 00 02 22 3a 69 32 2f 7b 5f 30 3d 5f 29 33 33  ...":i2/{_0=_)33
0000110: 3f 61 40 5c 2f 5c 2a 7d 2f 30 61 2f 6c 69 28 3d  ?a@\/\*}/0a/li(=
0000120: 60                                               <

Hoạt động bằng cách thay thế các lần chạy phổ biến (ví dụ 2 8 18 32:) bằng các số nguyên lớn hơn 32 và xem xét mảng của tất cả các cấu hình một số cơ sở 38, được mã hóa dưới dạng nhị phân.

Chạy ví dụ

$ base64 -d > electrons.cjam <<< Isy1oxr3vQcbJs5zFlWHCCfSZVRmrME4/96V2Ip3bU4NE9+7t8aMrmsyTbnxfLnxvGgtilwi5lwi4dfJgLqlXWQkRwuqeMkTpQplQQjz7uMuWJIZXxqA/NkwO1GZxxtRugyKPH3wYB7VHOcvMxbIH+bfJHXRUeavOLT3sWN3FI3TabyZnqWYVlPncfdIdnokp9xcIvymVQUw4gPWqO8an+QDxqBeYL4BK8oSg9RkaT2nLsxZXgy7abAZHeHyU+Qbbm3MRdMfzDy3G1/KyNCU/gXqrtyYnppHpvo6DsNF7zFhoHyAVZpdeq+OUehcecQiMjU2YjM4YiIkEiMgXCISIQgAAiI6aTIve18wPV8pMzM/YUBcL1wqfS8wYS9saSg9YA==
$ cksum electrons.cjam 
3109698089 289 electrons.cjam
$ LANG=en_US cjam electrons.cjam <<< 42; echo
[2 8 18 13 1]
$ for i in {1..118}; do LANG=en_US cjam electrons.cjam <<< $i; echo; done | md5sum
d09cb34c282ee52c2466a6b80aa30d22  -

— Dennis
nguồn