रिवर्स रेंज उत्तराधिकारी

Question

एक सकारात्मक पूर्णांक को देखते हुए n, निम्नलिखित करें (और हर चरण में आउटपुट करें):

1. की nप्रतियों वाली सूची के साथ शुरू करें n।
2. निम्न nबार करें:
3. पर iवें कदम है, धीरे-धीरे घटती iसूची की प्रविष्टि वें जब तक यह तक पहुँचता हैi

तो, उदाहरण के लिए, अगर दिया nहै 4, तो आप के साथ शुरू [4,4,4,4]में पहला कदम तुम हो पर, और फिर [3,4,4,4], [2,4,4,4], [1,4,4,4]। दूसरे चरण में, आप है [1,3,4,4], [1,2,4,4]। आपके पास तीसरे चरण में [1,2,3,4]। चौथे चरण पर कुछ भी नहीं किया जाता है।

तो अपने उत्पादन होता है [[4,4,4,4],[3,4,4,4],[2,4,4,4],[1,4,4,4],[1,3,4,4],[1,2,4,4],[1,2,3,4]]।

---

किसी भी उचित इनपुट / आउटपुट प्रारूप की अनुमति है।

---

मानक खामियां लागू होती हैं। यह कोड-गोल्फ है : सबसे छोटी बाइट-काउंट जीत के साथ उत्तर।

---

प्रयोजनों की जाँच के लिए पायथन कार्यान्वयन ।

Comments

आप स्पष्ट रूप से बताना चाह सकते हैं कि iवें हमेशा 1-अनुक्रमित होता है।

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

क्या हमें वास्तव में सरणी में हेरफेर करना है? मुझे किसी भी सरणी में हेरफेर किए बिना एक स्वीकार्य उत्तर मिलता है, जो एक स्वीकार्य आउटपुट का उत्पादन करता है।

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

@ OlivierGrégoire आपको चरणों का पालन करने की आवश्यकता नहीं है, आपको बस एक उचित प्रारूप में आउटपुट का उत्पादन करने की आवश्यकता है। (यानी आगे बढ़ो)

— लीक नन

Answer 1

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

r€⁸Œp»\QṚ

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

कैसे?

r€⁸Œp»\QṚ - Link: integer, N    e.g. 4
 €        - for €ach of implicit range of N (i.e. for i in [1,2,3,...N])
  ⁸       -   with the chain's left argument, N on the right:
