^{Publication sandbox (supprimée)}

Les anciennes formations de l'armée romaine sont très célèbres dans le monde entier. Dans ces formations, des légionnaires romains regroupés sous une forme géométrique (généralement un rectangle) protégeant les flancs et la partie supérieure de celui-ci à l'aide de leurs boucliers. Les légionnaires aux positions intérieures couvraient la partie supérieure en plaçant leur bouclier au-dessus de leur tête, les légionnaires sur les flancs portaient 2 boucliers ou plus: un pour protéger la partie supérieure et un ou plusieurs boucliers pour protéger les flancs (si quelqu'un était dans le coin) il avait 3 boucliers, si quelqu'un était seul dans une formation, il avait 5 boucliers ^{Oui, je sais qu'il est impossible pour un humain de porter 5 boucliers, mais ils l'ont fait d'une manière ou d'une autre} ). En utilisant cette formation, tous les légionnaires romains se protégeaient et étaient l'adversaire le plus dur à l'époque.

L'histoire raconte qu'il y avait un général romain qui a déclaré que la meilleure forme de formation était le carré (même nombre de légionnaires en rangées et en colonnes). Le problème était de savoir combien de formations (et la taille) il devrait diviser son armée afin de:

• Ne laissez aucun légionnaire hors d'une formation (bien qu'il ait admis une formation de légionnaire unique)
• Réduisez la quantité de boucliers requis

Le général, après avoir fait quelques calculs et calculs, il a compris que la meilleure façon d'accomplir ces 2 conditions est de commencer avec le plus grand carré possible, puis de répéter jusqu'à ce qu'il ne reste plus de légionnaires .

Exemple:

Si 35 légionnaires de son armée, la formation consistait à

