चेकर्स बोर्ड पर टुकड़ों की संख्या

Question

परिचय

एक सामान्य चेकर्स बोर्ड में 8 x 8 = 64 वर्ग होते हैं:

आप देख सकते हैं कि कुल मिलाकर, 12 सफेद टुकड़े हैं । काले और सफेद में हमेशा समान मात्रा में टुकड़े होते हैं। यदि बोर्ड पर कोई और टुकड़े हैं, तो टुकड़े पड़ोसी होंगे, जिन्हें इस चुनौती के लिए अनुमति नहीं है। चीजों को स्पष्ट करने के लिए, यहां कुछ उदाहरण दिए गए हैं:

इस चुनौती के लिए संभव सबसे छोटा बोर्ड 3 x 3 है :

आप देख सकते हैं कि टुकड़ों की अधिकतम मात्रा 2 के बराबर है । इसलिए, जब N = 3 दिया जाता है, तो आपको 2 आउटपुट की आवश्यकता होती है । यदि इनपुट N = 4 है , तो हमें निम्नलिखित मिलेंगे:

आप देख सकते हैं कि अधिकतम राशि भी 2 है। इसलिए एन = 4 के लिए , आउटपुट 2 होना चाहिए । के लिए एन = 5 , उत्पादन के बराबर होना चाहिए 5 :

उदाहरण

STDIN:  3
STDOUT: 2

STDIN:  4
STDOUT: 2

STDIN:  5
STDOUT: 5

STDIN:  6
STDOUT: 6

STDIN:  8
STDOUT: 12

नियम

• आपका सबमिशन एक प्रोग्राम, या फंक्शन आदि होना चाहिए जो एक पूर्णांक और आउटपुट लेता है या बोर्ड पर टुकड़ों की संख्या लौटाता है
• आप सुरक्षित रूप से मान सकते हैं कि इनपुट एक गैर-नकारात्मक पूर्णांक> 2 है
• यह कोड-गोल्फ है , इसलिए कम से कम बाइट्स जीत के साथ कार्यक्रम!
• ध्यान दें कि बोर्ड के निचले बाएँ में वर्ग हमेशा अंधेरा होता है। टुकड़े केवल अंधेरे वर्गों पर रखे जाते हैं
• आपको टुकड़ों के साथ एक पूरी पंक्ति पर कब्जा करना होगा

Comments

पूर्ण कार्यक्रमों और STDIN / STDOUT पर प्रतिबंध क्यों? IMO जो उन भाषाओं के लिए अनुचित है जिनके पास आवश्यक प्रोग्राम और / या इनपुट ओवरहेड है।

— lirtosiast

@ThomasKwa, आप सही कह रहे हैं। कार्यों आदि की अनुमति है

— अदनान

Answer 1

बराबर , 8 बाइट्स

✶″½↓┐*½┐

प्रति चरित्र एक बाइट का उपयोग किया जाता है।

व्याख्या

               ## [implicit: read line]      Example
✶              ## Convert to number           7
″              ## Duplicate                   7 7
½              ## Divide by two               7 3.5    half the board
↓              ## Minus one                   7 2.5    leave one row empty
┐              ## Ceiling                     7 3      a whole number of rows
*              ## Multiply                    21       total number of spaces
½              ## Divide by two               10.5     only the blue squares
┐              ## Ceiling                     11       starts with blue, so round up

Answer 2

हेक्सागोनी , 19 बाइट्स

