ब्लॉक पुनर्व्यवस्था

14

इसलिए आपका काम एक 3x3 ब्लॉक लेना है, जहां -रिक्त स्थान का मतलब है, और *उदाहरण के लिए रिक्त स्थान भरे हुए हैं:

-**
-*-
*-*

और ब्लॉक को फिर से व्यवस्थित करें ताकि *इस तरह से एक एक्स बन जाए:

*-*
-*-
*-*

इनपुट: ऊपर की तरह 3x3 वर्ग, वे 3 रेखाएं हो सकती हैं, एक सरणी, या हालांकि आप चाहते हैं।

आउटपुट: एक्स में पुनर्व्यवस्थित करने के लिए सबसे कम चालें। प्रत्येक चाल 2 वर्णों को स्पर्श कर रही है, जो एक दूसरे से क्षैतिज हैं, एक दूसरे से लंबवत हैं, या एक दूसरे से तिरछे हैं। यदि यह संभव नहीं है, उदाहरण के लिए, 999या किसी भी असंभव आउटपुट को लौटाएं -4242। 5इस तरह की सबसे छोटी संख्या है।

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

1) आउटपुट: 1

-**
-*-
*-*

2) आउटपुट: -1

-*-
-*-
*-*

3) आउटपुट: 3

---
-**
***

4) आउटपुट: 0

*-*
-*-
*-*

आप रिक्त और गैर-रिक्त वर्णों को स्थानापन्न कर सकते हैं लेकिन यह सुनिश्चित करें कि जो आपके पोस्ट में है उसे शामिल करें

कोड गोल्फ

याद रखें कि यह कोड गोल्फ सबसे छोटा कोड जीत है!

code-golf  array-manipulation  permutations 
— नूह क्रिस्टीनो
स्रोत
1
2 वर्णों को फ़्लिप करके, क्या आपका मतलब अंतरिक्ष से फ्लिप करना *और इसके विपरीत, या उनका आदान-प्रदान करना है?
— user202729
यदि पाँच से अधिक हैं तो क्या होगा *? क्या आप कुछ और परीक्षण मामलों को जोड़ सकते हैं?
— स्टिव ग्रिफ़िन
अगर आप अंतिम 2 वर्णों को फ़्लिप करते हैं तो @ ab20202729 उदाहरण के लिए, acb होगा।
— नूह क्रिस्टीनो
@StewieGriffin "यदि यह संभव नहीं है तो एक" 5 से अधिक *या 5 से कम रिटर्न असंभव बना देता है।
— नूह क्रिस्टीनो
6
क्या हम इसके अलावा कुछ और उपयोग कर सकते हैं -1? उदाहरण के लिए 5(अन्यथा असंभव), या एक त्रुटि फेंकना?
— जोनाथन एलन

जवाबों:

12

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

lambda n:-(sum(n)!=5)or sum(n[1::2])+n[4]*(max(n,n[6:],n[::3],n[2::3])>=[1]*3)

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

संपादित करें: @Jonathan Allan's और @ xnor के सुझावों को काफी हद तक बाइट की संख्या को कम करने के लिए लागू किया गया।

इनपुट ज़ीरो और लोगों के साथ लंबाई 9 की एक स्ट्रिंग सूची है, जो *एस हैं।

यहाँ कुछ अवलोकन हैं:

  • हमें कभी भी तारों को पहले से ही सही कोशिकाओं पर स्थानांतरित करने की आवश्यकता नहीं है। किसी भी गलत स्टार के पास 5 आसपास की कोशिकाएं हैं जिन्हें एक बार में अवरुद्ध नहीं किया जा सकता है (अन्यथा जवाब पहले से ही -1 है)।
  • प्रत्येक गलत स्टार की लागत या तो 1 या 2 है, और यह 2 है केवल अगर यह तीन सही ढंग से रखे गए तारों से घिरा हुआ है।
  • प्रत्येक गलत स्टार की लागत एक दूसरे से स्वतंत्र है।

