जिमी इन सरण


23

मेरे सहकर्मी, जिमी C / C ++ में थोड़े नए हैं। वह धीमे सीखने वाले भी हैं। अब, निष्पक्ष होने के लिए, उसका कोड हमेशा संकलित करता है, लेकिन उसके पास वास्तव में कुछ बुरी आदतें हैं। उदाहरण के लिए, हर कोई जानता है कि आप इस तरह एक सरणी को परिभाषित कर सकते हैं:

int spam[] = {4, 8, 15, 16, 23, 42};

जिमी को छोड़कर हर कोई है। वह आश्वस्त है कि एक सरणी बनाने का एकमात्र तरीका इस तरह है:

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

मैं कोड-समीक्षा में उसके लिए यह तय कर रहा हूं, लेकिन वह नहीं सीखेगा। इसलिए मुझे आपको एक ऐसा टूल लिखना होगा, जो कमिट होने पर ऑटोमैटिकली उसके लिए ऐसा करे।

चुनौती

मैं चाहता हूं कि आप या तो एक पूरा कार्यक्रम लिखें या एक फ़ंक्शन जो इनपुट के रूप में एक मल्टीलाइन स्ट्रिंग में लेता है, और सी सरणी के अधिक कॉम्पैक्ट संस्करण को आउटपुट करता है। इनपुट हमेशा इस प्रारूप का अनुसरण करेगा , जिसमें व्हाट्सएप शामिल है:

identifier_one identifier_two[some_length];
identifier_two[0] = some_number;
identifier_two[1] = some_number;
identifier_two[2] = some_number;
...
identifier_two[some_length - 1] = some_number;

संक्षेप में, इनपुट हमेशा मान्य और अच्छी तरह से परिभाषित सी होगा। अधिक विवरण में:

सभी पहचानकर्ता सिर्फ अक्षरों और अंडरस्कोर से बने होंगे। लंबाई हमेशा कम से कम एक होगी, और कोई भी लापता या सीमा सूचकांक से बाहर कभी नहीं होगा। आप यह भी मान सकते हैं कि अनुक्रमित क्रम में हैं। उदाहरण के लिए:

foo bar[3];
bar[0] = 1
bar[2] = 9;

foo bar[1];
bar[0] = 1;
bar[1] = 3;

तथा

foo bar[3];
bar[2] = 9;
bar[0] = 1
bar[1] = 3

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

identifier_one identifier_two[] = {n1, n2, n3, ...};

यहाँ कुछ नमूना डेटा है:

Input:
spam eggs[10];
eggs[0] = 0;
eggs[1] = 4;
eggs[2] = 8;
eggs[3] = -3;
eggs[4] = 3;
eggs[5] = 7;
eggs[6] = 888;
eggs[7] = 555;
eggs[8] = 0;
eggs[9] = -2;

Output:
spam eggs[] = {0, 4, 8, -3, 3, 7, 888, 555, 0, -2};

Input:
char ans[2];
ans[0] = 52;
ans[1] = 50;

Output:
char ans[] = {52, 50};

Input:
blah_blah quux[1];
quux[0] = 105;

Output:
blah_blah quux[] = {105};

आप अपने इनपुट और आउटपुट को किसी भी उचित प्रारूप में ले सकते हैं, जैसे STDIN / STDOUT, फ़ंक्शन आर्गुमेंट्स और रिटर्न वैल्यू, फाइल पढ़ना और लिखना आदि। स्टैंडर्ड लूपहोल्स लागू होते हैं। बाइट्स जीत में सबसे छोटा जवाब!


Ideaयह निष्क्रिय और आक्रामक विचार है। आप था नहीं मुझ से इस विचार को मिलता है।




@ डोल्स आह, यही जिमी अपनी पूर्व-प्रतिबद्ध स्क्रिप्ट में उपयोग कर रहा है!
बरगी

9
बेशक कि जिमी एक कोड गोल्फर नहीं है।
jimmy23013

