रूढ़िवादी कदम

26

2D मैट्रिक्स में नेविगेट करना एक आम समस्या है। हमने इसे कई बार देखा है और फिर से देखेंगे। तो आइए हम भविष्य में मदद करें और एक 2D मैट्रिक्स में सभी आठ संभावित चरणों को उत्पन्न करने के लिए सबसे छोटे समाधान विकसित करें।

चुनौती

आपका कोड किसी भी क्रम में -1,0,1 के निम्नलिखित 8 जोड़े का उत्पादन करना चाहिए: 

(0,1)
(0,-1)
(1,0)
(-1,0)
(1,1)
(1,-1)
(-1,1)
(-1,-1)

नियम

  1. कोई इनपुट नहीं है।
  2. आउटपुट ऑर्डर प्रासंगिक नहीं है
  3. आउटपुट लचीला है। संख्याओं के जोड़े को बस अलग-अलग होना चाहिए
  4. यह कोड-गोल्फ है , इसलिए बाइट्स जीत में सबसे छोटा जवाब है
code-golf  kolmogorov-complexity  matrix 
— मृत पोसुम
स्रोत
2
@MartinEnder मैं उस बारे में भी 99% निश्चित था, लेकिन वह भी नहीं मिला। इसलिए मैंने इसे कुछ दिनों के लिए सैंडबॉक्स में डाल दिया, लेकिन किसी ने डुप्लिकेट के बारे में कोई टिप्पणी नहीं की।
— डेड पॉसम
4
लचीले आउटपुट के कारण, इसमें एक दिलचस्प कोलमोगोरोव जटिलता स्वाद निकला। कुछ भाषाओं के लिए यह मुश्किल होगा कि वे केवल हार्ड कोडिंग से बेहतर उत्पादन करें। क्या यह टैग जोड़ा जाना चाहिए?
— एन जी एम
1
@ Adám हां, कुछ भी उपयोग करें जबकि संख्याओं के जोड़े अलग
— मृत पोसम
1
@ Adám लेकिन इसके बारे में क्या (1 + 0i)?
— मृत पोसुम
8
यह 8 आसन्न वर्गों का एक सटीक डुप्लिकेट है , पहले कोड गोल्फ में से एक जो मैंने कभी किया था।
— इसहाक

जवाबों:

19

ऑक्टेव , 24 बाइट्स

dec2base([0:3,5:8],3)-49

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

मैंने अभी तक इस दृष्टिकोण को नहीं देखा है।

पूर्णांक की एक सूची बनाता है [0, 1, 2, 3, 5, 6, 7, 8], और इसे वर्ण में लौटाता है, एक वर्ण सरणी लौटाता है:

00
01
02
10
12
20
21
22

सभी वर्णों से घटाना 49(ASCII-value 1) एक संख्यात्मक सरणी देता है:

-1  -1
-1   0
-1   1
 0  -1
 0   1
 1  -1
 1   0
 1   1
— स्टीवी ग्रिफिन
स्रोत
9

टी-एसक्यूएल, 80 78 बाइट्स

SELECT-1n INTO t;INSERT t VALUES(0),(1)SELECT*FROM t,t z WHERE t.n<>0OR z.n<>0

एक (स्थायी) तालिका बनाता है टी युक्त (-1,0,1)एक के साथ एक स्वयं शामिल होने, और प्रदर्शन WHEREखंड है कि शामिल नहीं 0,0पंक्ति। टेबल टी को मेरे कोड द्वारा साफ नहीं किया गया है, आपको इसे स्वयं छोड़ना होगा।

उबाऊ समाधान ( 44 बाइट्स ) के रूप में लंबे समय के रूप में लगभग दो बार , क्योंकि एसक्यूएल तार में रिटर्न की अनुमति देता है:

PRINT'0,1
0,-1
1,0
-1,0
1,1
1,-1
-1,1
-1,-1'
— BradC
स्रोत
मैं टी-एसक्यूएल को इतनी अच्छी तरह से नहीं जानता: क्या आप इसका उपयोग कर सकते हैं WHERE t.n OR z.n? (आप कुछ लेकिन सभी SQL बोलियों में नहीं कर सकते।)
— msh210
@ msh210 अच्छा विचार है, मैंने इसकी कोशिश की, लेकिन यह एमएस SQL ​​सर्वर पर काम नहीं करता है। मुझे त्रुटि मिलती है:An expression of non-boolean type specified in a context where a condition is expected
— ब्रैडेक
1
आप *
— रज़वान सोकोल
8

