कितने वज़ीर को N × N चेसबोर्ड पर रखा जा सकता है?

30

मान लीजिए कि वजीर नाम का एक नया परी शतरंज का टुकड़ा शतरंज के लिए पेश किया गया है। वज़ीर एक स्थिति ( x , y ) से:
 ( x +1, y )
 ( x , y +1)
 ( x -1, y )
 ( x , y -1) तक जा सकते हैं

यही है, वे रूढ़ि की तरह orthogonally चलते हैं, लेकिन राजा की तरह एक समय में केवल एक कदम। कितने ऐसे वज़ीर को N × N की बिसात पर रखा जा सकता है ताकि कोई भी दो वज़ीर एक दूसरे पर हमला न कर सकें?

 1 × 1 बोर्ड पर, केवल 1 ऐसा टुकड़ा हो सकता है।
 2 × 2 बोर्ड पर, ऐसे 2 टुकड़े हो सकते हैं।
 3 × 3 बोर्ड पर, ऐसे 5 टुकड़े हो सकते हैं।

N को देखते हुए, ऐसे वज़ीर की संख्या लौटाएं जिन्हें N × N शतरंज की बिसात पर रखा जा सकता है।

यह OEIS अनुक्रम A000982 है ।

अधिक परीक्षण के मामले

7 → 25

8 → 32

100 → 5000

code-golf  number  chess 
— साशा आर
स्रोत
4
तो ऊंट को रूक के राजा को रानी के लिए क्या करना है? Ie केवल मौखिक रूप से स्थानांतरित कर सकता है, और एक समय में केवल एक कदम।
— अडम
2
@ साशा मैं एक उचित कोड गोल्फ चुनौती के रूप में आपके प्रश्न को फिर से लिख सकता हूं?
— Adám
2
ज़रूर! इस तरह मैं यह भी देख सकता हूँ कि भविष्य में कोडिंग से संबंधित प्रश्न कैसे करें
— साशा आर
15
इस साइट के नए उपयोगकर्ता के रूप में, आप इस समय बहुत भाग्यशाली रहे हैं। इस साइट पर बहुत सारे (ऑफ-टॉपिक) प्रोग्रामिंग प्रश्नों को स्थायी रूप से बंद और डाउनवोट किया गया है, इसे एक चुनौती के रूप में संपादित नहीं किया गया है और इस तरह उत्थान किया गया है। जैसा कि अन्य लोगों ने पहले ही समझाया था, यह साइट केवल प्रोग्रामिंग प्रतियोगिताओं के लिए है, होमवर्क पूछने के लिए नहीं। अगली बार आम गलतियों से बचने के लिए एक चुनौती पोस्ट करने से पहले आप सैंडबॉक्स ( कोडगुल्फ.मेटा.स्टैकएक्सचेंज . com / questions / 2140 / … पर ) का उपयोग कर सकते हैं ; और ध्यान दें कि इस साइट पर अधिकांश उपयोगकर्ता, जैसा कि आपने देखा है, "अपठनीय" भाषाओं का उपयोग करें।
— user202729
16
यह सवाल बहुत भ्रामक है कि कैमल पहले से ही एक नाइट की तरह एक टुकड़ा के लिए मानक परी शतरंज का नाम है जो लंबे समय तक कूदता है और जिस टुकड़े का आप पहले से वर्णन करते हैं उसका एक परी शतरंज नाम है: वज़ीर ।
— मार्क एस।

जवाबों:

33

व्हॉट्सएप , 45 बाइट्स

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

