फ्लिपिन के वर्ग

Question

केवल पंक्तियों और स्तंभों को फ़्लिप करके (केंद्र बिंदु के चारों ओर उलट) अंकों के एक वर्ग को रोकने के लिए एक कार्यक्रम या फ़ंक्शन बनाएं।

इनपुट

इनपुट 9 लाइन स्ट्रिंग के रूप में अंकों का 9x9 ग्रिड होगा जैसे कि निम्नलिखित:

986553229
264564891
759176443
643982153
567891234
526917874
685328912
891732537
117644378

यह इनपुट प्रारूप गैर-परक्राम्य है - कोई भी समाधान जो इनपुट प्रारूप के साथ "रचनात्मक" हैं, को अमान्य माना जाएगा।

उत्पादन

आउटपुट फ़्लिप चालों की एक सूची होनी चाहिए जो दिए गए क्रम में इनपुट पर लागू होने पर, लक्ष्य ग्रिड को फिर से बनाना चाहिए।

एक उदाहरण आउटपुट (पिछले इनपुट उदाहरण का समाधान नहीं):

28IF5D3EAB9G3

यह आउटपुट स्वरूप गैर-परक्राम्य भी है। आउटपुट में कोई नयालेख या स्थान नहीं होना चाहिए, केवल वर्ण 1- 9और A- I(यदि आप चाहें तो ऊपरी मामले के पात्रों के स्थान पर निम्न केस वर्ण स्वीकार्य हैं)।

लक्ष्य ग्रिड (जिस राज्य को आपको पुनः बनाने की आवश्यकता है) इस प्रकार है:

123456789
234567891
345678912
456789123
567891234
678912345
789123456
891234567
912345678

संख्याओं 1- 9पंक्तियों को फ्लिप करने के लिए निर्देश के रूप में उपयोग किया जाना चाहिए, और पत्र A- Iकॉलम के लिए उपयोग किया जाना चाहिए। यह नीचे की स्थिति में ग्रिड के साथ दिखाया गया है।

     ABCDEFGHI
     |||||||||
     vvvvvvvvv
1 -> 123456789
2 -> 234567891
3 -> 345678912
4 -> 456789123
5 -> 567891234
6 -> 678912345
7 -> 789123456
8 -> 891234567
9 -> 912345678

तो एक 8साधन नीचे से दूसरी पंक्ति को फ्लिप करता है, और एक Fसाधन छठे कॉलम को फ्लिप करता है।

इस मामले में कि कोई समाधान संभव नहीं है, प्रोग्राम को कुछ भी आउटपुट किए बिना समाप्त होना चाहिए।

उदाहरण

इनपुट:

987654321
234567891
345678912
456789123
567891234
678912345
789123456
891234567
912345678

आउटपुट:

1

इस स्थिति में केवल शीर्ष पंक्ति को लक्ष्य स्थिति पर लौटने के लिए फ़्लिपिंग की आवश्यकता होती है।

इनपुट:

123456788
234567897
345678916
456789125
567891234
678912343
789123452
891234561
912345679

आउटपुट:

I

इस स्थिति में केवल अंतिम कॉलम (कॉलम I) को लक्ष्य स्थिति को फिर से बनाने के लिए फ़्लिपिंग की आवश्यकता होती है।

इनपुट:

123456788
798765432
345678916
456789125
567891234
678912343
789123452
891234561
912345679

आउटपुट:

2I

इस स्थिति में हमें लक्ष्य स्थिति पर लौटने के लिए पंक्ति को फ़्लिप करना होगा 2और फिर कॉलम Iको फ्लिप करना होगा।

टिप्पणियाँ:

• कृपया अपने उत्तर में एक उदाहरण का उपयोग शामिल करें।
• दिए गए आउटपुट में सबसे छोटा अनुक्रम नहीं होता है जो लक्ष्य स्थिति को लौटा देगा - कोई भी क्रम जो लक्ष्य राज्य को लौटाता है जब तक यह काम करता है (यानी जब तक मैं इसे परीक्षण कर सकता हूं)
• मैं प्रत्येक उत्तर का परीक्षण करने और उन सभी कामों को उभारने का प्रयास करूंगा और जाहिर तौर पर गोल्फिंग का प्रयास किया होगा।
• यह एक ओपन-एंडेड प्रतियोगिता है - मैं अगले हफ्ते कुछ समय में सबसे छोटा जवाब स्वीकार करूंगा, लेकिन अगर एक नया वैध जवाब आता है, जो भविष्य में किसी भी बिंदु पर छोटा है, तो मैं प्रतिबिंबित करने के लिए स्वीकृत उत्तर को बदल दूंगा ।
• २६/०१/२०१४ (GMT) को २६/०१/२०१४ को मिले सबसे छोटे उत्तर के लिए २०० की प्रतिष्ठा में यह इनाम निर्धारित किया गया है । बाउंटी को हावर्ड को २६ Golf चरित्रों वाले गोल्फस्क्रिप्ट समाधान के लिए सम्मानित किया गया ।

