सभी n कॉलम में 1 से L (n) के साथ मैट्रिक्स

Question

चुनौती:

एक सूची लें, L जिसमें इनपुट के रूप में धनात्मक पूर्णांक हैं:

3 5 2 1 6

और एक मैट्रिक्स बनाएं जहां n'th कॉलम में वेक्टर 1: L (n) होता है , जहां छोटी पंक्तियों को शून्य से गद्देदार किया जाता है।

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

3   5   2   1   6
-----------------
1   1   1   1   1
2   2   2   0   2
3   3   0   0   3
0   4   0   0   4
0   5   0   0   5
0   0   0   0   6

1
-
1

1   2   3   4   3   2   1
-------------------------
1   1   1   1   1   1   1
0   2   2   2   2   2   0
0   0   3   3   3   0   0
0   0   0   4   0   0   0

नियम:

• वैकल्पिक इनपुट और आउटपुट प्रारूप
  • सूचियों की सूची एक स्वीकार्य आउटपुट प्रारूप है
• मैट्रिक्स जितना संभव हो उतना छोटा होना चाहिए (आप इसे ज़रूरत से ज़्यादा शून्य के साथ पैड नहीं कर सकते)
• प्रत्येक भाषा में सबसे छोटा कोड जीतता है
• स्पष्टीकरण अत्यधिक प्रोत्साहित किया जाता है

Comments

क्या हम इसके बजाय क्षैतिज रूप से पर्वतमाला वितरित कर सकते हैं?

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

नहीं, वे ऊर्ध्वाधर होना चाहिए। यदि आप ऐसी भाषा का उपयोग करते हैं जहाँ क्षैतिज / ऊर्ध्वाधर शब्द का कोई अर्थ नहीं है तो यह वैकल्पिक है। (उन भाषाओं के लिए प्रासंगिक हो सकता है, जहाँ सूचियों की सूची क्षैतिज / ऊर्ध्वाधर दिशाओं से जुड़ी नहीं है)

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

@StewieGriffin नेस्टेड सूचियों के साथ कौन-सी भाषा आयाम को संबद्ध नहीं करती है?

— आउटगॉल्फ

@EriktheOutgolfer, इस साइट पर कितनी पागल भाषाओं का उपयोग किया जाता है?

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

@EriktheOutgolfer R के लिए मैटरिस को नेस्टेड सूची के रूप में नहीं देखा जाता है, बल्कि एक लंबी सूची है, जो पंक्ति-वार चारों ओर घूमती है।

— JAD

Answer 1

आर , 40 38 बाइट्स

function(l)outer(m<-1:max(l),l,"<=")*m

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

स्पष्टीकरण:

outerअपने पहले दो तर्कों के तत्वों के सभी संयोजनों के लिए अपने तीसरे तर्क (फ़ंक्शन) को लागू करता है, एक मैट्रिक्स का निर्माण करता है TRUEऔर FALSEजहां प्रत्येक कॉलम में TRUEजहां के 1:max(l)तत्त्व तत्व से कम या बराबर होता है l, उदाहरण के लिए l=c(3,5,2,1,6):

      [,1]  [,2]  [,3]  [,4] [,5]
[1,]  TRUE  TRUE  TRUE  TRUE TRUE
[2,]  TRUE  TRUE  TRUE FALSE TRUE
[3,]  TRUE  TRUE FALSE FALSE TRUE
[4,] FALSE  TRUE FALSE FALSE TRUE
[5,] FALSE  TRUE FALSE FALSE TRUE
[6,] FALSE FALSE FALSE FALSE TRUE

फिर परिणामी मैट्रिक्स को दबाना है A, फिर A*m-> A[i,j]=A[i,j]*iजो वांछित परिणाम का उत्पादन करने के TRUEलिए 1 और FALSE0 से जुटता है ।

Comments

मुझे लगता है कि - यदि आप 2 बाइट्स बचा सकता है की जगह function(l)के साथl=scan();