इसलिए, हम पहले परीक्षण करते हैं कि क्या स्ट्रिंग में पांच हैं, और फिर इन चीजों को गिनें:

  • गलत सितारों की संख्या (विषम सूचकांक में =)
  • लागत 2 की गलत सितारों की संख्या (= पर कोशिकाओं 0124, 0346, 2458, 4678सभी लोगों को किया जा रहा है)
    • फैक्टर n[4]एक होने के नाते, और फिर प्रत्येक रेंज निष्कर्षण होने का परीक्षण करें '111'।
    • चूंकि इस तरह का तारा सबसे अधिक है, इसलिए हम maxइसके बजाय सुरक्षित रूप से उपयोग कर सकते हैं sum।
— bubbler
स्रोत
एक स्ट्रिंग के बजाय एक सूची को स्वीकार करके 17 बाइट्स सहेजें ( countएस के साथ sumऔर एस के '111'साथ [1]*3) टीआईओ (मैं एक n[i::j]>=[1]*3लूप के साथ चतुर होने की कोशिश कर रहा हूं लेकिन कम नहीं मिला है)।
— जोनाथन एलन
चूंकि केवल एक कॉस्ट -2 स्टार हो सकता है, ऐसा लगता है कि आप कर सकते हैं max(n,n[6:],n[::3],n[2::3])>='1'*3।
— xnor
अन्य व्यवस्थाएं हैं जिनके लिए लागत -2 स्टार है। मुझे लगता है कि [0,1,1,1,1,0,1,0,0] को 2 के बजाय 3 वापस करना चाहिए
— रूटट्वो
इसके अलावा, [११,१,१,०,०,१,०,०] २ के बजाय ३ होना चाहिए
— २१-२१ के लिए रूटट्वो
इसके अलावा, [११,१,१,०,०,१,०,०] २ के बजाय ३ होना चाहिए
— २१-२१ के लिए रूटट्वो
4

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

5ḶḤd3ạŒ!Ṁ€€ḅ1Ṃ
T’d3Ç-L=5Ɗ?

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

इनपुट के रूप में एक फ्लैट सूची लें।

बहुत बुरा है कि जेली के पास "बहुआयामी सत्य सूचकांक" नहीं है ... T€ṭ€"JẎयह भी काम करता है लेकिन 1 और बाइट लेता है।

एल्गोरिथम: 5 वर्तमान ब्लॉक स्थिति और 5 लक्ष्य (गंतव्य) हैं, एल्गोरिथ्म 5 में से प्रत्येक की कोशिश करता है! मिलान, और स्रोत [गंतव्य,] Chebyshev दूरी की न्यूनतम राशि का उत्पादन।

— user202729
स्रोत
आप एक फ्लैट सूची ("हालांकि आप चाहते हैं") ले सकते हैं ... शायद आप 0-आधारित सूचकांक भी ले सकते हैं और 24 हो सकते हैं?
— जोनाथन एलन
4

हास्केल , 176 132 126 104 बाइट्स

w=0:1:w
m a|sum a/=5=5|1>0=sum$[a!!4|3<-sum.map(a!!)<$>[[0,1,2],[0,3,6],[2,5,8],[6,7,8]]]++zipWith(*)a w

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

गैर-रिक्त वर्ण के रूप में 1 के साथ पूर्णांकों की सूची लेता है। गैर-शून्य सम-अनुक्रमित वर्गों की संख्या का योग करता है, फिर 1 जोड़ता है यदि कोई डबल चाल पैटर्न पाया जाता है (केंद्र वर्ग और किनारे स्तंभ / पंक्ति पूरी तरह से भरा हुआ है)। अंतिम भाग थोड़ा बेकार है, मुझे लगता है कि शायद इस जानवर-बल पद्धति पर बहुत सुधार किया जा सकता है। एक असंभव इनपुट पर 5 (एक असंभव आउटपुट) देता है।