इस चुनौती ने वास्तव में मेरे जिस्मों को तोड़ दिया
DanTheMan

जवाबों:


8

विम, 43 36 बाइट्स

आपको जिमी को एक स्क्रिप्ट देने की आवश्यकता नहीं है, बस उसे एक उचित पाठ संपादक का उपयोग करने के लिए सिखाएं। (स्पष्टता के लिए शाब्दिक रिटर्न)

:%s/.*=//|%s/;\n/,/<cr><cr>
3wcf ] = {<esc>
$s};

अच्छा! इस विशिष्ट उदाहरण में, <C-a>की तुलना में कम है t], जो एक मजेदार छोटी हैक है। इसके अलावा, मुझे लगता है कि आपको तकनीकी रूप <cr>से 2 की आवश्यकता है क्योंकि यह पुष्टि के लिए पूछता है।
DJMcMayhem


इसके अलावा, norm df=की तुलना में कम हैs/.*=//g
DJMcMayhem

1
साथ ही, इससे 3wC] = {<esc>छोटा है <C-a>di]$s = {<esc>
DJMcMayhem

1
@Geobits अपने Emacs जवाब कहाँ है?
नील

7

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

qN/('[/~;"[] = {"@{S/W=W<}%", "*"};"

ऑनलाइन उदाहरण

स्पष्टीकरण:

qN/                                     |Read all lines to array
   ('[/~;                               |slice first line left of [
         "[] = {"                       |add formatting to stack
                 @                      |rotate to remaining lines
                  {      }%             |for each line in array
                   S/W=                 |split after last space
                       W<               |remove last character (;)
                           ", "*        |insert ", " to array
                                "};"    |add formatting

मेरे पहले सीजेएम उत्तर पर सुधार के लिए मार्टिन एंडर का एक बड़ा धन्यवाद ।


6

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

s=>`${s.split`[`[0]}[] = {${s.match(/-?\d+(?=;)/g).join`, `}};`

5

रेटिना , 30 28 बाइट्स

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

\d+];¶.+ 
] = {
;¶.+=
,
;
};

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

व्याख्या

हम उदाहरण के रूप में निम्नलिखित इनपुट का उपयोग करेंगे:

spam eggs[4];
eggs[0] = 0;
eggs[1] = 4;
eggs[2] = 8;
eggs[3] = -3;

चरण 1

\d+];¶.+ 
] = {

ध्यान दें कि पहली पंक्ति में एक अनुगामी स्थान है।

हम एक नंबर ];और उसके बाद एक पंक्ति का मिलान करके शुरू करते हैं , और फिर अगली पंक्ति के अंतिम स्थान तक सब कुछ। यह मैच केवल पहली पंक्ति के अंत में (के कारण ];) पाया जा सकता है । यह सब के साथ बदल दिया है ] = {। अर्थात्, यह हमारे उदाहरण इनपुट को निम्न में बदल देता है:

spam eggs[] = {0;
eggs[1] = 4;
eggs[2] = 8;
eggs[3] = -3;

चरण 2

;¶.+=
,

अब हम अगली पंक्ति पर एक ;अप से सब कुछ मेल खाते हैं =और एक के साथ प्रतिस्थापित करते हैं ,। यह स्ट्रिंग को निम्न में बदल देता है:

spam eggs[] = {0, 4, 8, -3;

स्टेज 3

;
};

सभी बाईं है कि अंत फिक्सिंग है और हम जगह ही शेष करके ऐसा कर ;के साथ };:

spam eggs[] = {0, 4, 8, -3};

5

जूलिया, 112 108 105 बाइट्स

f(s)=string(split(s,'[')[1],"[] = {",join([m[1] for m in [eachmatch(r"= *(-?\d+)",s)...]],", "),"};")

व्याख्या

string(                                                         # build output string
split(s,'[')[1],                                                # get declaration (e.g. spam eggs)
"[] = {",                                                       # add [] = {
join(                                                           # collect numbers
    [m[1] for m in [eachmatch(r"= *(-?\d+)",s)...]],            # regex out (signed) numbers
    ", "),                                                      # and join comma separated
"};"                                                            # add };
)                                                               # close string(

[प्रत्येक प्रहर () ...] और एक छोटी रीगेक्स के साथ कलेक्ट (प्रत्येक) () को हटाकर बाइट्स को सहेजा गया


नमस्ते, PPCG में आपका स्वागत है! यह एक बेहतरीन पहला जवाब लगता है। मुझ से +1। चूंकि चुनौती बताती है " आप अपने इनपुट और आउटपुट को किसी भी उचित प्रारूप में ले सकते हैं ", आप eachmatchकम सुंदर आउटपुट और -1 बाइट के लिए फ़ंक्शन-कॉल में अल्पविराम विभाजक के बाद स्थान को हटा सकते हैं । मैंने खुद जूलिया में कभी प्रोग्राम नहीं किया, लेकिन आपको यह पोस्ट पढ़ने में दिलचस्प लग सकती है: जूलिया में गोल्फ खेलने के टिप्स । फिर से स्वागत है, और अपने प्रवास का आनंद लें। :)
केविन क्रूज़सेन