— AndriusZ

@AndriusZ लेकिन फिर मुझे सब कुछ लपेटना printहोगा ताकि मैं उन बाइट्स को खो दूं ।

— ग्यूसेप

मुझे लगता है, आपको सब कुछ लपेटने की ज़रूरत नहीं है - TOI

— AndriusZ

@AndriusZ हम पहले भी इस बारे में बात कर चुके हैं। इस मेटा प्रश्न का एकमात्र उत्तर source(...,echo=TRUE)एक पूर्ण कार्यक्रम के रूप में, स्टड से उपयोग करने और पढ़ने के लिए +4 जुर्माना देता है , यदि आपके पास कोई वैकल्पिक सुझाव है, तो हर तरह से वहां तौलना चाहिए, लेकिन जहां तक ​​मुझे पता है कि हमारे निकटतम है पूर्ण कार्यक्रमों पर एक आम सहमति के लिए और यह समय के लिए खड़ा है।

— ग्यूसेप

खेल के अंत में: [इस टिप] ( codegolf.stackexchange.com/a/111578/80010 ) का उपयोग करके दो बाइट्स बचाएं

— JayCe

Answer 2

MATL , 8 बाइट्स

"@:]Xho!

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

व्याख्या

"      % Implicit input, L. For each k in L
  @    %   Push k
  :    %   Range [1 2 ... k]
]      % End
Xh     % Collect all stack contents in a cell array
o      % Convert to double matrix. The content of each cell is
       % right-padded with zeros if needed
!      % Transpose. Implicitly display

Answer 3

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

lambda x:[[-~i*(i<a)for a in x]for i in range(max(x))]

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

Answer 4

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

PadRight@Range@#&

इसमें U + F3C7 शामिल है (मैथमेटिका का बिल्टइन Transposeफंक्शन)

इसे वुल्फ्राम सैंडबॉक्स पर आज़माएं

प्रयोग

PadRight@Range@#&[{3, 5, 2, 1, 6}]

{
 {1, 1, 1, 1, 1},
 {2, 2, 2, 0, 2},
 {3, 3, 0, 0, 3},
 {0, 4, 0, 0, 4},
 {0, 5, 0, 0, 5},
 {0, 0, 0, 0, 6}
}

व्याख्या

PadRight@Range@#&

         Range@#    (* Generate {1..n} for all elements of input *)
PadRight@           (* Right-pad 0s so that all lists are equal length *)
                   (* Transpose the result *)

Comments

@ डाउनडॉटर्स क्यों डाउनवोट करते हैं? क्या तुम समझा सकते हो?

— जुंगवान मिन

मैं नीचे नहीं गया था, लेकिन मुझे संदेह है कि आप फ़ंक्शन हस्ताक्षर या तर्कों के अभाव की वजह से हैं, जो आपके कोड स्निपेट को ब्लैक बॉक्स नहीं होने का कारण बनता है!

— सर्गियोल

Answer 5

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

@(x)((y=1:max(x))'<=x).*y'

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

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

व्याख्या

इनपुट पर विचार करें x = [3 5 2 1 6]। यह आकार 1 × 5 की एक पंक्ति वेक्टर है।

1:max(x)पंक्ति सदिश देता है [1 2 3 4 5 6], जिसे चर में सौंपा गया है y।

उस [1; 2; 3; 4; 5; 6]का <=पारगमन , यानी कॉलम वेक्टर , इनपुट के साथ -compared (प्रसारण के साथ तत्व-वार) है [3 5 2 1 6]। परिणाम 6 × 5 मैट्रिक्स है

[1 1 1 1 1;
 1 1 1 0 1;
 1 1 0 0 1;
 0 1 0 0 1;
 0 1 0 0 1;
 0 0 0 0 1]

अंत में, बहुधा (प्रसारण के साथ तत्व-वार), कॉलम वेक्टर द्वारा [1; 2; 3; 4; 5; 6], जिसे yट्रांसपोज़ किया गया है, वांछित परिणाम देता है:

[1 1 1 1 1;
 2 2 2 0 2;
 3 3 0 0 3;
 0 4 0 0 4;
 0 5 0 0 5;
 0 0 0 0 6]

Comments

मैं MATLAB / ऑक्टेव सबमिशन देखने की उम्मीद कर रहा था। मैंने इसे बिना किसी विचार के लागू किया, इसलिए यह संभवतः 40 से अधिक बाइट्स था। बहुत अच्छा समाधान :)

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

