सबसे कम बाइट्स में नीचे प्रारूप कैसे प्रिंट करें?

Question

_{इस चुनौती से प्रेरित है यह , अब नष्ट कर दिया सवाल।}

---

इनपुट के रूप में एक धनात्मक पूर्णांक N लें , और संख्या 1 .. N ^{2 के} साथ एक मैट्रिक्स आउटपुट करें जो निम्न पैटर्न का अनुसरण करता है:

पहली पंक्ति को 1 .. N के साथ भरें और फिर अंतिम पंक्ति (पंक्ति संख्या N ) को (N + 1) .. 2N के साथ भरें, फिर दूसरी पंक्ति को (2N + 1) के साथ भरें । 3N और तब तक जारी रखें जब तक आपने भरा नहीं है सभी पंक्तियों।

आउटपुट स्वरूप लचीला है, इसलिए सूची आदि की सूची स्वीकार की जाती है।

N = 1
1

N = 2
1  2
3  4

N = 3
1  2  3
7  8  9
4  5  6

N = 4
 1  2  3  4
 9 10 11 12
13 14 15 16
 5  6  7  8

N = 5
 1  2  3  4  5
11 12 13 14 15
21 22 23 24 25
16 17 18 19 20
 6  7  8  9 10

मानक नियम लागू होते हैं। प्रत्येक भाषा में बाइट्स में सबसे छोटा उत्तर जीतता है। स्पष्टीकरण हमेशा की तरह प्रोत्साहित किया जाता है।

Comments

क्या प्रविष्टियों को एक त्रुटि के साथ समाप्त करने की अनुमति है, जब तक कि त्रुटि STDOUT में मुद्रित नहीं होती है?

— सोक

@ हाँ, यह डिफ़ॉल्ट रूप से अनुमत है।

— मार्टिन एंडर

मुझे लगता है कि शीर्षक हटाए गए प्रश्न से लिया गया है, लेकिन जैसा कि यह बहुत खोज योग्य नहीं है (डुबकी लगाने के लिए आदि), क्या आप बेहतर तरीके से बदल सकते हैं?

— user202729

चूंकि "आउटपुट प्रारूप लचीला है", क्या मैं एक-आयामी सरणी को लाइन से लाइन के लिए आदेशित संख्याओं के साथ आउटपुट कर सकता हूं? (पूर्व 1 2 3 7 8 9 4 5 6:) है कि उत्पादन प्रारूप लचीला?

— ओलिवियर ग्रामेइरे

एपीएल समाधान शायद पुरानी फ़ारसी क्यूनिफॉर्म का एकल चरित्र है।

— मार्क

Answer 1

05AB1E , 13 8 बाइट्स

रॉड के लिए 5 बाइट्स सहेजे गए

nLô«āÉÏ

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

व्याख्या

n           # push input^2
 L          # push range [1 ... input^2]
  ô         # split into pieces each the size of the input
   «       # append the reverse of this 2D-list
     ā      # push range [1 ... len(list)]
      É     # check each element for oddness
       Ï    # keep only the elements in the 2D list which are true in this list

Answer 2

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

->n{r=*1..n*n;n.times{|x|p r.slice!(r[x*=n]?x:-n,n)}}

स्पष्टीकरण:

पहले सभी संख्याओं को एक एकल सरणी में रखें, फिर प्रत्येक पुनरावृत्ति के लिए एक पंक्ति को छोड़ते हुए सरणी को स्लाइस करें। पहली (n / 2 + n% 2) पुनरावृत्तियों के बाद छोड़ देने के लिए कुछ भी नहीं बचा है, फिर शेष सभी पंक्तियों को पीछे की ओर प्राप्त करें।

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

Answer 3

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

def f(n):a=range(n);print[[i*n-~j for j in a]for i in a[::2]+a[~(n%2)::-2]]

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

Answer 4

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

@ उपयोगकर्ता 71546 द्वारा घर में सहेजे गए 3 बाइट्स संपादित करें

