मेरे लिए आउटपुट विकर्ण स्थिति

Question

एक संख्या को देखते हुए n, एक n*nवर्ग मैट्रिक्स के विकर्णों पर गिरने वाले 1-आधारित सूचकांकों की एक आदेशित सूची आउटपुट करें ।

उदाहरण:

के इनपुट के लिए 3:

वर्ग होगा:

1 2 3
4 5 6
7 8 9

अब हम सभी सूचकांकों का प्रतिनिधित्व करते हैं \, /या X( #या गैर-विकर्ण पदों को अस्वीकार कर दिया जाता है)

\ # /
# X #
/ # \

आउटपुट होगा:

[1,3,5,7,9]

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

1=>[1]
2=>[1,2,3,4]
3=>[1,3,5,7,9]
4=>[1,4,6,7,10,11,13,16]
5=>[1,5,7,9,13,17,19,21,25]

कोई स्वीकृत उत्तर नहीं होगा। मैं प्रत्येक भाषा के लिए सबसे छोटा कोड जानना चाहता हूं।

Comments

प्रश्न छवियों में से (1-अनुक्रमित) सूचकांक, /, और X वर्णों के लिए पूछ रहा है। प्रति प्रश्न बुरा नहीं है, लेकिन स्पष्टीकरण का अभाव है।

— अर्फि

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

— श्री एक्सकोडर

मैंने फिर से खोलने के लिए मतदान किया है, हालांकि आप असमंजस की छवियों को भ्रम से बचने के लिए उदाहरण क्षेत्र से बाहर ले जाना चाहते हैं। पहले तो मुझे यकीन नहीं था कि अगर मुझे भी उत्पादन करना है (लेकिन मैं समझता हूं कि वांछित उत्पादन केवल सूचकांकों की सूची है)

— Arfie

क्या आदेश मायने रखता है?

— श्री एक्सकोडर

FWIW मुझे लगता है कि आदेश अप्रासंगिक हो सकता है और अधिक दिलचस्प गोल्फ के लिए कर सकते हैं ...

— जोनाथन एलन

Answer 1

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

@(n)find((I=eye(n))+flip(I))

अनाम फ़ंक्शन जो किसी संख्या को इनपुट करता है और संख्याओं के एक स्तंभ वेक्टर को आउटपुट करता है।

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

Comments

इतना सरल ... :)

— स्टिव ग्रिफिन

Answer 2

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

स्ट्रिंग के रूप में पूर्णांकों की डैश-अलग-अलग सूची आउटपुट करता है।

f=(n,k=n*n)=>--k?f(n,k)+(k%~-n&&k%-~n?'':~k):'1'

प्रारूपित और टिप्पणी की गई

f = (n, k = n * n) => // given n and starting with k = n²
  --k ?               // decrement k; if it does not equal zero:
    f(n, k) + (       //   return the result of a recursive call followed by:
      k % ~-n &&      //     if both k % (n - 1) and
      k % -~n ?       //             k % (n + 1) are non-zero:
        ''            //       an empty string
      :               //     else:
        ~k            //       -(k + 1) (instantly coerced to a string)
    )                 //   end of iteration
  :                   // else:
    '1'               //   return '1' and stop recursion

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

f=(n,k=n*n)=>--k?f(n,k)+(k%~-n&&k%-~n?'':~k):'1'

;[1,2,3,4,5].forEach(n => console.log(n, '->', f(n)))

Comments

विभाजकों के रूप में संकेतों का उपयोग करते हुए, अच्छा वर्कअराउंड। क्या आप &एक बाइट को बचाने के लिए बिटवेई का उपयोग कर सकते हैं ?

— शैगी

@ शैगी नहीं, यह काम नहीं करेगा। उदाहरण के लिए: 4%3और 4%5सामान्य में कोई 1-बिट नहीं है, लेकिन दोनों गैर-शून्य हैं।

— अरनौलड

हाँ, बस के साथ यह परीक्षण किया n=5और देखा कि यह काम नहीं करेगा।

— झबरा

k%~-n&&k%-~nकार्य करना चाहिए। विभाजक के साथ अच्छी चाल!

— टाइटस

