Hasilkan kotak 7 dengan 7, diisi dengan angka acak. Namun, dalam sel dengan nomor baris dan kolom ganjil (mulai dari 0), Anda harus menggunakan jumlah sel di sekitarnya. Berikut ini contoh kecil dengan kisi 3 x 3 (jumlah kuadrat tebal):

2 2  2
2 16 2
2 2  2

Dan inilah contoh 7 dengan 7 kotak:

6 5  4 3  7 2  5
6 43 3 50 8 43 8
4 7  8 8  9 3  1
4 36 1 43 6 40 5
3 3  6 1  4 7  5
4 35 3 45 9 42 1
2 6  8 6  8 5  3

Aturan

• Angka yang bukan jumlah harus selalu antara 1 dan 9 inklusif.

• Kotak harus dibuat secara acak. Untuk setiap non-penjumlahan, setiap digit harus memiliki kesempatan yang sama untuk tampil, terlepas dari sel yang ada di dalamnya.

• Angka harus disejajarkan. Ini berarti bahwa digit pertama atau terakhir dari setiap angka dalam suatu kolom harus berbaris secara vertikal. (Anda dapat berasumsi bahwa angka tengah akan selalu dua digit.)

• Sel yang mengelilinginya termasuk diagonal. Oleh karena itu, setiap jumlah kuadrat akan memiliki delapan angka yang mengelilinginya, yang harus Anda tambahkan.

• Kode terpendek menang, karena ini kode-golf .

APL, 53 49 43 42 40 39 36

Saya berhasil meniru J ;.di APL, dan menggunakan pendekatan Gareth , menghemat 13 karakter.

{×5⌷⍵:5⌷⍵⋄+/⍵}¨3,⌿3,/×∘?∘9¨∘.∨⍨9⍴0 1

Contoh dijalankan:

      {×5⌷⍵:5⌷⍵⋄+/⍵}¨3,⌿3,/×∘?∘9¨∘.∨⍨9⍴0 1
9  9 6  1 7  5 6
7 55 5 39 9 54 9
9  8 2  1 8  1 9
2 43 8 41 6 42 5
7  3 4  4 8  3 2
2 29 1 26 2 35 8
6  4 2  3 2  3 7

Penjelasan:

• ∘.∨⍨9⍴0 1 menghasilkan topeng bit.
• ×∘?∘9¨ mengalikan setiap bit dengan nilai acak dari 1 hingga 9 inklusif, menghasilkan grid bertopeng dari angka acak.
• 3,⌿3,/menggunakan apa yang hanya bisa digambarkan sebagai peretasan untuk mengembalikan semua kotak 3 dengan 3 yang tumpang tindih dalam array yang tertutup. Ini juga diratakan dalam proses.
• {×5⌷⍵:5⌷⍵⋄+/⍵}¨iterates atas array, menugaskan masing-masing elemen ⍵. Untuk setiap iterasi, diperlukan yang kelima (tengah, mengingat bahwa pengindeksan APL berbasis 1), dan mengembalikan tanda. Dalam hal ini ini setara dengan pengujian jika angka lebih besar dari 0. Jika ini mengembalikan 1 (untuk true), maka kembalikan elemen itu. Jika tidak, kembalikan jumlah elemen dalam kotak 3 per 3 yang diratakan. Ini menggunakan :⋄operator ternary, yang setara ?:dengan banyak bahasa.

J, 63 61 59 55 52 51 49 47 39 37 karakter