पहले प्रयास करें, स्पष्ट मार्ग का अनुसरण करें: 1 से गिनती करें और बाहरी से आंतरिक तक दोनों तरफ से सरणी भरें

n=>(v=0,q=[...Array(n)]).map((_,i)=>q[i&1?--n:i/2]=q.map(_=>++v))&&q

परीक्षा

var F=
n=>(v=0,q=[...Array(n)]).map((_,i)=>q[i&1?--n:i/2]=q.map(_=>++v))&&q

function test() {
  var n=+N.value;
  O.innerHTML = '<tr><td>'
  +F(n).map(r=>r.join('</td><td>')).join('</td></tr><tr><td>')
  +'</td></tr>'
}

test()

#O { margin: 1em }
td { text-align: right }

<input id=N type=number min=1 value=5 oninput='test()'>
<table id=O>

Comments

70 बाइट्स ;)

— शायरु असाकोतो

@ user71546 अब 68

— edc65

Answer 5

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

(0#)
m#n|m>=n^2=[]|k<-m+n=[m+1..k]:(k+n)#n++[[k+1..k+n]|k<n^2]

इसे ऑनलाइन आज़माएं! आउटपुट सूचियों की एक सूची है, उदाहरण के लिए (0#) 3पैदावार [[1,2,3],[7,8,9],[4,5,6]]।

Answer 6

> <> , 51 + 3 = 54 47 बाइट्स

:&v
?!\1-:&:&*}}r:
 ~\
!~>1+::n&:&%:a84*@@?$~o?

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

-vझंडे का उपयोग करते हुए कार्यक्रम शुरू होने पर स्टैक के शीर्ष पर इनपुट की उम्मीद की जाती है । आउटपुट में सिंगल-स्पेस द्वारा अलग किए गए नॉन-एलाइन्ड नंबर होते हैं और हर लाइन को एक सिंगल न्यूलाइन द्वारा अलग किया जाता है। उदाहरण के लिए आउटपुट N=5:

1 2 3 4 5
11 12 13 14 15
21 22 23 24 25
16 17 18 19 20
6 7 8 9 10

... इसके बाद सिंगल न्यूलाइन। प्रोग्राम एक त्रुटि ( something smells fishy...) के साथ समाप्त होता है , लेकिन यह STDERR पर होता है, बल्कि STDOUT के बारे में।

explaination:

पहली पंक्ति Nमें रजिस्टर की एक प्रति है ।

दूसरी पंक्ति 1 से घटाकर प्रत्येक आउटपुट पंक्ति के लिए ऑफसेट का निर्माण करती Nहै N, इसे गुणा करके , इसे स्टैक के निचले हिस्से में घुमाती है और फिर पूरे स्टैक को उलट देती है। जब स्टैक के शीर्ष पर संख्या 0 तक पहुंच जाती है, तो स्टैक को इस तरह दिखना चाहिए (उदाहरण उपयोग करता है N=5):

5 15 20 10 0 0

तीसरी पंक्ति 0स्टैक के ऊपर से डुप्लिकेट को निकालती है।

चौथी पंक्ति स्टैक के शीर्ष को बढ़ाती है और इसकी एक प्रति उत्पन्न करती है। इसके बाद इसे लिया जाता है N, और इसका उपयोग यह तय करने के लिए किया जाता है कि क्या कोई स्थान या नई रेखा मुद्रित होनी चाहिए, और यदि स्टैक के शीर्ष को छोड़ दिया जाना चाहिए - यदि अंतिम संख्या मुद्रित है x, तो x mod N == 0इंगित करता है कि उस आउटपुट पंक्ति का अंत हो गया है । 1+समाप्ति स्टैक को समाप्त करने पर निष्कासन समाप्त होने पर निष्पादन समाप्त हो जाता है।

पुराना वर्जन