?({{&2'2':{):!/)'*/

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

व्याख्या

यह अभी भी वैसी ही संगणना है जैसा मैंने अपने सीजाम और भूलभुलैया के उत्तर में इस्तेमाल किया है, लेकिन हेक्सागोनी के ... विशेष ... स्मृति मॉडल के कारण, यह 19 बाइट्स में कम्प्यूटेशन को निचोड़ने के लिए थोड़ा पेचीदा है (ताकि यह अंदर से फिट हो जाए पक्ष-लंबाई 3 षट्भुज)।

मेरे भूलभुलैया उत्तर की तरह, यह विभाजन-दर-० त्रुटि के साथ समाप्त होता है।

यहाँ प्रकट कोड है:

जैसा कि मैंने कहा कि कोड पूरी तरह से रैखिक है। आप ग्रे-बैंगनी-हरे-लाल-नीले रंग के क्रम में निष्पादित पथ को एक साथ कर सकते हैं। पथ वास्तव में थोड़ा आगे तक जारी रहता है जब तक कि यह :बाईं ओर हिट नहीं हो जाता । /(जो केवल पुनर्निर्देशन नियंत्रण प्रवाह) को हटा रहा है , पूरा कार्यक्रम रैखिक रूप से नियंत्रित है:

?({2':{)'*){&2':!:&?':

तो सवाल यह है कि यह कैसे काम करता है। हेक्सागोनी की मेमोरी एक हेक्स ग्रिड का लाइन ग्राफ है, जहां ग्रिड के प्रत्येक किनारे में एक पूर्णांक मान (शुरू में शून्य) होता है। मेमोरी पॉइंटर (MP) हमेशा एक किनारे पर होता है और उस किनारे पर एक निश्चित दिशा में इंगित करता है। अंकगणित संचालन आम तौर पर इंगित किए गए दो किनारों पर लागू होते हैं और किनारे पर संग्रहीत होते हैं, जो सांसद पर होता है।

इस कार्यक्रम के लिए, हम ए , बी , सी लेबल वाले तीन किनारों का उपयोग कर रहे हैं , सांसद को यहां दिखाए गए अनुसार शुरू किया जाएगा:

तो यहाँ है कि यह कैसे काम करता है:

?  Read an integer N from STDIN into edge A.
(  Decrement to get N-1.
{  Move the MP forwards onto edge B.
2  Set the edge to 2.
'  Move the MP backwards onto edge C.
:  Divide edge A by edge B (rounding down) to compute (N-1)/2.
{  Move the MP forwards onto edge A.
)  Increment to restore value of N.
'  Move the MP backwards onto edge B.
*  Multiply edges A and C to compute N*(N-1)/2.
)  Increment to compute N*(N-1)/2 + 1.
{  Move the MP forwards onto edge C.
&  This actually a copy operation, but we use it to reset the edge to zero.
2  Set the edge to 2.
'  Move the MP backwards onto edge A.
:  Divide edge B by edge C to compute (N*(N-1)/2 + 1)/2.
!  Output the result as an integer. We're basically done now.
:  no-op (we already have this value)
&  Copy either B or C into A (doesn't matter).
?  Read a zero (EOF) into A.
'  Move the MP backwards onto an unused cell.
:  Divide some unused cell by A (which is zero), terminating with an error.

Comments

{{दो बार मेमोरी एज चलती है तो दूसरी पंक्ति में & # दोनों निगारबों में 0 होना चाहिए

— यूमेल

@Eumel वह क्रम नहीं है जिसमें कोड निष्पादित किया गया है। पहले के बाद {, आईपी 2बाएं कोने में कूदता है । बाद )दाएं कोने में, आईपी के लिए कूदता 'नीचे बाएँ कोने में। फिर आईपी एक अजीब तरह से लपेटने के तरीके में 2 और 4 को पीछे ले जाता है।

— मार्टिन एंडर

ओह, मैंने सोचा कि यह केवल मुझे बदल दिया आईपी नहीं। यह भी कि हेक्सागोनी का उपयोग करने के लिए केवल भाषा ही बहुत मज़ेदार है

— Eumel

@Eumel यह करता है। बस हेक्सागोनी में कोड के किनारों को कैसे लपेटना है।

— मार्टिन एंडर

Answer 3

लैबव्यू, 28 20 लैब व्यू आदिम

Answer 4

सीजेएम, 10 बाइट्स

ri_(2/*)2/

इसका परीक्षण यहां करें।

व्याख्या

ri   e# Read input and convert to integer N.
_    e# Duplicate N.
(2/  e# Decrement, integer divide by two, to determine the number of rows that can be used.
*    e# Multiply by the input to determine the number of cells that can be used.
)2/  e# Increment, integer divide by two, which essentially ceil()s the result of the
     e# division.

Answer 5

भूलभुलैया , 11 बाइट्स

वोहू, सीजेएम से केवल एक बाइट पीछे ।

?:(#/*)_2/!

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

यह अनिवार्य रूप से एक ही बात है:

? reads an integer value.
: duplicates the result.
( decrements it.
# pushes the stack depth which happens to be 2.
/ is integer division.
* is multiplication.
) increments the result.
_ pushes a 0.
2 turns it into a 2.
/ is once again integer division.
! prints the result as an integer.

हालाँकि, इस बिंदु पर कार्यक्रम अभी तक समाप्त नहीं हुआ है। इसके बजाय, निर्देश सूचक ने एक मृत अंत मारा है और चारों ओर मुड़ता है। लेकिन अब /गणना करने की कोशिश करता है 0/0जो एक त्रुटि के साथ समाप्त होता है ।

Answer 6

गंभीरता से , 8 बाइट्स

,;D½L*½K

गंभीरता से काम है ½(2 से विभाजित फ्लोट), और K(छत), इसलिए हमें विभाजन से पहले एक जोड़ने की आवश्यकता नहीं है।

स्पष्टीकरण के साथ यहाँ कोशिश करें ।

Answer 7

पायथन 2, 22 21 बाइट्स

lambda n:~-n/2*n+1>>1

मैं पहले दो मामलों में अलग हूं, विषम एन और यहां तक ​​कि एन।

विषम एन के साथ हम औसत एन / 2 टुकड़ों से युक्त (एन - 1) / 2 पंक्तियों को भर सकते हैं। चूंकि पहली पंक्ति में हमेशा अधिक टुकड़े होते हैं इसलिए हमें इस परिणाम को सीवन करना चाहिए। इसलिए जब N विषम है तो हमारे पास छत ((N-1) / 2 * N / 2) टुकड़े हैं।

एन के साथ भी हम एन / 2 - 1, या फर्श ((एन - 1) / 2) पंक्तियों को भर सकते हैं, प्रत्येक पंक्ति में एन / 2 टुकड़े होंगे।

हम इन दो भावों को छत (फर्श (N-1) / 2) * N / 2) से जोड़ सकते हैं। चूंकि छत (x / 2) = मंजिल ((x + 1) / 2) हम फर्श विभाजन का उपयोग कर सकते हैं ((N - 1) // 2 * N + 1) // 2:।

Answer 8

जावास्क्रिप्ट, 37 35 बाइट्स

alert(((n=prompt()/2)-.5|0)*n+.5|0)

व्याख्या

बाकी उत्तरों के समान तकनीक का उपयोग करता है। यह अ-भेदी एल्गोरिथम है:

var n = parseInt(prompt());
var result = Math.ceil(Math.floor((n - 1) / 2) * n / 2);
alert(result);

Answer 9

डीसी, १२

?d1-2/*1+2/p

परीक्षण उत्पादन:

$ for t in 3 4 5 6 8; do echo $t | dc -e?d1-2/*1+2/p; done
2
2
5
6
12
$ 

Answer 10

अजगर, 9 बाइट्स

/h*/tQ2Q2

मेरे अजगर 2 उत्तर के रूप में एक ही एल्गोरिदम।

Answer 11

जाप , 16 14 बाइट्स

U-1>>1 *U+1>>1

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

यह काम किस प्रकार करता है

बहुत साधारण:

         // Implicit: U = input number
U-1>>1   // Subtract 1 from U and integer divide by 2.
*U+1>>1  // Multiply the result by U, add 1, and integer divide by 2.
         // Implicit: output last expression

मैं चाहता हूं कि इस बात को ध्यान में रखा जाए कि कोड के दो हिस्से समान हैं। सुझावों का स्वागत है!

पुराना संस्करण (16 बाइट्स):

U*½-½|0 *U*½+½|0

Answer 12

जावा, २३० १५५ ५२

golfed:

int f(int s){return(int)Math.ceil(s*((s-1)/2)/2.0);}

Ungolfed:

public class NumberOfPiecesOnACheckersBoard {

  public static void main(String[] args) {
    // @formatter:off
    int[][] testData = new int[][] {
      {3, 2},
      {4, 2},
      {5, 5},
      {6, 6},
      {8, 12}
    };
    // @formatter:on

    for (int[] data : testData) {
      System.out.println("Input: " + data[0]);
      System.out.println("Expected: " + data[1]);
      System.out.print("Actual:   ");
      System.out.println(new NumberOfPiecesOnACheckersBoard().f(data[0]));
      System.out.println();
    }
  }

  // Begin golf
  int f(int s) {
    return (int) Math.ceil(s * ((s - 1) / 2) / 2.0);
  }
  // End golf

}

कार्यक्रम का उत्पादन:

Input: 3
Expected: 2
Actual:   2

Input: 4
Expected: 2
Actual:   2

Input: 5
Expected: 5
Actual:   5

Input: 6
Expected: 6
Actual:   6

Input: 8
Expected: 12
Actual:   12

Comments

throws Exceptionअनुमन्य है।

— नील

ओपी कार्यों की अनुमति दी।

— lirtosiast

आप Scannerइनपुट के लिए कक्षा का उपयोग कर सकते हैं । मुझे लगता है कि आपको बाइट्स का एक गुच्छा बच जाएगा। ( सामान्य उपयोग में BufferedReader/ InputStreamReaderकॉम्बो बेहतर हो सकता है, लेकिन यह कोड गोल्फ है, और Scannerसरल इनपुट के लिए ठीक काम करता है।)

— डारेल हॉफमैन

एक स्टैंड-अलोन फ़ंक्शन में परिवर्तित होने और मानक इनपुट / आउटपुट के बजाय पैरामीटर / रिटर्न मान का उपयोग करने से बहुत बड़ा अंतर आया।

Answer 13

Zilog ez80 मशीन कोड, 9 बाइट्स

हेक्स में:

6C 2D CB3D ED6C 2C CB3D

विधानसभा में:

ld l,h
dec l
srl l
mlt hl
inc l
srl l

इनपुट रजिस्टर में है h, और आउटपुट में है l।

Zilog ez80 एक 8-बिट प्रोसेसर है जिसमें 8 बिट संचायक और 24-बिट रजिस्टर हैं। Z80 के विपरीत, इसमें एक mlt(8-बिट गुणा) निर्देश है, जो 16-बिट मोड में, एक रजिस्टर जोड़ी के उच्च और निम्न बाइट्स को गुणा करता है, यहां hl, और वापस स्टोर करता है hl।

यह केवल उन मूल्यों के लिए काम करता है जिनके लिए दो बार परिणाम 8 बिट्स में फिट बैठता है; वह है, n≤23।

Answer 14

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

⁻int(⁻.5Ansint(Ans/2-.5

TI-BASIC के निहित गुणन में मदद मिलती है, लेकिन इसमें पूर्णांक विभाजन नहीं होता है। ⁻int(⁻Xछत (x) का एक छोटा रूप है।

Answer 15

vba, ४६

Function f(x)
f=(((x-1)\2)*x+1)\2
End Function

सूत्र में f (x), या = f (A1) के साथ कॉल करें

Answer 16

पायथ, 17 14 13 बाइट्स

-3 बाइट्स Ypnypn को धन्यवाद ! 1 बाइट को बचाने के लिए * ऑपरेटर की संख्याओं का पता लगाया।

/+*Q-/Q2-1%Q2 1 2 (original)
/h*Q-/Q2!%Q2 2
/h*-/Q2!%Q2Q2

स्पष्टीकरण:

जब n सम है, तो हम n / 2 टुकड़ों के साथ n / 2-1 पंक्तियों पर कब्जा कर सकते हैं, जिससे कुल n * (n / 2-1) / 2 टुकड़े हो सकते हैं। यह अभिव्यक्ति (n * (n / 2-1) +1) / 2 के बराबर है

जब n विषम होता है, तो हम पा सकते हैं कि टुकड़ों की संख्या दोगुनी कैसे दिखेगी, दो बार टुकड़ों की संख्या n-1 पंक्तियों की होगी, और यदि मैं एक टुकड़ा निकालता हूं, तो हम n-1 पंक्तियों को विभाजित कर सकते हैं (n- 1) / 2 समूहों की 2 पंक्तियाँ जैसे कि प्रत्येक समूह के n टुकड़े हैं, इसलिए इस मामले की अभिव्यक्ति है (n * (n / 2) +1) / 2

अब जबकि दोनों अभिव्यक्तियाँ काफी समान हैं, हम कोड लिख सकते हैं।

/h*-/Q2!%Q2Q2
        %Q2   Check if the number is odd
       !      Logical not to make 1 if even and 0 if odd
    /Q2       n/2
   -          n/2-1 if even, and n/2 if odd
  *        Q  n*(n/2-1) if even, n*(n/2) if odd
 h            Add one
/           2 Divide the result by two.

गोल्फ की भाषा का उपयोग करते हुए मेरा पहली बार।

Answer 17

जावास्क्रिप्ट, 33 बाइट्स

a=prompt();alert(a*(a-1>>1)+1>>1)

यदि ES6 फ़ंक्शन की अनुमति है तो 18 बाइट्स हैं:

a=>a*(a-1>>1)+1>>1

Answer 18

MATLAB, 37 25 बाइट्स

@(a)ceil(fix(a/2-.5)*a/2)

मेरा मानना ​​है कि यह सभी परीक्षण मामलों के लिए काम करना चाहिए।

यह ऑक्टेव पर भी काम करता है । आप यहाँ ऑनलाइन कोशिश कर सकते हैं ।

---

पुराने कोड के लिए मैंने प्रोग्राम को नाम की फाइल में उस कार्यक्षेत्र में जोड़ा checkerboard.m। आप इसे checkerboardप्रॉम्प्ट पर दर्ज करके चला सकते हैं , फिर जब यह शुरू होता है, तो प्रॉम्प्ट पर आवश्यक आकार दर्ज करें। परिणाम मुद्रित किया जाएगा।

नए कोड के लिए, बस यहां दिए गए कोड को प्रॉम्प्ट में दर्ज करें, फिर अनाम फ़ंक्शन को कॉल करें ans(n)।

Comments

वोट के लिए धन्यवाद, आखिरकार 1000 प्रतिनिधि पहुंच गए :) Woop।

— टॉम बढ़ई

@ThomasKwa कि बाहर इशारा करने के लिए धन्यवाद। बची 12 बाइट्स :)।

— टॉम कारपेंटर

Answer 19

रेटिना , 18 बाइट्स

11(..?$)?
$_
11?
1

इनपुट और आउटपुट एकात्मक है ।

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

रेटिना का नवीनतम संस्करण (इस चुनौती से नया) चार अतिरिक्त बाइट्स के लिए दशमलव I / O को संभाल सकता है:

.+
$*
11(..?$)?
$_
11?

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

यूरी इनपुट और दशमलव आउटपुट के साथ, हम 16 बाइट्स कर सकते हैं, लेकिन ऐसा लगता है कि थोड़ा खिंचाव:

11(..?$)?
$_
11?

व्याख्या

अभी भी किसी के साथ भी यही दृष्टिकोण है, लेकिन संख्या के एकात्मक प्रतिनिधित्व पर रेगेक्स प्रतिस्थापन का उपयोग करना।

11(..?$)?
$_

यह गणना करता है n*((n-1)/2)। हम इसे एक बार में दो वर्णों के मेल से करते हैं (दो से विभाजन) और उन्हें पूरी स्ट्रिंग (गुणा करके n) से बदल देते हैं। की घटती n, स्ट्रिंग के शेष लंघन द्वारा किया जाता है, तो केवल एक या दो वर्ण शेष हैं है।

11?
1

यह पूर्णांक विभाजन 2 है, गोल है। हम केवल दो वर्णों को एक से बदलते हैं (विभाजन को 2 से), लेकिन अंतिम मैच को केवल एक वर्ण (राउंड अप) से मिलकर बनाते हैं।

Comments

आपके 1000 वें उत्तर के लिए बधाई: p

— अदनान

Answer 20

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

यह थोड़ा फूला हुआ है, लेकिन मुझे यकीन नहीं है कि मैं इससे बहुत आगे निकल सकता हूं। परीक्षण के लिए एक लिंक।

n=int(input());print(((n-1)//2*n+1)//2)

Answer 21

प्रोलॉग, 39 38 बाइट्स

कोड:

p(N):-X is ((N-1)//2*N+1)//2,write(X).

स्पष्टीकरण:

Subtract 1 from input and integer divide by 2 to get number of rows available.
Multiply that number by input to get number of squares available. 
Add one and integer divide by 2 to round up, since at at least half the rows 
will have a checker at the first square.
Print.

उदाहरण:

p(8).
12

इसे यहाँ ऑनलाइन आज़माएँ

संपादित करें: छत 1/2 को + 1 // 2 से बदलकर 1 बाइट बचाया

Answer 22

कण्ठमाला, 17 बाइट्स

R I W I-1\2*I+1\2

सरल एल्गोरिथ्म स्पष्टीकरण के लिए Emigna के लिए धन्यवाद । यह मम्प्स की गणित की "कमी" का फायदा उठाता है कि संचालन को कड़ाई से बाएं से दाएं (PEMDAS) निष्पादित किया जाता है, इसलिए कोष्ठक की आवश्यकता नहीं होती है। :-)

आउटपुट एक अजीब सा दिखता है, हालाँकि, कैश के इनसेम्बल के रूप में (माइम्प्स पर्यावरण जिसकी मुझे एक्सेस है) इनपुट पर दबाए जाने पर भी स्वचालित रूप से आउटपुट रिटर्न नहीं देता है। यदि आप इसे प्रीटियर चाहते हैं, तो प्री / पोस्ट कैरिज रिटर्न के लिए 4 अक्षर जोड़ें:

R I W !,I-1\2*I+1\2,!

धन्यवाद!

Answer 23

बैश, 32 बाइट्स

read a;echo $((a*(a-1>>1)+1>>1))

Answer 24

पाइके, 8 बाइट्स, नॉनकमेटिंग

Dt2f*h2f

dup, दिसंबर, आधा, mult, इंक, आधा

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

Answer 25

बैच, 30 बाइट्स

@cmd/cset/a(%1*((%1-1)/2)+1)/2

38 बाइट्स यदि स्टड पर इनपुट आवश्यक है:

@set/pa=
@cmd/cset/a(a*((a-1)/2)+1)/2