Générez une grille de 7 x 7, remplie de nombres aléatoires. Cependant, dans les cellules avec un numéro de ligne et de colonne impair (à partir de 0), vous devez utiliser la somme des cellules environnantes. Voici un petit exemple avec une grille 3 x 3 (somme en carré en gras):

2 2  2
2 16 2
2 2  2

Et voici un exemple de grille 7 x 7:

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

Règles

• Les nombres qui ne sont pas des sommes doivent toujours être compris entre 1 et 9 inclus.

• La grille doit être générée aléatoirement. Pour chaque non-somme, chaque chiffre doit avoir une chance égale d'apparaître, quelle que soit la cellule dans laquelle il se trouve.

• Les nombres doivent être alignés. Cela signifie que le premier ou le dernier chiffre de chaque numéro d'une colonne doit être aligné verticalement. (Vous pouvez supposer que les chiffres du milieu seront toujours à deux chiffres.)

• Les cellules environnantes comprennent des diagonales. Par conséquent, chaque carré de somme aura huit chiffres qui l'entourent, que vous devez ajouter.

• Le code le plus court gagne, car il s'agit du code-golf .

APL, 53 49 43 42 40 39 36

J'ai réussi à répliquer les J ;.dans APL, et j'ai utilisé l'approche de Gareth , économisant 13 caractères.

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