यह स्पष्ट रूप से निष्पादन को समाप्त करने के लिए एक खाली स्टैक के लिए जाँच की गई थी, और मैं -vध्वज उपयोग के लिए 3 बाइट्स भी शामिल था ।

:&v
?!\1-:&:&*}}r:
 ~\
!;>1+::n&:&%:a84*@@?$~o?!~l?

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

Comments

इस मेटा के अनुसार , हम अब झंडे को बाइट की संख्या में नहीं जोड़ते हैं इसलिए यह पर्याप्त है कि आप निर्दिष्ट करें कि ध्वज का उपयोग किया गया है।

— एमिग्ना

@Emigna O_O इसके लिए शुक्रिया अदा करता है! सिर के लिए धन्यवाद

— सोक

Answer 7

पर्ल 5 , -p 52 51 बाइट्स

#!/usr/bin/perl -p
map{$|--?$\="@0
".$\:say"@0";$_+=@0for@0}@0=1..$_}{

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

Answer 8

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

n->{int x[][]=new int[n][n],i=0,j;for(;i<n;i++)for(j=0;j<n;)x[i%2<1?i/2:n+~i/2][j]=++j+i*n;return x;}

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

क्रेडिट

• -4 बाइट्स केविन क्रूज़सेन को धन्यवाद ।

Comments

आप 102 बाइट्स की स्थिति को बदलकर तीन बाइट्स बचा सकते हैंj++

— केविन क्रूज़सेन

और एक और बाइट 101 बाइट्स में बदल रही n-i/2-1हैn+~i/2

— केविन क्रूज़सेन

@ केविनक्रूजसेन धन्यवाद! मैंने किसी तरह कच्चे संस्करण को पोस्ट किया, न कि पूरी तरह से गोल्फ वाले के रूप में। मेरी गलती, पहला मुद्दा था, लेकिन दूसरा नहीं। लेकिन आपने उन्हें लिखा है, इसलिए आपको श्रेय ;-)

— ओलिवियर ग्रैगोइरे

नोट: यदि किसी भी तरह एक आयामी सरणियों को स्वीकार किया जाता है,n->{int i=n*n,x[]=new int[i],r;for(;i-->0;x[(r%2<1?r/2:n+~r/2)*n+i%n]=i+1)r=i/n;return x;}

— ओलिवियर ग्रेजेइर

Answer 9

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

n=>[...Array(n)].map((_,i,a,j=((i*=2)<n?i:n+n+~i)*n)=>a.map(_=>++j))

इससे पहले कि मैं इसे पोस्ट कर सकता था, लेकिन यहाँ यह वैसे भी बढ़ गया है। संपादित करें: सहेजे गए 1 बाइट @KevinCruijssen को धन्यवाद।

Comments

n+n-i-1n+n+~i-1 बाइट के लिए हो सकता है , तो आप फिर से अन्य जावास्क्रिप्ट जवाब के साथ पैर की अंगुली कर रहे हैं। :)

— केविन क्रूज़सेन

@KevinCruijssen शानदार धन्यवाद!

— नील

Answer 10

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

²ss2Ṛj@/Fs

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

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

²ss2Ṛj@/Fs  Main link. Argument: n

²           Square; yield n².
 s          Split; promote n² to [1, ..., n²] and split it into chuks of length n.
  s2        Split 2; generate all non-overlapping pairs of chunks.
            If n is odd, this leaves a singleton array at the end.
    Ṛ       Reverse the order.
     j@/    Reduce by join with reversed arguments.
            In each step, this places the first and second element of the next pair
            at the top and bottom of the accumulator.
        Fs  Flatten and split to restore the matrix shape.

Answer 11

स्टैक्स , 10 बाइट्स

│æ╘▐⌡r▌═∟Y

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

एक ही कार्यक्रम के संबंधित ascii प्रतिनिधित्व 12 वर्ण है।

JRx/r{]+rFmJ

यहां देखिए यह कैसे काम करता है।

