सीमाओं के बिना सही वर्ग

16

यह देखते हुए n=m^2, पूर्णांकों की एक सूची लौटाएँ, जो पूर्णांकों के m x mग्रिड की सीमा नहीं रखते हैं 1 to n।

उदाहरण

n = 1 (m = 1)

ग्रिड:

[1]

वापसी:

[]

n = 4 (एम = 2)

ग्रिड:

[1,2]
[3,4]

वापसी:

[]

n = 9 (एम = 3)

ग्रिड:

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

वापसी:

[5]

n = 16 (एम = 4)

ग्रिड:

[ 1, 2, 3, 4]
[ 5, 6, 7, 8]
[ 9,10,11,12]
[13,14,15,16]

वापसी:

[6,7,10,11]

के उच्च मूल्यों के लिए m, यह उत्तर एक महान दृश्य करता है।

नियम:

  • आप mया तो n(जहां n = m*m) ले सकते हैं ।
    • यदि आप में लेने के nलिए अपरिभाषित व्यवहार करने की अनुमति है, जहां (ईजी 15) के mलिए कोई मौजूद नहीं है n।
    • n > 0, m > 0: दोनों मूल्यों पूर्णांक होना चाहिए।
  • आउटपुट 1D / 2D सरणी, मैट्रिक्स या व्हाट्सएप सीमांकित के रूप में हो सकता है
  • आउटपुट कम से कम से सबसे बड़ा होना चाहिए।
    • यदि मैट्रिक्स के रूप में आउटपुट का अर्थ है कि यह ग्रिड में होगा जैसा होना चाहिए।
  • यह कोड-गोल्फ है , सबसे कम बाइट-काउंट जीतता है।
code-golf  matrix 
— जादू ऑक्टोपस Urn
स्रोत
मेरे अंत में पूरी गलती है, मैंने इसे गलत तरीके से पढ़ा।
— विकासशील विकासकर्ता
3
@DevelopingDeveloper अरे यार, अगर मेरे पास हर बार निकेल होता तो मैं एक बीयर या दो खरीद पाती।
— मैजिक ऑक्टोपस Urn
यदि 2D सरणी के रूप में आउटपुट किया जाता है, तो क्या परिणाम में एक भी खाली सरणी को शामिल किया जा सकता है?
— झबरा

जवाबों:

6

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

@(m)find((t=[0:m-2 0])'*t)

कोड एक अनाम फ़ंक्शन को परिभाषित करता है जो इनपुट करता है m और आउटपुट (संभवतः खाली) कॉलम वेक्टर को आउटपुट करता है।

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

व्याख्या

@(m)                          % Define anonymous function of m
          t=[0:m-2 0]         % Build row vector [0 1 2 ... m-2 0] and assign it
                              % to variable t
         (           )'       % Complex-conjugate transpose into a column vector
                       *t     % Matrix-multiply that column vector times the row
                              % vector t. This gives an m×m matrix with zeros in
                              % the border and nonzeros in the other entries.
    find(                )    % Linear indices of nonzero entries. The result is
                              % in increasing order
— लुइस मेंडो
स्रोत
5

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

’Ṗ×+€ṖḊ€

mसूचियों की सूची (आंतरिक पंक्तियों) को लेने और वापस करने वाला एक विचित्र लिंक ।

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

कैसे?

’Ṗ×+€ṖḊ€ - Link m                    e.g. 5
’        - decrement                      4
 Ṗ       - pop (implicit range of input)  [1,2,3]
  ×      - multiply by m                  [5,10,15]
     Ṗ   - pop m                          [1,2,3,4]
   +€    - add €ach                       [[6,7,8,9],[11,12,13,14],[16,17,18,19]]
      Ḋ€ - dequeue €ach                   [[7,8,9],[12,13,14],[17,18,19]]
— जोनाथन एलन
स्रोत
अजगर एक करने का मन नहीं था?)
— मैजिक ऑक्टोपस Urn
4

आर , 44 43 32 बाइट्स

function(n)(x=n:(n^2-n))[x%%n>1]

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

एक वेक्टर लौटाता है।

— ग्यूसेप
स्रोत
नीट आउटपुट स्वरूप, यह है कि डिफ़ॉल्ट रूप से आर में एक मैट्रिक्स कैसे आउटपुट है?
— मैजिक ऑक्टोपस Urn
1
हां, यह एक के लिए printकार्य है matrix।
— Giuseppe
1
आप दूसरे को छोड़ सकते हैं mमें matrix(1:m^2,m,m,T):matrix(1:m^2,m,,T)
— JAD
@ जद हां, बिल्कुल। धन्यवाद।
— ग्यूसेप
एक अच्छा, आप स्कैन () का उपयोग करने के बारे में क्या सोचते हैं? आप 2 बाइट्स बचा सकते हैं। इसे ऑनलाइन आज़माएं!
— रॉबर्ट हैकेन
3

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