वैसे, यहाँ एक प्रमाण है कि ²n⌉ / 2 is सूत्र सही है।

  • हम हमेशा कम से कम alwaysn² / 2az वज़ीर रख सकते हैं : बस उन्हें एक बिसात के पैटर्न में रखें! ऊपर-बाएँ टाइल को सफेद मानकर, n × n बोर्ड पर ²n⌉ / 2 tiles सफेद टाइलें और ²n² / 2 n काली टाइलें हैं। और अगर हम सफेद टाइलों पर वज़ीर रखते हैं, तो उनमें से कोई भी एक दूसरे पर हमला नहीं कर सकता है, जैसा कि हर वज़ीर केवल "काली टाइल" देखता है।

    यहां बताया गया है कि हम 5 × 5 बोर्ड पर 13 वज़ीर रखते हैं (प्रत्येक डब्ल्यू एक वज़ीर है)।

    　　　　　　　　　　5 × 5 बोर्ड पर 13 वज़ीर

  • हम कोई बेहतर नहीं कर सकते हैं : चलो मनमाने ढंग से 2 × 1 डोमिनोज़ टुकड़ों के साथ चेकबोर्ड को टाइल करें, वैकल्पिक रूप से एक विषम लंबाई के शतरंज के अंतिम कोने के लिए 1 × 1 टुकड़ा का उपयोग करके, जैसे:

    　　　　　　　　　　5 × 5 बोर्ड का डोमिनोज़ कवर

    शतरंज की बिसात को ढकने के लिए हमें covern need / 2⌉ डोमिनोज की जरूरत होती है। स्पष्ट रूप से, एक डोमिनो पर दो वज़ीर लगाने से ऐसा होता है कि वे एक दूसरे पर हमला कर सकते हैं! इसलिए प्रत्येक डोमिनो में केवल एक वज़ीर हो सकता है, जिसका अर्थ है कि हम संभवतः बोर्ड पर ²n² / 2 on से अधिक वज़ीर नहीं रख सकते हैं।

— लिन
स्रोत
आपको अंतिम भाग के लिए कबूतर के सिद्धांत की आवश्यकता नहीं है: आपके पास वास्तव में ²n⌉ / 2e टाइलें हैं, और प्रति टाइल ऊंट पर, इसलिए आपके पास अधिकांश ⌈n² / 2⌉ ऊंट हैं।
— श्रीवत्सआर
8
@ श्रीवत्सआर यह सुनिश्चित करता है कि आप ⌈n⌉ / 2⌈ टाइल्स में x> atsn⌉ / 2⌉ ऊंट नहीं डाल सकते? यह कबूतर का सिद्धांत है ...
— frarugi87
2
मैंने सोचा था कि पहली बार कोड लोड नहीं हुआ था, इसलिए मैंने पृष्ठ को रीफ्रेश किया, और यह अभी भी नहीं हुआ। तब मुझे महसूस हुआ कि किस भाषा का नाम सबसे ऊपर लिखा गया था।
— आर्थर
7
मैं सराहना करता हूं कि आपने अपने प्रमाण चित्रण में अपने 's' Cको बदल दिया W।
— ग्यूसेप
4
मैं यह भी सराहना करता हूं कि WHITESPACE में एक उत्तर के साथ डब्ल्यू सभी व्हाइट स्पेस पर हैं।
— corsiKa
10

प्रोलोग (एसडब्ल्यूआई) , 22 19 बाइट्स

केविन क्रूज़सेन के लिए धन्यवाद 3 बाइट्स बचाए

X*Y:-Y is(X*X+1)/2.

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

— Emigna
स्रोत
— केविन क्रूज़सेन
2
@ केविनक्रूजसेन: दोह! मैंने उसी परिवर्तन को किसी अन्य उपयोगकर्ता को सुझाया, लेकिन किसी तरह मैंने अपनी सलाह नहीं ली। धन्यवाद :)
— एमिग्ना
9

एपीएल (Dyalog) , 9 7 6 बाइट्स

अब उपयोग करता है श्री Xcoder के सूत्र का है।

यह एक अनाम उपसर्ग tacit फ़ंक्शन है जो N को तर्क के रूप में लेता है।

⌈2÷⍨×⍨

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

×⍨ वर्गाकार N (लिट। गुणा सेल्फी, अर्थात स्व द्वारा गुणा)

2÷⍨ 2 से विभाजित करें

⌈ छत (राउंड अप)