1
अपनी तरह के शब्दों के लिए बहुत बहुत धन्यवाद :) PPCG देखने में मजेदार लग रहा था, इसलिए मैंने सोचा कि मैं इसे आज़माऊँगा। इस जवाब के लिए जूलिया को चुन लें क्योंकि यह अभी तक मौजूद नहीं थी
nyro_0

उपयोग करने matchallकी संभावना छप से भी कम होगी eachmatch
A. पर एलेक्स ए।

मैं पहले matchall का उपयोग करने की कोशिश की, लेकिन यह मुझे regex समूहों (कोष्ठक में हिस्सा है कि मैं विशेष रूप से क्या दिलचस्पी है) का उपयोग करने के लिए प्रत्येक नमूने के विपरीत है। (या मैं इसे प्रलेखन में नहीं खोज सका?)
nyro_0

3

लूआ, 121 बाइट्स।

function g(s)print(s:gmatch('.-%[')()..'] = {'..s:gsub('.-\n','',1):gsub('.-([%d.-]+);\n?','%1, '):gsub(',%s+$','};'))end

व्याख्या की

function g(s)
    print(                              -- Print, Self Explaintry.
        s:gmatch('.-%[')()..'] = {'     -- Find the 'header', match the first line's class and assignment name (everything up to the 'n]') and append that. Then, append ] = {.
                                        -- In the eggs example, this looks like; 'spam eggs[] = {' now
        ..                              -- concatenate...
        s:gsub('.-\n','',1)             -- the input, with the first line removed.
        :gsub('.-([%d.-]+);\n?','%1, ') -- Then that chunk is searched, quite boringly, a number followed by a semicolon, and the entire string is replaced with an array of those,
                                        -- EG, '1, 2, 3, 4, 5, 6, '
        :gsub(',%s+$','};')          -- Replace the final ', ' (if any) with a single '};', finishing our terrifying combination
    )
end

3

बैच, 160 बाइट्स

