एक COBOL कार्यक्रम को रद्द करें!

64

COBOL एक बहुत पुरानी भाषा है, लिखने के समय यह 58 वर्ष की होती है। यह वास्तव में इतना पुराना है, कि इसमें एक बहुत ही दिलचस्प विचित्रता है: प्रत्येक पंक्ति के पहले छह अक्षर टिप्पणी हैं।

यह क्यों है, आप पूछें? खैर, उन 6 वर्णों को लाइन नंबर के रूप में उपयोग करने का इरादा था, दिन में जहां प्रोग्राम पूरी तरह से डिजिटल नहीं थे और कंप्यूटर पर टाइप किए गए थे।

इसके अलावा, सातवां वर्ण केवल बहुत छोटे सेट का हिस्सा हो सकता है (यह आमतौर पर *लाइन या कोड को कोड से अलग करने के लिए एक स्थान बाहर टिप्पणी करने के लिए होता है)

लेकिन क्या होगा यदि आप एक अधिक डिजिटल सिस्टम पर हैं, और आप सिर्फ कच्चा प्रोग्राम चाहते हैं?

टिप्पणी प्रणाली

COBOL में दो प्रकार की टिप्पणियाँ हैं: लाइन टिप्पणियां और उपरोक्त "लाइन नंबर" टिप्पणियां।

लाइन संख्याओं को जोड़ना सरल है: प्रत्येक लाइन से पहले सात (छह प्लस एक सिंगल स्पेस) अक्षर लें।

000000 apple
000001 banana
celery donuts

बन जाएगा:

apple
banana
donuts

रेखा की टिप्पणियाँ इसे थोड़ा और कठिन बनाती हैं। एक पंक्ति टिप्पणी लाइन *पर सातवें चरित्र की स्थिति में रखे गए तारांकन के साथ शुरू की जाती है , जैसे:

000323* this is a comment

यह एक लाइन टिप्पणी नहीं है:

*00000 this isn't a comment

एक पंक्ति टिप्पणी को अनसॉल्व करने के लिए, पूरी लाइन को हटा दें।

एक उदाहरण "कार्यक्रम" पर टिप्पणी की:

000000 blah blah
000001* apples
000002 oranges?
000003* yeah, oranges.
000*04 love me some oranges

अनियोजित संस्करण:

blah blah
oranges?
love me some oranges

दूसरे शब्दों में, एक स्ट्रिंग को असुविधाजनक करने के लिए, प्रत्येक पंक्ति के पहले छह वर्णों को हटा दें, फिर सभी को लौटाएं लेकिन हर पंक्ति का पहला वर्ण जो किसी स्टार से शुरू नहीं होता है।

चुनौती

एक प्रोग्राम या फ़ंक्शन बनाएं जो एक टिप्पणी किए गए प्रोग्राम को लेता है और इसके अधूरे संस्करण को लौटाता है।

स्पष्टीकरण

  • Asterisks ( *) कभी भी एक लाइन पर पहले सात वर्णों के बाहर नहीं मिलेगा (हम आपको सिंटैक्स सत्यापित करने के लिए नहीं कह रहे हैं)
  • प्रत्येक पंक्ति में हमेशा कम से कम 7 अक्षर होंगे।
  • आप मान सकते हैं कि सातवां वर्ण हमेशा एक तारांकन या एक स्थान है।
  • इनपुट या आउटपुट एक मैट्रिक्स या सूची हो सकती है।
  • केवल मुद्रण योग्य ASCII वर्ण (प्लस न्यूलाइन) को संभाला जाना चाहिए।
  • आप एक अनुगामी न्यूलाइन के साथ आउटपुट कर सकते हैं। यदि आप ऐसा चुनते हैं तो आप यह भी मान सकते हैं कि इनपुट में एक नई रूपरेखा होगी।

स्कोरिंग

चूंकि यह कोड-गोल्फ है , कम से कम बाइट्स जीत के साथ जवाब!

अस्वीकरण: मैं वास्तव में COBOL नहीं जानता हूं और दावा नहीं करता हूं। अगर इस प्रश्न में COBOL के बारे में कोई भी दावा गलत है, तो मैं कोई जिम्मेदारी नहीं लेता।

code-golf  string  comment 
— LyricLy
स्रोत
23
लाइन नंबर टिप्पणी नहीं हैं। वे एक स्तंभ हैं। शब्दावली कृपया।
— user207421
1
आपके उदाहरणों में सभी के बाद एक स्थान है *। क्या यह एक संयोग है?
— नील
6
पुराना अपने आप बुरा नहीं होता है। मैंने एक एजाइल कोबोल शॉप में काम किया है। वे एएस / 400 पर वे चीजें कर सकते थे जो हम जावा में नहीं कर सकते थे।
— थोरबजर्न रेवन एंडरसन
1
हे ... मैंने वास्तव में एक COBOL कॉपीबुक पार्सर लिखा है जो केवल तभी काम करता है जब फ़ील्ड पैक नहीं किए जाते हैं। बस इसे JSON में बदल देता है key:{key:{key:length,key:length}}। हालांकि सभी स्वरूपण डेटा और टाइपिंग डेटा स्ट्रिप्स।
— मैजिक ऑक्टोपस Urn
4
क्या पहले 6 पात्रों में जगह हो सकती है?