— aoemica
स्रोत
2
कुछ सुझाव: lengthपरीक्षण को छोटा किया जा सकता है sum[1|1<-a]। फंक्शन s: (1-e,n+sum[1|b>e])जिसे आप किसी अन्य बाइट को बचाने के लिए इनलाइन कर सकते हैं। आप उपयोग कर सकते हैं otherwiseगार्ड में mकी जोड़ी को बचाने ()। अंत में, &&एक गार्ड में शीर्ष स्तर पर प्रतिस्थापित किया जा सकता है ,। ...
— नमि
2
आप sumबूलियन को इंट करने के लिए सूची बोध पर एक अन्य बाइट का उपयोग करके बचा सकते हैं । इसे ऑनलाइन आज़माएं!
— पोस्ट रॉक गार्फ हंटर
2
वास्तव में आप काफी कुछ बाइट्स बचा सकते हैं क्योंकि एक बार पैटर्न गार्ड चले जाने के बाद आप पूरी चीज़ को ऊपर ले जा सकते हैं m। इसे ऑनलाइन आज़माएं!
— पोस्ट रॉक गार्फ हंटर
2
इसके अलावा के बाद से के हर गैर 1 तत्व aहोना चाहिए 0आप उपयोग नहीं कर सकते sum aकरने के बजाय sum[1|1<-a]? इसे ऑनलाइन आज़माएं!
— पोस्ट रॉक गार्फ हंटर
1
मुझे बस एहसास हुआ 1कि जब तक केंद्र नहीं है तब तक सभी के साथ 1 से अधिक पक्ष नहीं हो 0सकते, आप 3<-इसके बजाय कर सकते हैं elem 3$। इसके अलावा आप इसके sum.map(a!!)बजाय उपयोग कर सकते हैं sum<$>map(a!!)।
— पोस्ट रॉक गार्फ हंटर
3

पायथन 2 , 194 192 बाइट्स

from itertools import*
f=lambda l,k=0:-(sum(l)!=5)or[1,0]*4!=l[:-1]and k<4and-~min(f(l[:a]+[l[b]]+l[a+1:b]+[l[a]]+l[b+1:],k+1)for a,b in combinations(range(9),2)if max(b/3-a/3,abs(a%3-b%3))<2)

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

— OVS
स्रोत
1
के साथ काम नहीं करता है [0,1,0,1,0,1,1,1,0](अपेक्षित: 4, वास्तविक: 13)।
— बब्बलर
@ बब्बल ने इसे तय किया
— ovs
3

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

9-बिट पूर्णांक के रूप में इनपुट लेता है। भोलेपन से पहेली को नियमपूर्वक लागू करता है, जो कि सबसे छोटा दृष्टिकोण नहीं है।

f=(n,k=b=-1)=>n^341?k>2?b:[3,6,9,10,17,18,20,34,36].map(m=>[1,8,8].map(M=>(x=n&(m*=M))&-x^x||f(n^m,k+1)))|b:!~b|k<b?b=k+1:b

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

टिप्पणी की गई

f = (                           // f = recursive function taking:
  n,                            //   n = input
  k =                           //   k = number of moves, initialized to -1
  b = -1                        //   b = best result so far, initialized to -1
) =>                            //
  n ^ 341 ?                     // if n does not match the target pattern:
    k > 2 ?                     //   if we've already done more than 3 moves:
      b                         //     we're not going to find a solution -> abort
    :                           //   else:
      [3,6,9,10,17,18,20,34,36] //     for each swap bitmask m
      .map(m =>                 //     and
      [1,8,8]                   //     for each multiplier M:
      .map(M =>                 //       apply the multiplier to m and
        (x = n & (m *= M))      //       apply the final bitmask to n -> this gives x
        & -x                    //       isolate the least significant bit of x
        ^ x ||                  //       if it's the only bit set,
        f(n ^ m, k + 1)         //       then swap the bits and make a recursive call
      )) | b                    //     end of both map() loops; return b
  :                             // else:
    !~b | k < b ? b = k + 1 : b //   this is a solution in k+1 moves: update b