sƽḊṖ$⁺€

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

— आउटगोल्फ को एरिक करें
स्रोत
mएक का उपयोग कर सकता है²s⁸ḊṖ$⁺€ । (मैंने एक अन्य mवैकल्पिक विधि भी पोस्ट की है ।)
— जोनाथन एलन
@JonathanAllan ने पहले ही यह पता लगा लिया था, लेकिन कोई भी बाइट वहां नहीं ⁸
— बचती है
3

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

k=>filter(u=>1<u%k,k..k*~-k)

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

मी इनपुट के रूप में लेता है ।

कैसे?

पूर्णांक को [k, k 2 -k) में फ़िल्टर करता है है, जब k द्वारा विभाजित किया जाता है , तो 1 से अधिक शेषफल प्राप्त होता है । यह सुनिश्चित करता है कि दोनों सिरों को छंटनी की जाती है, क्योंकि पहले एक उपज 0 और अंतिम एक पैदावार 1 होती है । किसी भी मान्य पूर्णांक के लिए एक उच्च मूल्य वापस करने की भी गारंटी है, क्योंकि वे लगातार हैं।

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

MATL , 8 बाइट्स

:G\1>&*f

इनपुट है m। आउटपुट बढ़ते क्रम में संख्या है।

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

व्याख्या

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

:     % Implicit input: m. Push range [1 2 ... m-1 m]
      % STACK: [1 2 3 4]
G\    % Modulo m, element-wise
      % STACK: [1 2 3 0]
1>    % Greater than 1, element-wise.
      % STACK: [0 1 1 0]
&*    % Matrix of pair-wise products
      % STACK: [0 0 0 0;
                0 1 1 0;
                0 1 1 0;
                0 0 0 0]
f     % Column vector of linear indices of nonzeros. Implicit display
      % STACK: [ 6;
                 7;
                10;
                11]
— लुइस मेंडो
स्रोत
2

बैच, 85 बाइट्स

@for /l %%i in (3,1,%1)do @for /l %%j in (3,1,%1)do @cmd/cset/a(%%i-2)*%1+%%j-1&echo(

मैं आसानी से से पाश नहीं कर सकते 2करने के लिए m-1से तो मैं पाश 3करने के लिए mऔर गणना में समायोजित करें।

— नील
स्रोत
2

जाप, 12 बाइट्स

मैंने इतने लंबे समय तक गोल्फ तत्वों की निकासी में समय बिताया है जो मैं समय से पहले सरणी पीढ़ी को गोल्फ के लिए चला गया था। मैं भी अब केवल यह देख रहा हूं कि हम nइसके बजाय इनपुट के रूप में ले सकते हैं ताकि मैं वहां कुछ बचा सकूं। पुनर्विचार करने के लिए ...

òUnU²)òU m¤c

कोशिश करो

व्याख्या

                 :Implicit input of integer U=m     :e.g., 4
   U²            :U squared                         :16
 Un              :Minus U                           :12
ò                :Range [U,U**2-U]                  :[4,5,6,7,8,9,10,11,12]
      òU         :Partitions of length U            :[[4,5,6,7],[8,9,10,11],[12]]
         m       :Map
          ¤      :  Remove first 2 elements         :[[6,7],[10,11],[]]
           c     :Flatten                           :[6,7,10,11]
— झबरा
स्रोत
2

जे , 23 19 बाइट्स

-4 बाइट्स FrownyFrog के लिए धन्यवाद!

1 1}:@}.-@%:}:\1+i.

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

मेरा मूल olution

जे , 23 बाइट्स

[:|:@}:@}.^:2-@%:]\1+i.

N को इनपुट के रूप में लेता है, एक मैट्रिक्स लौटाता है

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

1+i. - एक सूची बनाता है 1..n.

-@%: - n का वर्गमूल ढूँढता है और इसे (m) को ऋणात्मक बनाता है।

]\ - सूची से एक तालिका (मैट्रिक्स) mxm बनाता है

^:2 - निम्नलिखित दो बार करें:

|:@}:@}. - पहली पंक्ति छोड़ें, फिर अंतिम पंक्ति छोड़ें, फिर स्थानांतरित करें

[: - कांटा टोपी

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

— गैलेन इवानोव
स्रोत
1}:@}.-@%:}.@}:\1+i.
— FrownyFrog
1
नहीं,1 1}:@}.-@%:}:\1+i.
— FrownyFrog
@FrownyFrog - कूल, धन्यवाद! मैं सूची के बारे में नहीं जानता था}.
— गैलेन इवानोव
2

भूसी , 9 बाइट्स

‼ȯTthS↑CN

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

व्याख्या