— एडम
स्रोत
! वाह मुझे पता नहीं कैसे आप ऐसा किया है !! तर्क समझ में नहीं आया, हालांकि आह
— साशा आर
डार, किसी को पहले से ही पैटर्न का पता चला।
— Feathercrown
1
हुह, बस एहसास हुआ कि सूत्र OEIS पृष्ठ पर है। शायद इससे जुड़ा नहीं होना चाहिए।
— Feathercrown
7

जेएस (ईएस 6) / सी # पॉलीग्लॉट, 11 बाइट्स

n=>n*n+1>>1

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

कोड स्निपेट दिखाएं

— Arnauld
स्रोत
3
— Shaggy
@ शागिर्द को धन्यवाद देने के लिए धन्यवाद!
— अरनौलद
1
जेएस और सी # बहुवचन उनके बीच मतभेदों को देखते हुए, अत्यंत दुर्लभ प्रतीत होता है। +1
— caird कॉइनहेरिंगहिंग
5

सी (जीसीसी) , 23 18 17 बाइट्स

  • ताग को धन्यवाद दिया , बाइट को बचाया ; गोल्फ n/2+n%2के लिए n+1>>1।
f(n){n=n*n+1>>1;}

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

सी (जीसीसी) , 22 बाइट्स (अपरिभाषित व्यवहार का उपयोग नहीं)

f(n){return n*n+1>>1;}

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

कुछ लोग वास्तव में विशिष्ट संकलक झंडे का उपयोग करते समय एक निश्चित संकलक के अपरिभाषित व्यवहार का शोषण करना पसंद नहीं करते हैं। ऐसा करने से बाइट्स बचते हैं, हालांकि।

— जोनाथन फ्रेच
स्रोत
3
एक उत्तर IMO प्रदान करने का अजीब तरीका है, लेकिन एक बाइट को बचाने के लिए f (n) {n = n * n + 1 >> 1;}।
— तहजीब
1
@ ताग धन्यवाद; यद्यपि आप किस तरीके से उत्तर देने का मेरा तरीका विषम पाते हैं?
— जोनाथन फ्रेच
2
मुझे नहीं लगा कि इनपुट तर्क बदलना सी। में एक मान लौटाने का एक सामान्य तरीका था
— ताह
2
@YSC फिर भी संकलक की राय में यह समझ में आता है और एक निष्पादन योग्य बनाता है जो काम करता है।
— जोनाथन फ्रेच
5
@YSC हम यहाँ PPCG पर विश्वास करते हैं कि, यदि प्रोग्राम एक दुभाषिया पर काम करता है, तो यह एक मान्य सबमिशन है। यह एक ऑनलाइन दुभाषिया पर काम करता है, इसलिए यह बिना किसी और टिप्पणी के मान्य है।
— कॉनर ओ'ब्रायन
4

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