3 3(4&{+4{*|+/)@,;._3(**1+?)+./~9$0 9

Dengan terima kasih Volatility untuk penghematan 10 karakternya.

Penjelasan (setiap langkah akan memiliki angka acak yang berbeda ...):

Hasilkan topeng untuk menghasilkan angka acak (menggunakan $:

   9 9$9$0 9
0 9 0 9 0 9 0 9 0
0 9 0 9 0 9 0 9 0
0 9 0 9 0 9 0 9 0
0 9 0 9 0 9 0 9 0
0 9 0 9 0 9 0 9 0
0 9 0 9 0 9 0 9 0
0 9 0 9 0 9 0 9 0
0 9 0 9 0 9 0 9 0
0 9 0 9 0 9 0 9 0

Sekarang kita punya kail . Ini sebenarnya kecelakaan yang membahagiakan sejak saya mengurangi versi sebelumnya. Itu dimaksudkan untuk menjadi transpose |:dan OR +.dengan aslinya. Masuk akal karena saya menggunakan yang dan nol pada saat itu, tetapi sekarang saya memiliki sembilan dan nol. Kebetulan bahwa ia bekerja dengan cara yang sama dengan makna GCD +.. Beruntung bagiku. :-)

   (+.|:)9 9$9$0 9
0 9 0 9 0 9 0 9 0
9 9 9 9 9 9 9 9 9
0 9 0 9 0 9 0 9 0
9 9 9 9 9 9 9 9 9
0 9 0 9 0 9 0 9 0
9 9 9 9 9 9 9 9 9
0 9 0 9 0 9 0 9 0
9 9 9 9 9 9 9 9 9
0 9 0 9 0 9 0 9 0

Jadi, sekarang kita memiliki kisi 9s dan 0s kita ingin menghasilkan beberapa angka acak. ?menghasilkan angka acak dari 0 hingga (tetapi tidak termasuk) nomor yang diberikan. Diberikan daftar itu akan menghasilkan satu nomor acak dengan cara ini untuk setiap anggota daftar. Jadi dalam hal ini akan menghasilkan angka dari 0 hingga 8 untuk setiap 9 dalam tabel dan angka floating point dari 0 hingga 1 untuk setiap 0.

   ?(+.|:)9 9$9$0 9
 0.832573 7 0.926379 7 0.775468 6 0.535925 3  0.828123
        7 0        5 5        4 3        4 5         4
0.0944584 2 0.840913 2 0.990768 1 0.853054 3  0.881741
        3 8        7 0        8 3        3 4         8
 0.641563 4 0.699892 7 0.498026 1 0.438401 6  0.417791
        6 8        7 5        2 3        6 6         3
 0.753671 6 0.487016 4 0.886369 7 0.489956 5  0.902991
        3 4        7 8        1 4        8 0         8
0.0833539 4 0.311055 4 0.200411 6 0.247177 5 0.0464731

Tapi kami ingin angka dari 1 hingga 9 bukan 0 hingga 8. Jadi kami menambahkan 1.

   (1+?)(+.|:)9 9$9$0 9
 1.4139 4  1.7547 7 1.67065 4 1.52987 1 1.96275
      2 8       2 4       3 9       6 9       9
1.15202 7 1.11341 5  1.0836 1 1.24713 2 1.13858
      9 3       3 2       4 7       3 8       6
1.06383 9 1.67909 4 1.09801 8  1.4805 6  1.0171
      9 5       5 5       9 5       9 4       3
1.22819 1 1.85259 4 1.95632 6 1.33034 3 1.39417
      4 2       5 1       3 7       2 5       6
1.06572 5  1.9942 5 1.78341 5 1.16516 6 1.37087

Ini sangat bagus tapi kami kehilangan nol yang saya inginkan, jadi kami akan mengalikannya dengan topeng asli setelah mengubah semua sembilan menjadi yang. Saya melakukan ini dengan memeriksa jika nilai lebih besar dari 1. Yang memberi kita: (1&<*1+?).
Ada beberapa hal yang terjadi di sini:

• Kami telah membuat garpu yang memungkinkan kami untuk mengemas banyak pekerjaan menjadi beberapa karakter.
• Kami telah menyatukan ( &) 1 ke <kata kerja.

Jadi semua yang digabungkan (1&<*1+?)menghasilkan angka acak, dan memberi nol pada semua angka yang mana dihasilkan oleh nol di grid asli.

   (1&<*1+?)(+.|:)9 9$9$0 9
0 3 0 2 0 7 0 1 0
9 5 2 7 7 1 4 5 7
0 6 0 8 0 3 0 1 0
4 8 7 5 9 7 7 9 4
0 9 0 6 0 9 0 9 0
6 1 2 1 4 6 8 9 4
0 3 0 8 0 6 0 6 0
2 5 2 2 2 2 3 9 3
0 9 0 3 0 5 0 3 0

Bit berikutnya adalah (menurut saya, bagaimanapun juga :-) bit pintar.
Potongan ;.kata kerja memiliki bentuk x u;._3 yyang memotong input ke dalam kotak yang dijelaskan oleh x, dan kemudian menerapkan kata kerja itu ukepada mereka. Dalam hal ini yang kita miliki 3 3(4&{++/*0=4&{)@,;._3.

• Itu 3 3 menggambarkan kotak yang kita inginkan - 3x3.
• Ini (4&{++/*0=4&{)@,adalah kata kerja kereta yang menggambarkan apa yang ingin kita lakukan untuk setiap kotak.

Untuk mendemonstrasikan ;.kata kerja yang akan saya gunakan <untuk menunjukkan setiap kotak:

   3 3(<);._3(1&<*1+?)(+.|:)9 9$9$0 9
┌─────┬─────┬─────┬─────┬─────┬─────┬─────┐
│0 8 0│8 0 7│0 7 0│7 0 4│0 4 0│4 0 3│0 3 0│
│9 1 3│1 3 2│3 2 3│2 3 8│3 8 5│8 5 5│5 5 9│
│0 6 0│6 0 1│0 1 0│1 0 2│0 2 0│2 0 4│0 4 0│
├─────┼─────┼─────┼─────┼─────┼─────┼─────┤
│9 1 3│1 3 2│3 2 3│2 3 8│3 8 5│8 5 5│5 5 9│
│0 6 0│6 0 1│0 1 0│1 0 2│0 2 0│2 0 4│0 4 0│
│7 1 6│1 6 7│6 7 1│7 1 2│1 2 1│2 1 6│1 6 1│
├─────┼─────┼─────┼─────┼─────┼─────┼─────┤
│0 6 0│6 0 1│0 1 0│1 0 2│0 2 0│2 0 4│0 4 0│
│7 1 6│1 6 7│6 7 1│7 1 2│1 2 1│2 1 6│1 6 1│
│0 7 0│7 0 5│0 5 0│5 0 9│0 9 0│9 0 7│0 7 0│
├─────┼─────┼─────┼─────┼─────┼─────┼─────┤
│7 1 6│1 6 7│6 7 1│7 1 2│1 2 1│2 1 6│1 6 1│
│0 7 0│7 0 5│0 5 0│5 0 9│0 9 0│9 0 7│0 7 0│
│7 9 9│9 9 7│9 7 1│7 1 9│1 9 4│9 4 9│4 9 5│
├─────┼─────┼─────┼─────┼─────┼─────┼─────┤
│0 7 0│7 0 5│0 5 0│5 0 9│0 9 0│9 0 7│0 7 0│
│7 9 9│9 9 7│9 7 1│7 1 9│1 9 4│9 4 9│4 9 5│
│0 3 0│3 0 2│0 2 0│2 0 7│0 7 0│7 0 9│0 9 0│
├─────┼─────┼─────┼─────┼─────┼─────┼─────┤
│7 9 9│9 9 7│9 7 1│7 1 9│1 9 4│9 4 9│4 9 5│
│0 3 0│3 0 2│0 2 0│2 0 7│0 7 0│7 0 9│0 9 0│
│3 1 6│1 6 1│6 1 7│1 7 6│7 6 8│6 8 9│8 9 9│
├─────┼─────┼─────┼─────┼─────┼─────┼─────┤
│0 3 0│3 0 2│0 2 0│2 0 7│0 7 0│7 0 9│0 9 0│
│3 1 6│1 6 1│6 1 7│1 7 6│7 6 8│6 8 9│8 9 9│
│0 9 0│9 0 3│0 3 0│3 0 4│0 4 0│4 0 3│0 3 0│
└─────┴─────┴─────┴─────┴─────┴─────┴─────┘

Beberapa hal yang perlu diperhatikan:

• Kotak tumpang tindih - kolom kedua dan ketiga di kotak kiri atas adalah yang pertama dan kedua di kotak di sebelah kanannya.
• Ada 7x7 kotak. Itu sebabnya kami memiliki grid 9x9 pada awalnya.
• Setiap tempat kami membutuhkan jumlah memiliki 0di pusat kotak.

Sekarang kita hanya perlu memberikan nilai di tengah belakang (jika bukan nol) atau menjumlahkan angka dalam kotak 3x3 (jika pusatnya nol).
Untuk melakukan ini kita perlu akses mudah ke nomor pusat. ,membantu di sini. Ternyata grid 3x3 ke daftar 9 item dengan nomor pusat di nomor 4.
4&{akan menggunakan {untuk menarik keluar nilai pusat dan kemudian membandingkannya dengan 0: 0=4&{. Ini mengembalikan a 0atau 1untuk benar atau salah, yang kemudian kita kalikan dengan jumlah +/. Jika nol di pusat kami sekarang memiliki jumlah kami seperti yang dipersyaratkan. Jika bukan kita memiliki nol, jadi untuk menyelesaikannya kita cukup menambahkan nilai tengah 4&{+.
Ini memberikan kata kerja kereta(4&{++/*0=4&{)@,

   3 3(4&{++/*0=4&{)@,;._3(1&<*1+?)(+.|:)9 9$9$0 9
2  6 9  3 7  9 7
3 47 6 51 5 49 5
3  9 9  6 6  2 8
7 48 6 47 1 37 5
5  4 5  7 7  2 6
5 35 3 49 8 51 9
1  6 6  6 7  4 8

Ruby (135 karakter)

a=(0..48).map{rand(9)+1}
([0,0,j=8]*3).each{|l|a[j]=[0,1,6,7,8].inject{|s,e|s+a[j+e]+a[j-e]};j+=l+2}
a.each_slice(7){|r|puts"%-3s"*7%r}

Output sampel

2  1  6  9  4  5  1  
9  34 4  37 2  31 3  
7  2  3  1  8  1  7  
5  42 4  40 2  47 9  
3  9  9  4  9  4  7  
3  44 4  41 2  47 4  
6  9  1  5  7  6  8  

Kerusakan

Tidak terlalu jelas bagaimana ini bekerja, jadi inilah uraian singkatnya. CATATAN: Anda mungkin dapat melewati beberapa langkah ini dan melompat ke versi yang lebih pendek dengan lebih cepat, tetapi saya pikir ini cukup mendidik untuk melihat berbagai cara saya mencukur karakter, terutama dengan melihat pola dalam literal untuk mengubah angka 2 digit menjadi versi 1 digit .

Versi naif

Berbeda dengan solusi Ruby lainnya yang mengandalkan array dua dimensi, Anda (akhirnya) bisa mendapatkan versi yang lebih pendek dengan memulai dengan array 1 dimensi dan bekerja dengan nilai offset, karena pola-pola tersebut berulang.

ary=(0..48).map { rand(9) + 1 }

offsets = [-8,-7,-6,-1,1,6,7,8]

3.times do |i|
  [8,10,12].each do |j|
    ary[j + 14*i] = ary.values_at(*offsets.map { |e| j+14*i + e }).inject(:+)
  end
end

ary.each.with_index do |e,i|
  $> << ("%-3s" % e)
  $> << ?\n if i % 7==6
end

Prinsip utama di sini adalah bahwa kami bekerja pada posisi indeks 8, 10, 12, hanya diimbangi dengan kelipatan 14. Posisi 8, 10 dan 12 adalah pusat dari kisi 3x3 yang kami simpulkan. Dalam output sampel, 34 adalah posisi 8, 42 adalah posisi 8 + 14 * 1, dll. Kami mengganti posisi 8 dengan posisi 34 dengan mengimbangi dari posisi 8 dengan [-8,-7,-6,-1,1,6,7,8]- dengan kata lain 34 = sum(ary[8-8], ary[8-7], ..., ary[8+8]). Prinsip yang sama berlaku untuk semua nilai[8 + 14*i, 10 + 14*i, 12 + 14*i] , karena polanya berulang.

Mengoptimalkannya

Pertama, beberapa optimisasi cepat:

• Dari pada 3.times { ... } , dan menghitung j + 14*isetiap waktu, "sebariskan" posisi [8,10,12,22,24,26,36,38,40].
• The offsetsarray digunakan sekali, sehingga mengganti variabel dengan literal tersebut.
• Ganti do ... enddengan {...}dan beralih ke pencetakan $> << foo. (Ada trik di sini yang melibatkanputs nil dan () == nil.)
• Nama variabel lebih pendek.

Kode setelah ini adalah 177 karakter:

a=(0..48).map{rand(9)+1}
[8,10,12,22,24,26,36,38,40].each{|j|a[j]=a.values_at(*[-8,-7,-6,-1,1,6,7,8].map{|e|j+e}).inject(:+)}
a.map.with_index{|e,i|$><<"%-3s"%e<<(?\nif i%7==6)}

Untuk reduksi berikutnya, perhatikan bahwa injectarray offset tidak perlu berurutan. Kami dapat memiliki [-8,-7,-6,-1,1,6,7,8]atau memesan lainnya, karena penambahan bersifat komutatif.

Jadi pertama-tama pasangkan hal positif dan negatif untuk didapatkan [1,-1,6,-6,7,-7,8,-8].

Sekarang Anda bisa mempersingkat

[1,-1,6,-6,7,-7,8,-8].map { |e| j+e }.inject(:+)

untuk

[1,6,7,8].flat_map { |e| [j+e, j-e] }

Ini menghasilkan

a=(0..48).map{rand(9)+1}
[8,10,12,22,24,26,36,38,40].each{|j|a[j]=a.values_at(*[1,6,7,8].flat_map{|e|[j+e,j-e]}).inject(:+)}
a.map.with_index{|e,i|$><<"%-3s"%e<<(?\nif i%7==6)}

yaitu 176 karakter.

Bergeser 8 dan pindah ke perbedaan

Nilai-nilai literal dua karakter sepertinya dapat dipersingkat, jadi ambil [8,10,12,22,24,26,36,38,40]dan geser semuanya dengan 8, memperbarui jpada awal loop. (Perhatikan bahwa Anda +=8tidak perlu memperbarui nilai ofset dari 1,6,7,8.)

a=(0..48).map{rand(9)+1}
[0,2,4,14,16,18,28,30,32].each{|j|j+=8;a[j]=a.values_at(*[1,6,7,8].flat_map{|e|[j+e,j-e]}).inject(:+)}
a.map.with_index{|e,i|$><<"%-3s"%e<<(?\nif i%7==6)}

Ini 179, yang lebih besar, tetapi j+=8sebenarnya bisa dihilangkan.

Perubahan pertama

[0,2,4,14,16,18,28,30,32]

ke berbagai perbedaan:

[2,2,10,2,2,10,2,2]

dan secara kumulatif menambahkan nilai-nilai ini ke awal j=8. Ini pada akhirnya akan mencakup nilai yang sama. (Kami mungkin bisa langsung beralih ke ini alih-alih menggeser 8 terlebih dahulu.)

Perhatikan bahwa kami juga akan menambahkan nilai dummy 9999ke akhir array perbedaan, dan menambahkannya jdi akhir , bukan awal dari loop. Pembenarannya adalah bahwa 2,2,10,2,2,10,2,2terlihat sangat dekat dengan menjadi 3 angka yang sama diulang 3 kali, dan dengan menghitung j+differencepada akhir loop, nilai akhir dari 9999tidak akan benar-benar mempengaruhi output, karena tidak ada a[j]panggilan di mana jada beberapa nilai selesai 10000.

a=(0..48).map{rand(9)+1}
j=8
[2,2,10,2,2,10,2,2,9999].each{|l|a[j]=a.values_at(*[1,6,7,8].flat_map{|e|[j+e,j-e]}).inject(:+);j+=l}
a.map.with_index{|e,i|$><<"%-3s"%e<<(?\nif i%7==6)}

Dengan array perbedaan ini, j+=8sekarang hanya j=8, tentu saja, karena kalau tidak kita akan berulang kali menambahkan 8terlalu banyak. Kami juga telah mengubah variabel blok dari jmenjadi l.

Jadi karena 9999elemen tidak berpengaruh pada output, kita dapat mengubahnya 10dan mempersingkat array.

a=(0..48).map{rand(9)+1}
j=8
([2,2,10]*3).each{|l|a[j]=a.values_at(*[1,6,7,8].flat_map{|e|[j+e,j-e]}).inject(:+);j+=l}
a.map.with_index{|e,i|$><<"%-3s"%e<<(?\nif i%7==6)}

Ini adalah 170 karakter.

Tapi sekarang j=8tampilannya agak kikuk, dan Anda dapat menyimpan 2 karakter dengan menggeser [2,2,10]ke bawah 2 untuk mendapatkan yang 8dapat Anda gunakan untuk tugas. Ini juga perlu j+=lmenjadi j+=l+2.

a=(0..48).map{rand(9)+1}
([0,0,j=8]*3).each{|l|a[j]=a.values_at(*[1,6,7,8].flat_map{|e|[j+e,j-e]}).inject(:+);j+=l+2}
a.map.with_index{|e,i|$><<"%-3s"%e<<(?\nif i%7==6)}

Ini adalah 169 karakter. Cara memutar untuk memeras 7 karakter, tapi rapi.

Tweak terakhir

The values_atpanggilan sebenarnya semacam berlebihan, dan kami dapat inline sebuah Array#[]panggilan. Begitu

a.values_at(*[1,6,7,8].flat_map{|e|[j+e,j-e]}).inject(:+)

menjadi

[1,6,7,8].flat_map{|e|[a[j+e],a[j-e]]}.inject(:+)

Anda juga dapat mengetahui bahwa flat_map+ j+e/j-e+ injectdapat direduksi menjadi penjumlahan yang lebih langsung dengan inisial 0dalam array.

Ini memberi Anda 152 karakter:

a=(0..48).map{rand(9)+1}
([0,0,j=8]*3).each{|l|a[j]=[0,1,6,7,8].inject{|s,e|s+a[j+e]+a[j-e]};j+=l+2}
a.map.with_index{|e,i|$><<"%-3s"%e<<(?\nif i%7==6)}

Akhirnya:

• map.with_indexbisa menjadi each_slice.
• Ubah pendekatan pencetakan.

135 :

a=(0..48).map{rand(9)+1}
([0,0,j=8]*3).each{|l|a[j]=[0,1,6,7,8].inject{|s,e|s+a[j+e]+a[j-e]};j+=l+2}
a.each_slice(7){|r|puts"%-3s"*7%r}

Python, 132

Secara teknis ini tidak memenuhi aturan, karena angka terakhir dari setiap angka disejajarkan daripada yang pertama. Tapi saya pikir saya akan tetap berbagi:

import numpy
G=numpy.random.randint(1,10,(7,7))
G[1::2,1::2]=sum(G[i:6+i:2,j:6+j:2]for i in[0,1,2]for j in[0,1,2]if i&j!=1)
print G

Output sampel:

[[ 8  9  8  3  8  5  8]
 [ 6 53  4 45  8 53  8]
 [ 8  2  8  1  5  3  8]
 [ 2 40  6 34  1 32  7]
 [ 4  1  9  1  3  3  2]
 [ 4 35  7 35  6 31  1]
 [ 1  7  2  5  2  8  6]]

Mathematica, 108

s=#-1;;#+1&;g=1+8~RandomInteger~{7,7};Column/@
ReplacePart[g,{i_?EvenQ,j_?EvenQ}:>g〚s@i,s@j〛~Total~2-g〚i,j〛]

Untuk output yang lebih cantik Column/@dapat diganti dengan TableForm@biaya 2 karakter.

GolfScript ( 79 78 72 70 68 66 65 60 karakter)

56,{13%5<,~9rand)}%9/`{>3<zip`{>3<(*(+(\{+}*or' '}+7,%n}+7,/

NB Ini berisi tab literal, yang mungkin rusak oleh penurunan harga.

Agak pandai itu karena Gareth: lihat solusi J-nya.

Demo online

R: 114 karakter

a=array(sample(1:9,49,r=T),c(7,7))
for(i in 2*1:3){for(j in 2*1:3)a[i,j]=sum(a[(i-1):(i+1),(j-1):(j+1)])-a[i,j]}
a

Baris pertama membuat array 7 dengan 7 diisi dengan angka yang dipilih secara acak dari 1 hingga 9 (distribusi seragam dengan penggantian, karenanya r=Tmerupakan kepanjangan dari replace=TRUE). Baris kedua, hitung jumlah 3 oleh 3 kisi, kurangi pusat dan gantikan dengan hasilnya. Baris ketiga cetak kisi-kisi yang dihasilkan (secara default, kolom matriks dan array disejajarkan dengan benar).

Contoh output:

     [,1] [,2] [,3] [,4] [,5] [,6] [,7]
[1,]    8    5    6    4    3    2    2
[2,]    1   37    6   41    7   38    8
[3,]    5    3    3    3    9    4    3
[4,]    4   31    3   41    3   44    9
[5,]    3    5    5    9    6    7    3
[6,]    3   32    2   40    4   37    5
[7,]    8    2    4    1    9    1    2

J, 67 65 byte

Solusi naif dan verbose dalam J. Ini adalah implementasi langsung dari tugas.

(+/^:_"2((,&.>/@(<:,],>:)"0)&.>m){0 m}a)(m=.{;~1 3 5)}a=.>:?7 7$9

Pertama saya membuat array integer 7 x 7 antara 1 dan 9. Sebenarnya J's? kata kerja menghasilkan angka hingga argumennya, itu sebabnya kita perlu meningkatkan setiap elemen,>: di J

a=.>:?7 7$9 

2 8 7 4 4 5 1
4 5 4 1 6 7 9
3 8 3 6 5 3 3
6 8 6 3 7 7 1
7 7 4 4 5 9 9
2 3 6 5 2 2 9
2 2 6 8 8 1 3

Saya menyiapkan topeng yang akan digunakan untuk mem-nolkan baris baris / kolom ganjil, sepasang indeks baris / kolom ganjil:

m=.{;~1 3 5
┌───┬───┬───┐
│1 1│1 3│1 5│
├───┼───┼───┤
│3 1│3 3│3 5│
├───┼───┼───┤
│5 1│5 3│5 5│
└───┴───┴───┘

Kata kerja Katalog {menggabungkan item dari atom di dalam daftar kotak

┌─────┬─────┐
│1 3 5│1 3 5│
└─────┴─────┘

untuk membentuk katalog, tabel 3x3 dari pasangan di atas

Kemudian saya menyiapkan tabel indeks baris / kolom yang akan digunakan untuk pemilihan masing-masing subarrays 3x3.

s=.(,&.>/@(<:,],>:)"0)&.>m
┌─────────────┬─────────────┬─────────────┐
│┌─────┬─────┐│┌─────┬─────┐│┌─────┬─────┐│
││0 1 2│0 1 2│││0 1 2│2 3 4│││0 1 2│4 5 6││
│└─────┴─────┘│└─────┴─────┘│└─────┴─────┘│
├─────────────┼─────────────┼─────────────┤
│┌─────┬─────┐│┌─────┬─────┐│┌─────┬─────┐│
││2 3 4│0 1 2│││2 3 4│2 3 4│││2 3 4│4 5 6││
│└─────┴─────┘│└─────┴─────┘│└─────┴─────┘│
├─────────────┼─────────────┼─────────────┤
│┌─────┬─────┐│┌─────┬─────┐│┌─────┬─────┐│
││4 5 6│0 1 2│││4 5 6│2 3 4│││4 5 6│4 5 6││
│└─────┴─────┘│└─────┴─────┘│└─────┴─────┘│
└─────────────┴─────────────┴─────────────┘

Untuk setiap pasangan dalam array m, saya membuat sepasang kembar tiga, berpusat di sekitar setiap jumlah pasangan m:

        ┌─────┬─────┐
 1 3 -> │0 1 2│2 3 4│
        └─────┴─────┘

Pasangan kembar tiga ini digunakan oleh kata kerja J From {, yang dapat memilih beberapa baris dan kolom secara bersamaan. 0 1 2/2 3 4 berarti saya memilih baris 0, 1 dan 2 bersamaan dengan kolom 2, 3 dan 4, sehingga memilih subarray 3x3 kedua di atas.

Akhirnya, saya bisa menggunakan array 7x7 dan topeng untuk mencapai tugas: Pertama saya menggunakan m sebagai topeng untuk mengatur elemen yang sesuai ke 0:

0 m}a

Lalu saya mengambil semua subarrays 3x3 menggunakan s sebagai pemilih dan menemukan jumlah mereka:

+/^:_"2 s{0 m}a

Lalu saya memasukkan angka-angka ini kembali ke array awal.

 (+/^:_"2 s{0 m}a)m}a 

2 8 7 4 4 5 1
4 39 4 39 6 36 9
3 8 3 6 5 3 3
6 44 6 40 7 42 1
7 7 4 4 5 9 9
2 36 6 43 2 46 9
2 2 6 8 8 1 3

Cobalah online!

APL (Dyalog Unicode) , 32 31 30 byte ^SBCS

-1 byte terima kasih kepada @jslip

|a-m×+/+/⊢⌺3 3⊢a←?9⌈m←∘.⍱⍨2|⍳7

Cobalah online!

Ruby, 207

Saya akan menyajikan solusi saya terlebih dahulu (seperti yang selalu saya lakukan):

a=Array.new(7){Array.new(7){rand(9)+1}}
s=[-1,0,1]
s=s.product s
s.slice!4
r=[1,3,5]
r.product(r).map{|x|u=0
s.map{|y|u+=a[x[0]+y[0]][x[1]+y[1]]}
a[x[0]][x[1]]=u}
puts a.map{|x|x.map{|y|y.to_s.ljust 3}.join

Ruby, 150 karakter

v=(a=0..6).map{a.map{rand(9)+1}}
(o=[1,3,5]).map{|i|o.map{|j|v[i][j]=0
(d=[0,-1,1]).map{|r|d.map{|c|v[i][j]+=v[i+r][j+c]}}}}
puts v.map{|r|"%-3d"*7%r}

jika persyaratan justifikasi kiri justifikasi hanya itu ljustharus digunakan ... baik, tidak. Saya suka kemampuan format Ruby.

Jangan gunakan Array.new(7){...}. (0..6).map{...}keduanya lebih pendek dan lebih mudah dibaca dan Anda mendapatkan rentang yang ditetapkan secara gratis.

Baris # 3 terinspirasi oleh solusi Doorknob .

GolfScript, 87 karakter

49,{.1&\7/1&!|9rand)*}%.7/{[..1>@0\+]zip{{+}*}%);}:^%zip{^~}%]zip{.0=!=}%{'  '+3<}%7/n*

Ada terlalu banyak ritsleting di sana ... (lihat online )

3  9  9  3  3  9  8  
6  46 2  50 3  39 8  
7  3  7  2  4  7  3  
8  33 9  51 8  49 5  
4  3  9  9  3  9  2  
1  45 9  41 6  33 2  
4  3  6  1  6  1  4  

J, 58/64/67 karakter

0j_1":(7$0,:7$0 1){"0 1 |:>v;v-~7 7{.0,.0,3+/\"1]3+/\v=.1+?7 7$9

Sementara spesifikasi membutuhkan angka-angka agar rata, tidak ada persyaratan untuk menggunakan notasi desimal, jadi saya kira ini adalah output yang valid:

1.0e0 8.0e0 9.0e0 6.0e0 2.0e0 9.0e0 6.0e0
6.0e0 3.9e1 8.0e0 4.0e1 2.0e0 3.8e1 4.0e0
1.0e0 4.0e0 2.0e0 8.0e0 3.0e0 9.0e0 3.0e0
2.0e0 2.4e1 5.0e0 4.1e1 9.0e0 4.7e1 8.0e0
1.0e0 3.0e0 6.0e0 5.0e0 3.0e0 5.0e0 7.0e0
4.0e0 3.0e1 1.0e0 2.3e1 1.0e0 3.1e1 1.0e0
6.0e0 5.0e0 4.0e0 2.0e0 1.0e0 5.0e0 8.0e0

Jika perataan kanan alih-alih keselarasan kiri dapat diterima, kita berada di 58 karakter

(7$0,:7$0 1){"0 1 |:>v;v-~7 7{.0,.0,3+/\"1]3+/\v=.1+?7 7$9

J ":(format) memiliki tiga mode pemformatan:

• lurus ke kanan dengan n digit atau dengan shrink-wrap (tampilan default)
• Notasi ilmiah rata kiri dengan total n digit dan m
• tampilan kotak menyusut dengan (kiri / tengah / kanan) - (atas / tengah / bawah) sejajar (di bawah, 69 karakter)

Yang paling verbose tetapi juga paling serbaguna dan satu-satunya yang dapat menghasilkan output seperti contohnya adalah 8!:2format asing, yang mengambil string format sebagai argumen kirinya. Juga 67 karakter :

'l3.'8!:2(7$0,:7$0 1){"0 1 |:>v;v-~7 7{.0,.0,3+/\"1]3+/\v=.1+?7 7$9

Berikut format kotaknya:

 0 0":<"0(7$0,:7$0 1){"0 1 |:>v;v-~7 7{.0,.0,3+/\"1]3+/\v=.1+?7 7$9

 ┌─┬──┬─┬──┬─┬──┬─┐
 │2│6 │5│7 │5│7 │6│
 ├─┼──┼─┼──┼─┼──┼─┤
 │8│40│4│35│9│49│6│
 ├─┼──┼─┼──┼─┼──┼─┤ 
 │6│7 │2│2 │1│9 │6│
 ├─┼──┼─┼──┼─┼──┼─┤
 │8│41│9│35│3│45│7│
 ├─┼──┼─┼──┼─┼──┼─┤
 │3│1 │5│6 │7│8 │4│
 ├─┼──┼─┼──┼─┼──┼─┤
 │7│37│4│45│6│48│8│
 ├─┼──┼─┼──┼─┼──┼─┤
 │8│4 │5│4 │8│1 │6│
 └─┴──┴─┴──┴─┴──┴─┘

Perl, 117 karakter

print$_,++$j%7?$":$/for map{++$i/7&$i%7&1?
eval join"+",@x[map{$i+$_,$i-$_}1,6,7,8]:" $_"}@x=map{1+int rand 9}$i--..48

Ini adalah salah satu skrip Perl di mana semua kecuali satu untuk for loop telah diciutkan map panggilan sehingga semuanya dapat dilakukan dalam satu pernyataan. Variabel global juga membuat beberapa penampilan penting dalam hal ini. Saya kira yang ingin saya katakan di sini adalah, program ini agak kotor.

Tunggu, itu semakin buruk: Ada bug yang dikenal dalam skrip! Namun, ia memiliki kurang dari satu dalam sejuta peluang untuk dipicu, jadi saya belum sempat memperbaikinya.

Mathematica , 106/100

Saya datang dengan sesuatu yang sangat mirip dengan kode ssch, sebelum melihatnya. Saya meminjam idenya untuk menggunakan Column. Dengan ASCII saja, 106 :

s=#-1;;#+1&
a=8~RandomInteger~{7,7}+1
a[[##]]=a[[s@#,s@#2]]~Total~2-a[[##]];&@@@{2,4,6}~Tuples~2
Column/@a

Dengan karakter Unicode (seperti yang digunakan oleh ssch), 100 :

s=#-1;;#+1&
a=8~RandomInteger~{7,7}+1
a〚##〛=a〚s@#,s@#2〛~Total~2-a〚##〛;&@@@{2,4,6}~Tuples~2
Column/@a

Excel VBA, 74 byte

Fungsi VBE langsung yang menghasilkan [B2:H9].

[B2:H9]="=IF(ISODD(ROW()*COLUMN()),SUM(A1:C1,A2,C2,A3:C3),INT(RAND()*8)+1)

Output Sampel

Powershell, 149 148 byte

-1 byte terima kasih kepada @AdmBorkBork. Itu keren!

$i=-1
($a=(,1*8+0,1*3)*3+,1*7|%{$_*(1+(Random 9))})|?{++$i;!$_}|%{6..8+1|%{$_,-$_}|%{$a[$i]+=$a[$i+$_]}}
-join($a|%{if(!(++$i%7)){"
"};'{0,3}'-f$_})

Penjelasan:

$i=-1                       # let $i store -1
($a=                        # let $a is array of random numbers with zero holes
    (,1*8+0,1*3)*3+,1*7|    # the one-dimension array equals
                            # 1 1 1 1 1 1 1
                            # 1 0 1 0 1 0 1
                            # 1 1 1 1 1 1 1
                            # 1 0 1 0 1 0 1
                            # 1 1 1 1 1 1 1
                            # 1 0 1 0 1 0 1
                            # 1 1 1 1 1 1 1
    %{                      # for each element
        $_*(1+(Random 9))   # multiply 0 or 1 element to random digit from 1 to 9
    }                       # now $a stores values like (* is a random digit from 1 to 9)
                            # * * * * * * *
                            # * 0 * 0 * 0 *
                            # * * * * * * *
                            # * 0 * 0 * 0 *
                            # * * * * * * *
                            # * 0 * 0 * 0 *
                            # * * * * * * *
)|?{++$i;!$_                # calc index $i and passthru values == 0 only
}|%{                        # for each zero value cell with index $i
    6..8+1|%{               # offsets for the surrounding cells
                            #  .  .  .
                            #  .  x +1
                            # +6 +7 +8  
        $_,-$_              # add the mirror offsets 
                            # -8 -7 -6
                            # -1  x +1
                            # +6 +7 +8  
    }|%{                    # for each offset 
        $a[$i]+=$a[$i+$_]   # add surrounding values to the cell
    }
}
                            # display the $a
-join(
    $a|%{                   # for each value of $a
        if(!(++$i%7)){"`n"} # line break for each 7 cells
        '{0,3}'-f$_         # formatted value of $a with width = 3 char and align right
    }
)                           # join all values to string

Mathematica 142 151 172 179

Kode

z = (m = RandomInteger[{1, 9}, {7, 7}]; s = SparseArray; o = OddQ; e = EvenQ; i = {1, 1, 1};
(m + ArrayPad[ListCorrelate[{i, i, i}, m] s[{{i_, j_} /; o@i \[And] o@j -> 1}, {5, 5}], 1]
- 2 m s[{{i_, j_} /; e@i \[And] e@j -> 1}, {7, 7}]) // Grid)

Pemakaian

z

Julia 0.6 , 127 (89) byte

x=rand(1:9,7,7);[x[i,j]=sum(!(0==k==l)*x[i+k,j+l]for k=-1:1,l=-1:1)for i=2:2:7,j=2:2:7]
Base.showarray(STDOUT,x,1<1;header=1<1)

Cobalah online!

89 byte menggunakan tampilan asli, yang mungkin diterima jika garis tambahan dapat dicetak:

7×7 Array{Int64,2}:
6   6  8   2  3   2  3
7  44  5  33  4  23  5
3   8  1   9  1   3  2
4  41  2  37  5  22  2
7   8  8   8  3   4  2
9  53  6  44  7  36  3
7   7  1   9  2   6  9

Java 10, 262 260 248 239 bytes

v->{int a[][]=new int[7][7],i=49,j,k;for(;i-->0;)a[i/7][i%7]+=Math.random()*9+1;var r="";for(;++i<7;r+="\n")for(j=0;j<7;r+=(k=a[i][j])>9|j++%2<1?k+" ":k+"  ")if(i*j%2>0)for(a[i][j]=k=0;k<9;k++)a[i][j]+=k!=4?a[i+k/3-1][j+k%3-1]:0;return r;}

-12 byte terima kasih kepada @ceilingcat .

Penjelasan:

Coba di sini.

v->{                        // Method with empty unused parameter and String return-type
  int a[][]=new int[7][7],  //  Integer-matrix with 7x7 zeroes
      i=49,j,k;             //  Index integers (`i` starting at 49)
  for(;i-->0;)              //  Loop `i` in the range (49, 0]:
    a[i/7][j%7]+=Math.random()*9+1;
                            //   Fill the current cell with a random 1..9 integer
  var r="";                 //  Result-String, starting empty
  for(;++i<7;               //  Loop `i` in the range [0, 7):
      r+="\n")              //    After every iteration: append a new-line to the result
    for(j=0;j<7;            //   Inner loop `j` in the range [0, 7):
        r+=                 //     After every iteration: append the result-String with:
           (k=a[i][j])>9    //      If the current number has 2 digits,
           |j++%2<1?        //      or it's an even column (indices 0/2/4/6)
            k+" "           //       Append the current number appended with one space
           :                //      Else:
            k+"  ")         //       Append the current number appended with two spaces
      if(i*j%2>1)           //    If both indexes `i` and `j` are odd
        for(a[i][j]=k=0;    //     Reset both the current item and index `k` to 0
            k<9;k++)        //     Inner loop `k` in the range [0, 9):
          a[i][j]+=         //      Sum the item at location `i,j` with:
           k!=4?            //       If `k` is not 4 (the current item itself)
            a[i+k/3-1][j+k%3-1]
                            //        Sum it with the numbers surrounding it
           :                //       Else:
            0;              //        Leave it the same by adding 0
  return r;}                //  Return the result-String