परिक्षण

कृपया अपने उत्तर के साथ निम्नलिखित तीन टेस्ट ग्रिड के लिए अपने प्रोग्राम का आउटपुट प्रदान करें:

986553229
264564891
759176443
643982153
567891234
526917874
685328912
891732537
117644378

927354389
194762537
319673942
351982676
567891234
523719844
755128486
268534198
812546671

813654789
738762162
344871987
341989324
567891234
576217856
619623552
194435598
926543271

मैंने परीक्षण उद्देश्यों के लिए वैध ग्रिड उत्पन्न करने के लिए एक छोटा अजगर कार्यक्रम बनाया है:

import random

def output(array):
  print '\n'.join([''.join(row) for row in array])

def fliprow(rownum, array):
  return [row[::1-2*(rownum==idx)] for idx,row in enumerate(array)]

def flipcol(colnum, array):
  return zip(*fliprow(colnum, zip(*array)))

def randomflip(array):
  op=random.randint(0,1)
  row=random.randint(0,9)
  if(op==1):
    return fliprow(row, array)
  else:
    return flipcol(row, array)

def jumble(array):
  arraycopy=array
  for i in range(10, 1000):
    arraycopy=randomflip(arraycopy)
  return arraycopy

startarray=[
['1','2','3','4','5','6','7','8','9'],
['2','3','4','5','6','7','8','9','1'],
['3','4','5','6','7','8','9','1','2'],
['4','5','6','7','8','9','1','2','3'],
['5','6','7','8','9','1','2','3','4'],
['6','7','8','9','1','2','3','4','5'],
['7','8','9','1','2','3','4','5','6'],
['8','9','1','2','3','4','5','6','7'],
['9','1','2','3','4','5','6','7','8']]

print output(jumble(startarray))

Comments

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

— जोश

@ जोश में आश्‍चर्य नहीं। यह समस्या एक रूबिक क्यूब को हल करने के समान प्रतीत होती है। मुझे लगता है कि किसी प्रकार की चौड़ाई-पहली खोज सबसे अच्छा जानवर बल होगा। कहा जा रहा है, यादृच्छिक एल्गोरिदम को सैद्धांतिक रूप से अंततः समाप्त करना पड़ता है, और निर्दिष्ट नियमों को फिट करने के लिए प्रकट होता है।

— क्रंचर

जानवर बल की जरूरत नहीं है इस तथ्य पर विचार करें कि प्रत्येक ग्रिड टाइल केवल चार स्थितियों में से एक में समाप्त हो सकती है : इसका सही स्थान, फ़्लिप एक्स, फ़्लिप Y, या फ़्लिप XY। यह आपको (0,0) केंद्र-सबसे अधिक टाइल होने के रूप में ग्रिड का मानसिक रूप से इलाज करने में मदद कर सकता है। आप टाइल (-2, 4) को सुलझाने कर रहे हैं, केवल उन्हीं स्थानों को लक्ष्य नंबर हो सकता है (-2, 4), (2, 4), (2, -4), या (-2, -4)।

— श्री लामा

@ क्रंचर: पूरी पंक्ति / कॉलम फ़्लिप का उपयोग करना असंभव बनाता है। उदाहरण के लिए, अपरलेफ्ट 1 ( A1) को लेने और इसे स्थानांतरित करने का प्रयास करें B1। आप 1स्थिति को प्राप्त कर सकते हैं B1, लेकिन यह टाइल से होगा B9, न कि टाइल से A1। क्योंकि हमें केवल पूरी पंक्ति / स्तंभ फ़्लिप की अनुमति है, ऊपरी तौर पर 1 केवल चार सबसे बाहरी कोनों में से एक में होगा। अगर मैंने नियमों को गलत माना है, तो कृपया मुझे बताएं।

— श्री लामा

बधाई हो, गैरेथ। यह बहुत अच्छी तरह से डिज़ाइन की गई समस्या है। साथ ही, काफी चुनौतीपूर्ण।

— डेविड जेएन

Answer 1

गोल्फस्क्रिप्ट, 300 279 268 वर्ण

n%`{\5,{.9+}%{;.2/\2%},\;''{1${.9/7+7*+}%+:z;}:?~{{.9<77*{\zip\9-}>:Z~{1$!{-1%}*\(\}@%\Z;}/}:E~{:^;{:c;.`{[\E[.^=\8^-=]{.c=\8c-=}%[^c+^8c-+8^-c+16c-^-]{9%49+}%=}+[[]]:K[[8^- 17c-][^9c+]1$]{:s;{[[]s.+.2$+]{1$+}/}%.&}/\,K+0=z?E}5,/}5,/{{+9%)}+9,%''*}9,%={z:u;}*}+1024,/u