जवाबों:

104

COBOL (GnuCOBOL), 191 + 17 = 208 बाइट्स

मैंने इस जवाब के लिए COBOL "सीखा", ​​इसलिए यह पूरी तरह से गोल्फ नहीं है।

यह एक पूर्ण कार्यक्रम है, जो मैं मानक इनपुट होने का अनुमान लगाता हूं और जो मैं मानक उत्पादन करता हूं उसे लिखता हूं। शायद एक दिन मैं इस पर लौटूंगा और (1) यह निर्धारित करूंगा कि क्या COBOL के कार्य हैं और यदि हां, तो (2) देखें कि क्या फ़ंक्शन समाधान कम होगा।

बाइट काउंट में प्रोग्राम और कंपाइलर फ्लैग ( -freeऔर -frelax-syntax) शामिल हैं।

program-id.c.select i assign keyboard line sequential.fd i. 1 l pic X(80). 88 e value 0.open input i perform until e read i end set e to true end-read if not e and l(7:1)<>'*'display l(8:73).

यह ऑनलाइन की कोशिश करो

अनलग कार्यक्रम

program-id. c.

select i assign to keyboard organization line sequential.

fd i.
    1 l pic X(80).
    88 e value 0.

open input i
perform until e
    read i
        end set e to true
    end-read
    if not e and l(7:1) <> '*'
        display l(8:73).

सीमाएं

आउटपुट तकनीकी रूप से सही नहीं है। मेरे सरसरी शोध से, COBOL में एक स्ट्रिंग को स्टोर करने का एकमात्र व्यावहारिक तरीका निश्चित आकार के बफर में है। मैंने 80 अक्षरों का एक बफर आकार चुना है, क्योंकि यह फिक्स्ड-फॉर्मेट प्रोग्राम्स के लिए लाइन की लंबाई सीमा है। यह दो सीमाएँ प्रस्तुत करता है:

  • 80 से अधिक वर्णों वाली पंक्तियों को छोटा किया गया है।
  • 80 वर्णों से छोटी रेखाएं रिक्त स्थान के साथ दाईं-गद्देदार होती हैं।

मुझे लग रहा है कि यह स्वीकार्य है, ठीक है, यह COBOL है। यदि नहीं, तो मैं विकल्पों पर गौर करने को तैयार हूँ।

स्वीकृतियाँ

  • -166 बाइट्स एडवर्ड एच के लिए धन्यवाद
  • -2 बाइट्स हॉर्नज के लिए धन्यवाद
— जेकब
स्रोत
10
तारांकन (*) एक पंक्ति में पहले सात वर्णों के बाहर कहीं भी नहीं मिलेगा ... और अभी तक ...;)
— काल
@ C useur Haha हाँ ... लेकिन मेरा समाधान उस धारणा का उपयोग नहीं करता है, इसलिए शायद यह उचित है!
— जकॉब
8
आप एक इंटरनेट जीतते हैं।
— जोशुआ
एक पूर्ण विवरण को छोड़कर @ C @ur।
— क्लिक करें
1
आपके सोने के बैज पर बधाई!
— Caird coinheringaahing
20

पायथन 2 , 39 38 37 बाइट्स

-1 बाइट लाइरिकली को धन्यवाद। मीगो को -1 बाइट।

lambda s:[i[7:]for i in s if'*'>i[6]]

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

मैं / ओ तार की सूची के रूप में।

— totallyhuman
स्रोत
2
एक बाइट के !=साथ बदलकर सहेजें <, क्योंकि अंतरिक्ष का कोड बिंदु एक तारांकन चिह्न की तुलना में कम है, और सातवां वर्ण हमेशा एक स्थान या तारांकन चिह्न होगा।
— LyricLy
तो, 7 वां वर्ण हमेशा एक स्थान या एक तारांकन होगा?
— 2:33 पर पूरी तरह से अमानवीय
हाँ। You may assume the seventh character is always an asterisk or a space.
— LyricLy
1
1 बाइट को बचाएंif'*'!=i[6]
— मेगो
13

पर्ल 5 , 19 + 1 (-पी) = 20 16 बाइट्स

पाव के सुझावों के साथ -4 बाइट्स

s/.{6}( |.*)//s

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

