26

पुराने रोमन सेना के रूप दुनिया भर में बहुत प्रसिद्ध हैं। इन संरचनाओं में रोम के दिग्गजों को एक ज्यामितीय आकार (आमतौर पर एक आयत) में बांटा जाता है जो उनके ढालों का उपयोग करते हुए फ़्लेक्स और उसके बेहतर हिस्से की रक्षा करता है। आंतरिक स्थितियों में दिग्गजों ने अपने सिर के ऊपर अपनी ढाल को ढालते हुए बेहतर हिस्से को कवर किया, फ़्लेक्स पर सेनाओं ने 2 या अधिक ढालें लीं: एक बेहतर भाग की रक्षा के लिए, और एक या अधिक ढालों की सुरक्षा के लिए (यदि कोई कोने में था) उसके पास 3 ढालें थीं, अगर कोई निर्माण में अकेला था तो उसके पास 5 ढालें थीं ^{हाँ, मुझे पता है कि मानव के लिए 5 ढालें ले जाना असंभव है, लेकिन किसी तरह उन्होंने इसे पूरा किया} )। इस गठन का उपयोग करते हुए सभी रोमन दिग्गजों ने खुद की रक्षा की और उस समय सबसे कठिन प्रतिद्वंद्वी थे।

इतिहास बताता है कि एक रोमन जनरल था जिसने कहा था कि सबसे अच्छा गठन आकार वर्ग था (पंक्तियों और स्तंभों में सेनाओं की समान संख्या)। समस्या यह पता लगा रही थी कि उसे अपनी सेना को कितने रूपों (और आकार) में विभाजित करना चाहिए:

एक गठन से बाहर किसी भी विरासत को छोड़ना नहीं है (हालांकि उन्होंने एकल विरासत गठन स्वीकार किया)
आवश्यक ढालों की मात्रा कम करें

सामान्य, कुछ गणित और गणना करने के बाद, उन्हें पता चला कि इस 2 स्थितियों को पूरा करने का सबसे अच्छा तरीका सबसे बड़ा वर्ग संभव है, और फिर तब तक दोहराएं जब तक कि कोई भी सेनापति नहीं छोड़े ।

उदाहरण:

यदि उसकी सेना में 35 सेनाएँ होती हैं, तो गठन में शामिल होता है

एक 5x5 लीजियनरीज़ वर्ग (यह सबसे बड़ा वर्ग संभव है)।

शेष दिग्गजों के साथ (10)

एक 3x3 वर्ग

शेष दिग्गजों के साथ (1)

1x1 वर्ग।

अंत में यह कुछ इस तरह दिखेगा:

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

आंतरिक स्थितियों में दिग्गजों ने अपने सिर के ऊपर अपनी ढाल रखकर बेहतर भाग को कवर किया । उन्हें केवल 1 ढाल की आवश्यकता थी।

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

फ्लैंक्स पर दिग्गजों ने 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 *

यदि कोई कोने में था तो उसके पास 3 ढालें थीं

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

यदि कोई निर्माण में अकेला था तो उसके पास 5 ढालें थीं

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

इस गठन के लिए कुल 71 ढालों की आवश्यकता थी।

चुनौती

दिग्गजों की एक एक्स राशि के लिए आवश्यक ढाल की मात्रा की गणना करें

इनपुट

सेना में सेनाओं की राशि

उत्पादन

शील्ड्स की जरूरत

परीक्षण के मामलों

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

मानक कोड-गोल्फ नियम लागू होते हैं

code-golf matrix

— लुइस फेलिप डी जीसस मुनोज
स्रोत

11

अच्छी तरह से "5 ढाल ले जाने" का Google परिणाम है, Amazon.com : Best-selling Nipple Shield Carrying Case, Perfect...इसलिए मुझे लगता है कि मैं वास्तव में कभी नहीं जान पाऊंगा। क्या वे वास्तव में 5 ढाल ले गए थे - या यह सवाल काम करने के लिए था: पी?

— मैजिक ऑक्टोपस Urn

1