शुद्ध बैश (कोई बाहरी उपयोगिताओं नहीं), 36

a=({0,-1,1},{0,-1,1})
echo ${a[@]:1}

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

सैड, 35 के साथ बैश

printf %s\\n {-1..1},{-1..1}|sed 5d

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

— डिजिटल आघात
स्रोत
वैकल्पिक रूपcut से 36 बाइट्स के लिए भी उपयोग कर रहे हैं।
— ბიმო
— सेड के
printf %s\\n {-1..1},{-1..1}|grep 1is 35.
— नील
7

जेली , 8 7 6 बाइट्स

3p_2ẸƇ

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

मेरी पहली कभी जेली जवाब! पहेली के अंतिम टुकड़े के लिए डेनिस को बहुत धन्यवाद।

अब, चलो देखते हैं कि क्या मैं इसे समझा सकता हूं ... योग्य।

3p_2ẸƇ   Main program, takes no input.
3p       Product with Range 3, yields [[1,1], [1,2], [1,3], [2,1], [2,2], ...]
  _2     Decrement twice, vectorizes, yields [[-1,-1], [-1,0], [-1,1], [0,-1], ...]
    ẸƇ   Comb, removes those that contain only falsey values, the [0,0]
         Implicit output

एरिक के लिए -1 बाइट धन्यवाद; मिस्टर एक्सकोडर और डेनिस को -1 बाइट

— AdmBorkBork
स्रोत
1
इस दृष्टिकोण के आधार पर अलग-अलग उत्तर:3p3_2ẸƇ
— श्री एक्सकोडर
@ Mr.Xcoder आप दूसरा छोड़ सकते हैं 3।
— डेनिस
@ डेनिस ओह, वास्तव में। इस स्थिति में, Adm 6-
— बटर के
7

आर , 26 24 बाइट्स

सीधे दृष्टिकोण के साथ दो और बाइट्स बचाने के लिए @JDoe को श्रेय:

paste(-1:1,-3:5%/%3)[-5]

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

मूल asnwer:

outer(-1:1,-1:1,paste)[-5]

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

या 27 बाइट्स के लिए

sapply(-1:1,paste,-1:1)[-5]

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

या कारकों के साथ 34 बाइट्स के लिए:

(gl(3,3,,-1:1):gl(3,1,9,-1:1))[-5]

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

यह अंतिम समाधान गोल्फस्ट हो सकता है अगर आउटपुट -1 से 3 के बजाय 1 से 3 हो सकता है।

साथ या साथ वैकल्पिक समाधान के लिए अन्य आर उत्तर देखें ।expand.gridcbind

— Jayce
स्रोत
हुह, लचीले आउटपुट प्रारूप का अच्छा उपयोग!
— ग्यूसेप
2
यह मेरी तुलना में बेहतर है क्योंकि यह अंततः कितना बेकार है: :)
— 14'18
@Giuseppe मूल रूप से मैंने कोशिश की थी cजो एक मैट्रिक्स के अंदर समझ में नहीं आया था इसलिए मैंने स्विच किया pasteऔर मूल आउटपुट स्वरूप ...
— JayCe
24 बाइट्स के साथpaste
— J.Doe
1
@ जे। आप रॉक!
— JayCe
6

जाप , १३ १२ ११ बाइट्स

@ शगुन को एक बाइट धन्यवाद दिया

9ó8_ìJõ é)Å

इसे ऑनलाइन आज़माएं! -Rप्रत्येक आइटम को अपनी लाइन पर रखने के लिए ध्वज का उपयोग करता है ।

व्याख्या

9ó8_ìJõ é)Å
9ó8             Create the range [9, 9+8). [9, 10, ..., 16]
   _            Map each item in this range through this function:
     Jõ é)        Generate the range [-1...1] and rotate to get [1, -1, 0].
    ì             Convert the item to an array of base-3 digits,
                  mapping [0,1,2] to [1,-1,0]. [[-1, 1, 1], [-1, 1,-1], [-1, 1, 0],
                                                [-1,-1, 1], [-1,-1,-1], [-1,-1, 0],
                                                [-1, 0, 1], [-1, 0,-1]]
          Å       Remove the first item (gets rid of the leading -1).
