इसे विस्फोट बनाओ!


33

इनपुट के रूप में धनात्मक पूर्णांक का एक मैट्रिक्स लें, और इसे विस्फोट करें!


जिस तरह से आप एक मैट्रिक्स का विस्फोट करते हैं वह बस बाहरी सीमाओं सहित हर तत्व के चारों ओर शून्य जोड़कर होता है।

इनपुट / आउटपुट प्रारूप हमेशा की तरह वैकल्पिक हैं!

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

1
-----
0 0 0
0 1 0
0 0 0
--------------

1 4
5 2
-----
0 0 0 0 0
0 1 0 4 0
0 0 0 0 0
0 5 0 2 0
0 0 0 0 0
--------------

1 4 7
-----
0 0 0 0 0 0 0
0 1 0 4 0 7 0
0 0 0 0 0 0 0
--------------

6
4
2
-----
0 0 0
0 6 0
0 0 0
0 4 0
0 0 0
0 2 0
0 0 0

जवाबों:


59

ऑपरेशन फ्लैशपॉइंट स्क्रिप्टिंग भाषा, 182 बाइट्स

f={t=_this;c=count(t select 0);e=[0];i=0;while{i<c*2}do{e=e+[0];i=i+1};m=[e];i=0;while{i<count t}do{r=+e;j=0;while{j<c}do{r set[j*2+1,(t select i)select j];j=j+1};m=m+[r,e];i=i+1};m}

Ungolfed:

f=
{
  // _this is the input matrix. Let's give it a shorter name to save bytes.
  t = _this;
  c = count (t select 0);

  // Create a row of c*2+1 zeros, where c is the number of columns in the
  // original matrix.
  e = [0];
  i = 0;
  while {i < c*2} do
  {
    e = e + [0];
    i = i + 1
  };

  m = [e]; // The exploded matrix, which starts with a row of zeros.
  i = 0;
  while {i < count t} do
  {
    // Make a copy of the row of zeros, and add to its every other column 
    // the values from the corresponding row of the original matrix.
    r = +e;
    j = 0;
    while {j < c} do
    {
      r set [j*2+1, (t select i) select j];
      j = j + 1
    };

    // Add the new row and a row of zeroes to the exploded matrix.
    m = m + [r, e];
    i = i + 1
  };

  // The last expression is returned.
  m
}

के साथ बुलाना:

hint format["%1\n\n%2\n\n%3\n\n%4",
    [[1]] call f,
    [[1, 4], [5, 2]] call f,
    [[1, 4, 7]] call f,
    [[6],[4],[2]] call f];

आउटपुट:

चुनौती की भावना में:


6
अनजान; आदमी; एक हज़ार।
मोसेबॉयस

2
अब मैं उलझन में हूँ
ग्रेगडेनू एलेक्स।

@MrGrj कमांड का शाब्दिक अर्थ है कुछ उड़ा देना

1
दूसरे gif के लिए " चुनौती की भावना में "! :)
केविन क्रूज़सेन

10

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

-1 बाइट की बदौलत एरिक द आउटोलफ़र (इसमें शामिल होने के लिए स्वैप किए गए तर्कों का उपयोग करने की आवश्यकता नहीं है)

j00,0jµ€Z$⁺

इसे ऑनलाइन आज़माएं! या एक परीक्षण सूट देखें।

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

कैसे?

j00,0jµ€Z$⁺ - Link: list of lists, m
          ⁺ - perform the link to the left twice in succession:
         $  -   last two links as a monad
      µ€    -     perform the chain to the left for €ach row in the current matrix:
j0          -       join with zeros                [a,b,...,z] -> [a,0,b,0,...,0,z]
  0,0       -       zero paired with zero = [0,0]
     j      -       join                     [a,0,b,0,...,0,z] -> [0,a,0,b,0,...,0,z,0]
        Z   -     and then transpose the resulting matrix

आप एक बाइट को बचा सकते हैं:j00,0jµ€Z$⁺
एरिक आउटगॉल्फ

ओह, बेशक, धन्यवाद!
जोनाथन एलन