• Une place des légionnaires 5x5 (c'est la plus grande place possible).

Avec les légionnaires restants (10)

• Un carré 3x3

Avec les légionnaires restants (1)

• Un carré 1x1.

À la fin, cela ressemblera à ceci:

   5x5      
* * * * *        3x3            
* * * * *       * * *      1x1  
* * * * *       * * *       *
* * * * *       * * *       
* * * * *               

Les légionnaires en position intérieure couvraient la partie supérieure en plaçant leur bouclier au-dessus de leurs têtes . Ils n'avaient besoin que d'un bouclier.

* * * * *                   
* 1 1 1 *       * * *       
* 1 1 1 *       * 1 *       *
* 1 1 1 *       * * *       
* * * * *               

Les légionnaires aux flancs portaient 2

* 2 2 2 *                   
2 1 1 1 2       * 2 *       
2 1 1 1 2       2 1 2       *
2 1 1 1 2       * 2 *       
* 2 2 2 *               

Si quelqu'un était dans le coin, il avait 3 boucliers

3 2 2 2 3               
2 1 1 1 2       3 2 3       
2 1 1 1 2       2 1 2       *
2 1 1 1 2       3 2 3       
3 2 2 2 3               

Si quelqu'un était seul dans une formation, il avait 5 boucliers

3 2 2 2 3               
2 1 1 1 2       3 2 3       
2 1 1 1 2       2 1 2       5
2 1 1 1 2       3 2 3       
3 2 2 2 3               

Cette formation a nécessité un total de 71 boucliers.

Défi

• Calculez la quantité de boucliers nécessaires pour un nombre X de légionnaires

Contribution

• Nombre de légionnaires dans l'armée

Sortie

• Quantité de boucliers nécessaires.

Cas de test

35 => 71
20 => 44
10 => 26
32 => 72

• Les règles de code-golf standard s'appliquent

Python 2 , 60 50 48 octets

def f(s):n=s**.5//1;return s and(n+4)*n+f(s-n*n)

Essayez-le en ligne!

Nouveau au golf de code, mais en lui donnant mon meilleur swing!

Méthode:

Additionnez n^2 + 4noù nest chacun des plus grands nombres carrés qui additionnent à l'entrée.

Modifier 1

Réduit à 50 octets grâce à @Jonathan Frech!

Modifier 2

Passé int(s**.5)à s**.5//1économiser 2 octets grâce à @ovs

R , 51 50 octets

f=function(x,y=x^.5%/%1)"if"(x,y^2+4*y+f(x-y^2),0)

Essayez-le en ligne!

Un carré de longueur latérale doit avoir exactement des écrans y 2 + 4 y . Nous réduisons par le plus grand carré inférieur ou égal à x jusqu'à ce que x soit nul, accumulant le nombre de boucliers au fur et à mesure.$y$$y^2+4y$$x$$x$

Preuve:

$y$$(y-2)^2$$y^2-(y-2)^2$$y=1$$y^2+4y$$5$$y=1$$y$

JavaScript (ES7), 34 octets

f=n=>n&&(w=n**.5|0)*w+w*4+f(n-w*w)

Essayez-le en ligne!

Comment?

$w = \lfloor\sqrt{n}\rfloor$$s_w$

$w=3$

La formule vaut pour , comme .s 1 = $w=1$$s_1=5$

Gelée , 13 octets

ƽ²ạƊƬ_Ɲ½ẋ4S+

Essayez-le en ligne!

-1 merci à Jonathan Allan .

Julia 0,6 , 36 octets

!n=(s=isqrt(n))*s+4s+(n>0&&!(n-s*s))

Essayez-le en ligne!

Utilise la même méthode que la réponse R de @ Giuseppe, bien que ma méthode pour y arriver impliquait une réflexion moins significative et une inspection visuelle plus juste: le carré intérieur de 1s a des dimensions par , ce qui a boucliers. Autour de cela, il y a 4 murs de soldats chacun, chacun avec 2 boucliers - ce qui ajoute boucliers. Enfin, il y a quatre 3 aux quatre coins, ce qui ajoute 12 boucliers.$n^2 + 4n$$(n - 2)$$(n - 2)$$(n - 2)^2$$n - 2$$4*(n - 2)*2$

Non golfé:

!n = begin       # Assign to ! operator to save bytes on function parantheses
  s = isqrt(n)   # Integer square root: the largest integer m such that m*m <= n
  s * s +
    4 * s +
      (n > 0 &&  # evaluates to false = 0 when n = 0, otherwise recurses
        !(n - s * s))
end

(Cela peut également être fait en 35 octets avec n>0?(s=isqrt(n))*s+4s+f(n-s*s):0, mais j'ai écrit cela pour Julia 0.7 voulait éviter les nouveaux avertissements de dépréciation (les espaces exigeant sont ?et :).)

Stax , 15 octets

ëñ|^○╖?║<l╛P╝z√

Exécuter et déboguer

Brachylog , 26 octets

0|⟧^₂ᵐ∋N&;N-ℕ↰R∧N√ȧ×₄;N,R+

Essayez-le en ligne!

0           % The output is 0 if input is 0
|           % Otherwise,
⟧           % Form decreasing range from input I to 0
^₂ᵐ         % Get the squares of each of those numbers
∋N          % There is a number N in that list
&;N-ℕ       % With I - N being a natural number >= 0 i.e. N <= I
            % Since we formed a decreasing range, this will find the largest such number
↰           % Call this predicate recursively with that difference I - N as the input
R           % Let the result of that be R
∧N√ȧ        % Get the positive square root of N
×₄          % Multiply by 4
;N,R+       % Add N and R to that
            % The result is the (implicit) output

Retina 0.8.2 , 28 octets

.+
$*
(\G1|11\1)+
$&11$1$1
.

Essayez-le en ligne! Le lien inclut des cas de test. Explication:

.+
$*

Convertissez en décimal.

(\G1|11\1)+

Faites correspondre les nombres impairs. Le premier passage dans le groupe \1n'existe pas encore, donc seul \G1peut correspondre, ce qui correspond à 1. Les correspondances suivantes ne peuvent pas correspondre \G1car \Gseules les correspondances au début du match, donc à la place nous devons faire correspondre ce 11\1qui est 2 de plus que le match précédent. Nous faisons correspondre autant de nombres impairs que possible, et la correspondance totale est donc un nombre carré, tandis que la dernière capture est inférieure à deux fois son côté.

$&11$1$1

Ajoutez les protections latérales à chaque match. $&est et est alors que nous avons besoin de .$n^2$$1$2n-1$$n^2+4n=n^2+2+2(2n-1)$

.

Additionnez et convertissez en décimal.

05AB1E , 17 octets

[Ð_#tïÐns4*+Šn-}O

Essayez-le en ligne ou vérifiez tous les cas de test .

Contournement parce que ΔDtïÐns4*+Šn-}O( 15 octets ) ne semble pas fonctionner. Essayez-le en ligne en mode débogage pour voir ce que je veux dire. Je m'attendrais à ce qu'il passe de [45,'35',25]à [45,10]après l' -itération suivante et suivante Δ, mais apparemment, il efface la pile à l'exception de la dernière valeur et devient [10], ce qui entraîne 0 à la fin .. Je ne sais pas si c'est un comportement prévu ou un bogue .. (EDIT: C'est prévu, voir en bas.)

Explication:

Utilise également où est la largeur d'une boucle comme la plupart des autres réponses.$w^2+4w$$w$

[        }     # Start an infinite loop:
 Ð             #  Triplicate the value at the top of the stack
  _#           #  If the top is 0: break the infinite loop
 t             #  Take the square-root of the value
               #   i.e. 35 → 5.916...
  ï            #  Remove any digits by casting it to an integer, so we have our width
               #   i.e. 5.916... → 5
   Ð           #  Triplicate that width
    n          #  Take the square of it
               #   i.e. 5 → 25
     s         #  Swap so the width is at the top again
      4*       #  Multiply the width by 4
               #   i.e. 5 → 20
        +      #  And sum them together
               #   i.e. 25 + 20 → 45
 Š             #  Triple-swap so the calculated value for the current width
               #  is now at the back of the stack
               #   i.e. [35,5,45] → [45,35,5]
  n            #  Take the square of the width again
               #   5 → 25
   -           #  Subtract the square of the width from the value for the next iteration
               #   i.e. 35 - 25 → 10
          O    # Take the sum of the stack
               #   i.e. [45,21,5,0,0] → 71

EDIT: Apparemment, le comportement que j'ai décrit ci-dessus Δest destiné. Voici deux alternatives de 17 octets fournies par @ Mr.Xcoder qui utilisent Δen mettant des valeurs dans le global_array (avec ^) et en les récupérant ensuite (avec ¯):

ΔЈtïnα}¯¥ÄDt··+O