NB : यह कोड बोर्ड के शीर्ष से परे कुछ गैरकानूनी चालें करता है जब एम 64 से गुणा किया जाता है। लेकिन उन्हें बस नजरअंदाज कर दिया जाता है, क्योंकि वे संभवतः सर्वश्रेष्ठ कानूनी समाधान की तुलना में कम समाधान का नेतृत्व नहीं कर सकते।

नीचे 9 बेस स्वैप बिटमास्क और लक्ष्य पैटर्न हैं। शीर्ष बाएं कोने सबसे महत्वपूर्ण बिट है।

000  000  001  001  010  010  010  100  100     101
011  110  001  010  001  010  100  010  100     010 (341)
(3)  (6)  (9)  (10) (17) (18) (20) (34) (36)    101
— Arnauld
स्रोत
क्या आप परीक्षण के लिए एक हेक्सडंप लिंक कर सकते हैं? इसके अलावा, मुझे नहीं पता था कि जेएस में 9 बिट पूर्णांक संभव थे
— स्टेन स्ट्रम
@StanStrum अधिक सरल एन्कोडिंग के साथ एक छोटे संस्करण में अपडेट किया गया। (और हां: जेएस 32 बिट्स के लिए बिटवाइज़ ऑपरेशंस का समर्थन करता है।)
— अरनॉल्ड
2

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

“ċȤ‘ḤB;U$=a¥;Ḋm2ƊẠ€SɓSn5Nȯ

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

एक मोनडिक लिंक।

कैसे?

बब्बलर के पायथन उत्तर से प्रेरित ; जेली सूट करने के लिए गोल्फ ...

“ċȤ‘ḤB;U$=a¥;Ḋm2ƊẠ€SɓSn5Nȯ - Link: length 9 list of ones & zeros, X
“ċȤ‘                       - list of code-page indices     = [232,154]
    Ḥ                      - double                        = [464,308]
     B                     - to binary     = [[1,1,1,0,1,0,0,0,0],[1,0,0,1,1,0,1,0,0]]
        $                  - last two links as a monad:
       U                   -   upend       = [[0,0,0,0,1,0,1,1,1],[0,0,1,0,1,1,0,0,1]]
      ;                    -   concatenate = [[1,1,1,0,1,0,0,0,0],[1,0,0,1,1,0,1,0,0],[0,0,0,0,1,0,1,1,1],[0,0,1,0,1,1,0,0,1]]
           ¥               - last two links as a dyad:
          a                -   logical AND (vectorises)
         =                 -   equal? (vectorises)
                Ɗ          - last three links as a monad:
             Ḋ             -   dequeue X (remove leftmost element)
               2           -   literal two
              m            -   modulo slice (keeps the "edge-elements") 
            ;              - concatenate
                 Ạ€        - all? for €ach (edge-elements: no-op
                           -                else: 1 for any cost-2 element 0 otherwise)
                   S       - sum
                    ɓ      - new dyadic chain ^that on the right; X on the left
                     S     - sum X
                       5   - literal five
                      n    - not equal?
                        N  - negate (-1 if not exactly 5 1s, 0 otherwise)
                         ȯ - logical OR with right
— जोनाथन एलन
स्रोत
2

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

s=>/^0*(10*){5}$/.test(s)*s.match(/(?=1.(..)*$|^1(..)?11.1|1.11(..)?1$)|$/g).length-1

यह बब्बलर के उत्तर का एक रेगीक्स पोर्ट है ।

0/1 की एक स्ट्रिंग के रूप में इनपुट।

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

— TSH
स्रोत
2

स्टेक्स , 23 22 बाइट्स

Ç╙╤Ü┤└åVτ┐├Y-²▼░█∩¡3ëâ

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

यह प्रोग्राम [0, 1]इनपुट के रूप में एक सरणी लेता है , और पूर्णांक संख्या में चालें, या कोई रिक्त स्ट्रिंग लौटाता है यदि कोई समाधान संभव नहीं है।

ग्रिड के लिए इस सूचकांक पर विचार करें