lambda x:-(-x*x//2)

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

lambda x:-(-x*x//2)  # Unnamed function
lambda x:            # Given input x:
            x*x      # Square
           -         # Negate
               //2   # Halve and Floor (equivalent of Ceil)
         -(       )  # Negate again (floor -> ceil)

-1 बाइट मिस्टर एक्सकोडर की बदौलत

— HyperNeutrino
स्रोत
x**2->x*x
— श्री Xcoder 13
@ Mr.Xcoder फेसपालम धन्यवाद
— हाइपरनेट्रिनो 13
किस बारे में lambda x:x*x+1>>1?
— एलिक्स ईसेनहार्ट
या lambda x:x*x+1//2 अस्वीकरण: मैं इस भाषा के वाक्यविन्यास या संचालन के आदेश को नहीं जानता, इसलिए मैंने अनुमान लगाया; मैं कह रहा हूं कि //2 दो बार नकारने के बजाय
— डैन हेंडरसन
@DanHenderson आपको अभी भी कोष्ठक की आवश्यकता है अन्यथा इसे पार्स किया जाता है (x*x) + (1//2), ताकि वास्तव में छोटा न हो।
— स्काइलर
4

x86_64 मशीन भाषा (लिनक्स), 9 8 बाइट्स

0:       97                      xchg   %eax,%edi
1:       f7 e8                   imul   %eax
3:       ff c0                   inc    %eax
5:       d1 f8                   sar    %eax
7:       c3                      retq

इसे ऑनलाइन करने का प्रयास करें! , संकलन और निम्नलिखित सी कार्यक्रम चलाएं।

#include<stdio.h>
const char *f="\x97\xf7\xe8\xff\xc0\xd1\xf8\xc3";
int main() {
  for(int i=1; i<10; i++) {
    printf("%d\n", ((int(*)())f)(i));
  }
}
— ceilingcat
स्रोत
3

जे , 8 बाइट्स

बेनामी tacit उपसर्ग समारोह।

2>.@%~*:

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

*: वर्ग

>. सीलिंग (राउंड अप) के
@ बाद
2... %~ दो से विभाजित

— एडम
स्रोत
वैकल्पिक समाधान: <.@-:@*:और*:<.@%2:
— कॉनर ओ'ब्रायन
2
@ ConorO'Brien 2>.@%~*:did मुझे वह कहां से मिला? मैं यह नहीं पढ़ सकता कि - मेरे लिए लाइन का शोर जैसा दिखता है ...
— अड्म
>.@-:@*: मेरा वोट मिलता है।
— योना
1
@ जोना अगर आप स्क्विंट करते हैं, तो आप ऊंट देख सकते हैं।
— Adám
3

आर , 22 21 बाइट्स

cat((scan()^2+1)%/%2)

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

वर्ग, वृद्धि, पूर्णांक विभाजित करते हैं। बहुत आसान।

स्टड से इनपुट; यह अंतरिक्ष या न्यूलाइन अलग इनपुट ले सकता है और यह प्रत्येक इनपुट बोर्ड के लिए अधिकतम वज़ीर की गणना करेगा। स्टडआउट के लिए आउटपुट।

-1 बाइट प्लैनैपस के लिए धन्यवाद

— ग्यूसेप
स्रोत
@plannapus तय, धन्यवाद।
— ग्यूसेप
2

सी # (.NET कोर) , 14 12 बाइट्स

-2 बाइट्स एमिग्ना के लिए धन्यवाद 

n=>(n*n+1)/2

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

— मेरा सर्वनाम monicareinstate है
स्रोत
— एमिग्ना
2
— केविन क्रूज़सेन
मैंने ऐसा करने के लिए जावास्क्रिप्ट उत्तर पर ध्यान दिया है, और यह परिवर्तन हमारे उत्तरों को बाइट के बराबर करेगा।
— मेरा सर्वनाम monicareinstate
2

क्यूबिक्स , 11 बाइट्स

Iu*:^\)2,O@

heheh, :^\)

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

निम्नलिखित घन के विस्तार:

    I u
    * :
^ \ ) 2 , O @ .
. . . . . . . .
    . .
    . .

जो एक ही एल्गोरिदम है जिसका कई उपयोग करते हैं।

  • ^Iu : इनपुट में इंट के रूप में पढ़ें और दिशाएं बदलें
  • :* : ढेर के शीर्ष, गुणा
  • \) : परिवर्तन दिशा, वेतन वृद्धि
  • 2, : पुश 2, पूर्णांक विभाजित
  • O@ : प्रिंट आउटपुट को इंट, एंड प्रोग्राम के रूप में।
— ग्यूसेप
स्रोत
1

जाप , 4 बाइट्स

चुनौती बंद होने के बाद से इन पर बैठे थे।

²Ä z

कोशिश करो

स्पष्टीकरण: वर्ग, 1 जोड़ें, 2 से फर्श विभाजित करें

विकल्प

²ÄÁ1

कोशिश करो

स्पष्टीकरण: स्क्वायर, 1 जोड़ें, 1 से बिट-शिफ्ट सही।

— झबरा
स्रोत
1

कमेंटेटर , 19 बाइट्स

//{-//-}! {-#  -}<!

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

कौन गोल्फ भाषाओं की जरूरत है? मुझे भ्रामक भाषाएँ मिली हैं!

Ungolfed संस्करण:

