Vous devez écrire un programme ou une fonction qui, donnée Npar Nune grille carrée équidistante et un cercle inscrit solide, affiche ou renvoie le nombre de carrés de la grille qui se chevauchent partiellement ou entièrement par le cercle plein.

Les chevauchements de taille 0 (c'est-à-dire lorsque le cercle ne touche qu'une ligne) ne sont pas comptés. (Ces chevauchements se produisent par exemple N = 10.)

Exemple

N = 8 (64 squares), Slices = 60

Contribution

• Un entier N > 0. (La grille aura des N * Ncarrés.)

Production

• Un entier, le nombre de tranches de cercle plein.

Exemples

(paires entrée-sortie)

Inputs:  1 2 3  4  5  6  7  8  9 10  11  12  13  14  15
Outputs: 1 4 9 16 25 36 45 60 77 88 109 132 149 172 201

C'est le golf de code, donc l'entrée la plus courte gagne.

Pyth, 27 26

-*QQ*4lfgsm^d2T*QQ^%2_UtQ2

Essayez-le en ligne: Pyth Compiler / Executor

J'utilise une 2Nx2Ngrille et compte les 2x2carrés qui se chevauchent . C'est un peu plus court, car je connais déjà le rayon N.

Et en fait, je ne compte pas les carrés qui se chevauchent. Je compte les carrés non superposés du deuxième quadrant, multiplie le nombre par 4 et soustrais le résultat deN*N .

Explication de la solution 27:

-*QQ*4lfgsm^-Qd2T*QQ^t%2UQ2   implicit: Q = input()
                     t%2UQ    generates the list [2, 4, 6, ..., Q]
                    ^     2   Cartesian product: [(2, 2), (2, 4), ..., (Q, Q)]
                              These are the coordinates of the right-down corners
                              of the 2x2 squares in the 2nd quadrant. 
       f                      Filter the coordinates T, for which:
        gsm^-Qd2T*QQ             dist-to-center >= Q
                                 more detailed: 
          m     T                   map each coordinate d of T to:
           ^-Qd2                       (Q - d)^2
         s                          add these values
        g        *QQ                 ... >= Q*Q
    *4l                       take the length and multiply by 4
-*QQ                          Q*Q - ...

Explication de la solution 26:

J'ai remarqué que j'utilise les coordonnées une seule fois et que je soustrais immédiatement les coordonnées de Q. Pourquoi ne pas simplement générer les valeursQ - coords directement ?

Cela se produit en %2_UtQ. Un seul caractère plus grand que dans la solution précédente et enregistre 2 caractères, car je n'ai pas à soustraire -Q.

Python 2, 72

lambda n:sum(n>abs(z%-~n*2-n+(z/-~n*2-n)*1j)for z in range(~n*~n))+n+n-1

Non golfé:

def f(n):
    s=0
    for x in range(n+1):
        for y in range(n+1):
            s+=(x-n/2)**2+(y-n/2)**2<(n/2)**2
    return s+n+n-1

La grille indique un (n+1)*(n+1)carré. Une cellule chevauche le cercle si son point de grille le plus proche du centre se trouve à l'intérieur du cercle. Donc, nous pouvons compter les points de grille, sauf qu'il manque des 2*n+1points de grille sur les axes (à la fois pour les paires et les impaires n), nous corrigeons donc cela manuellement.

Le code enregistre les caractères en utilisant des distances complexes pour calculer la distance au centre et un effondrement de boucle pour itérer sur un seul index.

CJam, 36 35 34 27 octets

Cela s'est avéré être le même algorithme que xnor, mais je me demande s'il y en a un meilleur.

rd:R,_m*{{2*R(-_g-}/mhR<},,

Explication du code :

rd:R                                "Read the input as double and store it in R";
    ,_                              "Get 0 to input - 1 array and take its copy";
      m*                            "Get Cartesian products";
                                    "Now we have coordinates of top left point of each";
                                    "of the square in the N by N grid";
        {               },,         "Filter the squares which are overlapped by the";
                                    "circle and count the number";
         {        }/                "Iterate over the x and y coordinate of the top left";
                                    "point of the square and unwrap them";
          2*                        "Scale the points to reflect a 2N grid square";
            R(-                     "Reduce radius - 1 to get center of the square";
               _g-                  "Here we are reducing or increasing the coordinate";
                                    "by 1 in order to get the coordinates of the vertex";
                                    "of the square closer to the center of the grid";
                    mhR<            "Get the distance of the point from center and check";
                                    "if its less than the radius of the circle";

MISE À JOUR : Utilisation de l'astuce 2N de Jakube avec d'autres techniques pour économiser 7 octets!

Essayez-le en ligne ici

Pyth,  44  36

JcQ2L^-+b<bJJ2sm+>*JJ+y/dQy%dQqQ1*QQ

Essayer de le nettoyer un peu au cas où je pourrais raser quelques octets.

Explication

                           Q = eval(input())    (implicit)
JcQ2                       calculate half of Q and store in J
L                          define function y(b) that returns
 ^-+b<bJJ2                 (b - J + (1 if b < J else 0)) ^ 2
s                          output sum of
 m                 *QQ      map d over integers 0..(Q*Q-1)
  +
   >*JJ                      J*J is greater than
       +y/dQy%dQ              sum of y(d / Q) and y(d % Q)
                qQ1          or Q is 1; see below

Je dois vérifier explicitement n = 1, car mon algorithme ne vérifie que le coin du carré le plus proche du centre (et aucun n'est couvert n = 1).

Octave (74) (66) (64)

Voici la version octave. Fondamentalement, trouver tous les sommets dans le cercle, puis trouver tous les carrés avec un ou plusieurs sommets valides via convolution. 64 octets:

x=ndgrid(-1:2/input(''):1);sum(conv2(x.^2+x'.^2<1,ones(2))(:)>0)

66 octets:

x=meshgrid(-1:2/input(''):1);sum(conv2(x.^2+x'.^2<1,ones(2))(:)>0)

74 octets:

n=input('');x=ones(n+1,1)*(-1:2/n:1);sum(conv2(x.^2+x'.^2<1,ones(2))(:)>0)

R - 64

function(n)sum(rowSums(expand.grid(i<-0:n-n/2,i)^2)<n^2/4)+2*n-1