— Xcali
स्रोत
2
आप तीन बाइट्स बचा सकता है अगर आप को बदलने के (\*.*$| )साथ( |.*)
— पावेल
@ पावेल की टिप्पणी के रूप में छोटा नहीं है, लेकिन / /;$_=/\* /?$,:$'एक और विकल्प है
— डोम हेस्टिंग्स
तुम भी जरूरत नहीं है ^।
— पावेल
11

वी , 13 11 10 बाइट्स

Î6x<<
çª/d

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

व्याख्या

Î       ' On every line
  x     ' delete the first...
 6      ' 6 characters
   <<   ' and unindent the line (removes the leading space)
ç /     ' on every line
 ª      ' matching \*
   d    ' delete the line

Hexdump:

00000000: ce36 783c 3c0a e7aa 2f64                 .6x<<.../d
— nmjcman101
स्रोत
क्या आप इसके 7xबजाय नहीं कर सकते 6x<<?
— DJMcMayhem
1
फिर यह *
— nmjcman101
क्या यह *पहले के साथ लिंस को हटाने के लिए काम करेगा और फिर करेगा Î7x? (संभालने * एक 0-5 वर्णों में नहीं कर सकते हैं)
— 12431234123412341234123
@ 12431234123412341234123 दुर्भाग्य से नहीं, क्योंकि *पहले 6 अक्षरों में एक हो सकता है ।
— nmjcman101
9

पारदोक (v0.2.8 +), 8 बाइट्स (CP-1252)

µ6>(7#;x

लाइनों की एक सूची लेता है, और अपूर्ण लाइनों की एक सूची में परिणाम होता है।

स्पष्टीकरण:

μ        .. Map the following block over each line (the block is terminated
         .. by }, but that doesn't exist, so it's until EOF)
 6>      .. Slice everything after the first six characters
   (     .. Uncons, so now the stack has the 6th character on top
         .. and the rest of the line second
    7#   .. Count the multiplicity of factors of 7 in the character
         .. (treated as an integer, so '*' is 42 and ' ' is 32)
      ;  .. Pop the top element of the stack (the rest of the line)...
       x .. ...that many times (so, don't pop if the 6th character was a
         .. space, and do pop if it was an asterisk)

नमस्ते, मैंने एक गोल्फ प्रोग्रामिंग भाषा लिखी। :)

मैं अभी भी इसे विकसित कर रहा हूं और इसे लिखने की कोशिश करने के बाद बिल्ट-इन का एक गुच्छा जोड़ा गया हूं, ताकि किसी स्पेस और "के अलावा" के बीच अंतर करने के लिए अधिक उचित तरीके हों 7#, लेकिन मुझे ऐसा लगता है कि यह नॉन-कमिंग होगा। यह सौभाग्य की बात है कि यह अभी भी काम कर रहा है (यह केवल v0.2.8 से सुविधाओं का उपयोग करता है, जो मैंने तीन दिन पहले किए थे)।

— betaveros
स्रोत
"हाय, मैंने एक गोल्फ प्रोग्रामिंग भाषा लिखी।" क्या वह संस्करण जिसे आप इस चुनौती के पोस्ट होने से पहले या बाद में जारी कर रहे हैं?
— मस्त
1
यह तीन दिन पहले से इस संस्करण पर काम करता है: github.com/betaveros/paradoc/releases/tag/v0.2.8
— Betaveros
ठीक है, आपने इसका उल्लेख किया है, लेकिन किसी तरह यह स्पष्ट रूप से पंजीकृत नहीं हुआ ...
— मस्त
1
— मार्टिन एंडर
7

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

@(s)s(s(:,7)~=42,8:end)

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

— rahnema1
स्रोत
4
मैं कभी नहीं जानता था कि ऑक्टेव इस तरह से तार कर सकता है ... यह लीजिए, MATLAB। xD
— Sanchises
R2016b के स्ट्रिंग सरणियों की शुरूआत के बाद से , मुझे पूरा यकीन है कि यह MATLAB में भी काम करेगा @Sanchises! मेरे पास केवल R2015b की पहुंच है, हालांकि इसकी पुष्टि नहीं हो सकती है। MATLAB 74 बाइट्स में कर सकता है, शायद कम @(s)cellfun(@(r)r(8:end),s(cellfun(@(r)r(7)~=42,s)),'uniformoutput',false), जहांs सेल सरणी है, न कि स्ट्रिंग सरणी। Regexp या कुछ का उपयोग करने की संभावना कम होगी, लेकिन मैंने जो विधि लिखी है वह इस उत्तर में पुराने मैटलैब के लिए कार्यप्रणाली की तुलना में है
— वोल्फी
6

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

ṫ€7Ḣ⁼¥Ðf⁶

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

इनपुट और आउटपुट लाइनों की एक सूची के रूप में।