@echo off
set/ps=
set s=%s:[=[] = {&rem %
set r=
:l
set t=
set/pt=
if "%t%"=="" echo %r%};&exit/b
set t=%t:* =%
set r=%r%%s%%t:~2,-1%
set s=, 
goto l

नोट: लाइन set s=,एक स्थान के साथ समाप्त होती है। STDIN पर इनपुट लेता है। वह अजीब रेखा 3 इनपुट लेती है (उदाहरण के लिए int spam[6];और जिसके परिणामस्वरूप [बदल [] = {&remजाती है, set s=int spam[] = {&rem 6];जिसके बाद दो कथनों के रूप में व्याख्या की जाती है, set s=int spam[] = {और rem 6];, जिसमें से एक टिप्पणी है। फिर प्रत्येक पंक्ति के लिए हम पाठ को पहले स्थान तक हटा देते हैं (क्योंकि आप कर सकते हैं) ' =पैटर्न में t का उपयोग और मिलान गैर-लालची है) और मान निकालें।


3

सी, 121 बाइट्स

n=2;main(i){for(;putchar(getchar())^91;);for(printf("] = {");~scanf("%*[^=]%*c%d",&i);n=0)printf(", %d"+n,i);puts("};");}

3

अजगर 112 111

मेरे लिए बहुत सीधा है, कृपया मन में आने वाले किसी भी सुधार का सुझाव दें।

def f(l):
 a,*b=l.split('\n')
 return a[:a.index('[')]+'[] = {'+', '.join(r.split(' = ')[1][:-1]for r in b)+'};'


# TEST

lines = """spam eggs[10];
eggs[0] = 0;
eggs[1] = 4;
eggs[2] = 8;
eggs[3] = -3;
eggs[4] = 3;
eggs[5] = 7;
eggs[6] = 888;
eggs[7] = 555;
eggs[8] = 0;
eggs[9] = -2;"""
print (f(lines))
assert f(lines) == 'spam eggs[] = {0, 4, 8, -3, 3, 7, 888, 555, 0, -2};'

एक त्वरित नज़र में, मैं देख सकता हूँ कि वहाँ एक बेकार व्हाट्सएप है [:-1] for
यति

2

05AB1E , 31 30 28 बाइट्स

žh-|vy#¤¨ˆ\}¨… = ¯ïžuDÀÀ‡';J

व्याख्या

žh-¨                            # remove numbers and ";" from first input
    |v      }                   # for each of the rest of the inputs
      y#                        # split on spaces
        ¤¨                      # take the last element (number) minus the last char (";") 
          ˆ\                    # store in global array and throw the rest of the list away
             … =                # push the string " = "
                 ¯ï             # push global array and convert to int
                   žuDÀÀ‡       # replace square brackets of array with curly ones
                         ';     # push ";"
                           J    # join everything and display

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

अदनान को बाइट देकर धन्यवाद दिया


žuDÀÀके बजाय „[]„{}एक बाइट बचाता है :)।
अदनान

@ अदनान: सही है, अच्छा कैच!
एमिग्ना

2

जावा 7, 159 158 149 154 बाइट्स

String c(String[]a){a[0]=a[0].split("\\d")[0]+"] = {\b";for(String i:a)a[0]+=i.split("= [{]*")[1];return a[0].replace(";",", ").replaceFirst("..$","};");}

एकाधिक बाइट्स के लिए धन्यवाद बचाया @cliffroot

Ungolfed और परीक्षण कोड:

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

class M{
  static String c(String[] a){
    a[0] = a[0].split("\\d")[0] + "] = {\b";
    for(String i : a){
      a[0] += i.split("= [{]*")[1];
    }
    return a[0].replace(";", ", ").replaceFirst("..$", "};");
  }

  public static void main(String[] a){
    System.out.println(c(new String[]{ "spam eggs[10];", "eggs[0] = 0;", "eggs[1] = 4;",
      "eggs[2] = 8;", "eggs[3] = -3;", "eggs[4] = 3;", "eggs[5] = 7;", "eggs[6] = 888;",
      "eggs[7] = 555;", "eggs[8] = 0;", "eggs[9] = -2;" }));
    System.out.println(c(new String[]{ "char ans[2]", "ans[0] = 52;", "ans[1] = 50;" }));
    System.out.println(c(new String[]{ "blah_blah quux[1];", "quux[0] = 105;" }));
  }
}

आउटपुट:

spam eggs[] = {0, 4, 8, -3, 3, 7, 888, 555, 0, -2};
char ans[] = {52, 50};
blah_blah quux[] = {105};

1
कुछ बाइट्स सहेजे गएString c(String[]a){a[0]=a[0].split("\\d")[0]+"]={ \b";for(String i:a)a[0]+=i.split("=[{]*")[1];return a[0].replace(';',',').replaceFirst(".$","};");}
क्लिफरॉट

@cliffroot धन्यवाद! वास्तव में कुछ अच्छी चालें जैसे Stringपैरामीटर में फिर से उपयोग करना और अंतिम चार्ट "};");को एक के बजाय बदलना "")+"};";
केविन क्रूज़सेन

