C सरणी का विस्तार करें


36

C प्रोग्रामिंग भाषा में, सरणियों को इस तरह परिभाषित किया जाता है:

int foo[] = {4, 8, 15, 16, 23, 42};      //Foo implicitly has a size of 6

सरणी का आकार प्रारंभिक तत्वों से माना जाता है, जो इस स्थिति में है। 6. आप इस तरह से सी सरणी भी लिख सकते हैं, स्पष्ट रूप से इसे आकार दे रहे हैं और फिर प्रत्येक तत्व को क्रम में परिभाषित कर रहे हैं:

int foo[6];        //Give the array an explicit size of 6
foo[0] = 4;
foo[1] = 8;
foo[2] = 15;
foo[3] = 16;
foo[4] = 23;
foo[5] = 42;

चुनौती

आपको एक प्रोग्राम या फ़ंक्शन लिखना होगा जो पहले रास्ते से दूसरे तक सरणियों का विस्तार करता है। चूंकि आप कोड को लंबे समय तक बनाने के लिए एक कार्यक्रम लिख रहे हैं, और आपको विडंबना पसंद है, इसलिए आपको अपने कोड को यथासंभव कम करना चाहिए।

इनपुट मूल सरणी का प्रतिनिधित्व करने वाला एक स्ट्रिंग होगा, और आउटपुट विस्तारित सरणी-परिभाषा होगा। आप सुरक्षित रूप से मान सकते हैं कि इनपुट हमेशा इस तरह दिखेगा:

<type> <array_name>[] = {<int>, <int>, <int> ... };

"टाइप" और "array_name" पूरी तरह से वर्णमाला वर्णों और अंडरस्कोर से बना होगा _। सूची के तत्व हमेशा -2,147,483,648 से 2,147,483,647 की संख्या में होंगे। किसी अन्य प्रारूप में इनपुट को संभालने की आवश्यकता नहीं है।

आपके आउटपुट में व्हाट्सएप को टेस्ट आउटपुट में व्हाट्सएप से बिल्कुल मेल खाना चाहिए, हालांकि एक अनुगामी न्यूलाइन की अनुमति है।

परीक्षण IO:

#in
short array[] = {4, 3, 2, 1};

#out
short array[4];
array[0] = 4;
array[1] = 3;
array[2] = 2;
array[3] = 1;


#in
spam EGGS[] = {42};

#out
spam EGGS[1];
EGGS[0] = 42;


#in
terrible_long_type_name awful_array_name[] = {7, -8, 1337, 0, 13};

#out
terrible_long_type_name awful_array_name[5];
awful_array_name[0] = 7;
awful_array_name[1] = -8;
awful_array_name[2] = 1337;
awful_array_name[3] = 0;
awful_array_name[4] = 13;

किसी भी भाषा में प्रस्तुतियाँ प्रोत्साहित की जाती हैं, लेकिन बोनस अंक यदि आप इसे सी में कर सकते हैं ।

लीडरबोर्ड:

यहाँ एक लीडरबोर्ड है जो शीर्ष उत्तर दिखा रहा है:


2
क्या सरणी इंडेक्स, समान चिह्न और आउटपुट में आवश्यक मान के बीच रिक्त स्थान हैं? उदाहरण के लिए, foo[0]=1;स्वीकार्य होगा ?
Mego

@Mego यह स्वीकार्य नहीं होगा। व्हाट्सएप की आवश्यकता है। मुझे लगता है कि में संपादित करेंगे।
DJMcMayhem

अनुगामी न्यूलाइन की अनुमति है?
लुइस मेंडो

क्या कार्यों की अनुमति है?
मेगो

क्या इसे प्रिंट करने के बजाय आउटपुट वापस करना ठीक है? (कार्यों के मामले में)
तिजोरी

जवाबों:


12

पायथ, 44 बाइट्स

++Khcz\]lJ:z"-?\d+"1"];"VJs[ecKd~hZ"] = "N\;

परीक्षण सूट

नियमित अभिव्यक्ति और स्ट्रिंग चॉपिंग। विशेष रूप से चतुर नहीं है।

स्पष्टीकरण:

++Khcz\]lJ:z"-?\d+"1"];"VJs[ecKd~hZ"] = "N\;
                                                Implicit: z = input()
    cz\]                                        Chop z on ']'
   h                                            Take string before the ']'
  K                                             Store it in K
 +                                              Add to that
         :z"-?\d+"1                             Find all numbers in the input
        J                                       Store them in J
       l                                        Take its length.