-2 बाइट्स के लिए धन्यवाद @EriktheOutgolfer और @JonathanAllan

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

ṫ€7Ḣ=¥Ðf⁶
 €           On each line:
ṫ 7            Replace the line with line[7:]
      Ðf     Keep all lines that meet condition:
     ¥         Dyad:
   Ḣ             First Element (modifies line)
    =            Equals
        ⁶    Space
— fireflame241
स्रोत
7$€हो सकता है€7
— एरिक आउटगोल्फर
इसे नीचे 9 तक ले जाएं:ṫ€7Ḣ⁼¥Ðf⁶
— जोनाथन एलन
5

पॉवरशेल , 32 बाइट्स

$input-replace'^.{6}( |.*)'-ne''

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

पाइपलाइन इनपुट स्ट्रिंग के एक सरणी के रूप में आता है, -replaceप्रत्येक स्ट्रिंग पर काम करता है, और -ne ''(खाली स्ट्रिंग के बराबर नहीं) एक सरणी पर लागू होता है, खाली लाइनों को फ़िल्टर करने का कार्य करता है।

— TessellatingHeckler
स्रोत
4

C, 63 59 55 48 47 46 बाइट्स

करने के लिए धन्यवाद "एक और बाइट से छुटकारा पाने एक गुमनाम उपयोगकर्ता " के लिए ।

" आप सातवें वर्ण को हमेशा एक तारक या अंतरिक्ष कह सकते हैं " की याद दिलाने के लिए फेलिक्स पालमेन का धन्यवाद करते हैं , जिसने एक और बाइट का मुंडन किया।

f(char**a){for(;*a;++a)(*a)[6]&2||puts(*a+7);}

उपयोग की तरह:

char** program = { "000000 apple", "000001 banana", "celery donuts", 0 };
f(program);

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

— साइमन
स्रोत
3

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

⌠6@tp' =*⌡M;░

इनपुट और आउटपुट स्ट्रिंग्स की एक सूची के रूप में किया जाता है।

स्पष्टीकरण:

⌠6@tp' =*⌡M;░
⌠6@tp' =*⌡M    for each line:
 6@t             discard the first 6 characters
    p            pop the first character of the remainder
     ' =         is it a space?
        *        multiply the string by the boolean - returns the string if true, and an empty string if false
           ;░  filter out empty strings

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

— मेगो
स्रोत
3

गैया , 9 बाइट्स

6>¦'*«⁈ḥ¦

एक फ़ंक्शन स्ट्रिंग की सूची को स्वीकार करता है और स्ट्रिंग्स की एक सूची वापस करता है।

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

व्याख्या

6>¦        Remove the first 6 characters of each string
   '*«⁈    Filter out ones that start with *
       ḥ¦  Remove the initial space from each
— बिजनेस कैट
स्रोत
मैं दस वर्णों को गिनता हूं, और चूंकि तीन गैर-एएससीआईआई हैं, क्या वे एक बाइट से अधिक नहीं लेते हैं?
— WGroleau
@WGroleau ⁈और «दोनों 1 वर्ण हैं। गैर-अस्की चरित्र (शायद नीम को छोड़कर) का उपयोग करने वाली गोल्फ भाषाएँ कस्टम एन्कोडिंग का उपयोग करती हैं, जो उन सभी गैर-एएससीआईआई को एकल बाइट्स के रूप में गिना जाता है। यहाँ Gaia का कोड पेज है ।
— श्री एक्सकोडर
@ Mr.Xcoder Neim में एन्कोडिंग भी है।
— एरिक आउटगोल्फर
3

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

ध्यान दें कि यह केवल तभी काम करता है जब कम से कम 1 पंक्ति एक टिप्पणी न हो और कम से कम 1 पंक्ति हो एक टिप्पणी। अन्य सभी समाधान सभी मामलों में काम करते हैं।

-2 बाइट्स @pizzakingme की बदौलत !

m>d7.m@b6

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

व्याख्या

m>d7.m@b6     - Full program with implicit input. Takes input as a list of Strings.

m>d7          - All but the first 7 letters of 
    .m   (Q)  - The input, filtered for its minimal value using the < operator on
      @b6     - the 7th character -- note that "*" is greater than " "
              - Implicitly Output the result.

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

tMfqhTdm>d6

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

व्याख्या

tMfqhTDM> d6 - निहित इनपुट के साथ पूर्ण कार्यक्रम। स्ट्रिंग्स की सूची के रूप में इनपुट लेता है।

       m> d6 - प्रत्येक पंक्ति के पहले 6 अक्षर निकालें।
    hT - प्रत्येक का पहला वर्ण प्राप्त करें।
  fq d - उन लोगों को रखें जिनके पास पहला वर्ण तारांकन है।