@MagicOctopusUrn Im बहुत यकीन है कि आपको जवाब पता है कि मुझे लगता है कि मुझे नहीं पता है कि किसी को 5 ढालों के साथ लड़ाई में बाहर जाने की हिम्मत है

— लुइस फेलिप डी जीसस मुनोज़

4

मैं सामान्य गणित नहीं करता हूं और गणना यह निष्कर्ष निकालना सही है कि बार-बार सबसे बड़ा वर्ग लेने के लिए आवश्यक ढालें कम से कम होती हैं। उदाहरण के लिए, ३२ कुल ५४ ढालों के लिए ५ * ५ + २ * २ * २ + १ * १ * १ + १ * १ वर्ग के बजाय ४४ कुल ढाल के लिए ३२ दिग्गजों को दो ४ * ४ वर्गों में विभाजित किया जा सकता है।

— xnor

6

@xnor शायद सामान्य स्थिति में सामान्य सही नहीं था, लेकिन जनरल सामान्य है (हालांकि हमें सामान्य नहीं करना चाहिए)।

— पाजोंक

2

@AJFaraday Asterix और भाड़े के बदमाश ?

— क्रिस एच

14

पायथन 2 , 60 50 48 बाइट्स

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

इसे ऑनलाइन आज़माएं!

गोल्फ को नया, लेकिन यह मेरा सबसे अच्छा स्विंग दे रही है!

तरीका:

Sum n^2 + 4nजहां nइनपुट के योग में सबसे बड़ा वर्ग संख्या है।

संपादित करें 1

@Jonathan Frech की बदौलत 50 बाइट्स में कमी!

संपादित करें 2

@Ovs के लिए 2 बाइट्स को बचाने के int(s**.5)लिए स्विच किया s**.5//1गया

— ईस्टन बोर्नमेयर
स्रोत

8

PPCG में आपका स्वागत है!

— लुइस फेलिप डी जीसस मुनोज

2

मुझे लगता n*nहै कि n**2आपको दो बाइट्स बचाने की तुलना में कम है ; इससे ज्यादा मैं नहीं कह सकता क्योंकि मैं अजगर नहीं लिखता ...

— Giuseppe

2

50 बाइट्स ।

— जोनाथन फ्रेच

2

int(s**.5)को छोटा किया जा सकता है s**.5//1।

— २१

2

@mypetlion यह करता है। //दोनों पायथन 2 में फ्लोर डिवीजन है और 3. दोनों संस्करणों में 3**.5//1मूल्यांकन 1.0करता है।

— अंडा

11

आर , 51 50 बाइट्स

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

इसे ऑनलाइन आज़माएं!

$y$ $y^2+4y$ $x$ $x$

प्रमाण:

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

— ग्यूसेप
स्रोत

y^{2}

$y^2$

4 \cdot y

$4\cdot y$

1

@ToddSewell यकीन है, यह है कि Arnauld की व्याख्या है, और यह है कहीं अधिक सुंदर है, लेकिन इस तरह से मैं इसे से संपर्क किया, तो मैं यह करने के लिए चिपके हुए कर रहा हूँ है! सौभाग्य से, यह एक सबूत-गोल्फ सवाल नहीं है।

— Giuseppe

10

जावास्क्रिप्ट (ईएस 7), 34 बाइट्स

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

इसे ऑनलाइन आज़माएं!

कैसे?

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

s_{w} = w^{2} + 4 w

$s_w = w^2+4w$

$w=3$

\begin{aligned} (\begin{matrix} 3 & 2 & 3 \\ 2 & 1 & 2 \\ 3 & 2 & 3 \end{matrix}) = & (s_{3} = 21) \\ (\begin{matrix} 1 & 1 & 1 \\ 1 & 1 & 1 \\ 1 & 1 & 1 \end{matrix}) + & (3^{²} = 9) \\ (\begin{matrix} 1 & 1 & 1 \\ 0 & 0 & 0 \\ 0 & 0 & 0 \end{matrix}) + (\begin{matrix} 0 & 0 & 1 \\ 0 & 0 & 1 \\ 0 & 0 & 1 \end{matrix}) + (\begin{matrix} 0 & 0 & 0 \\ 0 & 0 & 0 \\ 1 & 1 & 1 \end{matrix}) + (\begin{matrix} 1 & 0 & 0 \\ 1 & 0 & 0 \\ 1 & 0 & 0 \end{matrix}) & (4 \times 3 = 12) \end{aligned}