JR              range [1 .. x^2] where x=input
  x/            split into subarrays of size x
    r           reverse
     {   F      for each subarray, execute block
      ]+r       concat array, and reverse result
          m     for each row, output ...
           J        each subarray joined by spaces

Answer 12

जेली , 13 ... 6 बाइट्स

धन्यवाद जॉनथन -1 बाइट के लिए!

²sm0m2

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

---

05AB1E उत्तर के लिए एक समान एल्गोरिथ्म का उपयोग करें।

Comments

बायीं ओर की निहित सीमा के बाद से हटाकरR एक बाइट सहेजें s।

— जोनाथन एलन

Answer 13

आर , 70 59 47 बाइट्स

function(n)matrix(1:n^2,n,,T)[c(1:n,n:1)*!0:1,]

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

4 बाइट गोल्फ के लिए रॉबिन राइडर को धन्यवाद , जो मैंने फिर आगे गोल्फ किया।

एक मैट्रिक्स लौटाता है; matrixअनुक्रम में निर्माण , उदाहरण के लिए [[1 2 3] [4 5 6] [7 8 9]], फिर पंक्तियों को पुनर्व्यवस्थित करता है।

Comments

66 बाइट से बचें rbind।

— रॉबिन राइडर

@RobinRyder 59 बाइट्स - मोबाइल पर तो मैं इसे बाद में संपादित करूंगा

— Giuseppe

Answer 14

पायथन 2 , 72 68 63 बाइट्स

^{-4 बाइट्स नील को धन्यवाद}

def f(n):w=zip(*[iter(range(1,n*n+1))]*n);print(w+w[::-1])[::2]

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

Comments

मुझे लगता है कि आप मध्यवर्ती xचर को समाप्त करके 4 बाइट्स बचा सकते हैं ?

— नील

Answer 15

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

n=input('');A=B=vec2mat(1:n*n,n);i=j=0;do
B(++i,:)=A(++j,:);if++j<n
B(n-i+1,:)=A(j,:);end;until j>=n
B

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

Comments