tM - प्रत्येक का पहला वर्ण निकालें।
            - आउटपुट इंप्लीमेंटली।

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

m>d7fqd@T6Q

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

व्याख्या

m> d7fq @ T6dQ - पूर्ण कार्यक्रम। स्ट्रिंग्स की सूची के रूप में इनपुट लेता है।

      @ टी 6 - प्रत्येक का छठा वर्ण।
    fq dQ - उन लाइनों को रखें जिनके पास ^ के रूप में एक स्थान है।
m> d7 - पहले 7 अक्षरों को क्रॉप करें।
             - आउटपुट निहितार्थ।

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

tMfnhT\*m>d6

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

व्याख्या

tMfnhT \ * m> d6 - निहित इनपुट के साथ पूर्ण कार्यक्रम। स्ट्रिंग्स की सूची के रूप में इनपुट लेता है।

        m> d6 - प्रत्येक पंक्ति के पहले 6 अक्षर निकालें।
    hT - प्रत्येक का पहला वर्ण प्राप्त करें।
  fn \ * - उन फ़िल्टर करें जो तारांकन के बराबर नहीं हैं।
tM - प्रत्येक का पहला वर्ण निकालें।
             - आउटपुट इंप्लीमेंटली।

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

m>d7fn@T6\*Q

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

व्याख्या

m> d7fn @ T6 \ * Q - पूर्ण कार्यक्रम। स्ट्रिंग्स की सूची के रूप में इनपुट लेता है।

      @ टी 6 - प्रत्येक स्ट्रिंग का छठा वर्ण प्राप्त करें
    fn \ * Q - और उन फ़िल्टर करें जो तारांकन के बराबर नहीं हैं।
m> d7 - पहले 7 अक्षरों को क्रॉप करें।
              - आउटपुट निहितार्थ।
— मिस्टर एक्सकोडर
स्रोत
" उन लोगों को रखें जिनके पास पहला वर्ण तारांकन है। " मुझे लगता है कि आपका मतलब है "उन लोगों को रखें जिनमें से पहला चरित्र तारांकित नहीं है।"
— केविन क्रूज़सेन
m>d7.m@b69 बाइट्स पर काम करना चाहिए, जो कि *लेक्सिकोग्राफिक क्रम में अंतरिक्ष के बाद है
— डेव
अगर आप चाहें तो मैं इसे स्पष्टीकरण / परीक्षण लिंक से संपादित कर सकता हूँ!
— डेव
यदि आप मोबाइल पर हैं, तो मैं आपको संपादित करूँगा, तो मुझे खुशी होगी। बहुत बहुत धन्यवाद और नए समाधान के लिए खुद को श्रेय देना न भूलें!
— श्री Xcoder
क्या यह काम करता है अगर सभी लाइनें टिप्पणी हैं? (मुझे यकीन नहीं है कि अगर आपको इस मामले को संभालना है)
— बीटावेरोस
3

GNU Sed, 19 + 2 = 21 वर्ण

विस्तारित नियमित अभिव्यक्तियों को सक्षम -Eकरने के sedलिए तर्क की आवश्यकता होती है ।

/^.{6}\*/d;s/^.{7}/
— डैनियल स्कीपर
स्रोत
आप पर्ल लड़के के समान काम कर सकते हैं,s/^.{6}( |.*)//g
— markasoftware
3

जावा 8, 40 बाइट्स

नियमित अभिव्यक्ति: बस के बारे में, लेकिन काफी नहीं, नौकरी के लिए गलत उपकरण। लैम्ब्डा से Stringकरने के लिए String(करने के लिए आवंटित Function<String, String>)। इनपुट में एक अनुगामी न्यूलाइन होनी चाहिए।

s->s.replaceAll("(?m)^.{6}( |.*\\n)","")

यह ऑनलाइन की कोशिश करो

स्वीकृतियाँ

— जेकब
स्रोत
सही उपकरण! :)
— ओलिवियर ग्रेगोइरे
3

हास्केल , 27 25 बाइट्स

लाईकोनी का संस्करण मेरे से छोटा है:

f n=[x|' ':x<-drop 6<$>n]

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

मेरा संस्करण: 

f n=[drop 7x|x<-n,x!!6<'*']

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

— jferard
स्रोत
25 बाइट्स: f n=[x|' ':x<-drop 6<$>n]।
— लकोनी
@ लायकोनी यह अच्छा है !! मुझे नहीं पता था कि एक सूची समझ के जनरेटर में पैटर्न का मिलान करना संभव था।
— जफरार्ड
3

सी (जीसीसी) , 53 48 46 बाइट्स

x;main(y){for(y=&x;gets(y-6);x&2||puts(y+1));}

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