$\begin{align}&\pmatrix{3 & 2 & 3\\2 & 1 & 2\\3 & 2 & 3}=&(s_3=21)\\&\pmatrix{1 & 1 & 1\\1 & 1 & 1\\1 & 1 & 1}+&(3^²=9)\\&\pmatrix{1 & 1 & 1\\0 & 0 & 0\\0 & 0 & 0}+\pmatrix{0 & 0 & 1\\0 & 0 & 1\\0 & 0 & 1}+\pmatrix{0 & 0 & 0\\0 & 0 & 0\\1 & 1 & 1}+\pmatrix{1 & 0 & 0\\1 & 0 & 0\\1 & 0 & 0}&(4\times3=12)\end{align}$

सूत्र , जैसा कि । $w=1$ $s_1=5$

— Arnauld
स्रोत

5

जेली , 13 बाइट्स

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

इसे ऑनलाइन आज़माएं!

-1 जोनाथन एलन को धन्यवाद ।

— आउटग्रॉफर को एरिक करें
स्रोत

4

जूलिया 0.6 , 36 बाइट्स

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

इसे ऑनलाइन आज़माएं!

@ Giuseppe के R उत्तर के रूप में समान विधि का उपयोग करता है , हालांकि वहां पहुंचने की मेरी विधि में कम सार्थक सोच और अधिक सिर्फ दृश्य निरीक्षण शामिल है: 1s के आंतरिक वर्ग में आयाम द्वारा । ताकि ढाल हो। उस के चारों ओर, सैनिकों की 4 दीवारें हैं , प्रत्येक में 2 ढालें हैं - ताकि ढालें जुड़ जाएं । अंत में, चार कोनों में चार 3 एस हैं, जिससे 12 ढाल जुड़ती हैं। $n^2 + 4n$ $(n - 2)$ $(n - 2)$ $(n - 2)^2$ $n - 2$ $4*(n - 2)*2$

(n - 2)^{2} + 4 * (n - 2) * 2 + 4 * 3 = n^{2} + 4 - 4 n + 8 n - 16 + 12 = n^{2} + 4 n

$(n-2)^2 + 4*(n-2)*2 + 4*3 = n^2 + 4 - 4n + 8n - 16 + 12 = n^2 + 4n$

Ungolfed:

!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

(इसे 35 बाइट्स के साथ भी किया जा सकता है n>0?(s=isqrt(n))*s+4s+f(n-s*s):0, लेकिन मैंने जूलिया 0.7 के लिए यह लिखा था कि नए डिप्रेसेशन चेतावनियों से बचना चाहिए (रिक्त स्थान आवश्यक हैं ?और :)।)

— sundar - मोनिका को बहाल करना
स्रोत

शील्ड काउंट के लिए एक और अतिविशिष्ट स्पष्टीकरण, @ Giuseppe के उत्तर पर मेरी टिप्पणी देखें।

— टॉड सीवेल

2

@ToddSewell हाँ, क्षेत्र + परिधि इसे देखने का एक और अधिक सुंदर तरीका है। मैंने इसे इस तरह से नहीं किया था, और Giuseppe के समान मेरा इरादा सूत्र के सबसे स्वच्छ प्रमाण देने की तुलना में मेरे दृष्टिकोण का वर्णन करना है।

— सूंदर -

4

स्टैक्स , 15 बाइट्स

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

इसे चलाएं और डीबग करें

— wastl
स्रोत

3

ब्रेकीलॉग , 26 बाइट्स

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

इसे ऑनलाइन आज़माएं!

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

— sundar - मोनिका को बहाल करना
स्रोत