— ETHproductions
स्रोत
6

जाप -Q , 15 13 बाइट्स

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

##ü80ì3 mÉ ò
##ü80        // Take 14425280
     ì3      // and turn it into an array of base-3 numbers.
        mÉ   // Subtract one from each digit
           ò // and then split them pairwise.

झबरा के लिए धन्यवाद दो बाइट्स मुंडा ।

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

— लीख
स्रोत
6

हास्केल , 22 बाइट्स

_:l=mapM(:[1,-1])[0,0]

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

लाईकोनी ने 1 बाइट बचाई।

— XNOR
स्रोत
_:l=mapM(:[1,-1])[0,0]एक बाइट बचाता है। ( पहले की चुनौती के लिए isaacg के जवाब से लिया गया )।
— लकोनी
@ लिकोनी तो मैंने उस पर विचार किया था और सोचा था कि यह एक स्निपेट बन जाएगा (क्योंकि पुरानी चुनौती के कई जवाब थे)। लेकिन इस मेटा पोस्ट को नियम के साथ जोड़कर कार्य को परोक्ष रूप से परिभाषित किया जा सकता है, इसलिए यह ठीक लगता है। सलाह के लिये धन्यवाद।
— xnor
5

05AB1E , 8 7 बाइट्स

2Ý<ãʒĀZ

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

व्याख्या

2Ý<     # Range of 2 decremented, yields [-1, 0, 1]
   ã    # Cartesian product of the list with itself
    ʒ   # Filter by ...
     ĀZ # Maximum of the truthified values, yields 0 only if both values are 0.

-1 बाइट एमिग्ना को धन्यवाद!

— Kaldo
स्रोत
डांग, तुमने मुझे इसके लिए हराया। एक ही शुरुआत थी ( 2Ý<ã), लेकिन यह पता लगाना था कि जोड़े की सूची के मध्य तत्व को कैसे हटाया जाए .. क्या निरपेक्ष मूल्य के आधार पर सॉर्ट के बारे में नहीं सोचा था और पहले .. +1 को मुझसे हटा दिया था।
— केविन क्रूज़सेन
2
ʒĀZ1 बचाने के लिए उपयोग करें
— एमिग्ना
बनाने के लिए @Emigna धन्यवाद मुझे नियमित रूप से और truthified कमान की :-) 05AB1IE संस्करण के बीच अंतर समझना
— Kaldo
5

MATL , 12 बाइट्स

9:q4X-3YA49-

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

क्योंकि यह MATL महीना है, यहाँ @ Stewie के ऑक्टेव उत्तर का MATL पोर्ट है। अनुक्रम [0 1 2 3 5 6 7 8] को [0 ... 8] और 4 के बीच के अंतर के रूप में उत्पन्न किया जाता है।

— Sanchises
स्रोत
5

जावा 8, 83 42 बाइट्स

v->"1,1 1,0 1,-1 0,1 0,-1 -1,1 -1,0 -1,-1"

-41 बाइट्स हार्ड-कोडिंग द्वारा @AdmBorkBork का धन्यवाद ।।

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

संदर्भ के रूप में गैर हार्ड-कोडित संस्करण ( 83 72 70 68 बाइट्स ):

v->{for(int i=9;i-->1;)System.out.println(~i%3+1+","+(~(i/3)%3+1));}

-11 बाइट्स की बदौलत @ OlivierGrégoire ।
-2 बाइट्स @ETHproductions के जावास्क्रिप्ट (ES6) उत्तर का एक पोर्ट बनाते हैं ।

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

— केविन क्रूज़सेन
स्रोत
72 बाइट्स में नॉन-हार्डकोड जवाब v->{for(int i=9;i-->0;)if(i!=4)System.out.println((i/3-1)+","+(i%3-1));}:।
— ओलिवियर ग्रेजायर
@ OlivierGrégoire धन्यवाद, जोड़ा (और 2 और बाइट्स द्वारा गोल्फ)।
— केविन क्रूज़सेन
4