0 1 2
3 4 5
6 7 8
  • यदि 1इनपुट में वास्तव में 5 एस नहीं हैं, तो कोई समाधान नहीं है, इसलिए हम कोई आउटपुट नहीं देते हैं।
  • प्रत्येक पक्ष के केंद्र गलत स्थिति हैं। ये सूचकांक 1, 3, 5 और 7. हैं 1। इन पदों में से प्रत्येक के लिए दूरी तय करने से अंतिम परिणाम प्राप्त होगा।
  • प्रत्येक 1के लिए एक गलत स्थिति में उसकी दूरी या तो 1 या 2 है। यह 2 iff होगा, जो अन्य 1एस से घिरा हुआ है । उदाहरण के लिए, यदि 1सूचकांकों में [0, 1, 2, 4] हैं, तो गलत के लिए दूरी 12 है।

  • इसे ध्यान में रखते हुए, सूचकांक 1 द्वारा परिणाम में योगदान करने के लिए इस छद्म कोड पर विचार करें।

    1. सूचकांक से 4 बिट्स पढ़ें [1, 0, 2, 4]। यह गलत स्थिति को सबसे महत्वपूर्ण स्थिति में रखता है।
    2. इन बिट्स को b0 से 15 की संख्या में परिवर्तित करें ।
    3. जब 0 <= b <= 7दूरी 0. है। जब 8 <= b <= 14दूरी 1. है जब b == 15दूरी 2 है। यह पूर्णांक विभाजन का उपयोग करके गणना की जा सकती है b * 2 / 15।

तो कुल दूरी की गणना इस प्रक्रिया को 4 बार दोहराकर और बीच में ग्रिड को घुमाकर की जा सकती है।

1#5=4*  if the number of 1s is 5, then 4, else 0
D       repeat the rest of the program that many times
  x     push the value in the x register, which is initially the input
  3/    split into 3 rows
  rM    rotate 90 degrees
  $X    flatten back into single array, and save the "rotated" array in the X register
  A|2E  get the digits of 2^10 i.e. [1,0,2,4]
  @     read the bits from the current rotation at indices [1,0,2,4]
  :b    convert bits to integer
  H15/  double, then divide by 2
  +     add to running total

इसको चलाओ

— पुनरावर्ती
स्रोत
संपादित करें की जाँच करें, किसी भी असंभव मूल्य को स्वीकार किया जाता है, न कि सिर्फ -1 अगर यह आपकी मदद करता है
— नूह क्रिस्टीनो
हाँ। जिससे 2 बाइट बच गईं।
— पुनरावर्ती
1

एक्सेल, 86 81 बाइट्स

=SUM(B1,A2,B3,C2)+B2*(AND(A1:A3)+AND(A1:C1)+AND(C1:C3)+AND(A3:C3))/(SUM(A1:C3)=5)

पुराना: जब 'असंभव' आउटपुट था-1 

=IF(SUM(A1:C3)=5,SUM(B1,A2,B3,C2)+B2*(AND(A1:A3)+AND(A1:C1)+AND(C1:C3)+AND(A3:C3)),-1)

1भरे और 0खाली के लिए उपयोग करता है , सीमा में इनपुट A1:C3। यदि हम -1"असंभव" के अलावा अन्य मूल्यों को वापस कर सकते हैं, तो गोल्फ को आगे बढ़ाना संभव है । #DIV/0!असंभव ग्रिड पर एक त्रुटि देता है

बब्बलर के पाइथन उत्तर के समान तर्क पर कार्य करता है ।

— Chronocidal
स्रोत
संपादित करें की जाँच करें, किसी भी असंभव मूल्य को स्वीकार किया जाता है, न सिर्फ -1
— नूह क्रिस्टीनो
हमारी साइट का प्रयोग करके, आप स्वीकार करते हैं कि आपने हमारी Cookie Policy और निजता नीति को पढ़ और समझा लिया है।
Licensed under cc by-sa 3.0 with attribution required.