@ यह नहीं है कि यह वास्तव में मायने रखता है जब यह गोल्फ के लिए आता है लेकिन ... हाँ, यह थोड़ा अधिक पठनीय हो सकता है । :-) (अद्यतन)

— Arnauld

Answer 3

आर , 38 35 34 38 बाइट्स

whichफंक्शन के अस्तित्व के बारे में याद करते ही 3 बाइट्स बच गए ..., 1 बाइट @Rift की बदौलत बच गई

d=diag(n<-scan());which(d|d[n:1,])

तर्क के लिए +4 बाइट्स ec=T जब एक पूर्ण कार्यक्रम के रूप में कहा जाता हैsource()

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

स्पष्टीकरण:

n<-scan()            # take input
d=diag(n);           # create an identity matrix (ones on diagonal, zeros elsewhere)
d|d[n:1,]            # coerce d to logical and combine (OR) with a flipped version
which([d|d[n:1,]])   # Find indices for T values in the logical expression above

Comments

-1 बाइटd=diag(n<-scan());which(d|d[n:1,])

— Rift

जब इसे पूर्ण प्रोग्राम के रूप में चलाया जा रहा है ( source) यह कुछ भी प्रिंट नहीं करता है। आपको बुलाना पड़ेगा cat। इस पोस्ट को मेटा पर देखें ।

— JAD

@JarkoDubbeldam मेला काफी! मैंने हमेशा इस आधार पर काम किया था कि यह TIO पर मान्य आउटपुट देता है, कभी भी "पूर्ण कार्यक्रम" होने की आवश्यकताओं पर विचार नहीं किया।

— user2390246

हालांकि मैं वापस जाने और इसे ठीक करने के लिए अपने सभी पुराने उत्तरों को संपादित करने की योजना नहीं बना रहा हूं!

— user2390246

यह थोड़ा अस्पष्ट है, क्योंकि R और कोड स्निपेट के कंसोल वातावरण का उपयोग करने का मुख्य तरीका है। मुझे लगा कि मेटा थ्रेड पर अंतर्दृष्टि साझा करने के लिए स्वतंत्र महसूस करें। यह सब इतना इनपुट नहीं मिला है।

— JAD

Answer 4

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