Answer 6

05AB1E , 4 बाइट्स

€L0ζ

इसे ऑनलाइन आज़माएं! या एक अच्छी तरह से स्वरूपित परीक्षण सूट के रूप में

€L   # For each: get the range 1..input
  0ζ # zip, padding with 0s

Answer 7

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

सूचियों की सूची लौटाता है

T0mḣ

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

व्याख्या

  m    Map over the input
   ḣ   Range from 1 to n
T0     Transpose, padding with 0s

Answer 8

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

.tSMQZ

यहाँ कोशिश करो! या सभी परीक्षण मामलों (सुंदर प्रिंट के साथ) को सत्यापित करें!

---

व्याख्या

.tSMQZ - पूर्ण कार्यक्रम

  SMQ - प्रत्येक के लिए समावेशी संयुक्त पर्वतमाला प्राप्त करें।
.t - स्थानांतरित, की प्रतियों के साथ पैडिंग ...
     Z - ... शून्य।
         - इम्प्लांट प्रिंट।

एक गैर-निर्मित ट्रांज़ोज़ संस्करण होगा :

mm*hd<dkQeS

यह निम्नानुसार काम करता है:

mm*hd<dkQeS   - Full program.

m        eS   - Map over [0, max(input)) with a variable d.
 m      Q     - Map over the input with a variable k.
   hd         - d + 1.
  *           - Multiplied by 1 if...
     <dk      - ... d is smaller than k, else 0.
              - Output implicitly.

Answer 9

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

Rz0

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

व्याख्या

Rz0  Input: array A
R    Range, vectorizes to each integer
 z0  Transpose and fill with 0

Answer 10

दरअसल , 17 बाइट्स