अच्छा! मुझे नहीं पता था कि ऑक्टेव के पास एक untilकमान थी । और मैं इसके बारे में नहीं जानता vec2mat:( दुर्भाग्य से एक ही लंबाई A=B=vec2mat(1:(n=input(''))*n,n):( :

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

while j++<nयह भी बिल्कुल वैसी ही लंबाई है ... क्या आपने विभिन्न विकल्पों की कोशिश की है या वे सिर्फ संयोग हैं?

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

@StewieGriffin इस मामले में whileलूप समान लंबाई है, मैंने इसे दोनों तरीकों से आज़माया। अक्सर do ... untilएक बाइट से छोटा होता है while ... end, हालांकि।

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

Answer 16

सी (जीसीसी) , 110 बाइट्स

i,c,t,b;f(a,n)int*a;{for(b=n-1;i<n*n;t++,b--){for(c=0;c<n;)a[t*n+c++]=++i;for(c=0;c<n&i<n*n;)a[b*n+c++]=++i;}}

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

पंक्तियों के लिए 2 सूचकांकों के बीच बारी-बारी से एक सरणी को भरता है: एक सूचकांक शीर्ष पर शुरू होता है और एक नीचे से शुरू होता है। शीर्ष पंक्ति सूचकांक 0 से शुरू होता है और हर 2 पंक्तियों में वृद्धि होती है; निचला पंक्ति सूचकांक n-1 से शुरू होता है और हर 2 पंक्तियों में घटाया जाता है।

Ungolfed:

void f(int* a, int n)
{
    //i = value to be written [1,n]; c = column index; t = top row index; b = bottom row index
    for(int i=1, c=0, t=0, b=n-1;
        i <= n*n; //when i = n*n, we have written all the values and we're done
        t++, b--) //t increments every 2 rows, b decrements every 2 rows
    {
        //write out 2 rows per loop

        //first row: fill out row at t
        for(c=0; c<n; c++, i++)
            a[t*n+c]=i;

        //second row: fill out row at b
        //this step will be skipped on the final loop for odd values of n, hence the (i<=n*n) test
        for(c=0; c<n && i<=n*n; c++, i++) 
            a[b*n+c]=i;
    }
}

Answer 17

सी ++ + रेंज वी 3 , 159 बाइट्स

#include<range/v3/all.hpp>
using namespace ranges::view;

[](int n){auto r=iota(1,n*n+1)|chunk(n);return concat(r|stride(2),r|reverse|drop(n%2)|stride(2));}

वैंडबॉक्स पर लाइव

बाद में 2 नए अंक गिनना नहीं using namespace range::view; वे सिर्फ लैंबडा से आयात को अलग करने के लिए हैं।

हल्के से दिलचस्प तथ्य: यह समाधान कोई ढेर आवंटन नहीं करता है। यह O(1)अंतरिक्ष में समस्या को हल करता है ।

---

स्पष्टीकरण:

1. iota(1, n*n+1) -> [1 ... n*n]
2. chunk(n): हर nतत्व एक साथ, इसलिए[1 ... n] [n+1 ... 2*n] ...
3. उसको बुलाओ r
4. r | stride(2): हर दूसरे तत्व को लें: [1 ... n] [2*n+1...] ...
5. यह समझें कि:
6. r | reverse | drop(n % 2): रिवर्स, तब [1 ... n]शब्द को ड्रॉप करें यदि nविषम है (पंक्तियों की एक विषम संख्या होगी और हम केवल पहले शब्द को एक बार प्रिंट करना चाहते हैं)। ऐसा लगता है कि मुझे बस करने में सक्षम होना चाहिए r | reverse | take, लेकिन यह किसी कारण से काम नहीं करता है।
7. stride(2)फिर से, हर दूसरे तत्व को लें। इस समय यह उल्टा है।

अधिक पठनीय, और परीक्षण योग्य:

#include <range/v3/all.hpp>
using namespace ranges::view;

auto f(int n)
{
    auto rows = iota(1, n * n + 1)
        | chunk(n);
    return concat(
        rows | stride(2),
        rows
            | reverse
            | drop(n % 2)
            | stride(2));
}

#include <iostream>
int main(int argc, char** argv)
{
    std::cout << "N = " << argc << '\n';
    auto res = f(argc);

    for (auto const& row : res | bounded) {
        for (auto const& elem : row | bounded) {
            std::cout << elem << ' ';
        }
        std::cout << '\n';
    }
}

Comments

इनपुट को संग्रहीत करने के लिए ओ (लॉग (एन)), यदि बिट जटिलता में मापा जाता है।

— user202729

@ user202729 आपका क्या मतलब है, यह पता लगाएँ। क्या आप कह रहे हैं कि इनपुट के लिए int nमुझे log(n)बिट्स की जरूरत है ? लेकिन यह है कि इनपुट वैसे भी है, और हम intजहां sizeof(int) == 4(अधिकांश सिस्टम) के साथ काम कर रहे हैं , इसलिए यह इनपुट की परवाह किए बिना उपयोग किए जाने वाले बाइट्स की एक निरंतर संख्या है।

— जस्टिन

Answer 18

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

s2ZU2¦Ẏị²s$

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

Answer 19

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

ri__*,:)/2/z[1W].{%:p}

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

Answer 20

सी (जीसीसी) 80 78

मैं देख रहा हूं कि अब यह समाधान गलत है

i;f(n){for(i=0;i++<n*n;printf("\n%3d"+!!(~-i%n),i>n?n+(i+n>n*n?i%n?:n:i):i));}

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

Answer 21

C (gcc) , 36 + 8 + 61 = 105 बाइट्स

संकलन -Dp=printf("%d ",i),i++%n;);puts("") -Dq=i,n)

f(q{g(1,i);}g(q{for(;p;i<n*n&&h(q;}h(q{for(n+i<n*n&&g(n+q;p;}

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