2

पर्ल, 42 + 2 ( -0p) = 44 बाइट्स

s%\d+].*%] = {@{[join",",/(-?\d+);/g]}};%s

जरूरत -pऔर -0झंडे चलाने के लिए। उदाहरण के लिए :

perl -0pe 's%\d+].*%] = {@{[join",",/(-?\d+);/g]}};%s' <<< "blah_blah quux[1];
quux[0] = 105;"

1

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

Ỵ©ḢḟØDṖ“ = {”®Ḳ€Ṫ€Ṗ€j⁾, ⁾};

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

व्याख्या

Ỵ         Split into lines
 ©Ḣ       Take the first one, store the others in ®
   ḟØD    Remove digits
      Ṗ   Remove trailing ;

“ = {”    Print a literal string

®         Recall the remaining lines
 Ḳ€       Split each into words
   Ṫ€     Keep each last word
     Ṗ€   Remove each trailing ;

j⁾,       Join by “, ”
    ⁾};   Literal “};”


1

जावा, 106 बाइट्स

जावा में स्ट्रिंग हेरफेर हमेशा की तरह नरक है।

a->a[0].join("",a).replaceAll(";\\w+\\[\\d+\\] = ",", ").replaceAll("\\d+\\], ","] = {").replace(";","};")

यह एक शुद्ध रेगेक्स उत्तर है। एक समवर्ती बनाएं String, फिर replaceXxxठीक होने तक प्रदर्शन करें ।

परीक्षण और अपुष्ट:

import java.util.function.Function;

public class Main {

  public static void main(String[] args) {
    Function<String[], String> f = a ->
        String.join("", a)                          // I think this would join. Not sure, though. Golfed into a[0].join because static members are accessible from instances.
            .replaceAll(";\\w+\\[\\d+\\] = ", ", ") // replace with regex
            .replaceAll("\\d+\\], ", "] = {")       // replace with regex
            .replace(";", "};");                    // replace no regex

    String[] spam = {
      "int spam[6];",
      "spam[0] = 4;",
      "spam[1] = 8;",
      "spam[2] = 15;",
      "spam[3] = 16;",
      "spam[4] = 23;",
      "spam[5] = 42;"
    };
    test(f, spam, "int spam[] = {4, 8, 15, 16, 23, 42};");

    String[] eggs = {
      "spam eggs[10];",
      "eggs[0] = 0;",
      "eggs[1] = 4;",
      "eggs[2] = 8;",
      "eggs[3] = -3;",
      "eggs[4] = 3;",
      "eggs[5] = 7;",
      "eggs[6] = 888;",
      "eggs[7] = 555;",
      "eggs[8] = 0;",
      "eggs[9] = -2;"
    };
    test(f, eggs, "spam eggs[] = {0, 4, 8, -3, 3, 7, 888, 555, 0, -2};");

    String[] ans = {
      "char ans[2];",
      "ans[0] = 52;",
      "ans[1] = 50;"
    };
    test(f, ans, "char ans[] = {52, 50};");

    String[] quux = {
      "blah_blah quux[1];",
      "quux[0] = 105;"
    };
    test(f, quux, "blah_blah quux[] = {105};");

  }

  static void test(Function<String[], String> f, String[] input, String expected) {
    System.out.printf("Result:   %s%nExpected: %s%n", f.apply(input), expected);
  }
}

0

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