2

रेटिना 0.8.2 , 28 बाइट्स

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

इसे ऑनलाइन आज़माएं! लिंक में परीक्षण के मामले शामिल हैं। स्पष्टीकरण:

.+
$*

दशमलव में परिवर्तित करें।

(\G1|11\1)+

विषम संख्याओं का मिलान करें। समूह के माध्यम से पहली पास, \1नहीं अस्तित्व अभी तक, इसलिए केवल करता है \G1जो मेल खाता है 1. इसके बाद मैचों से मेल नहीं कर सकते हैं मिलान कर सकते हैं, \G1के बाद से \Gमैच की शुरुआत में ही मैच, तो बजाय हम मैच के लिए है 11\1जो अधिक से अधिक 2 है पिछला मैच। हम जितना हो सके उतने विषम संख्याओं से मेल खाते हैं, और कुल मैच इसलिए एक वर्ग संख्या है, जबकि अंतिम कैप्चर इसके पक्ष से दोगुना कम है।

$&11$1$1

प्रत्येक मैच में साइड शील्ड्स जोड़ें। $&है और है जब तक हम जरूरत । $n^2$ $1 $2n-1$ $n^2+4n=n^2+2+2(2n-1)$

योग करें और दशमलव में परिवर्तित करें।

— नील
स्रोत

2

05AB1E , 17 बाइट्स

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

इसे ऑनलाइन आज़माएं या सभी परीक्षण मामलों को सत्यापित करें ।

काम के आसपास ΔDtïÐns4*+Šn-}O( क्योंकि 15 बाइट्स ) काम करने के लिए नहीं लगता है .. इसे डिबग-मोड में ऑनलाइन देखें कि मैं क्या मतलब है। मुझे उम्मीद है कि इसके और अगले पुनरावृत्ति के बाद से जाने के [45,'35',25]लिए , लेकिन जाहिरा तौर पर यह पिछले मूल्य को छोड़कर स्टैक को साफ करता है और बन जाता है , जिसके परिणामस्वरूप 0 बहुत अंत में है। निश्चित नहीं कि यह अभिप्रेत व्यवहार है या बग .. (संपादित करें: यह इरादा है, नीचे देखें।)[45,10]-Δ[10]

स्पष्टीकरण:

इसके अलावा का उपयोग करता है जहां सबसे अधिक अन्य उत्तरों की तरह लूप में चौड़ाई है। $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

संपादित करें: जाहिरा तौर पर मैं ऊपर वर्णित व्यवहार Δका इरादा है। यहाँ दो 17-बाइट द्वारा प्रदान की विकल्पों @ Mr.Xcoder कि उपयोग करना Δ(साथ global_array में मान रख कर ^) और उन्हें बाद में फिर से पुन: प्राप्त करने (साथ ¯):

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

इसे ऑनलाइन आज़माएं या सभी परीक्षण मामलों को सत्यापित करें ।

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

इसे ऑनलाइन आज़माएं या सभी परीक्षण मामलों को सत्यापित करें ।

— केविन क्रूज़सेन
स्रोत

2

डीसी , 25 बाइट्स

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

इसे ऑनलाइन आज़माएं!

पैदावार के रूप में ढालों sum(n^2)(मूल संख्या) के रूप में गणना करता 4*sum(n)है, प्रत्येक वर्ग की लंबाई की एक प्रति को स्टैक रजिस्टर में धकेलता है aजैसा कि यह जाता है, फिर रजिस्टर से सभी मानों aको पुनरावृत्ति के रूप में जोड़ते हुए "अनरोल" करते हैं।

— सोफिया लेचनर
स्रोत

2

भूसी , 17 बाइट्स

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

इसे ऑनलाइन आज़माएं!

विकल्प

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

इसे ऑनलाइन आज़माएं!

— श्री एक्सकोडर
स्रोत

2

एपीएल (डायलॉग यूनिकोड) , 31 30 बाइट्स

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

इसे ऑनलाइन आज़माएं!

-1 बाइट @jslip को धन्यवाद