Exemple d'exécution:

      {×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

Explication:

• ∘.∨⍨9⍴0 1 génère un masque de bits.
• ×∘?∘9¨ multiplie chaque bit par une valeur aléatoire de 1 à 9 inclus, générant une grille masquée de nombres aléatoires.
• 3,⌿3,/utilise ce qui ne peut être décrit que comme du piratage pour renvoyer toutes les cases se chevauchant 3 par 3 dans le tableau masqué. Ceux-ci sont également aplatis dans le processus.
• {×5⌷⍵:5⌷⍵⋄+/⍵}¨itère sur le tableau, en affectant chaque élément à ⍵. Pour chaque itération, il prend la cinquième (au milieu, en se souvenant que l'indexation APL est basée sur 1), et retourne son signe. Dans ce cas, cela équivaut à tester si le nombre est supérieur à 0. Si cela renvoie 1 (pour vrai), alors retournez cet élément. Sinon, renvoyez la somme des éléments dans la case 3 par 3 aplatie. Il utilise l' :⋄opérateur ternaire, qui est l'équivalent de ?:dans de nombreuses langues.

J, 63 61 59 55 52 51 49 47 39 37 caractères

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

Merci à Volatility pour sa sauvegarde de 10 personnages.

Explication (chaque étape aura des nombres aléatoires différents ...):

Générez le masque pour générer les nombres aléatoires (utilise $:

   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

Maintenant, nous avons un crochet . Il s'agit en fait d'un heureux accident lorsque je réduisais une version antérieure. Il devait être transposé |:et OU +.avec l'original. Cela avait du sens puisque j'utilisais des uns et des zéros à l'époque, mais maintenant j'ai des neuf et des zéros. Il se trouve que cela fonctionne de la même manière avec la signification GCD de +.. Heureusement pour moi. :-)

   (+.|:)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

Donc, maintenant que nous avons une grille de 9 et de 0, nous voulons générer des nombres aléatoires. ?génère un nombre aléatoire de 0 à (mais sans inclure) un nombre donné. Étant donné une liste, il générera un nombre aléatoire de cette manière pour chaque membre de la liste. Ainsi, dans ce cas, il générera un nombre de 0 à 8 pour chaque 9 du tableau et un nombre à virgule flottante de 0 à 1 pour chaque 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

Mais nous voulons des nombres de 1 à 9 et non de 0 à 8. Nous ajoutons donc 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

C'est très bien mais nous avons perdu les zéros que je veux, nous allons donc le multiplier par le masque d'origine après avoir transformé tous les neuf en un. Je le fais en vérifiant si la valeur est supérieure à 1. Cela nous donne: (1&<*1+?).
Il se passe deux ou trois choses ici:

• Nous avons créé une fourchette qui nous permet de regrouper beaucoup de travail en très peu de caractères.
• Nous avons lié ( &) le 1 au <verbe.

Ainsi, tous combinés (1&<*1+?)génèrent des nombres aléatoires et mettent à zéro tous les nombres générés par des zéros dans la grille d'origine.

   (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

Le bit suivant est le (à mon avis, de toute façon :-) peu intelligent.
Le ;.verbe coupé a une forme x u;._3 yqui coupe l'entrée dans les cases décrites par x, puis leur applique le verbe u. Dans ce cas, nous avons 3 3(4&{++/*0=4&{)@,;._3.

• Le 3 3décrit les boîtes que nous voulons - 3x3.
• Le (4&{++/*0=4&{)@,est un train de verbes qui décrit ce que nous voulons faire pour chaque boîte.

Pour démontrer le ;.verbe que j'utiliserai <pour montrer chaque case:

   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│
└─────┴─────┴─────┴─────┴─────┴─────┴─────┘

Quelques points à noter:

• Les cases se chevauchent - les deuxième et troisième colonnes dans la case en haut à gauche sont la première et la seconde dans la case à droite de celle-ci.
• Il y a des boîtes 7x7. C'est pourquoi nous avions initialement une grille 9x9.
• Chaque endroit dont nous avons besoin d'une somme a un 0au centre de la boîte.

Il ne nous reste plus qu'à passer la valeur au centre arrière (si elle n'est pas nulle) ou à additionner les nombres dans la case 3x3 (si le centre est zéro).
Pour ce faire, nous avons besoin d'un accès facile au numéro du centre. ,aide ici. Il fait tourner la grille de 3x3 dans une liste de 9 articles avec le numéro du centre au numéro 4.
4&{utilisera {pour tirer la valeur centrale, puis le comparer avec 0: 0=4&{. Cela renvoie un 0ou 1pour vrai ou faux, que nous multiplions ensuite par la somme +/. Si elle était nulle au centre, nous avons maintenant notre somme comme requis. Si ce n'est pas le cas, nous avons zéro, donc pour terminer, nous ajoutons simplement la valeur centrale 4&{+.
Cela donne le train de verbes(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 caractères)

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}

Exemple de sortie

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  

Panne

Ce n'est pas trop évident comment cela fonctionne, alors voici une ventilation rapide. REMARQUE: vous pouvez probablement ignorer certaines de ces étapes et passer à des versions plus courtes plus rapidement, mais je pense que c'est assez pédagogique pour voir différentes façons dont je rase les caractères, en particulier en repérant les modèles dans les littéraux pour transformer les nombres à 2 chiffres en versions à 1 chiffre .

Version naïve

Contrairement aux autres solutions Ruby qui reposent sur un tableau bidimensionnel, vous pouvez (éventuellement) obtenir une version plus courte en commençant par un tableau unidimensionnel et en travaillant avec des valeurs de décalage, car les motifs se répètent.

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

Le principe clé ici est que nous travaillons aux positions d'index 8, 10, 12, juste compensées par des multiples de 14. Les positions 8, 10 et 12 sont les centres des grilles 3x3 que nous résumons. Dans l'exemple de sortie, 34 est la position 8, 42 est la position 8 + 14 * 1, etc. Nous remplaçons la position 8 par 34 par des positions décalées de la position 8 par [-8,-7,-6,-1,1,6,7,8]- en d'autres termes 34 = sum(ary[8-8], ary[8-7], ..., ary[8+8]). Ce même principe vaut pour toutes les valeurs de [8 + 14*i, 10 + 14*i, 12 + 14*i], puisque le motif se répète.

L'optimiser

Tout d'abord, quelques optimisations rapides:

• Au lieu de 3.times { ... }, et calculant à j + 14*ichaque fois, "aligner" les positions [8,10,12,22,24,26,36,38,40].
• Le offsetstableau est utilisé une fois, alors remplacez la variable par le littéral.
• Remplacez do ... endpar {...}et basculez l'impression vers $> << foo. (Il y a un truc ici impliquant puts nilet () == nil.)
• Noms de variables plus courts.

Le code suivant est de 177 caractères:

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)}

Pour la prochaine réduction, notez que le injecttableau de décalages n'a pas besoin d'être en ordre. Nous pouvons avoir [-8,-7,-6,-1,1,6,7,8]soit un autre ordre, car l'addition est commutative.

Donc, associez d'abord les points positifs et les points négatifs à obtenir [1,-1,6,-6,7,-7,8,-8].

Vous pouvez maintenant raccourcir

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

à

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

Il en résulte

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)}

qui est de 176 caractères.

Décaler de 8 et passer aux différences

Les valeurs littérales à deux caractères semblent pouvoir être raccourcies, alors prenez [8,10,12,22,24,26,36,38,40]et décalez tout par le bas 8, en mettant jà jour au début de la boucle. (Notez que cela +=8évite d'avoir à mettre à jour les valeurs de décalage de 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)}

C'est 179, ce qui est plus grand, mais il j+=8peut être supprimé.

Premier changement

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

à un tableau de différences:

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

et ajouter cumulativement ces valeurs à une initiale j=8. Cela couvrira éventuellement les mêmes valeurs. (Nous pourrions probablement passer directement à cela au lieu de passer de 8 en premier.)

Notez que nous ajouterons également une valeur fictive de 9999à la fin du tableau des différences et ajouterons jà la fin , pas au début de la boucle. La justification est que cela 2,2,10,2,2,10,2,2ressemble terriblement aux mêmes 3 chiffres répétés 3 fois, et en calculant j+differenceà la fin de la boucle, la valeur finale de 9999n'affectera pas réellement la sortie, car il n'y a pas d' a[j]appel où jest une valeur fini 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)}

Avec ce tableau de différences, le j+=8est maintenant juste j=8, bien sûr, car sinon nous en ajouterions 8trop à plusieurs reprises . Nous avons également changé la variable de bloc de jà l.

Donc, puisque l' 9999élément n'a aucun effet sur la sortie, nous pouvons le changer 10et raccourcir le tableau.

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)}

C'est 170 caractères.

Mais maintenant, l' j=8apparence est un peu maladroite, et vous pouvez enregistrer 2 caractères en diminuant [2,2,10]de 2 pour obtenir facilement un que 8vous pouvez utiliser pour l'attribution. Cela doit aussi j+=ldevenir 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)}

Il s'agit de 169 caractères. Un moyen détourné de presser 7 caractères, mais c'est bien.

Derniers ajustements

L' values_atappel est en fait en quelque sorte redondant, et nous pouvons incorporer un Array#[]appel. Donc

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

devient

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

Vous pouvez également remarquer que flat_map+ j+e/j-e+ injectpeut être réduit à une somme plus directe avec une initiale 0dans le tableau.

Cela vous laisse avec 152 caractères:

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)}

Finalement:

• map.with_indexpeut devenir each_slice.
• Modifiez l'approche d'impression.

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

Techniquement, cela ne satisfait pas aux règles, car les derniers chiffres de chaque numéro sont alignés plutôt que le premier. Mais je pensais partager quand même:

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

Exemple de sortie:

[[ 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〛]

Pour une sortie plus jolie, il Column/@peut être remplacé par TableForm@un coût de 2 caractères.

GolfScript ( 79 78 72 70 68 66 65 60 caractères)

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

NB Il contient un onglet littéral que Markdown pourrait bien casser.

Le morceau intelligent est dû à Gareth: voir sa solution J.

Démo en ligne

R: 114 caractères

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

La première ligne crée un tableau 7 x 7 rempli de nombres choisis au hasard de 1 à 9 (distribution uniforme avec remplacement, donc r=Tqui signifie replace=TRUE). Deuxième ligne, calculer des sommes de 3 par 3 grilles, soustraire le centre et le remplacer par le résultat. La troisième ligne imprime la grille résultante (par défaut, les colonnes de matrice et de tableau sont alignées à droite).

Exemple de sortie:

     [,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 octets

Une solution naïve et verbeuse en J. C'est une implémentation simple de la tâche.

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

Je crée d'abord un tableau 7 x 7 d'entiers compris entre 1 et 9. En fait, J? le verbe génère des nombres jusqu'à son argument, c'est pourquoi nous devons incrémenter chaque élément,>: in 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

Je prépare un masque à utiliser pour la remise à zéro des cellules impaires de lignes / colonnes, une paire d'indices de lignes / colonnes impaires:

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

Le verbe Catalogue {combine les éléments des atomes à l'intérieur de la liste encadrée

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

pour former un catalogue, le tableau 3x3 des paires ci-dessus

Ensuite, je prépare un tableau des indices ligne / col à utiliser pour la sélection de chacun des sous-réseaux 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││
│└─────┴─────┘│└─────┴─────┘│└─────┴─────┘│
└─────────────┴─────────────┴─────────────┘

Pour chaque paire dans le tableau m, je fais une paire de triplets, centrée autour de chaque numéro de la paire m:

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

Ces paires de triplets sont utilisées par le verbe J From {, qui peut sélectionner plusieurs lignes et colonnes simultanément. 0 1 2/2 3 4 signifie que je sélectionne les lignes 0, 1 et 2 ainsi que les colonnes 2, 3 et 4, sélectionnant ainsi le deuxième sous-tableau 3x3 en haut.

Enfin, je peux utiliser le tableau 7x7 et les masques pour accomplir la tâche: d'abord j'utilise m comme masque pour mettre les éléments correspondants à 0:

0 m}a

Ensuite, je prends tous les sous-réseaux 3x3 en utilisant s comme sélecteur et trouve leurs sommes:

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

Ensuite, je remets ces chiffres dans le tableau de départ.

 (+/^:_"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

Essayez-le en ligne!

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

-1 octet grâce à @jslip

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

Essayez-le en ligne!

Rubis, 207

Je présenterai d'abord ma solution (comme je le fais toujours):

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 caractères

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}

si la justification de l'exigence de justification de gauche est juste, cela ljustdevrait être utilisé ... eh bien, non. J'adore les capacités de formatage de Ruby.

Ne pas utiliser Array.new(7){...}. (0..6).map{...}est à la fois plus court et plus lisible et vous obtenez une plage assignable gratuitement.

Ligne # 3 inspirée de la solution de Doorknob .

GolfScript, 87 caractères

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

Il y a trop de zips là-dedans ... (voir en ligne )

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 caractères

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

Bien que la spécification exige que les nombres soient alignés à gauche, il n'est pas nécessaire d'utiliser la notation décimale, donc je suppose que c'est une sortie valide:

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

Si l'alignement à droite au lieu de l'alignement à gauche est acceptable, nous sommes à 58 caractères

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

J's ":(format) a trois modes de formatage:

• aligné à droite avec n chiffres ou avec film rétractable (affichage par défaut)
• notation scientifique alignée à gauche avec n chiffres et m caractères au total
• affichage en boîte sous film rétractable avec (gauche / centre / droite) - (haut / milieu / bas) alignement (ci-dessous, 69 caractères)

Le format le plus verbeux mais aussi le plus polyvalent et le seul capable de produire la sortie selon l'exemple est le 8!:2formatage étranger, qui prend une chaîne de formatage comme argument de gauche. Aussi 67 caractères :

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

Voici le format encadré:

 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 caractères

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

C'est l'un de ces scripts Perl où toutes les boucles for sauf une ont été regroupées en mapappels afin que tout puisse être fait en une seule instruction. Les variables globales font également des apparitions importantes dans celle-ci. Je suppose que ce que j'essaie de dire ici, c'est que ce programme est un peu dégoûtant.

Attendez, ça empire: il y a un bug connu dans le script! Cependant, il a moins d'une chance sur un million de se déclencher, donc je n'ai pas encore réussi à le réparer.

Mathematica , 106/100

J'ai trouvé quelque chose de très similaire au code de ssch, avant de le voir. J'emprunte son idée d'utilisation Column. Avec ASCII uniquement, 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

Avec les caractères Unicode (tels qu'utilisés par 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 octets

Fonction immédiate VBE qui sort vers [B2:H9].

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

Exemple de sortie

Powershell, 149 148 octets

-1 octet grâce à @AdmBorkBork. C'est cool!

$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$_})

Explication:

$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

Code

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)

Usage

z

Julia 0,6 , 127 (89) octets

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)

Essayez-le en ligne!

89 octets utilisant l'affichage natif, ce qui pourrait être admissible si des lignes supplémentaires peuvent être imprimées:

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 octets

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 octets grâce à @ceilingcat .

Explication:

Essayez-le ici.

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