ỴḊḲ€Ṫ€K⁾;,yṖ“{“};”j
ỴḢḟØDṖ,⁾ =,ÇK

TryItOnline

कैसे?

ỴḊḲ€Ṫ€K⁾;,yṖ“{“};”j - Link 1, parse and reform the values, same input as the Main link
Ỵ                   - split on line feeds
 Ḋ                  - dequeue (remove the first line)
  Ḳ€                - split each on spaces
    Ṫ€              - tail each (get the numbers with trailing ';')
      K             - join on spaces
       ⁾;,          - ";,"
          y         - map (replace ';' with ',')
           Ṗ        - pop (remove the last ',')
            “{“};”  - list of strings ["{","};"]
                  j - join (making "{" + "n0, n1, ,n2, ..." + "};")

ỴḢḟØDṖ,⁾ =,ÇK - Main link, takes one argument, the multiline string
Ỵ             - split on line feeds
 Ḣ            - head (just the first line)
   ØD         - digits yield "0123456789"
  ḟ           - filter out
     Ṗ        - pop (remove the trailing ';')
      ,   ,   - pair
       ⁾ =    - the string " ="
           Ç  - call the previous Link (1)
            K - join on spaces (add the space after the '=')

मतदाता - इसमें क्या गलत है?
जोनाथन एलन


0

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

मुझे पता है कि यह दूसरों की तुलना में लंबा है, लेकिन मैं वास्तव में उपयोग करना चाहता था eval। सिर्फ मनोरंजन के लिए।

f=function(s){m=/^(\w+ )(\w+).*?(;.*)/.exec(s)
eval("var "+m[2]+"=new Array()"+m[3]+'alert(m[1]+m[2]+"={"+eval(m[2])+"};")')}

चलाने के लिए, निम्नलिखित को यहाँ पेस्ट करें :

s='int spam[6];\
spam[0] = 4;\
spam[1] = 8;\
spam[2] = 15;\
spam[3] = 16;\
spam[4] = 23;\
spam[5] = 42;'
f=function(s){m=/^(\w+ )(\w+).*?(;.*)/.exec(s)
eval("var "+m[2]+"=new Array()"+m[3]+'alert(m[1]+m[2]+"={"+eval(m[2])+"};")')}
f(s)

0

हैक्स, 234 बाइट्स

function R(L:Array<String>){var S=L[0];var W=S.indexOf(" ");var T=S.substr(0,W),M=S.substring(W+1,S.indexOf("["));var r=[for(i in 1...L.length)L[i].substring(L[i].lastIndexOf(" ")+1,L[i].length-1)].join(', ');return'$T $M[] = {$r};';}

लंबे फ़ंक्शन नामों ने इसे मार दिया: डी

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


0

वी , 25 , 24 बाइट्स

3wC] = {òJd2f $s, òhC};

इसे ऑनलाइन आज़माएं! इसमें एक वर्णनीय <esc>चरित्र है, इसलिए यहां एक हेक्सडंप है:

0000000: 3377 435d 203d 207b 1bf2 4a64 3266 2024  3wC] = {..Jd2f $
0000010: 732c 20f2 6843 7d3b                      s, .hC};

स्पष्टीकरण:

3w                              "Move forward 3 words
  C     <esc>                   "Delete everything until the end of the line, and enter this text:
   ] = {                        "'] = {'
             ò         ò        "Recursively:
              J                 "  Join these two lines (which enters a space)
               d                "  Delete everything until you
                2f              "  (f)ind the (2)nd space
                   $            "  Move to the end of this line
                    s           "  Delete a character, and enter:
                     ,          "  ', '
                                "
                        h       "Move one character to the left
                         C      "Delete everything until the end of the line, and enter this text:
                          };    "'};'
हमारी साइट का प्रयोग करके, आप स्वीकार करते हैं कि आपने हमारी Cookie Policy और निजता नीति को पढ़ और समझा लिया है।
Licensed under cc by-sa 3.0 with attribution required.