आर , 27 बाइट्स

expand.grid(-1:1,-1:1)[-5,]

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

30 और 35 बाइट्स:

cbind(-1:1,rep(-1:1,e=3))[-5,]
expand.grid(rep(list(-1:1),2))[-5,]
— एन जी एम
स्रोत
कुछ फंकी दिखने वाले आउटपुट, मुझे यह पसंद है: डी गुड जॉब
— डेड पॉसम
expand.grid(-1:1,-1:1)[-5,]27 बाइट्स है।
— ग्यूसेप
4

भूसी , 7 6 बाइट्स

बहुत सारे तरीके हैं (मुश्किल / महंगा भाग से छुटकारा मिल रहा है [0,0]), 7 बाइट्स सबसे छोटा है जो मैं लियो के लिए धन्यवाद का उपयोग कर सकता हूं ताकि दशमलव रूपांतरण ( d) को फ़िल्टर के रूप में उपयोग किया जा सके :

fdπ2ṡ1

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

व्याख्या

fdπ2ṡ1  -- constant function (expects no arguments)
    ṡ1  -- symmetric range [-n..n]: [-1,0,1]
  π2    -- cartesian power of 2: [[-1,-1],[-1,0],[0,-1],[-1,1],[0,0],[1,-1],[0,1],[1,0],[1,1]]
f       -- filter only elements that are truthy when
 d      -- | decimal conversion (interpret as polynomial and evaluate at x=10)
        -- : [[-1,-1],[-1,0],[0,-1],[-1,1],[1,-1],[0,1],[1,0],[1,1]]

वैकल्पिक, 7 बाइट्स

tπ2ṙ1ṡ1

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

व्याख्या

tπ2ṙ1ṡ1  -- constant function (expects no arguments)
     ṡ1  -- symmetric range [-n..n]: [-1,0,1]
   ṙ1    -- rotate by 1: [0,1,-1]
 π2      -- cartesian power of 2: [[0,0],[0,1],[1,0],[0,-1],[1,1],[-1,0],[1,-1],[-1,1],[-1,-1]]
t        -- tail: [[0,1],[1,0],[0,-1],[1,1],[-1,0],[1,-1],[-1,1],[-1,-1]]
— ბიმო
स्रोत
1
एक और 7 बाइट विकल्प tπ2↑3İZ।
— लकोनी
2
आप उनके दशमलव रूपांतरण के आधार पर सूचियों को फ़िल्टर करके एक बाइट बचा सकते हैं इसे ऑनलाइन आज़माएं!
— सिंह
3

पॉवरशेल , 41 बाइट्स

(1..-1|%{$i=$_;1..-1|%{"$i,$_"}})-ne'0,0'

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

सीमा के ऊपर डबल-लूप के लिए 1..-1, बाहरी प्रवेश को बाहर निकालने के लिए अंत में एक -nओटी eयोग्यता के साथ 0,0। वे प्रत्येक व्यक्तिगत रूप Write-outputसे पाइप लाइन पर छोड़ दिए गए हैं और कार्यक्रम पूरा होने पर निहित है , जो हमें मुफ्त में नई सुर्खियां देता है।

अफसोस की बात है, सिर्फ नंगे तारों स्ट्रिंग उत्पादन दो बाइट्स छोटा है:

'1,1
1,0
1,-1
0,1
0,-1
-1,1
-1,0
-1,-1'

लेकिन यह उबाऊ है।

— AdmBorkBork
स्रोत
3

जे , 18 16 बाइट्स