-5 बाइट्स: यह " पूरे कार्यक्रम " को गुरका के कार्य के समान आकार में लाने के लिए बहुत मुश्किल था । अब यह गलत प्रकार की एक सरणी की सीमा से बाहर (दोनों दिशाओं में) लिख रहा है और तारांकन खोजने के लिए थोड़ा एंडियन और 4 बाइट पूर्णांक पर निर्भर करता है ... लेकिन हे, यह काम करता है;)

-2 बाइट्स: ठीक है, अगर हम पहले से ही कुछ "यादृच्छिक" .bssस्थान पर लिखते हैं, तो एक सरणी की घोषणा करने में परेशान क्यों हैं ! तो यहाँ स्ट्रिंग हैंडलिंग प्रोग्राम आता है जो न तो charटाइप करता है और न ही एरे का उपयोग करता है ।

— फेलिक्स पालमेन
स्रोत
अच्छा! और *x&2मुझे याद आया "आप सातवें वर्ण को हमेशा एक तारांकित या एक अंतरिक्ष मान सकते हैं।", इसलिए मुझे अपने उत्तर से कुछ बाइट्स निकालने में सक्षम होना चाहिए :-)
— सिमोन
@ गुरुका धन्यवाद: D -2, hehe
— फेलिक्स पालमेन
3

आर, 47 45 बाइट्स

function(x)gsub("(?m)^.{6}( |.*\\n)","",x,,T)
— स्वेन होहेंस्टीन
स्रोत
यदि आप इनपुट को स्ट्रिंग्स की सूची के रूप में लेते हैं, तो मुझे लगता है कि आप regex को "^। {6} (! *। * $)" के लिए छोटा कर सकते हैं -6।
— CriminallyVulgar
@CriminallyVulgar सही। इस मामले में, मैं pe=Tतर्क को छोड़ भी सकता हूं । हालांकि, मुझे यकीन नहीं है कि स्ट्रिंग्स की सूची के रूप में इनपुट की अनुमति है या नहीं।
— स्वेन हॉन्स्टीन
ओपी से:Input or output may be a matrix or list.
— अमानवीय
@CriminallyVulgar समस्या आउटपुट में रिक्त स्ट्रिंग्स की उपस्थिति है।
— स्वेन होइनस्टीन
@SvenHohenstein आह, मैं उस पर विचार नहीं किया था।
— क्रिमिनलवल्गर
3

SNOBOL4 (CSNOBOL4) , 72 70 66 50 बाइट्स

R	INPUT POS(6) (' '  REM . OUTPUT | '*') :S(R)
END

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

एसएनओबीओएल में पैटर्न मिलान रेगेक्स से काफी अलग है, लेकिन यहां विचार अभी भी समान है: यदि एक पंक्ति "छह वर्ण और फिर तारांकन" से मेल खाती है, तो इसे हटा दें, अन्यथा, लाइन के पहले सात वर्णों को हटा दें और परिणाम प्रिंट करें।

यह अब वास्तव में SNOBOL के सशर्त असाइनमेंट ऑपरेटर का बेहतर लाभ उठाता है।

पैटर्न की POS(6) (' ' REM . OUTPUT | '*')व्याख्या इस प्रकार की जाती है:

6 की स्थिति पर शुरू, एक स्थान या एक तारांकन से मेल खाता है, और यदि आप एक स्थान से मेल खाते हैं, तो शेष रेखा को असाइन करें OUTPUT।

— ग्यूसेप
स्रोत
3

विम, 14 बाइट्स

Ctrl-VG5ld:%g/\*/dEnter

संपादित करने के लिए बफर के रूप में इनपुट फ़ाइल लोड करें, फिर उपरोक्त कमांड दर्ज करें। आउटपुट नया बफर है।

— डेविड हेमैन
स्रोत
2

रूबी , 39 38 36 29 23 22 20 + 1 = 21 बाइट्स

$_[/.{6}( |.*
)/]=''

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

-pध्वज का उपयोग करता है ।

स्पष्टीकरण:

-pझंडा कोड के आसपास एक अंतर्निहित ब्लॉक कहते हैं, तो कोड है कि वास्तव में चलाने के हो जाता है इस प्रकार है:

while gets
    $_[/.{6}( |.*
)/]=''

    puts $_
end

getsपाठ की एक पंक्ति पढ़ता है और उसके परिणाम को संग्रहीत करता है $_।

$_[/.../]=''रेगेक्स की पहली घटना को दूर करता ...है $_।

/.{6}( |.*\n)/किसी पंक्ति के प्रारंभ में किसी वर्ण के 6 से मेल खाता है, उसके बाद या तो स्थान या शेष रेखा। क्योंकि अंतरिक्ष पहले दिखाई देता है, यह पूरी लाइन को हटाने के प्रयास से पहले केवल पहले 6 वर्णों और एक स्थान को हटाने का प्रयास करेगा।