ध्यान दें कि यह कोड बेहद धीमा है (भारी कोड-ब्लॉक हेरफेर के कारण भी) और कई मिनट चल सकता है। कोड बहुत संयुक्त राष्ट्र का गोल्फ-ईश है जिसमें बहुत सारे चर और स्पष्ट लूप हैं।

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

ऊपर दी गई पहेलियों के उत्तर:

1A2C4D9G9G9G9G1C1C1C1C9F9F9F9F1D1D1D1D2A2A2A2A8H8H8H8H2B2B2B2B2C2C8F8F2D2D2D2D3A3A7I7I3B3B7H7H7G7G7G7G3D3D7F7F6I6I6I6I4A4A4A4A6H6H6H6H6G6G4C4C4C4C6F6F4D4D

1AB39I9I1A1A9I9I1B1B9F9F8I8I8I8I2B2B8H8H8G8G8G8G2D2D2D2D3A3A3A3A7H7H7H7H3C3C3C3C3D3D7F7F6I6I4A4A6I6I4B4B4B4B6G6G4C4C4C4C6F6F6F6F4D4D

1A34D9I9I9I9I1A1A1A1A1B1B1B1B9G9G1C1C1C1C9F9F9F9F1D1D9F9F8I8I2A2A2A2A8H8H8H8H2C2C2C2C8F8F2D2D8F8F7I7I7I7I3A3A3B3B7G7G7G7G3C3C3C3C6I6I6I6I6H6H6H6H4B4B4B4B6G6G6G6G4C4C6G6G6F6F4D4D6F6F

Comments

खैर, यह बहुत मुश्किल काम होने वाला है ...

— गारेथ

लगता है मैं गलत था ...

— गैरेथ

@ गैरेथ मुझे पता था कि यह एक चुनौती है जो उदाहरण के लिए गणित के मुकाबले कठिन है।

— हॉवर्ड

@ हॉवर्ड - आपने किस दृष्टिकोण का उपयोग किया? आपके द्वारा उल्लेखित 'कोशिश-और-जाँच संस्करण' क्या है?

— सर्गेईस

Answer 2

गणितज्ञ 582 575 503 464 282

Golfscripters के साथ लड़ने के लिए मुझे भारी तोपखाने का उपयोग करना होगा!

i = "986553229
264564891
759176443
643982153
567891234
526917874
685328912
891732537
117644378";