6

MATL , 12 बाइट्स

FTXdX*0JQt&(

इनपुट एक मैट्रिक्स है जिसमें ;पंक्ति विभाजक है।

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

व्याख्या

FT     % Push [0 1]
Xd     % Matrix with that diagonal: gives [0 0; 0 1]
X*     % Implicit input. Kronecker product
0      % Push 0
JQt    % Push 1+j (interpreted as "end+1" index) twice
&(     % Write a 0 at (end+1, end+1), extending the matrix. Implicit display

5

जाप , 18 बाइट्स

Ov"y ®î íZ c p0Ã"²

इसे ऑनलाइन टेस्ट करें! ( -Qध्वज का उपयोग करता है ताकि आउटपुट को समझना आसान हो।)

जेली जवाब के समान है, लेकिन एक पूरी बहुत लंबे समय तक ...

व्याख्या

जेली के अनुकरण के लिए कोड का बाहरी भाग सिर्फ एक समाधान है :

  "             "²   Repeat this string twice.
Ov                   Evaluate it as Japt.

कोड ही है:

y ®   î íZ c p0Ã
y mZ{Zî íZ c p0}   Ungolfed
y                  Transpose rows and columns.
  mZ{          }   Map each row Z by this function:
     Zî              Fill Z with (no argument = zeroes).
        íZ           Pair each item in the result with the corresponding item in Z.
           c         Flatten into a single array.
             p0      Append another 0.

दो बार दोहराया गया, यह प्रक्रिया वांछित आउटपुट देती है। परिणाम स्पष्ट रूप से मुद्रित है।


5

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

₁₁
Tm»o:0:;0

एक 2 डी पूर्णांक सरणी लेता है और वापस करता है। इसे ऑनलाइन आज़माएं!

व्याख्या

कई अन्य उत्तरों के समान विचार: प्रत्येक पंक्ति में शून्य जोड़ते हैं और दो बार स्थानांतरित करते हैं। पंक्ति संचालन एक गुना के साथ लागू किया जाता है।

₁₁         Main function: apply first helper function twice
Tm»o:0:;0  First helper function.
 m         Map over rows:
  »         Fold over row:
   o         Composition of
      :       prepend new value and
    :0        prepend zero,
       ;0    starting from [0].
            This inserts 0s between and around elements.
T          Then transpose.

5

मैथेमेटिका, 39 बाइट्स

r=Riffle[#,0,{1,-1,2}]&/@Thread@#&;r@*r

इसे वुल्फ्राम सैंडबॉक्स पर आज़माएं! इसे " r=Riffle[#,0,{1,-1,2}]&/@Thread@#&;r@*r@{{1,2},{3,4}}" की तरह बुलाओ ।

कई अन्य उत्तरों की तरह, यह प्रत्येक पंक्ति में शून्य को स्थानांतरित और फिर से विभाजित करके काम करता है और फिर से वही काम करता है। जोनाथन एलन के जेली जवाब से प्रेरित होकर विशेष रूप से, लेकिन केवल इसलिए कि मैं पहले उस जवाब को देखने के लिए हुआ था।


4

दिल्लोग एपीएल, 24 बाइट्स

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

5 बाइट्स ने @KritiiLithos को धन्यवाद दिया

{{⍵↑⍨-1+⍴⍵}⊃⍪/,/2 2∘↑¨⍵}

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


आप के आसपास parens की जरूरत नहीं है 1,1,⍴⍵, क्या तुम?
जच्चा

मुझे यह मिलता है: {{⍵↑⍨-1 1+⍴⍵}⊃⍪/,/2 2∘↑¨⍵}26 पर
क्रिति लिथोस

@KritiiLithos का अच्छा उपयोग 1 1+!
उरेल

APL की सरणी उन्मुख है, इसलिए 1+काम करेगा ?
जच्चा

@ZacharyT मुझे सिर्फ इतना पता चला है कि आपका जवाब देखने के बाद ...
क्रिटिक्स लिथोस


3

पायथन 3 , 104 101 97 93 86 बाइट्स

  • @Zachary T ने 3 बाइट्स बचाए: अप्रयुक्त चर wहटा दिया और एक अवांछित स्थान
  • @Zachary T ने अभी तक एक और 4 बाइट्स बचाए: [a,b]जैसे a,bकि किसी सूची में संलग्न होते समय
  • @ नोर ने 4 बाइट्स बचाए: स्लाइसिंग का उपयोग
  • @Zachary T और @ovs ने 7 बाइट्स बचाने में मदद की: लूप के लिए स्टेटमेंट को निचोड़ना
def f(a):
 m=[(2*len(a[0])+1)*[0]]
 for i in a:r=m[0][:];r[1::2]=i;m+=r,m[0]
 return m

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


1
आप w2 बाइट्स निकाल सकते हैं और बचा सकते हैं : repl.it/JBPE
Zacharý

1
ओह, आपके पास लाइन के बाद एक अनावश्यक जगह हैm+=[r,w]
Zacharý

1
इसके अलावा, आप को बदलने के द्वारा 4 बाइट को बचाने कर सकते हैं [j,0]करने के लिए j,0और [r,m[0]करने के लिए r,m[0]?
ज़ाचरी

1
आप सरणी स्लाइस का उपयोग करके 4 अन्य बाइट्स बचा सकते हैं ।
नॉर

1
आप python2 में कनवर्ट करके और forएक ही टैब पर लूप इंडेंटेशन को बदलकर तीन बाइट्स बचा सकते हैं ।
ज़ाचरी

3

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

def a(b):
    z='00'*len(b[0])+'0'
    r=z+'\n'
    for c in b:
        e='0'
        for d in c:e+=str(d)+'0'
        r+=e+'\n'+z+'\n'
    return r

पहली बार गोल्फ! सबसे अच्छा नहीं है, लेकिन मुझे बहुत गर्व है अगर मैं ऐसा खुद कह सकता हूं!

  • गेहूं टिप्पणी से -17 बाइट्स
  • -4 बाइट्स लूप के लिए दूसरे को इनलाइन करने से

नमस्कार और साइट पर आपका स्वागत है। आपको लगता है कि यहां व्हॉट्सएप का अच्छा कारोबार है। उदाहरण के लिए आपके कुछ +=और =रिक्त स्थान से घिरे हैं, जिन्हें हटाया जा सकता है। +=एक पंक्ति में दो बार करने के अलावा , एक बयान में सरल किया जा सकता है, उदाहरण के लिएe+=str(d)+'0'
गेहूं जादूगर

@WheatWizard: धन्यवाद और धन्यवाद। सहेजे गए 17 बाइट्स :)
लिरन

मैं अब देख रहा हूँ कि आप अपने आंतरिक forलूप को एक ही लाइन पर ढहा सकते हैं for d in c:e+=str(d)+'0', लेकिन आप एक , in which case it becomes pointless to define सम्मिलित मानचित्र (str, d) + '0' e 'के साथ जाना चाहते हैं ।
गेहूं जादूगर

1
आह, सिर्फ अपने बारे में सोचा! हम्म, मुझे सीखना होगा कि .जॉइन और मैप () पहले मुझे क्या लगता है। मैं वापस आऊंगा!
लिरन

1
आप की परिभाषा डाल सकते हैं zऔर rएक ही पंक्ति (एक साथ पर ;, उन दोनों के बीच) खरोज की एक बाइट की बचत।
nore

3

आर, 65 बाइट्स

बहुत मूल्यवान टिप्पणियों के लिए जार्को डुबेल्डम और ग्यूसेप को धन्यवाद!

कोड

f=function(x){a=dim(x);y=array(0,2*a+1);y[2*1:a[1],2*1:a[2]]=x;y}

फ़ंक्शन के लिए इनपुट एक मैट्रिक्स या दो आयामी सरणी होना चाहिए।

परीक्षा

f(matrix(1))
f(matrix(c(1,5,4,2),2))
f(matrix(c(1,4,7),1))
f(matrix(c(6,4,2)))

उत्पादन

> f(matrix(1))
     [,1] [,2] [,3]
[1,]    0    0    0
[2,]    0    1    0
[3,]    0    0    0
> f(matrix(c(1,5,4,2),2))
     [,1] [,2] [,3] [,4] [,5]
[1,]    0    0    0    0    0
[2,]    0    1    0    4    0
[3,]    0    0    0    0    0
[4,]    0    5    0    2    0
[5,]    0    0    0    0    0
> f(matrix(c(1,4,7),1))
     [,1] [,2] [,3] [,4] [,5] [,6] [,7]
[1,]    0    0    0    0    0    0    0
[2,]    0    1    0    4    0    7    0
[3,]    0    0    0    0    0    0    0
> f(matrix(c(6,4,2)))
     [,1] [,2] [,3]
[1,]    0    0    0
[2,]    0    6    0
[3,]    0    0    0
[4,]    0    4    0
[5,]    0    0    0
[6,]    0    2    0
[7,]    0    0    0

एक नज़र में मैं का उपयोग कर लगता है a=dim(x)*2+1के बजाय nrowऔर ncolबेहतर होगा। आप तब कर सकते हैं y=matrix(0);dim(y)=aऔर 2*1:a[1],2*1:a[2]
JAD

1
वास्तव में और y=array(0,a)भी छोटा होगा।
JAD

1
मेरा मानना ​​है कि आप सूचकांकों के आसपास कोष्ठक को हटा सकते हैं, अर्थात, 2*1:a[1]क्योंकि :पूर्ववर्ती उच्चता है*
Giuseppe


2

PHP , 98 बाइट्स

2 डी सरणी के रूप में इनपुट, स्ट्रिंग के रूप में आउटपुट

<?foreach($_GET as$v)echo$r=str_pad(0,(count($v)*2+1)*2-1," 0"),"
0 ".join(" 0 ",$v)." 0
";echo$r;

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

PHP , 116 बाइट्स

इनपुट और आउटपुट 2D सरणी के रूप में

<?foreach($_GET as$v){$r[]=array_fill(0,count($v)*2+1,0);$r[]=str_split("0".join(0,$v)."0");}$r[]=$r[0];print_r($r);

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


2

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

#(for[h[(/ 2)]i(range(- h)(count %)h)](for[j(range(- h)(count(% 0))h)](get(get % i[])j 0)))

आधे से अधिक चरणों में Iterates।



2

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

lambda l:map(g,*map(g,*l))
g=lambda*l:sum([[x,0]for x in l],[0])

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

फ़ंक्शन gशून्य के बीच इनपुट को इंटरपर्स करता है। मुख्य कार्य आवेदन करते समय इनपुट को स्थानांतरित gकरता है, फिर ऐसा करता है। शायद मुख्य कार्य में पुनरावृत्ति से बचने का एक तरीका है।


2

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

a=>(g=a=>(r=[b],a.map(v=>r.push(v,b)),b=0,r))(a,b=a[0].map(_=>0)).map(g)

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

क्षैतिज और लंबवत रूप से शून्य सम्मिलित करना बहुत समान संचालन है। यहां विचार दोनों चरणों के लिए समान फ़ंक्शन जी () का उपयोग करना है ।

a =>                            // a = input array
  (g = a =>                     // g = function that takes an array 'a',
    (                           //     builds a new array 'r' where
      r = [b],                  //     'b' is inserted at the beginning
      a.map(v => r.push(v, b)), //     and every two positions,
      b = 0,                    //     sets b = 0 for the next calls
      r                         //     and returns this new array
  ))(a, b = a[0].map(_ => 0))   // we first call 'g' on 'a' with b = row of zeros
  .map(g)                       // we then call 'g' on each row of the new array with b = 0

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


2

चारकोल , 49 बाइट्स

A⪪θ;αA””βF⁺¹×²L§α⁰A⁺β⁰βA⁺β¶βFα«βA0δFιA⁺δ⁺κ⁰δ⁺䶻β

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

इनपुट एक सिंगल स्ट्रिंग है जो पंक्तियों को अर्धविराम से अलग करती है।


1
आधुनिक चारकोल 24 बाइट्स में कर सकता है: ≔E⪪θ;⪫00⪫ι0θFθ⟦⭆ι0ι⟧⭆⊟θ0लेकिन स्ट्रिंगपैप से बचने के बावजूद मुझे लगता है कि यह 27 बाइट्स में किया जा सकता है।
नील

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

2

सी ++ 17 + मॉड्यूल, 192 बाइट्स

सिनेमा से स्ट्रिंग की पंक्तियों के रूप में इनपुट , आउटपुट कोउट तक

import std.core;int main(){using namespace std;int i;auto&x=cout;string s;while(getline(cin,s)){for(int j=i=s.length()*2+1;j--;)x<<0;x<<'\n';for(auto c:s)x<<'0'<<c;x<<"0\n";}for(;i--;)x<<'0';}

2

सी # , 146 बाइट्स


डेटा

  • इनपुट Int32[,] m मैट्रिक्स का विस्फोट होना
  • आउटपुट Int32[,] धमाका मैट्रिक्स

golfed

(int[,] m)=>{int X=m.GetLength(0),Y=m.GetLength(1),x,y;var n=new int[X*2+1,Y*2+1];for(x=0;x<X;x++)for(y=0;y<Y;y++)n[x*2+1,y*2+1]=m[x,y];return n;}

Ungolfed

( int[,] m ) => {
    int
        X = m.GetLength( 0 ),
        Y = m.GetLength( 1 ),
        x, y;

    var
        n = new int[ X * 2 + 1, Y * 2 + 1 ];

    for( x = 0; x < X; x++ )
        for( y = 0; y < Y; y++ )
            n[ x * 2 + 1, y * 2 + 1 ] = m[ x, y ];

    return n;
}

अनपढ़ पठनीय

// Takes an matrix of Int32 objects
( int[,] m ) => {
    // To lessen the byte count, store the matrix size
    int
        X = m.GetLength( 0 ),
        Y = m.GetLength( 1 ),
        x, y;

    // Create the new matrix, with the new size
    var
        n = new int[ X * 2 + 1, Y * 2 + 1 ];

    // Cycle through the matrix, and fill the spots
    for( x = 0; x < X; x++ )
        for( y = 0; y < Y; y++ )
            n[ x * 2 + 1, y * 2 + 1 ] = m[ x, y ];

    // Return the exploded matrix
    return n;
}

पूर्ण कोड

using System;
using System.Collections.Generic;
using System.Linq;
using System.Text;
using System.Threading.Tasks;

namespace TestBench {
    public static class Program {
        private static Func<Int32[,], Int32[,]> f = ( int[,] m ) => {
            int
                X = m.GetLength( 0 ),
                Y = m.GetLength( 1 ),
                x, y,

                a = X * 2 + 1,
                b = Y * 2 + 1;

            var
                n = new int[ a, b ];

            for( x = 0; x < X; x++ )
                for( y = 0; y < Y; y++ )
                    n[ a, b ] = m[ x, y ];

            return n;
        };

        public static Int32[,] Run( Int32[,] matrix ) {
            Int32[,]
                result = f( matrix );

            Console.WriteLine( "Input" );
            PrintMatrix( matrix );

            Console.WriteLine( "Output" );
            PrintMatrix( result );

            Console.WriteLine("\n\n");

            return result;
        }

        public static void RunTests() {
            Run( new int[,] { { 1 } } );
            Run( new int[,] { { 1, 3, 5 } } );
            Run( new int[,] { { 1 }, { 3 }, { 5 } } );
            Run( new int[,] { { 1, 3, 5 }, { 1, 3, 5 }, { 1, 3, 5 } } );
        }

        static void Main( string[] args ) {
            RunTests();

            Console.ReadLine();
        }

        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 - 146 bytes- प्रारंभिक समाधान।

टिप्पणियाँ

  • कोई नहीं

आप की जरूरत नहीं है (int[,] m)=>, बस m=>अगर आप राज्य mहै एक 2 डी int- सरणी अपने जवाब int जाएगा। इसके अलावा, आप बदल सकते हैं ,x,करने के लिए ,x=0,और से छुटकारा पाने x=0के लिए -1 बाइट के लिए लूप प्रारंभ में। और अगर आप निकाल सकते हैं y++बदलकर भीतरी पाश से =m[x,y];करने के लिए =m[x,y++];एक अतिरिक्त -1 बाइट के लिए। लेकिन मुझ से +1, और यदि मैं आपके उत्तर का एक पोर्ट बनाता हूं तो यह मेरे वर्तमान जावा उत्तर से भी छोटा है। :)
केविन क्रूज़सेन

1

दिल्लोग एपीएल, 24 बाइट्स

{{⍵↑⍨¯1-⍴⍵}⊃⍪/,/2 2∘↑¨⍵}

किसी भी सुधार का स्वागत करते हैं और चाहते हैं!




1

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

a=>[...a,...a,a[0]].map((b,i)=>[...b,...b,0].map((_,j)=>i&j&1&&a[i>>1][j>>1]))


1

एपीएल (डायलॉग) , 22 बाइट्स

मैट्रिक्स के लिए संकेत, संलग्न मैट्रिक्स लौटाता है।

{⍺⍀⍵\a}/⍴∘0 1¨1+2×⍴a←⎕

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

a←⎕ मैट्रिक्स के लिए संकेत और एक को असाइन करें

एक पंक्तियों  के आयाम (पंक्तियाँ, कॉलम)

 दो से गुणा करें

1+ एक जोड़ें

⍴∘0 1¨संख्याओं को शून्य (और) एक-एक  करके r eshape (चक्रीय रूप से) का उपयोग करें

{}/ दो नंबरों के बीच निम्न अनाम फ़ंक्शन सम्मिलित करके कम करें:

⍵\a विस्तार * के कॉलम एक सही तर्क के अनुसार

⍺⍀a बाएं तर्क के अनुसार उस की पंक्तियों का विस्तार करें

* मैं एक कॉलम / पंक्ति की शून्य पंक्ति सम्मिलित करता है, 1 एक मूल डेटा कॉलम / पंक्ति सम्मिलित करता है


1

जावा 8, 183 166 162 129 बाइट्स

m->{int a=m.length,b=m[0].length,x=0,y,r[][]=new int[a*2+1][b*2+1];for(;x<a;x++)for(y=0;y<b;r[x*2+1][y*2+1]=m[x][y++]);return r;}

इनपुट और आउटपुट एक के रूप में int[][]

-33 बाइट्स का एक पोर्ट @auhman 's C # उत्तर बनाकर

स्पष्टीकरण:

इसे यहाँ आज़माएँ।

m->{                                // Method with 2D integer-array as parameter and return-type
  int a=m.length,                   //  Current height
      b=m[0].length,                //  Current width
      x=0,y,                        //  Two temp integers
      r[][]=new int[a*2+1][b*2+1];  //  New 2D integer-array with correct size
  for(;x<a;x++)                     //  Loop (1) over the height
    for(y=0;y<b;                    //   Inner loop (2) over the width
      r[x*2+1][y*2+1]=m[x][y++]     //    Fill the new array with the input digits
    );                              //   End of inner loop (2)
                                    //  End of loop (1) (implicit / single-line body)
  return r;                         //  Return result 2D integer-array
}                                   // End of method


0

05AB1E , 22 बाइट्स

"vy0ý0.ø})"©.V€Sø®.Vø»

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


वास्तव में कोड 2x का एक ही टुकड़ा उपयोग करता है, इसलिए मैं इसे एक स्ट्रिंग के रूप में संग्रहीत कर सकता हूं और -10 बाइट्स के लिए इवल का उपयोग कर सकता हूं।

हमारी साइट का प्रयोग करके, आप स्वीकार करते हैं कि आपने हमारी Cookie Policy और निजता नीति को पढ़ और समझा लिया है।
Licensed under cc by-sa 3.0 with attribution required.