$_ तब इसका प्रिंट आउट लिया जाता है, और यह प्रक्रिया प्रत्येक पंक्ति के लिए दोहराई जाती है।

— पावेल
स्रोत
1
रूबी में विधि कॉल को कोष्ठक की आवश्यकता नहीं है, उन्हें हटाने से आपको बाइट की बचत होगी।
— m-chrzan
2

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

s=>s.map(c=>c[6]<"*"?console.log(c.substr(7)):1)

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

— sgtdck
स्रोत
1
यह न तो कोई फ़ंक्शन है, और न ही एक पूर्ण कार्यक्रम, क्योंकि यह मानता है कि इनपुट को इसमें संग्रहीत किया गया है z, जिसे यहां अनुमति नहीं है। हालांकि आप इसे वैध बनाने के लिए इसे एक गुमनाम एरो फंक्शन में बदल सकते हैं।
— caird coinheringaahing
1
@cairdcoinheringaahing आप बिल्कुल सही कह रहे हैं। समाधान अपडेट किया गया - यह सुनिश्चित नहीं है कि fn के आसपास (और )आसपास के नियम क्या हैं , उन्हें सुनिश्चित करने के लिए जोड़ा गया।
— sgtdck 13
1
आपको ()फ़ंक्शन की आवश्यकता नहीं है , लेकिन अन्यथा यह ठीक दिखता है।
— caird coinheringaahing 13
2

> <>, 57 53 बाइट्स