Essayez-le en ligne ou vérifiez tous les cas de test .

ΔЈtïnα}¯¥ÄtD4+*O

Essayez-le en ligne ou vérifiez tous les cas de test .

dc , 25 octets

d[dvddSa*-d0<MLa+]dsMx4*+

Essayez-le en ligne!

Calcule les boucliers comme sum(n^2)(le nombre d'origine) plus 4*sum(n)en poussant une copie de chaque longueur de côté carré dans le registre de pile au afur et à mesure, puis en ajoutant toutes les valeurs du registre acomme la récursion "se déroule".

Husk , 17 octets

ṁS+o*4√Ẋ≠U¡S≠(□⌊√

Essayez-le en ligne!

Alternative

ṁS*+4m√Ẋ≠U¡S≠(□⌊√

Essayez-le en ligne!

APL (Dyalog Unicode) , 31 30 octets

{⍵<2:⍵×5⋄(S×S+4)+∇⍵-×⍨S←⌊⍵*.5}

Essayez-le en ligne!

-1 octet grâce à @jslip

Rubis , 45 octets

->n{n+(1..n).sum{n-=(z=(n**0.5).to_i)*z;z*4}}

Essayez-le en ligne!

PHP , 67 octets

<?for($n=$argv[1];$w=(int)sqrt($n);$n-=$w**2)$a+=$w**2+$w*4;echo$a;

Pour l'exécuter:

php -n <filename> <n>

Exemple:

php -n roman_army_shields.php 35

Ou essayez-le en ligne!

En utilisant l' -Roption, cette version fait 60 octets :

for(;$w=(int)sqrt($argn);$argn-=$w**2)$a+=$w**2+$w*4;echo$a;

Exemple:

echo 35 | php -nR "for(;$w=(int)sqrt($argn);$argn-=$w**2)$a+=$w**2+$w*4;echo$a;"

(sous Linux, remplacer "par ')

Remarque: Ceci utilise la grande formule de réponse d'Arnauld , je n'ai pas pu trouver quelque chose de plus court que cela.

Pyth , 19 octets

Une fonction récursive, qui devrait être appelée en utilisant y(voir le lien).

L&b+*Ks@b2+4Ky-b^K2

Essayez-le ici!

Pyth , 21 octets

L'historique des révisions est assez drôle, mais assurez-vous de le visiter si vous voulez une version beaucoup plus rapide :)

sm*d+4deeDsI#I#@RL2./

Essayez-le ici!

Explication

sm*d+4deeDsI#I#@RL2./ Programme complet, appelons l'entrée Q.
                   ./ Partitions entières de Q. Donne toutes les combinaisons de positifs
                          entiers qui totalisent Q.
               @ RL2 Prenez la racine carrée de tous les entiers de chaque partition.
             I # Conservez uniquement les partitions invariantes sous:
          sI # Jeter tous les non-entiers. Cela ne fait que maintenir
                          des partitions entièrement constituées de carrés parfaits, mais
                          au lieu d'avoir les carrés eux-mêmes, nous avons leurs racines.
       eeD Obtenez la partition (disons P) avec le maximum le plus élevé.
 m Pour chaque d dans P ...
  * d + 4d ... Rendement d * (d + 4) = d ^ 2 + 4d, la formule utilisée dans toutes les réponses.
s Additionnez les résultats de ce mappage et sortez implicitement.

Swift 4 , 111 99 84 78 octets

func f(_ x:Int)->Int{var y=x;while y*y>x{y-=1};return x>0 ?(y+4)*y+f(x-y*y):0}

Essayez-le en ligne!

Cette sensation lors de l'implémentation manuelle de la racine carrée entière est beaucoup plus courte que celle intégrée ...

Non golfé et expliqué

// Define a function f that takes an integer, x, and returns another integer
// "_" is used here to make the parameter anonymous (f(x:...) -> f(...))
func f(_ x: Int) -> Int {

    // Assign a variable y to the value of x

    var y = x

    // While y squared is higher than x, decrement y.

    while y * y > x {
        y -= 1
    }

    // If x > 0, return (y + 4) * y + f(x - y * y), else 0.

    return x > 0 ? (y + 4) * y + f(x - y * y) : 0
}