5//{-8}//{5-}
print(10!= 5)
x={-1,3,4} # Smiley :-}
print(5<!=10)*/ # Weird comparision.

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

यह कैसे काम करता है? मैं समझाता हूँ, इनपुट 5 के साथ

//                         - Take input.                           Tape: [5 0 0]
  {-//-}!                  - Square the input.                     Tape: [25 0 0]
  {-                         - Move one along the tape
    //                       - Copy the input to the tape.         Tape: [5 5 0]
      -}                     - Move one back along the tape
        !                    - Take the product of the tape.       Tape: [25 5 0]
         <space>           - Increment the tape head.              Tape: [26 5 0]
                 {-#  -}<! - Halve the tape head (floor division). Tape: [13 2 0]
                 {-          - Move one along the tape
                   #         - Set the tape head to 2.             Tape: [26 2 0]
                      -}     - Move one back along the tape
                        <!   - Reduce the tape by floor division.  Tape: [13 2 0]
— केर्ड सिक्काहिरिंग
स्रोत
1

OCaml , 19 बाइट्स

let f n=(n*n+1)/2;;

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

इससे पहले कि मैं यह लिखने में कामयाब रहा, मैं थोड़ा ऊब गया हूं नाम "ऊंट" से "वज़ीर" में बदल गया है, लेकिन मुझे लगा कि मैं इसे फिर भी पोस्ट करूँगा।

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

टीआई-बेसिक, 7 बाइट्स

round(Ans²/2,0

वैकल्पिक रूप से (8 बाइट्स):

int(Ans²/2+.5
— Timtech
स्रोत
-int(-.5Ans²यह भी काम करता है
— ओकी
@ ओकी यह सुनिश्चित करता है। काश उनके पास कोई ceil(फंक्शन होता।
— टाइमटेक
1

/// , 35 बाइट्स

/I///,*/+,//+/I//**,/,A//*/A//,//,I

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

यूनरी में इनपुट का उपयोग करता है प्रतीक का उपयोग करता है *, और आउटपुट में यूनिक का उपयोग करता है A। यह कुछ विशिष्ट भाषाओं के लिए अनुमत है, जिनमें /// ( मेटा ) शामिल है

क्योंकि /// में इनपुट लेने का कोई तरीका नहीं है, इनपुट हार्डकोड होना चाहिए:

/I/«put input here»//,*/+,//+/I//**,/,A//*/A//,//,I

इनपुट के लिए = 4।

स्पष्टीकरण: (पढ़ने से पहले, आप को पता है कि केवल वाक्य रचना की जरूरत है ///कर रहे हैं /pattern/replacement/, जिनमें से हर घटना की जगह patternसे replacement, और \से बचने के लिए, अन्य पात्रों के उत्पादन के लिए मुद्रित किया जाता है)

के लिए n=4:

/I/****//,*/+,//+/I//**,/,A//*/A//,//,I    Start program.
/I/****/                                   Replace all `I` in the program by the input.

/,*/+,//+/****//**,/,A//*/A//,//,****      Remaining part of the program.
/,*/+,/                                    Use the `,` as a scanner, scan through `*` after it and convert to `+`.
       /+/****//**,/,A//*/A//,//++++,      Note that only `*` in the second group is affected.
       /+/****/                            Replace all `+` (which is just created) by `n` asterisks (from the first `I` group)

/**,/,A//*/A//,//****************,         Now at the last of the program before the `,` there are `n²` asterisks.
/**,/,A/                                   Scan the `,` to the left to perform division by 2:
                                           replace each `**` by a `A` as the scanner `,` pass through.
/*/A//,//,AAAAAAAA                         Remaining program.
/*/A/                                      If there is any `*` remaining (if `n²` is odd), replace it with `A`.
     /,//                                  Remove the scanner `,`.
          AAAAAAAA                         Output the result.
— user202729
स्रोत
हमारी साइट का प्रयोग करके, आप स्वीकार करते हैं कि आपने हमारी Cookie Policy और निजता नीति को पढ़ और समझा लिया है।
Licensed under cc by-sa 3.0 with attribution required.