>i~i~i~i~i~i~i67*=\
<o$/?:$/?=a:;?(0:i<
\~$/~\ $
/  <o\?/

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

व्याख्या

>i~i~i~i~i~i~i67*=    Read in the first seven bytes of the line
 i~i~i~i~i~i~         Read, and discard 6 characters
             i        Read the seventh
              67*=    Check if the seventh character was an 
                      asterisk (and leave that value on the stack );

<o$/?:$/?=a:;?(0:i<    Read characters until a newline or eof
                 i     Read the next character of the line
            ;?(0:      If it's a -1, terminate the program
       /?=a:           If it's a newline, break out of the loop
   /?:$                If the seventh character was not an asterisk
<o$                    Output this character
\~$/                   otherwise discard it

   /~\ $    Having reached the end of the line, output
/  <o\?/    the newline only if it was not a comment

संपादित करें: 53 बाइट्स

>   i~i~i~i~i~i~i67*=\
/?=a<o/?$@:$@:$;?(0:i<
~   \~/

मूल रूप से पहले की तरह ही सामान, लेकिन थोड़ा पुनर्गठन

एक साइड नोट के रूप में: मैं अभी तक किसी से भी निराश नहीं हूं, लेकिन मैंने अभी तक कोबोल में ऐसा नहीं किया है।

— साशा
स्रोत
2

सी #, 160 145 90 89 बाइट्स

t=>{var o="";foreach(var s in i.Split('\n'))if(s[6]!=42)o+=s.Substring(7)+"\n";return o;}

आकार को कम करने के लिए पावेल और auhmaan के लिए धन्यवाद।

— snorepion
स्रोत
PPCG में आपका स्वागत है! मैं सुझाव दूंगा कि यह आपके उत्तर के लिए ऑनलाइन लिंक का प्रयास करे ताकि अन्य लोग आपके कोड का परीक्षण कर सकें। इसके अलावा, महान पहले (अच्छी तरह से, दूसरा) जवाब!
— 3
आप इस फॉर्म में एक लैम्ब्डा लिखकर इसे छोटा बना सकते हैंt=>{...}
— Pavel
@LyricLy मैंने ऐसा करने की कोशिश की, वास्तव में, लेकिन किसी कारण से, यह वहां काम नहीं करता है। यह एक वीएस कंसोल ऐप में पूरी तरह से ठीक काम करता है, हालांकि।
— स्नोरपियन
@ पावेल को इतना पसंद है? मुझे यकीन नहीं है कि अगर मैंने इसे पूरी तरह से सही ढंग से किया; मुझे पहले कभी लंबोदर अभिव्यक्ति का उपयोग करने की आवश्यकता नहीं है।
— स्नोरपियन
हाँ बिल्कुल। आप इसे असाइन करके परीक्षण कर सकते हैं func<string, string>।
— पावेल
2

पायथन 3, 71 बाइट्स (रेगेक्सप नहीं)

def f(s):
 for w in s.split('\n'):
  t=w[6:]
  if t[0]!='*':print(t[1:])

यह काम करता हैं!

>>> s="""000000 blah blah
000001* apples
000002 oranges?
000003* yeah, oranges.
000*04 love me some oranges"""
>>> f(s)
blah blah
oranges?
love me some oranges
— धनुराशि
स्रोत
1

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

क्रॉस-आउट 44 अभी भी नियमित 44 है।

6 बाइट्स टीश के लिए धन्यवाद बचा लिया

a=>a.replace(/^.{6}( |.*\n)/gm,'')

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

s=>s.replace(/^.{6}( |\*.*\s)?/mg,'')
— tsh
— टीएच
@tsh। जब तक एक स्थिर दुभाषिया है जो इसे अनुमति देता है, मुझे लगता है कि यह एक मान्य प्रोग्रामिंग भाषा के रूप में नहीं गिना जाता है।
ऐसा नहीं लगता कि यह सही आउटपुट देता है यदि अंतिम पंक्ति एक टिप्पणी रेखा है।
— LyricLy
@LyricLy। ऐसा इसलिए है क्योंकि मैंने यह मान लिया है कि इनपुट में हमेशा एक अनुगामी नई रेखा होगी। आप देख सकते हैं कि यह काम करता है इनपुट के बाद एक खाली लाइन है। अगर मुझे यह नहीं मानना ​​चाहिए, तो फिक्स 1 बाइट ( ?बाद में जोड़कर \n) खर्च करेगा ।
1

C ++ (GCC), 121 112 बाइट्स

9 बाइट बचाने के लिए @gurka को धन्यवाद!

#import<bits/stdc++.h>
void f(std::list<std::string>l){for(auto s:l)if(s[6]-42)std::cout<<s.substr(7,s.size());}

इनपुट को लाइनों की सूची के रूप में लेता है।

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

— Steadybox
स्रोत
#import? इसके अलावा, मुझे लगता है कि मानक को छोड़ना ठीक है।
— साइमन
#importC ++ मानक नहीं है, लेकिन कम से कम GCC और MSVC इसका समर्थन करते हैं। कुछ को शामिल करना C के साथ काम करता है, लेकिन C ++ के साथ नहीं। कोड शामिल किए बिना काम नहीं करता है, इसलिए उन्हें कुल बायटेकाउंट में गिना जाना है।
— स्टेडीबॉक्स
अहा, मुझे लगा कि आप इसमें शामिल हो सकते हैं क्योंकि आपको importअजगर के उत्तर या usingसी # उत्तर में कोई भी नहीं दिखता है। इसके अलावा, #include <bits/stdc++.h>आपके उत्तर के लिए छोटा नहीं होगा ?
— साइमन
@ गुरका हां, यह कम होगा। धन्यवाद!
— स्टेडीबॉक्स
@gurka आयातों को पायथन उत्तरों में गिना जाता है, यह सिर्फ इतना है कि पायथन में बहुत सारे कार्य हैं जिन्हें आयात की आवश्यकता नहीं है। C # में कथन का उपयोग नहीं करने के लिए जाता है क्योंकि यह आमतौर पर लिखने के लिए छोटा system.foo()होता हैusing system;foo()
— Pavel
1

जावा 8, 95 54 53 बाइट्स

s->s.filter(x->x.charAt(6)<33).map(x->x.substring(7))

-42 बाइट्स @ OliverGrégoire के लिए धन्यवाद , Stream<String>इसके बजाय का उपयोग करकेString इन-इन और आउटपुट के ।

स्पष्टीकरण:

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

s->                          // Method with Stream<String> as parameter and return-type
  s.filter(x->x.charAt(6)<33)//  Filter out all lines containing an asterisk as 7th char
   .map(x->x.substring(7))   //  And remove the first 7 characters from the remaining lines
                             // End of method (implicit / single-line body)
— केविन क्रूज़सेन
स्रोत
ऐसा लगता है कि आप -12 बाइट्स के लिए String[]या List<String>इनपुट के रूप में उपयोग कर सकते हैं ।
— जकॉब
या Stream<String>अगर वह मदद कर सकता है। उदाहरण:s->s.map(x->x.charAt(6)!=42?x.substring(7):"")
— ओलिवियर ग्रेगोइरे
1
ओह, इसे फ़िल्टर करने की आवश्यकता है ... फिर s->s.filter(x->x.charAt(6)!=42).map(x->x.substring(7))54 बाइट्स के लिए।
— ओलिवियर ग्रेगोइरे
1
<42इसके बजाय का उपयोग करें !=42"आप मान सकते हैं कि सातवें वर्ण हमेशा एक तारांकन या एक स्थान है।"
— ओलिवियर ग्रेगोइरे
1
@ ओलिवियरग्रैगो आह, उस नियम से चूक गए, अन्यथा मैं खुद ऐसा कर लेता। सुधारों के लिए धन्यवाद।
— केविन क्रूज़सेन
हमारी साइट का प्रयोग करके, आप स्वीकार करते हैं कि आपने हमारी Cookie Policy और निजता नीति को पढ़ और समझा लिया है।
Licensed under cc by-sa 3.0 with attribution required.