a=Array;h@M_:=Join@@a[9(M〚##〛/. 9->9⌈2Random[]⌉)+Abs[{##}-5]&,n={9,9}];
For[i_~t~j_:=i{#2,10-#2}+j#-9&~a~{9,4},!ListQ[e=GroupElementToWord[
PermutationGroup[Cycles/@Join[1~t~9,9~t~1]],
h[ToCharacterCode@StringSplit@i-48]~FindPermutation~h@a[Mod[8+##,9,1]&,n]]],];
e~IntegerString~36<>""

आउटपुट:

g69g69g8g8g7g7gd96d96d8d8d7d7dh6h64a6a46d6d4g4g6b6b7h7h7c7c2a8a27b7bd8db8b7f7fg8g82c2c94a4a3a3aigfdc91

यहाँ PermutationGroup[...]संभव फ़्लिप सेट करता है और GroupElementToWord[...]समस्या ( 0.2सेकंड के बारे में ) को हल करता है । मुख्य समस्या यह है कि 9प्रारंभिक और अंतिम ग्रिड की स्थिति के बीच पत्राचार की पहचान करना मुश्किल है । गोल्फ के लिए मैं इसे बेतरतीब ढंग से करता हूं (इसमें कई सेकंड लगते हैं)। कुछ चेतावनी हैं लेकिन कोई भी उन्हें अनदेखा कर सकता है।

ग्रिड का परीक्षण करने के लिए अन्य:

g69g69g8g8g7g7gh89h89h7h7h6h6hf6f6g6g64f4f4h4hg7g73g3g2a8a28d8db8b83d3dg8g82c2c9a3a643a3a2g9f9d9c9ga
h89h89h7h7h6h6h6h6h6f6f6g6g6d6d3a7a37g7g7h7h3c3c2a8a27b7b8d8d2f2f8b8b3f3f2b2ba2a764a8aih9g9c9gb1i

यह पूरी तरह से उदाहरण प्रस्तुत करता है:

1
i
2i

---

पिछला समाधान (464)

बिना किसी चतुर कार्य के और रनटाइम 4 एमएस के साथ:

M=ToCharacterCode@StringSplit@i-48;
S="";s=Signature;H=(S=S<>{#,#2+9}~IntegerString~36)&;
A=(m=M〚##〛)-9Mod[m+##,2]&[s@{2#3,5}#,2#2#3~Mod~2-#2]&~Array~{4,4,4};
u=s/@Join@@A;
H@@({k,l}=#&@@@#~Position~1&/@{v=u〚13;;〛;{h=#2u〚2〛,-#u〚5〛,-#u〚9〛}&@@v,v〚4〛=u〚4〛h;v});
A〚k〛=A〚k,;;,{2,1,3,4}〛;A〚;;,l〛=A〚;;,l,{3,2,1,4}〛;
MapIndexed[4#≠#4&&H@@@If[#2<3,#0[#3,#,#2,#4];k,#0[#,#3,#4,#2];10-k]&@@
If[s@#<0,#〚{1,3,2,4}〛,#]&@Ordering[k={#2,#2};#]&,A,{2}];
M〚5,1〛<5&&5~H~{};M〚1,5〛<5&&{}~H~5;S

यहां सभी नई लाइनें आवश्यक नहीं हैं।

आउटपुट:

3b9i9i1a1a1a1a9i9i1a1a9h9h1b1b1b1b9h9h9g9g1c1c9g9g9f9f1d1d9f9f8h8h2b2b8f8f8f8f7i7i7h7h3b3b3b3b7h7h3b3b7h7h7g7g3c3c7g7g3c3c7f7f6i6i4a4a6h6h4b4b4b4b6g6g4c4c6g6g4c4c6f6f4d4d4d4d6f6f4d4d6f6f4d4d

अन्य दो परीक्षण ग्रिड:

13ab9i9i1a1a9i9i9h9h1b1b1b1b9h9h9f9f8i8i8i8i8h8h2b2b2b2b8h8h8h8h8g8g8g8g8f8f2d2d2d2d8f8f2d2d7i7i3a3a3a3a7i7i7h7h3b3b7h7h3b3b7g7g3c3c3c3c7g7g3c3c7f7f3d3d3d3d7f7f7f7f6i6i4a4a6i6i6h6h4b4b4b4b6h6h4b4b6g6g4c4c4c4c6f6f4d4d4d4d6f6f4d4d6f6f
2bc9i9i1a1a9i9i9g9g1c1c9g9g1c1c9f9f1d1d1d1d8i8i8i8i8h8h2b2b2b2b8f8f2d2d7i7i7h7h3b3b3b3b7h7h3b3b7g7g3c3c7f7f3d3d3d3d7f7f3d3d6i6i4a4a4a4a6h6h4b4b6g6g6g6g6f6f4d4d

दृश्य:

anim = Reap[Fold[Function[{m, i}, 
 If[i > 9, (Sow@Grid[#, Background -> {i - 9 -> Pink, None}] & /@ {m, #}; #) &@
   Transpose@MapAt[Reverse, Transpose@m, i - 9], (Sow@Grid[#, 
         Background -> {None, i -> Pink}] & /@ {m, #}; #) &@
   MapAt[Reverse, m, i]]], M, IntegerDigits[FromDigits[S, 36], 36]]];

ListAnimate[Join[{#, #} &@Grid@M, anim[[2, 1]], {#, #} &@Grid@anim[[1]]], 5]

इनपुट स्ट्रिंग iको अनियमित रूप से उत्पन्न किया जा सकता है

M = Array[Mod[8 + ##, 9, 1] &, {9, 9}];
(M[[#]] = Reverse@M[[#]]; M[[All, #2]] = Reverse@M[[All, #2]];) & @@@
   RandomInteger[{1, 9}, {10000, 2}];
i = ToString /@ # <> "\n" & /@ M <> ""

छोटी चर्चा

• फ़्लिप केवल इन तत्वों ("चौगुनी") को बदल सकते हैं:

  

• इन तत्वों को अन्य तत्वों से अलग-अलग करना संभव है, यदि प्रारंभिक और अंतिम आदेश में एक ही हस्ताक्षर है।

• इन चार तत्वों के झंडे डिग्री 4 के वैकल्पिक समूह (= टेट्राहेड्रल के घुमावों का समूह) का निर्माण करते हैं। इस समूह का प्रत्येक तत्व 2 उत्पादक तत्वों की एक संरचना है। इसलिए यदि हम प्रारंभिक और अंतिम स्थिति को जानते हैं, तो हम एक साधारण फ्लिप के संयोजन के रूप में संबंधित परिवर्तन को विघटित कर सकते हैं।

विवरण

स्पोर्ट्समैनशिप के लिए मैं इनाम के अंत से पहले विवरण पोस्ट करता हूं!

M=ToCharacterCode@StringSplit@i-48;

स्ट्रिंग iको मैट्रिक्स में बदलें M।

S="";s=Signature;H=(S=S<>{#,#2+9}~IntegerString~36)&;

हम चार्ट को संलग्न करेंगे S। अब यह खाली स्ट्रिंग है। H[i,j]चरित्र i( 1,2,3,...,9) और चरित्र j( a,b,c,...,iआधार -36 में) जोड़ देगा ।

A=(m=M〚##〛)-9Mod[m+##,2]&[s@{2#3,5}#,2#2#3~Mod~2-#2]&~Array~{4,4,4};

मैं तत्वों को रूपांतरित करता हूं

निम्न रूप में लक्ष्य मैट्रिक्स प्राप्त करने के लिए

फिर मेरे एल्गोरिथ्म में दो मुख्य चरण हैं

1. ढूँढें (जैसे के हस्ताक्षर लक्ष्य मैट्रिक्स में ही हस्ताक्षर प्राप्त करने के लिए flips {-7,-1,1,7}है 1और के हस्ताक्षर {-6,2,-2,6}है -1):

   u=s/@Join@@A;
   H@@({k,l}=#&@@@#~Position~1&/@{v=u〚13;;〛;{h=#2u〚2〛,-#u〚5〛,-#u〚9〛}&@@v,v〚4〛=u〚4〛h;v});
   A〚k〛=A〚k,;;,{2,1,3,4}〛;A〚;;,l〛=A〚;;,l,{3,2,1,4}〛;
   

2. सही क्रम प्राप्त करने के लिए हर "चौगुनी" घुमाएँ:

   MapIndexed[4#≠#4&&H@@@If[#2<3,#0[#3,#,#2,#4];k,#0[#,#3,#4,#2];10-k]&@@
   If[s@#<0,#〚{1,3,2,4}〛,#]&@Ordering[k={#2,#2};#]&,A,{2}];
   

   यह एल्गोरिथ्म का सबसे nontrivial हिस्सा है। उदाहरण के लिए, परिवर्तन 1b1bमें परिवर्तित कर देंगे {-7,-1,1,7}करने के लिए {-1,1,-7,7}। परिवर्तन 9h9hमें परिवर्तित कर देंगे {-7,-1,1,7}करने के लिए {-7,7,-1,1}। इसलिए हमारे पास दो नक्शे हैं

   {1,2,3,4} -> {2,3,1,4}
   {1,2,3,4} -> {1,4,2,3}
   

   और हम एक मनमाना आदेश परिवर्तित करना चाहते {x,y,z,w}करने के लिए {1,2,3,4}। सरल विधि है (एक यादृच्छिक खोज को छोड़कर)

   repeat   
   {x, y, z, w} -> If[z < 3, {y, z, x, w}, {x, w, y, z}]
   until {1,2,3,4}
   

   मैं इसका प्रमाण नहीं दे सकता, लेकिन यह काम करता है!

अंतिम चरण है

M〚5,1〛<5&&5~H~{};M〚1,5〛<5&&{}~H~5;S

यह केंद्र पंक्ति और केंद्र स्तंभ के तुच्छ फ़्लिप करता है और परिणाम लौटाता है।

Comments

@ गैरेथ क्या मैं आउटपुट में छोटे पात्रों का उपयोग कर सकता हूं? यह मुझे कई पात्रों को बचाता है।

— ybeltukov

हां, मैं आउटपुट में लोअर-केस कैरेक्टर्स को स्वीकार करूंगा (मैं इसे नोट करने के लिए प्रश्न बदल दूंगा)। मेरे पास Mathematica नहीं है इसलिए कुछ अन्य Mathematica उपयोगकर्ता पुष्टि कर सकते हैं कि कोड वास्तव में आउटपुट उत्पन्न करता है? मैंने तीन परीक्षण समाधानों को मान्य किया है और वे सभी सही हैं, इसलिए +1। अच्छी नौकरी!

— गारेथ

बस जिज्ञासु - आपके दृष्टिकोण का प्रदर्शन क्या है? क्या आपने हजारों फ़्लिप द्वारा उत्पन्न इनपुट पर परीक्षण किया था?

— सर्गेस

@ सर्जिस हां, इसमें लगभग 50 ms :)

— ybeltukov

@ गैरेथ मैं अपने कार्यक्रम को फिर से लिखता हूं, क्या आप परिणामों की जांच कर सकते हैं? मेरे परीक्षणों से पता चला है कि सब कुछ सही है।

— ybeltukov

Answer 3

जम्मू 487 438

q=:3 :'(>:9|+/~i.9)=/&((,{;/(,.8&-)y){])g'
l=:2 :0
:
o=:o,(m+x){a.
x&(|.@{`[`]})&.v y
)
r=:49 l]
c=:97 l|:
w=:2 :'g=:4 v^:(4=(<m){g)g'
p=:_1=C.!.2@,@:I.@q
t=:2 :'for_i.>:i.3 do.g=:i v^:(p m*i)g end.'
z=:2 :0
'i j I J'=.y,8-y
g=:".'(',(,' ',.,(I.m{q y){,;._1 n),'])^:2 g'
)
d=:3 :0
g=:9 9$".,_ list,' ',.y
o=:''
0 4 w c
4 0 w r
0 1 t c
g=:0 c^:(-.(p 1 0)=p 1 2)g
1 0 t r
for_k.>,{;~i.4 do.0 z';;jcir;irjc;Irjc'k
3 z';;IrJc;JcIr;'k end.o
)

d एक क्रिया है जो निर्दिष्ट प्रारूप में ग्रिड स्ट्रिंग लेता है और निर्दिष्ट प्रारूप में एक समाधान स्ट्रिंग देता है।

उदाहरण का उपयोग करें:

   d '987654321',LF,'234567891',LF,'345678912',LF,'456789123',LF,'567891234',LF,'678912345',LF,'789123456',LF,'891234567',LF,'912345678'
bcda2341a1a1b1b1c1c1d1da2a2b2b2c2c2d2d2a3a3b3b3c3c3d3d3a4a4b4b4c4c4d4d4

अब या तो newline प्रकार स्वीकार करता है।

परीक्षण ग्रिड के समाधान:

b3a1a11b1bc9c99g9gd9d99f9fb8b8f8f87i7i7h7hc3c3g7g77f7fa6a64b4bh6h6c4c4g6g6d6d6f6f6
cd24a9a91c1c1d1d9f9fa2a2i8i88h8hc2c2g8g82d2d3b3bh7h7d3d37f7fa6a64b4bg6g64d4d6f6f
bc2a9a99i9ic1c1g9g91d1df9f9i8i8b2b2h8h82c2cd8d87i7ib3b3c7c7d3d34a4ai6i6b6b6g6g6d6d6

मैं जे के लिए काफी नया हूँ; यह शायद आगे भी गोल्फ हो सकता है।

---

अमान्य / अयोग्य ग्रिड के लिए जाँच करने से 123 वर्ण दंड मिलता है। मुझे नहीं लगता कि आज तक के अन्य उत्तरों में ऐसी त्रुटि जाँच है।

ऐसा करने के लिए, इस की पहली पंक्ति बदलें d:

if.-.+./89 90=#y do.0 return.end.if.-.*./(/:~y)=/:~(#y)$'123456789',LF do.0 return.end.g=:9 9$".,_ list,' ',.y

और यह करने के लिए अंतिम पंक्ति:

3 z';;IrJc;JcIr;'k end.if.*./,g=>:9|+/~i.9 do.o return.end.0

मैंने 0ऐसी त्रुटियों पर लौटने के लिए चुना है क्योंकि एक खाली स्ट्रिंग को वापस करने से पूरी तरह से हल किए गए ग्रिड को सही ढंग से हल करने से अप्रभेद्य होगा। ध्यान दें कि यह UNIX newlines (फिर से) को मानता है।

Comments

बधाई हो, आप अभी लीड में आए हैं। :-)

— गारेथ

ऐसा लगता है कि आपका इनपुट नियमों के अनुसार एक स्ट्रिंग नहीं है, या मुझे कुछ याद है?

— सर्गेस

@ शेयर्स: आप भ्रमित हो सकते हैं। जहाँ तक मुझे पता है, जे के पास स्ट्रिंग लिटरल्स में एस्केप (जैसे कि नईलाइन) रखने का कोई तरीका नहीं है। J में कंस्ट्रक्शन 'a', LF, 'b' "" + "\ n" + "b" भाषाओं के समान है जहाँ + तार जोड़ने का काम करता है।

— AlliedEnvy

ठीक है, यह समझ में आता है, धन्यवाद।

— सर्गेस

मैं 1962 की एपीएल पुस्तक की फाइलों पर अनुभाग पढ़ रहा था, और मुझे लगता है कि @AlliedEnvy सही है। यह इस तरह से है कि प्रश्न के प्रारूप में एक फ़ाइल से पढ़ने पर डेटा कार्यक्रम में दिखाई देगा। LFरों प्रतिनिधित्व विभाजन अनुक्रमिक फ़ाइल की।

— लूजर ने

Answer 4

सी# 540 399

ठीक है, बलिदान का प्रदर्शन (अब इसमें 30 सेकंड तक का समय लगता है), गतिशील चर, समाधान के थोड़े बदले हुए तर्क पेश किए। और हाँ, अब यह लाइन-ब्रेक (नियमों में आवश्यक) के साथ एक स्ट्रिंग के रूप में इनपुट की उम्मीद कर रहा है।

बेशक C # में गणित के कार्य पूर्वनिर्धारित नहीं हैं, इसलिए गणितज्ञों से लड़ना कठिन होगा। फिर भी, यह एक बड़ी चुनौती थी, लेखक का धन्यवाद!

string S(string _){for(i=0,e=1>0;e;){
for(h=v=j=0;j<89;)m[j/10,j%10+9]=_[j++]-49;a="";
for(j=i++;j>0;v++,j/=2)if(j%2>0)F(v);
for(;h<9&(h<4|!e);h+=j/36,j%=36)if((e=m[h,g=j++%9+9]!=(t=(h+g)%9))|m[v=8-h,g]==t){F(v);F(g);F(v);F(g);}
}return a;}void F(int z){for(f=z<9;++l<9;)m[0,l]=m[f?z:l,f?9+l:z];for(;l-->0;)m[f?z:l,f?9+l:z]=m[0,8-l];a+=(char)(z+=f?49:56);}
dynamic h,v,i,j,e,t,l=-1,g,a,m=new int[9,19],f;

टेस्ट ग्रिड:

3B9A9A9B9B9C9C9D9D9F9F9G9G9H9H9I9I9B9B9C9C9D9D9F9F9G9G9H9H9C9C9D9D9C9C9D9D8B8B8F8F8H8H8B8B8F8F8B8B8H8H7B7B7C7C7F7F7H7H7I7I7H7H6A6A6B6B6C6C6D6D6F6F6H6H6A6A6B6B6D6D6F6F6D6D6D6D6F6F5A5A5B5B5C5C5D5D5E5E5F5F5G5G5H5H5I5I5A5A5B5B5C5C5D5D5E5E5F5F5G5G5H5H5I5I5A5A5B5B5C5C5D5D5E5E5F5F5G5G5H5H5I5I5A5A5B5B5C5C5D5D5E5E5F5F5G5G5H5H5I5I

13AB9A9A9B9B9F9F9H9H9A9A9B9B9H9H9I9I8B8B8D8D8F8F8G8G8H8H8I8I8B8B8G8G8H8H8I8I8H8H7A7A7B7B7C7C7D7D7F7F7G7G7I7I7A7A7D7D7F7F7I7I7F7F6A6A6B6B6C6C6D6D6F6F6G6G6H6H6I6I6A6A6C6C6F6F6I6I6A6A6A6A5A5A5B5B5C5C5D5D5E5E5F5F5G5G5H5H5I5I5A5A5B5B5C5C5D5D5E5E5F5F5G5G5H5H5I5I5A5A5B5B5C5C5D5D5E5E5F5F5G5G5H5H5I5I5A5A5B5B5C5C5D5D5E5E5F5F5G5G5H5H5I5I

2BC9A9A9C9C9D9D9F9F9A9A9D9D9I9I8B8B8D8D8H8H8I8I8B8B8D8D8I8I7B7B7C7C7D7D7F7F7G7G7H7H7I7I7C7C7C7C7G7G6A6A6B6B6D6D6F6F6G6G6I6I6A6A6B6B6D6D6G6G6D6D6F6F5A5A5B5B5C5C5D5D5E5E5F5F5G5G5H5H5I5I5A5A5B5B5C5C5D5D5E5E5F5F5G5G5H5H5I5I5A5A5B5B5C5C5D5D5E5E5F5F5G5G5H5H5I5I5A5A5B5B5C5C5D5D5E5E5F5F5G5G5H5H5I5I

---

पुराना समाधान (540)

किसी भी इनपुट पर एक सेकंड से भी कम समय में काम करता है (हजारों बेतरतीब ढंग से उत्पन्न ग्रिड पर परीक्षण)। आउटपुट स्ट्रिंग की अधिकतम लंबाई 165 है (शुरू में कोई भी ग्रिड 82 से अधिक फ़्लिप में हल नहीं किया गया था, लेकिन गोल्फिंग के दौरान मैंने यह बलिदान किया था)।

string S(string[]_){for(i=0;i<1<<18;){
for(j=0;j<81;)m[j/9+49,j%9+65]=_[j/9][j++%9]-49;a="";char g,h='1',v='9',b,x=h,y;
for(j=i;j>0;x=x==v?'A':++x,j/=2)if(j%2>0)F(x);j=i+1;
for(i+=1<<19;h<58;h++,v--)for(g='A',b='I';g<74;g++,b--){
t=(h+g-6)%9;e=m[h,g];q=m[v,g];i=h>52&t!=e?j:i;
if(e!=t|q==t){x=q==t?v:g;y=q==t?g:v;
if(m[h,b]==t){x=b;y=h;}
F(x);F(y);F(x);F(y);}}}return a;}
void F(char z){var f=z<65;for(l=0;l<4;l++){n=m[d=f?z:49+l,s=f?65+l:z];m[d,s]=m[o=f?z:57-l,u=f?73-l:z];m[o,u]=n;}a+=z;}
int i,j,q,e,t,l,s,d,n,u,o;int[,]m=new int[99,99];string a;

उदाहरण के लिए उत्तर 1:

15A5A5B5B5C5C5D5DE5E55F5F5G5G5H5H5I5I

उदाहरण 2 के लिए उत्तर:

19AI1I1H1H1G1G1F1F19F9F9G9G9H9H9I9I8A8AI8I87A7AI7I76A6AI6I65A5A5B5B5C5C5D
5DE5E55F5F5G5G5H5H5I5I

उदाहरण 3 के लिए उत्तर:

129AI1I1H1H1G1G1F1F19F9F9G9G9H9H9I9I8A8AI8I87A7AI7I76A6AI6I65A5A5B5B5C5C5
D5DE5E55F5F5G5G5H5H5I5I

परीक्षण वर्गों के लिए उत्तर:

346B9A9AH1H1C9C9D9D99F9F9G9GH9H99I9IB8B8F8F87B7B7C7C7F7FH7H77I7I6A6A6B6BC6C66D6DG6G6H6H66I6I5A5A5B5B5C5C5D5DE5E55F5F5G5G5H5H5I5I

1346ABA9A9H1H19F9FH9H99I9IH2H28D8D8F8FG8G8I8I8I3I37B7B7C7CF3F37G7GI7I7H4H4D6D66F6F5A5A5B5B5C5C5D5DE5E55F5F5G5G5H5H5I5I

2BCA9A99C9CF1F19F9F9I9IH2H2D8D88H8HI8I87B7BC7C77D7D7F7F7H7H7I7II4I4B6B6D6D6G6G66I6I5A5A5B5B5C5C5D5DE5E55F5F5G5G5H5H5I5I

Comments

मैं अभी अपने मैक के लिए मोनो डाउनलोड कर रहा हूं, इसलिए मैं स्वयं कार्यक्रम का परीक्षण कर सकता हूं, लेकिन मेरे पास पहले से ही एक सत्यापनकर्ता है जो किसी दिए गए ग्रिड पर दिए गए समाधान को चलाता है और मुझे बताता है कि क्या समाधान उस ग्रिड के लिए एक वैध समाधान है - और यह है मुझे बता रहा है कि आपने मुझे दिए तीन उदाहरण समाधान मान्य नहीं हैं। मैं अभी जांच कर रहा हूं कि अब क्यों।

— गारेथ

अहा! मुझे लगा कि यहाँ क्या हुआ है! आपके दिए गए उत्तर 3 उदाहरणों के उत्तर प्रतीत होते हैं, न कि तीन परीक्षण ग्रिड (जो प्रश्न में कम हैं)। वे वास्तव में उन ग्रिड करने के लिए सही समाधान कर रहे हैं, हालांकि वे काफ़ी अधिक अवधि की 1, Aऔर 2Iजो सबसे सरल समाधान कर रहे हैं - लेकिन यह है कि वास्तव में बात के बाद से मैं ग्रिड समाधान लंबाई पर पहचानने नहीं कर रहा हूँ नहीं है :-) यदि आप संपादित कर सकता है और 3 टेस्ट ग्रिड के लिए उत्तर दें (मैं यह देखने के लिए जा रहा हूं कि क्या मैं अपने मैक पर अब इसे चला सकता हूं) मैं आपको अपना +1 दे सकता हूं।

— गैरेथ

@ गैरेथ - उफ़, मैंने परीक्षण वर्गों के लिए उत्तर याद किए, जो इस ओर इशारा करने के लिए धन्यवाद। मैंने उन्हें अब अपने उत्तर में जोड़ दिया है।

— सर्गेस

बहुत बढ़िया, इसके लिए धन्यवाद। वे सभी मान्य हैं। Xamarin किसी कारण से मेरे मैक पर नहीं चलेगा, इसलिए मुझे कुछ घंटों में कार्यक्रम का परीक्षण करना होगा।

— गारेथ

@ गैरेथ - वास्तव में उस कोड में C # के लिए कुछ भी विशिष्ट नहीं है, कोई शायद इसे जावा या यहां तक ​​कि C ++ में बहुत अधिक दर्द के बिना बदल सकता है ... और इसमें से कुछ वर्णों को गॉल्फ़ करें :) इसके अलावा इसे गोल्फस्क्रिप्ट या कुछ और में बदलने के लिए स्वतंत्र महसूस करें संक्षिप्त - यह दो बार या उससे अधिक छोटा दिखाई दे सकता है;)

— सर्गेईस