;M╗♂R⌠╜;0@α(+H⌡M┬

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

स्पष्टीकरण:

;M╗♂R⌠╜;0@α(+H⌡M┬
;M╗                store the maximal element (M) of the input in register 0
   ♂R              range(1, n+1) for each n in input
     ⌠╜;0@α(+H⌡M   for each range:
      ╜;0@α          push a list containing M 0s
           (+        append to range
             H       take first M elements
                ┬  transpose

Comments

हाँ, वास्तव में वास्तव में पेडिंग सपोर्ट के साथ जिप की जरूरत है ...

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

Answer 11

Pyke , 3 बाइट्स

यह Pyke, hex encodings की नई विशेषता का उपयोग करता है ... सबसे अच्छी बात यह है कि हम जेली को बाँधते हैं! कच्चे बाइट्स:

4D 53 AC

यहाँ कोशिश करो!

ASCII-Pyke समकक्ष 4 बाइट होगा :

MS.,

कैसे?

4 डी 53 एसी - पूर्ण कार्यक्रम।

4D - मानचित्र।
   53 - समावेशी सीमा।
      एसी - शून्य के साथ संक्रमण।
           - आउटपुट निहितार्थ।

-------------------------------------

एमएस।, - पूर्ण कार्यक्रम।

एम - नक्शा।
 एस - समावेशी सीमा।
  ।, - शून्य के साथ संक्रमण।
       - आउटपुट निहितार्थ।

यहां ASCII के साथ एक सुंदर-प्रिंट संस्करण है, और यहां हेक्स एनकोडिंग के साथ एक है।

Answer 12

पर्ल 6 , 39 बाइट्स

{zip (1 X..$_).map:{|@_,|(0 xx.max-1)}}

कोशिश करो

विस्तारित:

{                # bare block lambda with implicit parameter ｢$_｣

  zip

    (1 X.. $_)   # turn each input into a Range that starts with 1

    .map:        # map each of those Ranges using the following code

    {            # bare block lambda with implicit parameter ｢@_｣ 
                 # (｢@_｣ takes precedence over ｢$_｣ when it is seen)

      |@_,       # slip the input into a new list

      |(         # slip this into the list

        0        # a ｢0｣
        xx       # list repeated by

          .max   # the max of ｢$_｣ (implicit method call)
          - 1    # minus 1 (so that zip doesn't add an extra row)
      )
    }
}

ध्यान दें कि zipएक बार सबसे छोटी इनपुट सूची समाप्त हो जाती है।

Answer 13

सी # , 136 बाइट्स

---

डेटा

• इनपुट Int32[] i ints की एक सरणी
• आउटपुट Int32[,] एक बोली-संबंधी सरणी।

---

golfed

i=>{int m=System.Linq.Enumerable.Max(i),l=i.Length,x,y;var o=new int[m,l];for(y=0;y<m;y++)for(x=0;x<l;)o[y,x]=i[x++]>y?y+1:0;return o;};

---

Ungolfed

i => {
    int
        m = System.Linq.Enumerable.Max( i ),
        l = i.Length,
        x, y;

    var o = new int[ m, l ];

    for( y = 0; y < m; y++ )
        for( x = 0; x < l; )
            o[ y, x ] = i[ x++ ] > y ? y + 1 : 0;

    return o;
};

---

अनपढ़ पठनीय

// Take an array of Int32
i => {

    // Store the max value of the array, the length and declare some vars to save some bytes
    int
        m = System.Linq.Enumerable.Max( i ),
        l = i.Length,
        x, y;

    // Create the bidimensional array to output
    var o = new int[ m, l ];

    // Cycle line by line...
    for( y = 0; y < m; y++ )

        // ... and column by column...
        for( x = 0; x < l; )

            // And set the value of the line in the array if it's lower than the the value at the index of the input array
            o[ y, x ] = i[ x++ ] > y ? y + 1 : 0;

    // Return the bidimentional array.
    return o;
};

---

पूर्ण कोड

using System;
using System.Collections.Generic;

namespace TestBench {
    public class Program {
        // Methods
        static void Main( string[] args ) {
            Func<Int32[], Int32[,]> f = i => {
                int
                    m = System.Linq.Enumerable.Max( i ),
                    l = i.Length,
                    x, y;
                var o = new int[ m, l ];
                for( y = 0; y < m; y++ )
                    for( x = 0; x < l; )
                        o[ y, x ] = i[ x++ ] > y ? y + 1 : 0;
                return o;
            };

            List<Int32[]>
                testCases = new List<Int32[]>() {
                    new[] { 1, 2, 5, 6, 4 },
                    new[] { 3, 5, 2, 1, 6 },
                    new[] { 1, 2, 3, 4, 3, 2, 1 },
                };

            foreach( Int32[] testCase in testCases ) {
                Console.WriteLine( " INPUT: " );
                PrintArray( testCase );

                Console.WriteLine( "OUTPUT: " );
                PrintMatrix( f( testCase ) );
            }

            Console.ReadLine();
        }

        public static void PrintArray<TSource>( TSource[] array ) {
            PrintArray( array, o => o.ToString() );
        }
        public static void PrintArray<TSource>( TSource[] array, Func<TSource, String> valueFetcher ) {
            List<String>
                output = new List<String>();

            for( Int32 index = 0; index < array.Length; index++ ) {
                output.Add( valueFetcher( array[ index ] ) );
            }

            Console.WriteLine( $"[ {String.Join( ", ", output )} ]" );
        }

        public static void PrintMatrix<TSource>( TSource[,] array ) {
            PrintMatrix( array, o => o.ToString() );
        }
        public static void PrintMatrix<TSource>( TSource[,] array, Func<TSource, String> valueFetcher ) {
            List<String>
                output = new List<String>();

            for( Int32 xIndex = 0; xIndex < array.GetLength( 0 ); xIndex++ ) {
                List<String>
                    inner = new List<String>();

                for( Int32 yIndex = 0; yIndex < array.GetLength( 1 ); yIndex++ ) {
                    inner.Add( valueFetcher( array[ xIndex, yIndex ] ) );
                }

                output.Add( $"[ {String.Join( ", ", inner )} ]" );
            }

            Console.WriteLine( $"[\n   {String.Join( ",\n   ", output )}\n]" );
        }
    }
}

---

विज्ञप्ति

• v1.0 - 136 bytes- प्रारंभिक समाधान।

---

टिप्पणियाँ

• कोई नहीं

Answer 14

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

i,j,k;main(c,v)char**v;{for(;++i<c;k=k<*v[i]?*v[i]:k)printf("%c ",*v[i]);for(i=48;puts(""),i++<k;)for(j=1;j<c;)printf("%c ",i<=*v[j++]?i:48);}

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

Answer 15

जावा 10, 115 बाइट्स

a->{int l=a.length,m=0;for(int j:a)m=j>m?j:m;var r=new int[m][l];for(;l-->0;)for(m=0;m<a[l];r[m][l]=++m);return r;}

स्पष्टीकरण:

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

a->{                  // Method with integer-array parameter and integer-matrix return-type
  int l=a.length,     //  Length of the array
      m=0;            //  Largest integer in the array, 0 for now
  for(int j:a)        //  Loop over the array
    m=j>m?            //   If the current item is larger than `m`:
       j              //    Set `m` to this item as new max
      :               //   Else:
       m;             //    Leave `m` the same
  var r=new int[m][l];//  Result-matrix of size `m` by `l`, filled with zeroes by default
  for(;l-->0;)        //  Loop over the columns
    for(m=0;m<a[l];   //   Inner loop over the rows
      r[m][l]=++m);   //    Set the cell at position `m,l` to `m+1`
  return r;}          //  Return the result-matrix

Answer 16

पर्ल 5 , 62 + 1 ( -a) = 63 बाइट्स

$,=$";map$m=$_>$m?$_:$m,@F;say map$_&&$_--&&$i,@F while$i++-$m

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

Answer 17

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

a=>[[i<j?-~i:0for j:a]for i:0..max(a)]

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

Comments

मुझे लगता है, बग इसके बाद अंतरिक्ष है?

— caird coinheringaahing

@cairdcoinheringaahing हाँ। प्रश्न चिह्न के बाद चरित्र का उपभोग करेगा यह सुनिश्चित करने के लिए कि यह एक और प्रश्न चिह्न नहीं है, लेकिन मैं अतिरिक्त चरित्र की भरपाई करना भूल गया, जिसके परिणामस्वरूप इसे छोड़ दिया गया।

— हाइपरन्यूट्रिनो 20

लगता है कि आपको एक पुल मिल गया है, अब आप नोटिस हटा सकते हैं :)

— आउटगॉल्फ

Answer 18

++ , 37 बाइट्स जोड़ें

D,g,@@*,bL_1+0XA$p$+bUp
L~*,€RAbM€gBc

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

Answer 19

जावास्क्रिप्ट (Node.js) , 55 बाइट्स

x=>f=(t=1,s,e=x.map(y=>y<t?0:s|=t))=>s?[e,...f(++t)]:[]

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

जावास्क्रिप्ट (Node.js) , 63 बाइट्स

x=>[...Array(Math.max(...x,t=0))].map(_=>x.map(y=>y<t?0:t,++t))

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