echo}.,{;~0 1 _1

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

— FrownyFrog
स्रोत
TIO में माइनस को अंडरस्कोर के रूप में क्यों दिखाया जाता है?
— मृत पोस्सम
18 बाइट्स विकल्प: echo }.>,{;~0 1 _1 टीआईओ
— गैलन इवानोव
@ डेड पॉसम नेगेटिव नंबरों को जे
— गैलेन इवानोव के साथ
1
हां, 17 :) echo}.>,{;~0 1 _1
— गैलेन इवानोव
2
की echoजरूरत है?
— कोल
3

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

3,:(2m*{2b},`

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

व्याख्या

3,    e# Range [0,3):       [0 1 2]
:(    e# Decrement each:    [-1 0 1]
2m*   e# Cartesian square:  [[-1 -1] [-1 0] [-1 1] [0 -1] [0 0] [0 1] [1 -1] [1 0] [1 1]]
{     e# Filter by
 2b   e#   conversion to binary:
},    e#                    [[-1 -1] [-1 0] [-1 1] [0 -1] [0 1] [1 -1] [1 0] [1 1]]
`     e# Stringify:         "[[-1 -1] [-1 0] [-1 1] [0 -1] [0 1] [1 -1] [1 0] [1 1]]"
— फल तोड़ना
स्रोत
3

Befunge-93 , 24 बाइट्स

11#v91090~9~19~<
9.._@#,

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

मुझे ऐसा लगता है कि यह चुनौती 2 डी भाषाओं से उत्तर याद कर रही है, भले ही अधिकांश तिरछे न हों। यह स्पेस अलग संख्याओं को आउटपुट करता है, प्रत्येक जोड़ी टैब द्वारा अलग होती है।

— मजाक कर रहा है
स्रोत
3

एफ # (मोनो) , 54 बाइट्स

let f=Seq.where((<>)(0,0))(Seq.allPairs[-1..1][-1..1])

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

44 बाइट्स - लाइकोनी के लिए धन्यवाद:

let f=Seq.tail(Seq.allPairs[0;-1;1][0;-1;1])
— हेनरिक हैनसेन
स्रोत
1
(0,0)पहला तत्व और कॉलिंग करके 44 बाइट्स Seq.tail: इसे ऑनलाइन आज़माएं!
— लैकोनी
3

MATL , 12 बाइट्स

3:qq2Z^[]5Y(

MATL ऑनलाइन पर यह कोशिश करो!

मेरा पहला गंभीर MATL उत्तर! मदद के लिए लुइस मेंडो , Sanchises और DJMcMayhem को बहुत धन्यवाद ।

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

3: qq2Z ^ [] 5Y (- पूरा कार्यक्रम। STDOUT को आउटपुट।
3: - रेंज 3. स्टैक में [1 2 3] दबाएं।
  qq - 2 से कमी। पैदावार [-1 0 1]।
    2Z ^ - 2 का कार्टेशियन पावर।
         5Y (- पंक्ति को अनुक्रमणिका 5 में बदलें ...
       [] - एक खाली वेक्टर।
— श्री एक्सकोडर
स्रोत
3

पर्ल 5 , 31 बाइट्स

map/1/&&say,<{-1,0,1},{-1,0,1}>

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

— डोम हेस्टिंग्स
स्रोत
-1..1ग्लोब में काम करेगा ?
— msh210
@ msh210 दुर्भाग्य से नहीं ... मैंने इसके साथ प्रयोग किया, और यह काम करता है bash, लेकिन पर्ल में नहीं :(
— डोम हेस्टिंग्स
3

बैश , 30 बाइट्स

echo "
"{-1..1},{-1..1}|grep 1

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

प्रत्येक पंक्ति पर एक अनुगामी स्थान प्रिंट करता है लेकिन अंतिम। ( @Neil के लिए धन्यवाद - यह मूल रूप से एक अग्रणी स्थान मुद्रित करता है, लेकिन उनकी टिप्पणी के अनुसार एक अनुगामी स्थान बेहतर है)

— डोम हेस्टिंग्स
स्रोत
मुझे लगता है कि आप एक विकल्प के रूप में सभी पर एक अंतिम स्थान प्रिंट कर सकते हैं।
— नील
2

बैच, 77 बाइट्स

@for %%x in (-1 0 1)do @for %%y in (-1 0 1)do @if not %%x%%y==00 echo %%x %%y

63 बाइट्स यदि एक अमानक विभाजक की अनुमति है:

@for %%x in (-1/-1 -1/0 -1/1 0/-1 0/1 1/-1 1/0 1/1)do @echo %%x
— नील
स्रोत
2

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

t^+U2_1 2

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

व्याख्या

t^+U2_1 2
  +U2_1     [0, 1, -1]
 ^      2   Product with itself.
t           Exclude the first.

समान रूप से, हम उपयोग कर सकते हैं t*J+U2_1J, लेकिन यह कोई छोटा नहीं है।

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