⁼þ`+Ṛ$ẎT

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

अपने MATL उत्तर पर लुइस मेन्डो के एल्गोरिथ्म का उपयोग करता है।

Comments

मम, मैं काफी हैरान हूं कि आपने इसका इस्तेमाल नहीं किया ŒD।

— श्री एक्सकोडर

@ Mr.Xcoder ŒDएक विशिष्ट आकार के X से पूरी तरह से अलग कुछ करता है।

— आउटगॉल्फ

Answer 5

ऑक्टेव , 41 37 बाइट्स

यह MATLAB में भी काम करता है। कोई डरपोक ऑक्टेव विशिष्ट कार्यक्षमता :)

@(x)unique([x:x-1:x^2-1;1:x+1:x*x+1])

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

स्पष्टीकरण:

एक वर्ग मैट्रिक्स बनाने के बजाय, और दो विकर्णों को ढूंढें, मुझे लगा कि मैं इसके बजाय सीधे विकर्णों की गणना करता हूं। यह 17 बाइट्स छोटा था! =)

@(x)                                   % Anonymous function that takes 'x' as input
    unique(...                   ...)  % unique gives the unique elements, sorted
           [x:x-1:x^2-1                % The anti-diagonal (is that the correct word?)
                       ;               % New row
                        1:x+1:x*x+1])  % The regular diagonal

यह ऐसा है, जैसा दिखता है, बिना unique:

ans =    
    6   11   16   21   26   31
    1    8   15   22   29   36

_{हां, मुझे शायद इसे और अधिक मानव-अनुकूल बनाने के लिए विकर्णों के आदेश को छोड़ देना चाहिए था।}

Answer 6

MATL , 6 बाइट्स

XytP+f

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

व्याख्या

मेरे ऑक्टेव जवाब के रूप में एक ही दृष्टिकोण।

3उदाहरण के रूप में इनपुट पर विचार करें ।

Xy   % Implicit input. Identity matrix of that size
     % STACK: [1 0 0;
               0 1 0;
               0 0 1]
t    % Duplicate
     % STACK: [1 0 0
               0 1 0
               0 0 1],
              [1 0 0
               0 1 0
               0 0 1]
P    % Flip vertically
     % STACK: [1 0 0
               0 1 0
               0 0 1],
              [0 0 1
               0 1 0
               1 0 0]
+    % Add
     % STACK: [1 0 1
               0 2 0
               1 0 1]
f    % Linear indices of nonzero entries. Implicit display  
     % STACK:[1; 3; 5; 7; 9]

रैखिक अनुक्रमण स्तंभ-प्रमुख है , 1-आधारित। अधिक जानकारी के लिए लंबाई-12 झलकी को देखने के लिए यहाँ ।

Comments

"संक्रमण" का क्या अर्थ है?

— आउटगॉल्फ

@EriktheOutgolfer क्षमा करें, मेरा बुरा। tडुप्लिकेट है, ट्रांज़ोज़ नहीं। इसके अलावा, मैंने एक काम किया उदाहरण भी जोड़ा है

— लुइस मेंडो

गजब का! अगर मुझे यह पूरा करना है तो मुझे दो लूप लेने होंगे।

— mr5

@LuisMendo मुझे इस पर संदेह था, क्योंकि एक पहचान मैट्रिक्स को ट्रांसप्लांट करने से कोई मतलब नहीं है ... हम्म, मैं आपके एल्गोरिथ्म के साथ एक बाइट को बचाने में कामयाब रहा।

— को आउटगोल्फर एरिक

Answer 7

पायथन 2 , 54 53 बाइट्स

lambda n:[i+1for i in range(n*n)if i%-~n<1or i%~-n<1]

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

Answer 8

ऑक्टेव, 68 54 बाइट्स

14 बाइट बचाने के लिए @Stewie ग्रिफिन को धन्यवाद!

@(x)unique([diag(m=reshape(1:x^2,x,x)),diag(flip(m))])

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

MATLAB, 68 बाइट्स

x=input('');m=reshape([1:x*x],x,x);unique([diag(m) diag(flipud(m))])

स्पष्टीकरण:

@(x)                               % Anonymous function
m=reshape([1:x*x],x,x);            % Create a vector from 1 to x^2 and
                                   % reshape it into an x*x matrix.
diag(m)                            % Find the values on the diagonal.
diag(flip(m))                      % Flip the matrix upside down and
                                   % find the values on the diagonal.
unique([])                         % Place the values from both diagonals
                                   % into a vector and remove duplicates.

Comments

@LuisMendo धन्यवाद, जिमी मेरा पसंदीदा है।

— स्टेडीबॉक्स

Answer 9

गणितज्ञ, 42 बाइट्स

Union@Flatten@Table[{i,#+1-i}+i#-#,{i,#}]&

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

@ केलीलॉडर ने इसे नीचे गिरा दिया।

गणितज्ञ, 37 बाइट्स

##&@@@Table[{i-#,1-i}+i#,{i,#}]⋃{}&

और @alephalpha ने मेज को फेंक दिया!

गणितज्ञ, 34 बाइट्स

Union@@Range[{1,#},#^2,{#+1,#-1}]&

Comments

##&@@@Table[{i-#,1-i}+i#,{i,#}]⋃{}& 5 बाइट्स छोटी है

— केली लोडर

Union@@Range[{1,#},#^2,{#+1,#-1}]&

— alephalpha

Answer 10

प्रोटॉन , 41 बाइट्स

n=>[i+1for i:0..n*n if!(i%-~n)or!(i%~-n)]

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

Answer 11

MATL , 14 बाइट्स

U:GeGXytPY|*Xz

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

Comments

6 बाइट्स

— लुइस मेंडो

वाह! कृपया इसे पोस्ट करें, मैं अंततः मेरा डिलीट कर दूंगा

— सिनेस्की

यदि आप इसे अपने उत्तर में शामिल नहीं करने जा रहे हैं तो मैं इसे पोस्ट करूंगा; लेकिन आपको हटाने की कोई आवश्यकता नहीं है

— लुइस मेंडो

Answer 12

सी (जीसीसी) , 65 58 बाइट्स

टाइटस को -7 बाइट्स धन्यवाद!

f(n,i){for(i=0;i<n*n;i++)i%-~n&&i%~-n||printf("%d ",i+1);}

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

Comments

i%-~n&&i%~-n||printf("%d ",i+1)(-7 बाइट्स)

— टाइटस

Answer 13

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

f=>{var s="[";for(int i=0;i<n*n-1;)s+=i%-~n<1|i++%~-n<1?i+",":"";return s+n*n+"]";}

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

यहां परिवर्तन संख्याओं को खोजने के बीच बदलाव पर आधारित है। 0 पर शुरू होने वाली दो शिफ्ट हैं n-1और n+1इसलिए n=5, यदि , के लिए संख्या n-1होगी 0,4,8,12,16,20और n+1होगी 0,6,12,18,24। इन्हें मिलाकर 1-इंडेक्सिंग (0-इंडेक्सिंग के बजाय) देता है 1,5,7,9,13,17,19,21,25। nबिटवाइस निगेटिव (बिटवाइज सप्लीमेंट ऑपरेशन), जहां ~-n==n-1और का उपयोग कर से ऑफसेट प्राप्त किया जाता है -~n==n+1।

पुराना संस्करण

f=>{var s="[";for(int i=0;i<n*n-1;i++)s+=(i/n!=i%n&&n-1-i/n!=i%n?"":i+1+",");return s+$"{n*n}]";}

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

यह दृष्टिकोण यह निर्धारित करने के लिए स्तंभ और पंक्ति सूचकांकों का उपयोग करता है कि क्या संख्या विकर्णों पर है। i/nपंक्ति सूचकांक i%nदेता है , और स्तंभ सूचकांक देता है।

केवल संख्या सरणी वापस करना

यदि केवल संख्या सरणी का निर्माण बाइट लागत की ओर गिना जाता है, तो डेनिस.विरवाइज के सुझाव के आधार पर निम्नलिखित कार्य किए जा सकते हैं (using System.Linq; अतिरिक्त 18 बाइट्स जोड़ता है) के हैं:

सी # (.NET कोर) , 66 + 18 = 84 बाइट्स

x=>Enumerable.Range(1,x*x).Where(v=>~-v%~-x<1|~-v%-~x<1).ToArray()

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

Comments

आप अतिरिक्त से छुटकारा पाकर कोड को कम कर सकते हैं &। &यदि केवल पहला इनपुट गलत है तो तुलना को तोड़ने के लिए अतिरिक्त MSDN है

— Dennis.Verweij

वास्तव में आप लाइनक का उपयोग करके 92 बाइट्स कर सकते हैं इसे ऑनलाइन आज़माएं!

— डेनिस.वीरवीज

@ डेनिस.वीरवीज नीट, मुझे यकीन नहीं था कि मैं TIO में हेडर या फुटर में कितना बदलाव कर सकता हूं। मेरा मेरे साथ एक नाटक होगा।

— Ayb4btu 20

आपको linq के संदर्भ के लिए 18 बाइट्स को शामिल करना याद रखना होगा (System.Linq का उपयोग करके?) जो दुर्भाग्यपूर्ण है, लेकिन यह कैसे काम करता है: S

— Dennis.Verweij

आह अच्छा। लेकिन यह आवश्यक नहीं है using System;? (मुझे लगता है कि यह एक namespace System.Linqवैध नहीं है लपेटकर ?)

— Ayb4btu

Answer 14

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

पुराना संस्करण

n=>[...Array(y=n*n).keys(),y].filter(x=>(--x/n|0)==x%n||(x/n|0)==n-x%n-1)

@ बग्घी की बदौलत 10 बाइट्स बचाए

n=>[...Array(n*n)].map((_,y)=>y+1).filter(x=>!(--x%-~n&&x%~-n))

पहली बार गोल्फ! यहाँ उम्मीद है कि मैं बहुत बुरी तरह से गड़बड़ नहीं था।

let f=n=>[...Array(n*n)].map((_,y)=>y+1).filter(x=>!(--x%-~n&&x%~-n));
[1,2,3,4,5].forEach(n=>console.log(f(n)))

Comments

PPCG में आपका स्वागत है :) मैं जिस पर काम कर रहा था उसका एक समान समाधान (केवल मेरा 0-अनुक्रमित है)। आप अपने filterफ़ंक्शन में निम्नलिखित का उपयोग करके कुछ बाइट्स को बचाने में सक्षम हो सकते हैं : !(--x%(n+1)&&x%(n-1))और अपनी सरणी को इस तरह से बनाकर:[...Array(n*n+1).keys()]

— झबरा

@ शगुन शुक्रिया! जैसे ही मुझे काम से घर मिलेगा, मैं आपके सुझाव के साथ उत्तर को बेहतर बनाने की कोशिश करूँगा!

— मार्को लेपोर

आपका स्वागत है। वैसे: " यह एक [1...n*n]सीमा बनाने के मुकाबले थोड़ा कम हैArray(n*n).fill().map((x,i)=>i+1) " - [...Array(n*n)].map((_,y)=>y+1)भविष्य में संदर्भ के लिए, ऐसा करने का एक छोटा तरीका है।

— झबरा

इसके साथ थोड़ा और किया और 56 बाइट्स के लिए इसे समाप्त किया:n=>[...Array(n*n+1).keys()].filter(x=>!(--x%-~n&&x%~-n))

— Shaggy

@ शैग्गी मैंने आपके अंतिम संस्करण की कोशिश की लेकिन यह f (1) और f (2) के लिए एक अतिरिक्त शून्य आउटपुट करेगा, यह एक [1 ... n * n] श्रेणी के साथ काम करता है, हालांकि मैंने जिस तरह से आपने मुझे दिखाया पिछली टिप्पणी। या शायद मैंने किसी को गड़बड़ कर दिया?

— मार्को लेपोर

Answer 15

पायथ , 20 18 बाइट्स

^{( यहाँ प्रारंभिक संस्करण है ।)}

hMf|<%ThQ1<%TtQ1U*

परीक्षण सूट।

पायथ , 18 बाइट्स

hMf>1*%ThQ%T|tQ1U*

परीक्षण सूट।

Answer 16

पर्ल 5 , 56 + 1 (एन) = 57 बाइट्स

!(($_+1+$_/$,)%$,&&$_%($,+1))&&say++$_ for 0..($,=$_)**2

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

Comments

क्या `-n` को +3 नहीं होना चाहिए?

— सेरगिओल

सं। कमांड लाइन है perl -e। इस उदाहरण के लिए कमांड लाइन होगी perl -ne। यह +1 का अंतर है।

— Xcali

Answer 17

जावा (ओपनजेडके 8) , 71 बाइट्स

n->{for(int i=0;i<n*n;i++)if(i%-~n<1||i%~-n<1)System.out.println(i+1);}

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

स्कॉचनेट के उत्तर का पोर्ट ।

Answer 18

Japt , 16 बाइट्स

इससे बेहतर करने के लिए प्रतीत नहीं कर सकते, लेकिन मुझे यकीन है कि यह संभव है। 1-अनुक्रमण का उपयोग करने वाली अनावश्यक आवश्यकता के लिए 2 बाइट्स का त्याग करना पड़ा।

²õ f@´XvUÉ ªXvUÄ

झसे आज़माओ

Answer 19

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

@(n)find((m=abs(--n:-2:-n))==m')

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

Answer 20

PHP, 56 54 + 1 बाइट्स

-Rझंडे के लिए +1 बाइट

for(;$z**.5<$n=$argn;$z++)$z%-~$n&&$z%~-$n||print~+$z;

प्रिंट की संख्या डैश द्वारा पूर्वनिर्मित है। ऑनलाइन के साथ पाइप के रूप में चलाएं -nRया इसे आज़माएं ।

**ऑपरेटर के लिए PHP 5.6 या बाद के संस्करण की आवश्यकता है ।
पुराने PHP के लिए एक बाइट जोड़ें: बदलें ;$z**.5<$n=$argnसाथ $z=$argn;$z<$n*$n।

Answer 21

रूबी, 45 बाइट्स

->n{(n*n).times{|i|i%-~n>0&&i%~-n>0||p(i+1)}}

आंतरिक रूप से शून्य अनुक्रमित के रूप में काम करता है। अगर iमॉडुलो n+1या n-10 है, तो प्रिंट करता है i+1।