r         -     inclusive range (for i<=N this yields [i, i+1, ..., N]
          - ...leaving us with a list of lists like the post-fixes of [1,2,3,....,N]
          -                     e.g. [[1,2,3,4],[2,3,4],[3,4],[4]]
   Œp     - Cartesian product* of these N lists
          -                     e.g. [[1,2,3,4],[1,2,4,4],[1,3,3,4],[1,3,4,4],[1,4,3,4],[1,4,4,4],[2,2,3,4],[2,2,4,4],[2,3,3,4],[2,3,4,4],[2,4,3,4],[2,4,4,4],[3,2,3,4],[3,2,4,4],[3,3,3,4],[3,3,4,4],[3,4,3,4],[3,4,4,4],[4,2,3,4],[4,2,4,4],[4,3,3,4],[4,3,4,4],[4,4,3,4],[4,4,4,4]]
      \   - cumulative reduce with:
     »    -   maximum (vectorises)
          -                     e.g. [[1,2,3,4],[1,2,4,4],[1,3,4,4],[1,3,4,4],[1,4,4,4],[1,4,4,4],[2,4,4,4],[2,4,4,4],[2,4,4,4],[2,4,4,4],[2,4,4,4],[2,4,4,4],[3,4,4,4],[3,4,4,4],[3,4,4,4],[3,4,4,4],[3,4,4,4],[3,4,4,4],[4,4,4,4],[4,4,4,4],[4,4,4,4],[4,4,4,4],[4,4,4,4],[4,4,4,4]]
       Q  - de-duplicate        e.g. [[1,2,3,4],[1,2,4,4],[1,3,4,4],[1,4,4,4],[2,4,4,4],[3,4,4,4],[4,4,4,4]]
        Ṛ - reverse             e.g. [[4,4,4,4],[3,4,4,4],[2,4,4,4],[1,4,4,4],[1,3,4,4],[1,2,4,4],[1,2,3,4]]

* यह देखना आसान हो सकता है कि कार्टेसियन उत्पाद के साथ एक अलग इनपुट के साथ क्या हो रहा है:

the Cartesian product of [[0,1,2],[3,4],[5]]
is [[0,3,5],[0,4,5],[1,3,5],[1,4,5],[2,3,5],[2,4,5]]

Comments

आपने अन-आउटगोल्फ-समर्थ को पछाड़ दिया।

— लीक नन

Answer 2

आर , 83 82 74 बाइट्स

N=rep(n<-scan(),n);while({print(N);any(K<-N>1:n)})N[x]=N[x<-which(K)[1]]-1

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

डबल-लूप के बजाय, एक whileलूप यहां पर्याप्त है: हम पहला इंडेक्स पाते हैं जहां सूची इंडेक्स से अधिक है, और वहां डिक्रिप्ट।

Kहै TRUEजहाँ भी N[i]>i, which(K)रिटर्न सच सूचकांक, और हम के साथ पहली बार ले [1]।

Answer 3

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

R‘®¦<³S©$пṚ

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

Comments

रजिस्टर के बिना 13 बाइट्स: इसे ऑनलाइन आज़माएं!

— user202729

Answer 4

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

f=(n,a=Array(n).fill(n))=>[[...a],...a.some(v=>v>++j,j=0)?f(a[j-1]--,a):[]]

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

Answer 5

एपीएल + विन, 54 बाइट्स

पूर्णांक के स्क्रीन इनपुट के लिए संकेत

((⍴m)⍴n)-+⍀m←0⍪(-0,+\⌽⍳n-1)⊖((+/+/m),n)↑m←⊖(⍳n)∘.>⍳n←⎕

4 के लिए प्रत्येक चरण के परिणाम का प्रतिनिधित्व करने वाली प्रत्येक पंक्ति के साथ एक मैट्रिक्स आउटपुट:

4 4 4 4
3 4 4 4
2 4 4 4
1 4 4 4
1 3 4 4
1 2 4 4
1 2 3 4

Answer 6

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

x`’Jḟḣ1Ʋ¦ÐĿ

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

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

x`’Jḟḣ1Ʋ¦ÐĿ  Main link. Argument: n

x`           Repeat self; yield an array of n copies of n.
         ÐĿ  While the results are unique, repeatedly call the link to the left.
             Return the array of all unique results, including the initial value.
  ’     ¦      Decrement the return value at all indices specified by the chain
               in between.
       Ʋ         Combine the four links to the left into a monadic chain.
   J               Indices; yield [1, ..., n].
    ḟ              Filterfalse; remove all indices that belong to the return value.
     ḣ1            Head 1; truncate the result to length 1.

Answer 7

पायथन 3 , 91 बाइट्स

n=int(input())
x=[n]*n;print(x)
for i in range(n):
    for j in[0]*(n-i-1):x[i]-=1;print(x)

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

Comments

1 स्थान अजगर में कोड को इंडेंट करने के लिए पर्याप्त है। अनावश्यक स्थानों को हटाने और अजगर 2 पर स्विच करने से 10 बाइट्स बचते हैं: इसे देखें

— डेड पोसुम

@DeadPossum, भले ही मुझे पता है कि मैं पायथन 2 में बेहतर कर सकता हूं, जल्द ही यह अप्रचलित होने वाला है इसलिए मैं अपने पायथन 3 कौशल का यथासंभव अभ्यास करना चाहता था।

— डेट

Answer 8

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

a->{int r[]=new int[a],i=0;java.util.Arrays x=null;x.fill(r,a);for(r[0]++;i<a;r[i++]++)for(;--r[i]>i;System.out.print(x.toString(r)));}

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

स्पष्टीकरण:

int r[]=new int[a],i=0;    //Initialize array and loop counter
java.util.Arrays x=null;    //reduces the number of of “Arrays” needed from 3 to 1
x.fill(r,a);    //Sets each value in array length n to int n
for(r[0]++;i<a;r[i++]++)    //Increment everything!
  for(;--r[i]>i;    //If decremented array element is larger than element number:
     System.out.print(x.toString(r)));}    //Print the array

क्रेडिट:

-8 बाइट्स जोनाथन फ्रेच को धन्यवाद !

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

ओकेक्स के लिए -1 बाइट !

Comments

import java.util.*;बाइट गिनती मुझे डर लग रहा का हिस्सा है। और @ जोनाथनफ्रेच के कोड को 4 और बाइट्स के ,i=0बाद और बाद में r[]बदलकर गोल्फ किया जा सकता <-~aहै <=a। ( यह ऑनलाइन की कोशिश करो। 144 बाइट्स ) (और मैं बदल ~-iकरने के लिए i-1इसे और अधिक पठनीय बनाने के लिए ..)

— केविन Cruijssen

139 बाइट्स से छुटकारा पाने import java.util.*;का उपयोग करके java.util.Arrays x=null;और x.fillऔर x.toString। (ध्यान दें कि आपका वर्तमान समाधान आवश्यक के साथ 155 बाइट्स हैimport java.util.*;।)

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

के for(;r[i-1]>i;बजाय का उपयोग करके एक बाइट गोल्फ for(;r[i-1]!=i;।

— ओकेक्स

@ केविनक्रूजसेन एक और बाइट को गोल्फिंग द्वारा बचाया जा सकता ++i<=aहै i++<a।

— जोनाथन फ्रीच

एक और -2 बाइट अंतिम भाग को बदलकर for(r[0]++;i<a;r[i++]++)for(;--r[i]>i;System.out.print(x.toString(r)));। :) यह ऑनलाइन प्रयास करें 135 बाइट्स

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

Answer 9

हास्केल, 69 67 65 63 बाइट्स

पुनरावर्ती परिभाषा:

f 0=[[]]
f a=map(:(a<$[2..a]))[a,a-1..2]++[1:map(+1)x|x<-f$a-1]

2 बाइट्स के लिए लकोनी का धन्यवाद!

Comments

दूसरा mapदो बाइट्स है जो एक सूची समझ के साथ छोटा है: इसे ऑनलाइन आज़माएं!

— लकोनी

Answer 10

PHP, 153 बाइट्स

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

कोड

function f($n){
$a=array_fill(0,$n,$n);$r=json_encode($a)."\n";$p=0;while($p<$n)
{if($a[$p]!=$p+1){$a[$p]--;$r.=json_encode($a)."\n";}else{$p++;}}echo$r;}

गया बाइट्स को कम करने या पुनरावर्ती फ़ंक्शन को पूरा करने का प्रयास करें

व्याख्या

function f($n){
  $a=array_fill(0,$n,$n);          #start with $nlength array filled with $n
  $r=json_encode($a)."\n";         #pushed to the string to output
  $p=0;                            #first position
  while($p<$n){                    #on position $n ($n-1) we do nothing
    if($a[$p]!=$p+1){              #comparing the position+1 to the value
     $a[$p]--;                     #it gets decreased by 1
     $r.= json_encode($a)."\n";    #and pushed
   } else {
     $p++;                       #when position+1 = the value,
   }                               #position is changed ++
  }
   echo $r;
  }

Comments

ऐसा लगता है कि आपके पास कुछ अनावश्यक व्हाट्सएप है, इसलिए यह 153 बाइट्स होना चाहिए - ध्यान दें कि मुझे PHP नहीं पता है।

— Giuseppe

हाँ, बस एहसास, धन्यवाद, संपादन अब।

— फ्रांसिस्को हैन

Answer 11

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

i=input();l=[i]*i;print l
for x in range(i):
 while l[x]>x+1:l[x]-=1;print l

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

थोड़ा बेकार दो printबयानों लेकिन मैं इस समय एक बेहतर तरीका के बारे में सोच भी नहीं सकते।

Comments

75 बाइट्स ।

— जोनाथन फ्रीच

Answer 12

अजगर २ , 70 बाइट्स

-2 बाइट्स का शुक्रिया @LeakyNun
-2 बाइट्स का शुक्रिया @JonathanFrech को

i=I=input()
l=[I]*I
exec"exec'print l;l[-i]-=1;'*max(~-i,2);i-=1;"*~-I

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

Comments

(I-1)->~-I

— लीक नन

70 बाइट्स , आरंभीकरण i=Iऔर अपघटन।

— जोनाथन फ्रीच

Answer 13

जावा (JDK 10) , 112 बाइट्स

n->{var s="";for(int i=1,k=n,j;i<=n;k=--k>i?k:n-++i+i)for(j=0;j++<n;)s+=(j<i?j:j>i?n:k)+(j<n?",":";");return s;}

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

Answer 14

जे , 17 15 बाइट्स

+/\@,(#=)@i.&.-

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

व्याख्या

+/\@,(#=)@i.&.-  Input: n
              -  Negate n
          i.     Reverse of range [0, n)
       =           Identity matrix of order n
      #            Copy each row by the reverse range
              -  Negate
    ,            Prepend n
+/\              Cumulative sum of rows

Answer 15

रेटिना , 49 बाइट्स

.+
*
_
$`_,$= 
.{*\`_+,(_+)
$.1
0`(\b(_+),\2)_
$1

इसे ऑनलाइन आज़माएं! स्पष्टीकरण:

.+
*

इनपुट को unary में बदलें।

_
$`_,$= 

i,nजहाँ पर n प्रतियों की सूची बनाएँi अनुक्रमणिका है ।

.

कुछ भी प्रिंट न करें (जब लूप पूरा हो जाए)।

{

जब तक पैटर्न नहीं बदलता है तब तक लूप करें।

*\`_+,(_+)
$.1

अस्थायी रूप से is हटाएं और कनवर्ट करेंn s को दशमलव और आउटपुट में बदल दें।

0`(\b(_+),\2)_
$1

पहली सूची प्रविष्टि लें जिसका मूल्य इसके सूचकांक से अधिक है और इसे घटाता है।

Answer 16

पायथन 3 , 70 67 65 बाइट्स

def f(n):
 k=0;a=[n]*n
 while k<n-1:print(a);k+=a[k]==k+1;a[k]-=1

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

• (67) कार्य करने के लिए परिवर्तित: -3 बाइट्स
• (65) अनावश्यक कोष्ठकों को हटाना: -2 बाइट्स

Ungolfed संस्करण:

def f(n):
    k = 0
    a = [n] * n             # create n-item list with all n's
    while k < n - 1:        # iterate through columns 0..n-1
        print(a)            # print whole list
        if a[k] == k + 1:   # move to the next column when current item reaches k+1
            k += 1
        a[k] -= 1           # decrement current item

Answer 17

सी (क्लैंग) , 131 141 बाइट्स

i,j,k,m[99];p(){for(k=0;m[k];printf("%d ",m[k++]));puts("");}f(n){for(j=k=m[n]=0;k<n;m[k++]=n);p();for(;j<n;j++)for(i=1;i++<n-j;m[j]--,p());}

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

यह सभी n99 तक काम करेगा । TIO ट्रंकट्स आउटपुट। यह nसरणी के आकार को बदलकर मनमाने ढंग से बड़ा समर्थन कर सकता हैm मेमोरी परमिट के रूप ।

---

निम्नलिखित n = 1..9 तक सीमित है, लेकिन काफी कम है

सी (क्लैंग) , 89 92 बाइट्स

i,j;char m[12];f(n){j=!puts(memset(m,n+48,n));for(;j<n;j++)for(i=1;i++<n-j;m[j]--,puts(m));}

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

अपडेट किया गया: स्थैतिक आरंभ पर निर्भरता से बचने के लिए संशोधित

Comments

आपकी static/global initialization because multiple test casesअनुमति नहीं है, क्योंकि फ़ंक्शन को एक से अधिक बार कॉल करने योग्य होना चाहिए।

— जोनाथन फ्रीच

@ जोनाथन अद्यतित उत्तर। मैं हमेशा सोचता था कि क्या इसकी अनुमति होनी चाहिए, और यह मेरा मन नहीं बना सका।

— जीपीएस

यहाँ प्रासंगिक मेटा पोस्ट है: codegolf.meta.stackexchange.com/a/4940/73111

— जोनाथन

आप गोल्फ कर सकता m[j]--,p()करने के लिए p(m[j]--)और एक बाइट बचाने।

— जोनाथन फ्रीच

128 बाइट्स

— सीलिंगकैट

Answer 18

क्लोजर, 132 बाइट्स

#(loop[R[(vec(repeat % %))]j(- % 2)i 0](if(> i j)R(recur(conj R(update(last R)i dec))(if(= i j)(- % 2)(dec j))(if(= i j)(inc i)i))))

मैं उम्मीद कर रहा था कि यह छोटा होगा ...

कम स्टेटफुल लेकिन 141 बाइट्स पर लंबा :

#(apply map list(for[i(range %)](concat(repeat(nth(cons 0(reductions +(reverse(range %))))i)%)(range % i -1)(if(>(dec %)i)(repeat(inc i))))))

Answer 19

पायथन 3, 101 बाइट्स

def f(n):
 p=print;m=[n for_ in range(n)];p(m)
 for i in range(n):
    while m[i]>1+i:m[i]-=1;p(m)

मैं शायद प्रिंट के साथ अधिक गोल्फ सकता हूं, लेकिन मैं अपने कंप्यूटर से दूर हूं और प्रिंट करने के लिए एक चर सेट करने पर अजगर 2 के नियमों के बारे में पूरी तरह से निश्चित नहीं हूं। कंप्यूटर पर मिलने पर या किसी की टिप्पणियों में स्पष्ट होने पर मैं बाद में अपडेट करूंगा।

Answer 20

के (ngn / k) , 34 32 बाइट्स

{{x[y]-:1;x}\(,x#x),,/(|!x)#'!x}

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