‼ȯTthS↑CN  Implicit input, say m=4.
       CN  Cut the natural numbers by m: [[1,2,3,4],[5,6,7,8],[9,10,11,12],..
     S↑    Take first m lists: [[1,2,3,4],[5,6,7,8],[9,10,11,12],[13,14,15,16]]
‼ȯ         Do this twice:
    h       Remove last row,
   t        remove first row,
  T         transpose.
           Result is [[6,7],[10,11]]; print it implicitly.
— Zgarb
स्रोत
2

जाप , 14 बाइट्स

²õ òU ÅkJ ®ÅkJ

mइनपुट के रूप में लेता है

व्याख्या

 ²õ òU ÅkJ ®ÅkJ                                      
                // U = input                         | 3
U²              // U squared                         | 9
  õ             // Range [1...U²]                    | [1,2,3,4,5,6,7,8,9]
    òU          // Cut into slices of U              | [[1,2,3],[4,5,6],[7,8,9]]
       Å        // Remove the first item             | [[4,5,6],[7,8,9]]
        kJ      // Remove the last item              | [[4,5,6]]
           ®    // Map:                              |
            ÅkJ //   Remove the first and last items | 5

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

इसका समाधान nभी 14 बाइट्स है:

õ òU¬ ÅkJ ®ÅkJ

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

— ओलिवर
स्रोत
2

TI-BASIC, 44 43 बाइट्स (टोकन)

DC 4D 3F CE 4D 6D 32 3F CF 3F DE 2A 08 09 3F D0 3F 4D 71 32 3F 23 4D 70 32 70 58 70 32 B1 58 83 72 11 2B 58 2B 30 2B 72 0D 71 31

पठनीय संस्करण:

:Input M
:If M≤2
:Then
:Disp "{}
:Else
:M-2
:seq(M+2+X+2int(X/Ans),X,0,Ans²-1

दुर्भाग्य से खाली सूचियों को मैन्युअल रूप से प्रिंट करना आवश्यक था क्योंकि टीआई-बेसिक सामान्य रूप से इसकी अनुमति नहीं देता है। यदि mदो से अधिक दिए गए थे, तो कोड को केवल 29 बाइट्स तक कम किया जा सकता था ।

— fakedad
स्रोत
1

Pyt , 13 बाइट्स

ĐĐ⁻⁻ř*⇹⁻⁻ř⁺ɐ+

पोर्ट ऑफ जोनाथन एलन के जेली उत्तर

स्पष्टीकरण:

                    Implicit input (takes m)
ĐĐ                  Triplicate the input (push it on the stack two more times)
  ⁻⁻                Decrement top of stack twice
    ř               Push [1,2,...,m-2]
     *              Multiplies by m
      ⇹             Swaps top two items on stack
       ⁻⁻           Decrement (m-2 is now on top)
         ř          Push [1,2,...,m-2]
          ⁺         Increment each element by 1
           ɐ+       Add [2,3,...,m-1] to each element of [m,2m,...,m(m-2)]
                    Implicit print

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

— mudkip201
स्रोत
1

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

def f(s):
 r=[]
 for i in[i[1:-1]for i in[[(j*s)+i+1 for i in range(s)]for j in range(s)][1:-1]]:r+=i
 return r
— sonrad10
स्रोत
1

जावा 8 , 241 183 170 162 160 132 122 बाइट्स

j->{if(j<3)return new int[1];int e[]=new int[j*j-4*j+4],x=0,i=0;for(;++i<=j*j;)if(!(i<j|i>j*j-j|i%j<2))e[x++]=i;return e;}

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

जब आप कुछ "अज्ञात" आकार का एक सरणी बनाना होता है, तो जावा इसे बहुत कठिन (बहुत सारे बाइट्स) बनाता है।

  • -8 बाइट्स मैजिक ऑक्टोपस यूरन को धन्यवाद
  • -28 बाइट्स मिस्टर एक्सकोडर का धन्यवाद
  • -10 बाइट्स केविन क्रूज़सेन को धन्यवाद
— DevelopingDeveloper
स्रोत
1
इसके अलावा, हाँ, कोड-गोल्फ के लिए जावा मोटा है। लेकिन आप स्पष्ट रूप से अच्छे हैं। यार, आपको इस भाषा को देखने की ज़रूरत है जिसे Groovyमूल रूप से शॉर्टहैंड जावा कहा जाता है।
— मैजिक ऑक्टोपस Urn
2
इफ स्टेटमेंट और अतिरिक्त ट्रिक से एक अतिरिक्त स्थिति को हटाकर 132 बाइट्स ।
— मिस्टर एक्सकोडर
1
122 बाइट्स जारी है @ Mr.Xcoder के 132-बाइट संस्करण को जोड़कर int, बदलने, ||करने के लिए |और एकल-पंक्ति के कोष्ठक को हटाकर यदि शरीर।
— केविन क्रूज़सेन
1
— सीलिंग
हमारी साइट का प्रयोग करके, आप स्वीकार करते हैं कि आपने हमारी Cookie Policy और निजता नीति को पढ़ और समझा लिया है।
Licensed under cc by-sa 3.0 with attribution required.