+                  "];"                         Add on "];" and print.
                       VJ                       For N in J:
                         s[                     Print the following, concatenated:
                            cKd                 Chop K on spaces.
                           e                    Take the last piece (array name)
                               ~hZ              The current interation number
                                  "] = "        That string
                                        N       The number from the input
                                         \;     And the trailing semicolon.

यह उत्तर मेरे पक्ष में कांटा है। मैंने सोचा था कि मैं इसे जीत सकता हूं, लेकिन मेरे जीवन के लिए, मैं आखिरी 2-3 बाइट्स नहीं हासिल कर सकता। = डी अच्छा जवाब!
DJMcMayhem

28

विम, ५४, ५२, ४ ९ ४yst कीस्ट्रोक्स


2wa0<esc>qqYp<c-a>6ldf @qq@q$dT]dd:%norm dwf{xwC;<CR>gg"0P

स्पष्टीकरण:

2wa0<esc>                     'Move 2 words forward, and insert a 0.
         qq                   'Start recording in register Q
           Yp                 'Duplicate the line
             <c-a>6l          'Increment the next number then move 6 spaces right
                    df        'Delete until the next space
                       @qq@q  'Recursively call this macro

अब हमारा बफर इस तरह दिखता है:

int foo[0] = {4, 8, 15, 16, 23, 42};
int foo[1] = {8, 15, 16, 23, 42};
int foo[2] = {15, 16, 23, 42};
int foo[3] = {16, 23, 42};
int foo[4] = {23, 42};
int foo[5] = {42};
int foo[6] = {42};

और हमारा कर्सर अंतिम पंक्ति पर है।

दूसरी पारी:

$                           'Move to the end of the line
 dT]                        'Delete back until we hit a ']'
    dd                      'Delete this whole line.
      :%norm         <CR>   'Apply the following keystrokes to every line:
             dw             'Delete a word (in this case "int")
               f{x          '(f)ind the next '{', then delete it.
                  wC;       'Move a word, then (C)hange to the end of this line, 
                            'and enter a ';'

अब सब कुछ अच्छा लग रहा है, हमें बस मूल सरणी-घोषणा को जोड़ने की आवश्यकता है। तो हम करते हैं:

gg        'Move to line one
  "0P     'Print buffer '0' behind us. Buffer '0' always holds the last deleted line,
          'Which in this case is "int foo[6];"

3
जब भी मैं विम-गोल्फ पढ़ता हूं, मुझे एहसास होता है कि मैं जो भी कोडिंग करता हूं (ज्यादातर मेरी विविध जीयूआई संपादकों में कीबोर्ड कमांड) ऐसा ही दिखता है, और मेरा दिमाग एक मिनट के लिए झुकता है (विम सिर्फ ट्यूरिंग पूर्ण (पूर्ण और कूलर)) : पी
बिल्ली

मुझे यह काम करने के लिए नहीं मिल सकता है - जब मैं पहला "@q" ("@ qq @ q" का) टाइप करता हूं, तो मैक्रो तब चलता है, और जाहिर है इससे आगे बढ़ना चाहिए, जैसी चीजें मिल रही हैं int foo[6] = {और समाप्त हो रही हैं int foo[12(कर्सर पर) "2")
लॉर्डआरो

@ लॉरड्रो शायद मुझे इसका उल्लेख करना चाहिए था। ऐसा इसलिए है क्योंकि q में पहले से ही एक मैक्रो है, और यह आपके रिकॉर्डिंग के दौरान चलता है, इसे गड़बड़ कर रहा है। मैं बताया कि कैसे चारों ओर पाने के लिए यहाँ है कि करने के लिए: codegolf.stackexchange.com/a/74663/31716
DJMcMayhem

1
@ लॉर्डआरो ओह, डुह, मुझे पता है कि क्या कारण है। मैं एक बाइट को बचाने के df<space>लिए बदल गया dW, लेकिन मैं भूल गया कि df<space>लाइन 6 पर मैक्रो से बाहर निकल जाएगा, लेकिन dWनहीं। मैं एक संशोधन रोलबैक करूंगा। यह बात बताने के लिए धन्यवाद!
DJMcMayhem

1
हालांकि यह सबसे छोटा जवाब नहीं है, यह अब तक का सबसे प्रभावशाली है।
isaacg

10

रेटिना, 108 104 100 69 बाइट्स

बाइट गिनती आईएसओ 8859-1 एन्कोडिंग मानती है।

].+{((\S+ ?)+)
$#2];$1
+`((\w+\[).+;(\S+ )*)(-?\d+).+
$1¶$2$#3] = $4;

यह मारो, PowerShell ...

कोड स्पष्टीकरण

पहली पंक्ति: ].+{((\S+ ?)+)

सबसे पहले, हमें प्रकार, सरणी का नाम और उद्घाटन ब्रैकेट रखना होगा (यह एक बाइट बचाता है), इसलिए हम उनसे मेल नहीं खाते। इसलिए हम समापन कोष्ठक, वर्णों की किसी भी संख्या और एक प्रारंभिक घुंघराले ब्रेस से मेल खाते हैं ].+{:। फिर हम संख्या सूची से मेल खाते हैं। अब तक का सबसे छोटा मैं यह पा सकता हूँ ((\S+ ?)+):। हम किसी भी गैर-अंतरिक्ष वर्णों से मेल खाते हैं (इसमें संख्याएँ, संभव ऋणात्मक चिह्न और संभव अल्पविराम शामिल हैं), इसके बाद एक स्थान है, जो हो सकता है या नहीं भी हो सकता है \S+ ?:। वर्णों के इस समूह को तब आवश्यकतानुसार कई बार दोहराया जाता है: (\S+ ?)+और बड़े कैप्चरिंग समूह में डाल दिया जाता है। ध्यान दें कि हम समापन घुंघराले ब्रेस या अर्धविराम से मेल नहीं खाते हैं। तीसरी पंक्ति का विवरण बताता है कि क्यों।

दूसरी पंक्ति: $#2];$1

चूँकि हमने केवल इनपुट के एक हिस्से का मिलान किया था, अतुलित हिस्से अभी भी मौजूद हैं। इसलिए हम बेजोड़ उद्घाटन ब्रैकेट के बाद सूची की लंबाई डालते हैं $#2:। बदले हुए संशोधक से #हमें मदद मिलती है, क्योंकि यह हमें एक विशेष कैप्चरिंग समूह द्वारा किए गए मैचों की संख्या प्रदान करता है। इस मामले में ग्रुप कैप्चरिंग 2। फिर हम एक समापन ब्रैकेट और एक अर्धविराम लगाते हैं, और अंत में हमारी पूरी सूची।

इनपुट के साथ short array[] = {4, 3, 2, 1};, इस के बाद आंतरिक प्रतिनिधित्व है:

लघु सरणी [4]; 4, 3, 2, 1};

(नोट बंद करने के लिए घुंघराले ब्रेस और अर्धविराम)

तीसरी पंक्ति: +`((\w+[).+;(\S+ )*)(-?\d+).+

यह एक लूप्ड सेक्शन है। इसका मतलब है कि यह तब तक चलता है जब तक लूप में कोई चरण इनपुट में बदलाव नहीं करता है। पहले हम सरणी नाम से मेल खाते हैं, उसके बाद एक उद्घाटन ब्रैकेट (\w+\[):। फिर किसी भी वर्ण और अर्धविराम की एक मनमानी संख्या .+;:। फिर हम फिर से सूची से मेल खाते हैं, लेकिन इस बार प्रत्येक संख्या के बाद केवल संख्याएं और अल्पविराम हैं, जिनके पीछे एक स्थान है (\S+ )*:। फिर हम सूची में अंतिम संख्या पर कब्जा करते हैं: (-?\d+)और इसके पीछे कोई भी शेष अक्षर .+:।

चौथी पंक्ति: $1¶$2$#3] = $4;

हम तो सरणी नाम और सूची एक नई पंक्ति के बाद से बदलने: $1¶। अगला, हम अंतिम तत्व (अनिवार्य रूप से list.length - 1) के बिना, पहले से मिलान की गई सूची की लंबाई के बाद सरणी नाम डालते हैं $2$#3:। रिक्त स्थान के साथ एक समापन ब्रैकेट और एसिगमेंट ऑपरेटर द्वारा अनुसरण किया जाता है, और इसके बाद हमारी संख्या सूची का अंतिम तत्व होता है:] = $4;

पहले की जगह के बाद, आंतरिक प्रतिनिधित्व इस तरह दिखता है:

short array[4];4, 3, 2, 
array[3] = 1;

ध्यान दें कि समापन घुंघराले ब्रेस और अर्धविराम गायब हो गया, .+तीसरी पंक्ति के अंत में धन्यवाद । तीन और प्रतिकृति के बाद, आंतरिक प्रतिनिधित्व इस तरह दिखता है:

short array[4];
array[0] = 4;
array[1] = 3;
array[2] = 2;
array[3] = 1;

चूंकि तीसरी पंक्ति से मेल खाने के लिए अधिक कुछ नहीं है, चौथा कुछ भी प्रतिस्थापित नहीं करता है और स्ट्रिंग वापस आ जाती है।

टीएल; डीआर: पहले हम इंट लिस्ट प्रारूप को थोड़ा बदलते हैं। फिर हम सूची और नाम के अंतिम तत्व को लेते हैं, और सरणी आरंभीकरण के बाद उन्हें डालते हैं। हम ऐसा तब तक करते हैं जब तक कि इंट लिस्ट खाली न हो जाए। फिर हम बदले हुए कोड को वापस देते हैं।

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


किसी ने मुझे इसे हरा दिया .... :(
कैलक्यूलेटरफैनलाइन

M!`और G`समान हैं, लेकिन काफी समान नहीं हैं। सावधान रहे।
कैलक्यूलेटरफेलीन

तीसरी पंक्ति का स्पष्टीकरण मुझे भ्रमित करता है। पहला आइटम उसके पीछे एक जगह के बिना एकमात्र है, आखिरी नहीं।
कैलक्यूलेटरफलाइन

@CatsAreFluffy मैंने अभी-अभी शब्दांकन को थोड़ा बदलने की कोशिश की। मेरा मतलब था कि एक संख्या के बाद एक जगह थी , इससे पहले नहीं। मुझे लगता है कि मुझे "पीछे" का अर्थ पूरी तरह से महसूस नहीं हुआ। मुझे वास्तव में 2 बजे कोड स्पष्टीकरण नहीं लिखना चाहिए।
डेवको

@daavko "आम तौर पर" का अर्थ "के बाद" अर्थात "निम्नलिखित" है, बोलचाल की अंग्रेजी में। आप ठीक थे।
निधि मोनिका का मुकदमा

9

वी, 37 बाइट्स

2Eé0òYp6ldf ò$dT]ddÎdwf{xwC;
gg"1P

V एक 2D, स्ट्रिंग आधारित गोल्फिंग भाषा है जिसे मैंने लिखा है, जिसका डिज़ाइन ऑफ विम है। यह प्रतिबद्ध 17 के रूप में काम करता है ।

स्पष्टीकरण:

यह मेरे विम उत्तर का सीधा अनुवाद है , हालांकि यह काफी छोटा है।

2E                               "Move to the end of 2 words forward.
  é0                             "Insert a single '0'
    ò       ò                    "Recursively do:
     Yp6ldf                      "Yank, paste, move 6 right, delete until space.
             $dT]                "Move to the end of line, delete backwards until ']'
                 dd              "Delete this line
                   Î             "Apply the following to every line:
                    dwf{xwC;<\n> "Delete word, move to '{' and delete it, Change to end of line, and enter ';'

फिर हमारे पास बस:

gg"1P     "Move to line 1, and paste buffer '1' behind us.

चूंकि इस यूनिकोड पागलपन में प्रवेश करना कठिन हो सकता है, आप इस प्रतिवर्ती हेक्सडंप के साथ फाइल बना सकते हैं:

00000000: 3245 e930 f259 7001 366c 6466 20f2 2464  2E.0.Yp.6ldf .$d
00000010: 545d 6464 ce64 7766 7b78 7743 3b0d 6767  T]dd.dwf{xwC;.gg
00000020: 2231 500a                                "1P.

इसे V स्थापित करके और टाइप करके चलाया जा सकता है:

python main.py c_array.v --f=file_with_original_text.txt

1
Designed off of vim.2 नोट: 1. अधिकांश लोग कहते हैं कि fromनहीं off of, और 2. ऐसा क्यों नहीं हुआ। +1
Rɪᴋᴇʀ

8

सी, 215 बाइट्स , 196 बाइट्स

19 बाइट्स @tucuxi की बदौलत बच गईं!

golfed:

char i[99],o[999],b[99],z[99];t,x,n,c;main(){gets(i);sscanf(i,"%s %[^[]s",b,z);while(sscanf(i+t,"%*[^0-9]%d%n",&x,&n)==1)sprintf(o,"%s[%d] = %d;\n",z,c++,x),t+=n;printf("%s %s[%d];\n%s",b,z,c,o);}

Ungolfed:

/*
 *  Global strings:
 *   i: input string
 *   o: output string
 *   b: input array type
 *   z: input array name
*/
char i[ 99 ], o[ 999 ], b[ 99 ], z[ 99 ];

/* Global ints initialized to zeros */
t, x, n, c;

main()
{
    /* Grab input string from stdin, store into i */
    gets( i );

    /* Grab the <type> <array_name> and store into b and z */
    sscanf( i, "%s %[^[]s", b, z );

    /* Grab only the int values and concatenate to output string */
    while( sscanf( i + t, "%*[^0-9]%d%n", &x, &n ) == 1 )
    {
        /* Format the string and store into a */
        sprintf( o, "%s[%d] = %d;\n", z, c++, x );

        /* Get the current location of the pointer */
        t += n;
    }

    /* Print the <type> <array_name>[<size>]; and output string */
    printf( "%s %s[%d];\n%s", b, z, c, o );
}

संपर्क:

http://ideone.com/h81XbI

स्पष्टीकरण:

पाने के लिए <type> <array_name>, sscanf()प्रारूप स्ट्रिंग यह है:

%s          A string delimited by a space
    %[^[]   The character set that contains anything but a `[` symbol
         s  A string of that character set

स्ट्रिंग से इंट वैल्यू निकालने के लिए int foo[] = {4, 8, 15, 16, 23, 42};, मैं अनिवार्य रूप से इस फ़ंक्शन के साथ स्ट्रिंग को टोकन देता हूं:

while( sscanf( i + t, "%*[^0-9]%d%n", &x, &n ) == 1 )

कहा पे:

  • iइनपुट स्ट्रिंग (ए char*) है
  • t सूचक स्थान ऑफ़सेट है i
  • xintस्ट्रिंग से पार्स किया गया वास्तविक है
  • n पाया अंकों सहित कुल पात्रों का उपभोग किया जाता है

sscanf()प्रारूप स्ट्रिंग इसका मतलब यह है:

%*            Ignore the following, which is..
  [^0-9]      ..anything that isn't a digit
        %d    Read and store the digit found
          %n  Store the number of characters consumed

यदि आप चार स्ट्रिंग के रूप में इनपुट स्ट्रिंग की कल्पना करते हैं:

int foo[] = {4, 8, 15, 16, 23, 42};
^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
00000000001111111111222222222233333
01234567890123456789012345678901234

साथ int 4सूचकांक 13 पर स्थित जा रहा है, 8सूचकांक 16, और इतने पर पर, यह क्या की तरह दिखता है पाश में प्रत्येक रन का परिणाम है:

Run 1)  String: "int foo[] = {4, 8, 15, 16, 23, 42};"
        Starting string pointer: str[ 0 ]
        Num chars consumed until after found digit: 14
        Digit that was found: 4
        Ending string pointer: str[ 14 ]

Run 2)  String: ", 8, 15, 16, 23, 42};"
        Starting string pointer: str[ 14 ]
        Num chars consumed until after found digit: 3
        Digit that was found: 8
        Ending string pointer: str[ 17 ]

Run 3)  String: ", 15, 16, 23, 42};"
        Starting string pointer: str[ 17 ]
        Num chars consumed until after found digit: 4
        Digit that was found: 15
        Ending string pointer: str[ 21 ]

Run 4)  String: ", 16, 23, 42};"
        Starting string pointer: str[ 21 ]
        Num chars consumed until after found digit: 4
        Digit that was found: 16
        Ending string pointer: str[ 25 ]

Run 5)  String: ", 23, 42};"
        Starting string pointer: str[ 25 ]
        Num chars consumed until after found digit: 4
        Digit that was found: 23
        Ending string pointer: str[ 29 ]

Run 6)  String: ", 42};"
        Starting string pointer: str[ 29 ]
        Num chars consumed until after found digit: 4
        Digit that was found: 42
        Ending string pointer: str[ 33 ]

1
आप oस्प्रिंट के माध्यम से, अंदर घुसकर स्ट्रैकट का उपयोग करने से बच सकते हैं %s। यह लगभग 7 वर्णों का होना चाहिए।
tucuxi

@tucuxi आह, अच्छी पकड़। धन्यवाद!
होमसर्पसन

7

सी, 195 180 बाइट्स

195-बाइट मूल:

golfed:

char*a,*b,*c,*d;j;main(i){scanf("%ms %m[^]]%m[^;]",&a,&b,&c);
for(d=c;*d++;i+=*d==44);printf("%s %s%d];\n",a,b,i);
for(d=strtok(c,"] =,{}");j<i;j++,d=strtok(0," ,}"))printf("%s%d] = %s;\n",b,j,d);}

ungolfed:

char*a,*b,*c,*d;
j;
main(i){
    scanf("%ms %m[^]]%m[^;]",&a,&b,&c); // m-modifier does its own mallocs
    for(d=c;*d++;i+=*d==44);            // count commas
    printf("%s %s%d];\n",a,b,i);        // first line
    for(d=strtok(c,"] =,{}");j<i;j++,d=strtok(0," ,}"))
        printf("%s%d] = %s;\n",b,j,d);  // each array value
}

दोनों शॉर्टकट नंबर-पार्सिंग भाग करने के लिए अपनी खुद की मेमोरी को आवंटित mकरने के लिए स्कैन करने के %sलिए (चार सरणियों की घोषणा को बचाता है), और strtok(जो कि डिफ़ॉल्ट रूप से भी उपलब्ध है, बिना शामिल है) को आवंटित करने के लिए संशोधक का उपयोग कर रहे हैं ।


180-बाइट अपडेट:

char*a,*b,*c,e[999];i;main(){scanf("%ms %m[^]]%m[^}]",&a,&b,&c);
for(c=strtok(c,"] =,{}");sprintf(e,"%s%s%d] = %s;\n",e,b,i++,c),
c=strtok(0," ,"););printf("%s %s%d];\n%s",a,b,i,e);}

ungolfed:

char*a,*b,*c,e[999];
i;
main(){
    scanf("%ms %m[^]]%m[^}]",&a,&b,&c);
    for(c=strtok(c,"] =,{}");sprintf(e,"%s%s%d] = %s;\n",e,b,i++,c),c=strtok(0," ,"););
    printf("%s %s%d];\n%s",a,b,i,e);
}

कॉमा को गिनने से बचने के लिए एक स्ट्रिंग में जोड़ने के bnf679 के विचार का उपयोग करता है ।


6

पायथन 3.6 (प्री-रिलीज़), 133

m,p=str.split,print;y,u=m(input(),'[');t,n=m(y);i=m(u[5:-2],', ')
l=len(i);p(t,n+f'[{l}];')
for x in range(l):p(n+f'[{x}] = {i[x]};')

एफ-स्ट्रिंग्स का भारी उपयोग करता है ।

Ungolfed संस्करण:

y, u = input().split('[')
t, n = y.split()
i = u[5:-2].split(', ')
l = len(i)
print(t, n + f'[{l}];')
for x in range(l):
    print(n + f'[{x}] = {i[x]};')

1
वाह, मैं एफ-स्ट्रिंग्स के बारे में भूल गया। वे गोल्फ के लिए सुपर उपयोगी होने जा रहे हैं!
मॉर्गन थ्रैप

मुझे लगता है कि आप सामान्य लूप के बजाय एक सूची समझ का उपयोग करके एक बाइट को बचा सकते हैं
someonewithpc

@someonewithpc: nope, यह वास्तव में 1 अतिरिक्त बाइट
जोड़ेगा

5

रूबी, 127 110 108 99 88 बाइट्स

इनपुट के रूप में एकल तर्क के साथ अनाम फ़ंक्शन।पूरा कार्यक्रम, STDIN से इनपुट पढ़ता है। (यदि आप किसी फ़ाइल को पाइप करते हैं, तो अनुगामी न्यूलाइन वैकल्पिक है।) रिटर्न आउटपुट स्ट्रिंग को प्रिंट करता है।

@TimmyD ने उनके समाधान के बारे में डींग मारते हुए अन्य सभी गैर-पलायनियों को एक चुनौती के रूप में लिया, और आखिरकार उन्होंने (बाइटिंग के समय) 114 बाइट पॉवर्स हल जो उन्होंने पोस्ट किया था, को पार कर लिया। C O'Blic की चाल को विभाजित करने ]और दूसरी छमाही में अंक पाने में मदद करने के लिए छलनी के साथ ।

मुझे स्पैट ऑपरेटर का अधिक उपयोग करने की आवश्यकता है। यह बहुत उपयोगी है!

@ नील के जावास्क्रिप्ट ES6 जवाब से एक चाल उधार लिया उपयोग करने के बजाय शब्दों के लिए स्कैन करके और बाइट्स को बचाने के लिए .. gsubऔरsplit

t,n,*l=gets.scan /-?\w+/;i=-1
puts t+" #{n}[#{l.size}];",l.map{|e|n+"[#{i+=1}] = #{e};"}

AFAICT का कार्य एक पूर्ण कार्यक्रम लिखना है।
तिजोरी

@vaultah कोड गोल्फ के लिए डिफ़ॉल्ट एक प्रोग्राम या कार्य है
Mego

@ मेगो: ओपी ने कहा "आपको एक कार्यक्रम लिखना होगा"
तिजोरी

@vaultah आम तौर पर मैं कहूंगा कि कोड गोल्फ मुझे एक फ़ंक्शन का उपयोग करने की अनुमति देता है, लेकिन एक पूर्ण कार्यक्रम ने मुझे 2 बाइट्स बचाए, तो क्यों नहीं?
वैल्यू इंक

Ooof ... मुझे नहीं लगता कि PowerShell उस तक उतर सकता है। एक +1
AdmBorkBork

4

05AB1E , 52 50 47 बाइट्स

कोड:

… = ¡`¦¨¨ð-',¡©gr¨s«„];«,®v¹ð¡¦¬s\¨N"] = "y';J,

CP-1252 एन्कोडिंग का उपयोग करता है । इसे ऑनलाइन आज़माएं!


1
यह उस बिंदु पर पहुँच गया है जहाँ मैं अन्य सभी उत्तरों को छोड़ देता हूँ और आपके 05AB1E उत्तरों की तलाश करता हूँ। भाषा मुझे बिल्कुल रोमांचित करती है।
वॉरसडॉटनट

1
@WorseDoughnut धन्यवाद! यह सबसे अच्छी बात है जो किसी ने मुझे 05AB1E के बारे में कभी कहा है :)!
अदनान

4

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

(s,[t,n,...m]=s.match(/-?\w+/g))=>t+` ${n}[${m.length}];`+m.map((v,i)=>`
${n}[${i}] = ${v};`).join``

चूँकि केवल शब्द ही महत्वपूर्ण हैं, यह मूल स्ट्रिंग में सभी शब्दों के मेल से ही काम करता है, और इसके बाद ऋणात्मक संकेत प्राप्त करता है, फिर परिणाम का निर्माण करता है। (मैंने मूल रूप से सोचा था कि मैं उपयोग करने जा रहा हूं replaceलेकिन यह एक लाल हेरिंग निकला।)


[t,n,...m]लगभग एक रहस्यवादी दृष्टि
edc65


4

पिप , 48 47 बाइट्स

qR`(\S+)(. = ).(.+)}`{[b#Yd^k']';.n.b.,#y.c.y]}

स्टडिन और प्रिंट्स से स्टडआउट तक इनपुट लेता है।

व्याख्या

Tl; dr: परिणाम का निर्माण करने के लिए कैप्चर समूहों और कॉलबैक फ़ंक्शन का उपयोग करके एक रेगेक्स प्रतिस्थापन करता है।

qविशेष चर इनपुट की एक पंक्ति पढ़ता है। रेगेक्स वह है (\S+)(. = ).(.+)}, जो टाइप (स्पेसिंग ट्रेल सहित) और अंतिम अर्धविराम को छोड़कर सब कुछ मेल खाता है। सवाल से पहला उदाहरण का उपयोग करना, कब्जा समूहों मिल foo[, ] = और4, 8, 15, 16, 23, 42

प्रतिस्थापन अनाम फ़ंक्शन का वापसी मान है {[b#Yd^k']';.n.b.,#y.c.y]}, जिसे पूरे मैच के साथ-साथ कैप्चरिंग समूहों को तर्क के रूप में कहा जाता है। इस प्रकार, फ़ंक्शन के भीतर, bसमूह 1 पर कब्जा कर cलेता है , समूह 2 प्राप्त करता है, औरd समूह 3 प्राप्त करता है।

हम एक सूची का निर्माण, जिनमें से पहले तीन आइटम हो जाएगा "foo[", 6और "]"। प्राप्त करने के लिए 6, हम dअंतर्निहित चर k= ", ", भविष्य के उपयोग के लिए चर Yमें पूर्णांकों की परिणामी सूची को विभाजित करते yहैं, और लंबाई ( #) लेते हैं ।']एक चरित्र शाब्दिक है।

फार्म के तारों की एक श्रृंखला का निर्माण करने के लिए क्या रहता है ";\nfoo[i] = x"। ऐसा करने के लिए, हम निम्नलिखित श्रेणीबद्ध: ';, n(एक अंतर्निहित न्यू लाइन के लिए), b(1 कब्जा समूह), ,#y(अजगर के बराबर range(len(y))), c(2 कैप्चर समूह), और y। कॉन्टेक्टेशन सूचियों और श्रेणियों पर आइटम वाइज काम करता है, इसलिए परिणाम स्ट्रिंग्स की एक सूची है। सभी को एक साथ रखकर, फ़ंक्शन का रिटर्न मान इस तरह से एक सूची होगा:

["foo[" 6 "]"
 [";" n "foo[" 0 "] = " 4]
 [";" n "foo[" 1 "] = " 8]
 [";" n "foo[" 2 "] = " 15]
 [";" n "foo[" 3 "] = " 16]
 [";" n "foo[" 4 "] = " 23]
 [";" n "foo[" 5 "] = " 42]
]

चूँकि इस सूची का उपयोग स्ट्रिंग Rविस्थापन में किया जा रहा है , इसलिए इसे अंतर्निहित रूप से एक स्ट्रिंग में डाला जाता है। पिप में डिफ़ॉल्ट सूची-से-स्ट्रिंग रूपांतरण सभी तत्वों को मिला रहा है:

"foo[6];
foo[0] = 4;
foo[1] = 5;
foo[2] = 15;
foo[3] = 16;
foo[4] = 23;
foo[5] = 42"

अंत में, परिणाम (प्रकार और अंतिम अर्धविराम सहित), जो रेगेक्स द्वारा मेल नहीं खाते थे और इस प्रकार अपरिवर्तित रहते हैं) स्वतः-मुद्रित होता है।


4

पर्ल 5.10, 73 72 68 66 + 1 (एक स्विच के लिए) = 67 बाइट्स

perl -nE '($t,$n,@a)=/[-[\w]+/g;say"$t $n".@a."];";say$n,$i++,"] = $_;"for@a'

यह पर्ल के लिए एक अच्छी चुनौती है और अब तक की सामान्य-उद्देश्य वाली भाषाओं में सबसे छोटी है। के बराबर

($t, $n, @a) = /[-[\w]+/g;
say "$t $n" . @a . "];";
say $n, $i++, "] = $_;" for @a;

4

PowerShell v2 +, 114 105 बाइट्स

$a,$b,$c,$d=-split$args-replace'\[]';"$a $b[$(($d=-join$d|iex|iex).length)];";$d|%{"$b[$(($i++))] = $_;"}

इनपुट स्ट्रिंग लेता है $argsऔर -replaceवर्ग ब्रैकेट को कुछ भी नहीं करता है, फिर व्हाट्सएप -splitपर करता है । हम पहले बिट में $a, दूसरे बिट में $b, =में $cऔर सरणी तत्वों को स्टोर करते हैं $d। नीचे दिए गए उदाहरण के लिए, इस भंडार fooमें $aऔर barमें $bऔर सरणी के सभी में$d

हम तो उत्पादन के साथ हमारी पहली लाइन "$a ..."और बीच में परिणत $dप्रपत्र के तार के एक एक सरणी से {1,, 2,... 100};द्वारा एक नियमित पूर्णांक सरणी के लिए -joinयह एक साथ ing एक स्ट्रिंग में है, तो के माध्यम से यह चल रहा है iexदो बार (के समान eval)। हम उस परिणामी सरणी को स्टोर करते हैं $dजिससे .lengthविधि को कॉल करने से पहले उपयुक्त संख्या को बीच में पॉपुलेट किया जा सके[] आउटपुट लाइन के ।

हम तब के $dसाथ एक पाश के माध्यम से भेजते हैं |%{...}। प्रत्येक पुनरावृत्ति हम "$b..."एक $iकोष्ठक और वर्तमान मूल्य में समझाया काउंटर चर के साथ उत्पादन करते हैं $_$iचर अप्रारंभीकृत शुरू होता है (के बराबर $nullहै), लेकिन ++एक के लिए यह डाली होगा intउत्पादन से पहले, तो यह कम से उत्पादन शुरू कर देंगे 0बढ़ाने से पहले, सभी$i अगले पाश यात्रा के लिए।

सभी आउटपुट लाइनों को पाइपलाइन पर छोड़ दिया जाता है, और टर्मिनल में आउटपुट प्रोग्राम समाप्ति पर निहित है।

उदाहरण

PS C:\Tools\Scripts\golfing> .\expand-a-c-array.ps1 "foo bar[] = {1, 2, 3, -99, 100};"
foo bar[5];
bar[0] = 1;
bar[1] = 2;
bar[2] = 3;
bar[3] = -99;
bar[4] = 100;

वाह! मैं एक चुनौती के रूप में अन्य गैर-esolangs की पिटाई के बारे में अपनी टिप्पणी लेने के द्वारा अपने रूबी जवाब गोल्फ पिछले तुम्हारा पाने में कामयाब रहे! अच्छा काम, यद्यपि, +1।
वैल्यू इंक

@KevinLau धन्यवाद! अब 105 के साथ वाई पर वापस। ;-)
AdmBorkBork

मैं आपका १०५ पर कॉल करूँगा, और आपको ९९ बढ़ाऊंगा! : D
मूल्य इंक

अब रेटिना को पीटना बंद नहीं है।
कैलक्यूलेटरफेलीन

3

सी, 278 280 बाइट्स

golfed:

x,e,l,d;char *m,*r,*a;char i[999];c(x){return isdigit(x)||x==45;}main(){gets(i);m=r=&i;while(*r++!=32);a=r;while(*++r!=93);l=r-a;d=r-m;for(;*r++;*r==44?e++:1);printf("%.*s%d];\n",d,m,e+1);r=&i;while(*r++){if(c(*r)){m=r;while(c(*++r));printf("%.*s%d] = %.*s;\n",l,a,x++,r-m,m);}}}

ungolfed:

/* global ints
 * x = generic counter
 * e = number of elements
 * l = length of the array type
 * d = array defination upto the first '['
 */
x,e,l,d;
/* global pointers
 * m = memory pointer
 * r = memory reference / index
 * a = pointer to the start of the array type string
 */
char *m,*r,*a;
/* data storage for stdin */
char i[999];
c(x){return isdigit(x)||x=='-';}
main(){
    gets(i);
    m=r=&i;
    while(*r++!=32);                // skip first space
    a=r;
    while(*++r!=93);                // skip to ']'
    l=r-a;
    d=r-m;
    for(;*r++;*r==44?e++:1);        // count elements
    printf("%.*s%d];\n",d,m,e+1);   // print array define
    r=&i;
    while(*r++) {                   // print elements
        if(c(*r)) {                 // is char a - or a digit?
            m=r;
            while(c(*++r));         // count -/digit chars
            printf("%.*s%d] = %.*s;\n",l,a,x++,r-m,m);
        }
    }
}

इस पर काम करते समय किसी ने डेटा पॉइंटर्स का उपयोग करने के बजाय पार्सिंग के लिए sscanf का उपयोग करके एक छोटा संस्करण पोस्ट किया ... अच्छा!

अद्यतन: तत्व मुद्रण में बराबरी के आसपास गायब रिक्त स्थान, आईडीई ऑनलाइन लिंक: http://ideone.com/KrgRt0 । ध्यान दें कि यह कार्यान्वयन नकारात्मक संख्याओं का समर्थन करता है ...


2

अवाक, 101 बाइट्स

{FS="[^[:alnum:]_-]+";printf"%s %s[%d];\n",$1,$2,NF-3;for(i=3;i<NF;i++)printf$2"[%d] = %d;\n",i-3,$i}

अधिक आसानी से:

{
FS="[^[:alnum:]_-]+"
printf "%s %s[%d];\n", $1, $2, NF - 3
for (i=3; i < NF; i++)
    printf $2"[%d] = %d;\n", i-3, $i
}
  • मैंने अक्षर, अंक, अंडरस्कोर और को छोड़कर सभी को फ़ील्ड विभाजक सेट किया -। तो, फ़ील्ड प्रकार नाम, चर नाम और संख्याएँ होंगे।
  • फ़ील्ड की संख्या 1 होगी (प्रकार के लिए) + 1 (नाम के लिए) + एन (संख्या) + 1 (अनुगामी के बाद एक खाली फ़ील्ड };)। तो, सरणी का आकार हैNF - 3
  • फिर यह केवल घोषणा के लिए एक विशेष लाइन को प्रिंट कर रहा है, और संख्याओं पर लूपिंग कर रहा है।
  • मुझे या तो असाइन करना चाहिएFS जब awk का उपयोग करना (उपयोग करना -F) या किसी BEGINब्लॉक में। संक्षिप्तता के हितों में,…।

1
वास्तव में, FSया तो इसमें इस्तेमाल किया जाना चाहिए BEGINया -Fअन्यथा इसे पहली पंक्ति को विभाजित करने के लिए उपयोग नहीं किया जाएगा, और चूंकि इनपुट की केवल 1 पंक्ति है ...
रॉबर्ट बेंसन

@RobertBenson आप सही कह रहे हैं, इसलिए कमांड होगा awk '-F[^[:alnum:]_-]+' '{printf"%s %s[%d];\n",$1,$2,NF-3;for(i=3;i<NF;i++)printf$2"[%d] = %d;\n",i-3,$i}', जो 102 बाइट्स की गिनती awkखुद नहीं कर रहा है। हममम। क्या मुझे उद्धरणों को छोड़ना है?
मुरु

हां, आप उद्धरणों को बाहर कर सकते हैं। आप कभी-कभी इसे C+O bytesजहां Cऔर जहां Oकोड और विकल्पों से क्रमशः बाइट्स का प्रतिनिधित्व करते हैं, के रूप में सूचीबद्ध करते हैं। बेशक मैं आमतौर पर सिर्फ एक BEGINब्लॉक का उपयोग करता हूं, इसलिए मुझे इसके बारे में सोचने की जरूरत नहीं है। : पी
रॉबर्ट बेन्सन

2

जावास्क्रिप्ट ईएस 6, 134 132 130 129 बाइट्स

नील की बदौलत बचा 1 बाइट।

x=>(m=x.match(/(\w+) (\w+).+{(.+)}/),m[1]+` `+(q=m[2])+`[${q.length-1}];
`+m[3].split`, `.map((t,i)=>q+`[${i}] = ${t};`).join`
`)

नहीं `[${i}] = `+t+";"होना चाहिए `[${i}] = ${t};`?
नील

@ नील धन्यवाद, एक बाइट बचाया!
कॉनर ओ'ब्रायन

2

बैश, 133 129 बाइट्स

read -a l
d="${l[@]:0:2}"
e=("${l[@]:3}")
echo "${d%?}${#e[@]}];"
for i in "${!e[@]}"
{
echo "${l[0]}[$i] = ${e[$i]//[!0-9]/};"
}

पहला प्रयास, सुनिश्चित करें कि इसका पॉसिबल कम हो।


2

डी, 197 , 188 बाइट्स

import std.array,std.stdio;void main(){string t,n,e;readf("%s %s] = {%s}",&t,&n,&e);auto v=e.replace(",","").split;writeln(t,' ',n,v.length,"];");foreach(i,c;v)writeln(n,i,"] = ",c,";");}

या अपुष्ट:

import std.array, std.stdio;

void main() {
    string type, nameAndBracket, elems;
    readf("%s %s] = {%s}", &type, &nameAndBracket, &elems);

    // remove all commas before splitting the string into substrings
    auto vector = elems.replace(",","").split();

    // writeln is shorter than fln by 1 char when filled in
    writeln(type, ' ', nameAndBracket, vector.length, "];");

    // print each element being assigned
    foreach(index, content; vector)
        writeln(nameAndBraket, index, "] = ", content, ";");
}

मुझे D नहीं पता है, लेकिन क्या आप नाम के हिस्से के रूप में शुरुआती वर्ग ब्रैकेट पढ़ सकते हैं? इससे आपको बाद में अलग से एक वर्ग ब्रैकेट लिखने में मदद मिलेगी।
DLosc

2

जूलिया, 154 134 101 बाइट्स

f(s,c=matchall(r"-?\w+",s),n=endof(c)-2)=c[]" "c[2]"[$n];
"join([c[2]"[$i] = "c[i+3]";
"for i=0:n-1])

यह एक फ़ंक्शन है जो एक स्ट्रिंग को स्वीकार करता है और एक एकल अनुगामी न्यूलाइन के साथ एक स्ट्रिंग देता है।

Ungolfed:

function f(s, c = matchall(r"-?\w+", s), n = endof(c) - 2)
    c[] " " c[2] "[$n];\n" join([c[2] "[$i] = " x[i+3] ";\n" for i = 0:n-1])
end

हम cनियमित अभिव्यक्ति पर इनपुट के मिलान के एक सरणी के रूप में परिभाषित करते हैं -?\w+। यह प्रकार, सरणी नाम, फिर प्रत्येक मान को कैपिटल करता है। हम nकी लंबाई के रूप में संग्रहीत करते हैंc - 2 , जो मानों की संख्या है। आउटपुट का निर्माण प्रकार, नाम और लंबाई स्ट्रिंग के रूप में किया जाता है, जिसे न्यूलाइन द्वारा अलग-अलग परिभाषा रेखा के साथ जोड़ा जाता है। जो भी कारण हो, c[]वही है c[1]

डेनिस की मदद से 32 बाइट्स बचाए!



1

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

t,v,_,*l=input().split();v=v[:-1]+'%s]'
print(t,v%len(l)+';');i=0
for x in l:print(v%i,'= %s;'%x.strip('{,};'));i+=1

इनपुट को प्रकार, नाम और संख्याओं की सूची में विभाजित करता है। घोषित करने वाले सरणी को प्रिंट करने के बाद, पहले और अंतिम एक से जुड़े अतिरिक्त विराम चिह्नों को हटाते हुए, संख्याओं के माध्यम से मैन्युअल रूप से गणना करके तत्वों को प्रिंट करता है।

पायथन 2 में एक अलग दृष्टिकोण 122 बाइट्स के लिए निकला:

a,b=input()[:-2].split('] = {')
l=eval(b+',')
print a+`len(l)`+"];"
for y in enumerate(l):print a.split()[1]+'%s] = %s;'%y

विचार evalएक टपल के रूप में संख्याओं की सूची है, अंत में एक अल्पविराम के साथ ताकि एक एकल संख्या को एक प्रकार के रूप में मान्यता दी जाए। संख्याओं की गणना की गई सूची स्ट्रिंग-प्रारूप में ट्यूपल प्रदान करती है।


1

PHP, 143 बाइट्स

golfed

<?$t=count($n=explode(' ',preg_replace('/[^\s\w]/','',$argv[1])))-3;echo"$n[0] {$n[1]}[$t];";for($i=2;$t>$j=++$i-3;)echo$n[1]."[$j] = $n[$i];";

Ungolfed

<?  
$t = count(                                  // Get the number of elements for our array...
    $n = explode(' ',                            // After split the input on whitespace...
    preg_replace('/[^\s\w]/','',$argv[1])))-3;  // After removing all special characters.
echo "$n[0] {$n[1]}[$t];";                     // First line is type, name, and count.
for($i=2;                                        // Loop through array elements
    $t > $j = ++$i-3;)                         // Assign j to be the actual index for our new array
    echo $n[1]."[$j] = $n[$i];";                // Print each line

इनपुट कमांड लाइन तर्क के माध्यम से लिया जाता है। नमूना:

C:\(filepath)>php Expand.php "int foo[] = {4,8,15,16,23,42};"

आउटपुट:

int foo[6];foo[0] = 4;foo[1] = 8;foo[2] = 15;foo[3] = 16;foo[4] = 23;foo[5] = 42;

0

MATL , 68 64 58 बाइट्स

'\w+'XX2:H#)XKxXIZc'['KnV'];'v!K"I2X)'['X@qV'] = '@g';'6$h

यह C नहीं है, लेकिन यह C-like sprintfफंक्शन Nah का उपयोग करता है , जो 4 बाइट बर्बाद कर रहा था।

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

          % Take input implicitly
'\w+'XX   % Find substrings that match regex '\w+'. Gives a cell array
2:H#)     % Split into a subarray with the first two substrings (type and name), and 
          % another with the rest (numbers that form the array)
XKx       % Copy the latter (numbers) into clipboard K. Delete it
XI        % Copy the former (type and name) into clipboard I
Zc        % Join the first two substrings with a space
'['       % Push this string
K         % Paste array of numbers
nV        % Get its length. Convert to string
'];'      % Push this string
v!        % Concatenate all strings up to now. Gives first line of the output
K"        % For each number in the array
  I2X)    %   Get name of array as a string
  '['     %   Push this string
  X@qV    %   Current iteration index, starting at 0, as a string
  '] = '  %   Push this string
  @g      %   Current number of the array, as a string
  ';'     %   Push this string
  5$h     %   Concatenate top 6 strings. This is a line of the output
          % Implicity end for each
          % Implicitly display

0

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

#(let[[t n & v](re-seq #"-?\w+"%)](apply str t" "n\[(count v)"];\n"(map(fn[i v](str n"["i"] = "v";\n"))(range)v))))

मैं अच्छी तरह से विलय awful_array_name[5];और awful_array_name[0] = 7;भागों में सक्षम नहीं था ताकि वे कोड का फिर से उपयोग करें: /

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