— जाकारी
स्रोत

0.5 -> .5 के लिए 1 बाइट

— jslip

वाह, मैं कैसे याद किया कि

— Zacharý

1

रूबी , 45 बाइट्स

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

इसे ऑनलाइन आज़माएं!

— जीबी
स्रोत

1

PHP , 67 बाइट्स

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

इसे चलाने के लिए:

php -n <filename> <n>

उदाहरण:

php -n roman_army_shields.php 35

या इसे ऑनलाइन आज़माएं!

-Rविकल्प का उपयोग करते हुए , यह संस्करण 60 बाइट्स है :

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

उदाहरण:

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

(लिनक्स पर, की जगह "के साथ ')

नोट: यह अरनॉल्ड के उत्तर महान सूत्र का उपयोग कर रहा है, मुझे इससे छोटा कुछ भी नहीं मिल रहा था।

— Night2
स्रोत

1

पायथ , 19 बाइट्स

एक पुनरावर्ती कार्य, जिसे उपयोग किया जाना चाहिए y(लिंक देखें)।

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

यहाँ कोशिश करो!

पायथ , 21 बाइट्स

संशोधन इतिहास काफी मज़ेदार है, लेकिन यदि आप बहुत तेज़ संस्करण चाहते हैं, तो इसे ज़रूर देखें :)

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

यहाँ कोशिश करो!

व्याख्या

sm*d+4deeDsI#I#@RL2./ पूरा कार्यक्रम, चलिए इनपुट Q पर कॉल करते हैं।
                   ./ Q का पूर्णांक विभाजन। सकारात्मक के सभी संयोजनों को जन्म देता है
                          पूर्णांक जो Q में जुड़ते हैं।
               @ RL2 प्रत्येक विभाजन के सभी पूर्णांकों का वर्गमूल लीजिए।
             मैं # केवल उन्हीं विभाजनों को रखता हूँ जो निम्न हैं:
          sI # सभी गैर-पूर्णांक को छोड़ना। यह मूल रूप से केवल रखता है
                          विभाजन जो पूर्ण वर्गों के पूर्ण रूप से बनते हैं, लेकिन
                          स्वयं वर्ग होने के बजाय, हमारी जड़ें हैं।
       eeD उच्चतम अधिकतम के साथ विभाजन (पी कहो) प्राप्त करें।
 पी में प्रत्येक घ के लिए मीटर ...
  * d + 4d ... यील्ड d * (d + 4) = d ^ 2 + 4d, सभी उत्तरों में प्रयुक्त सूत्र।
s इस मैपिंग के परिणाम और निहित आउटपुट।

— श्री एक्सकोडर
स्रोत

1

स्विफ्ट 4 , 111 99 84 78 बाइट्स

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}

इसे ऑनलाइन आज़माएं!

यह महसूस करते हैं कि पूर्णांक वर्गमूल को मैन्युअल रूप से लागू करते समय बिल्ट-इन की तुलना में बहुत कम होता है ...

अनगढ़ और समझाया हुआ

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

— श्री एक्सकोडर
स्रोत

रोमन सेना ढाल

पायथन 2 , 60 50 48 बाइट्स

आर , 51 50 बाइट्स

जावास्क्रिप्ट (ईएस 7), 34 बाइट्स

कैसे?

जेली , 13 बाइट्स

जूलिया 0.6 , 36 बाइट्स

Ungolfed:

स्टैक्स , 15 बाइट्स

ब्रेकीलॉग , 26 बाइट्स

रेटिना 0.8.2 , 28 बाइट्स

05AB1E , 17 बाइट्स

डीसी , 25 बाइट्स

भूसी , 17 बाइट्स

विकल्प

एपीएल (डायलॉग यूनिकोड) , 31 30 बाइट्स

रूबी , 45 बाइट्स

PHP , 67 बाइट्स

पायथ , 19 बाइट्स

पायथ , 21 बाइट्स

व्याख्या

स्विफ्ट 4 , 111 99 84 78 बाइट्स

अनगढ़ और समझाया हुआ