आपका कार्य एक प्रोग्राम (या फ़ंक्शन) लिखना है जो इनपुट के रूप में एक स्ट्रिंग लेगा और पाठ को प्रत्येक पंक्ति की शुरुआत में जोड़ देगा जो निम्नलिखित नियमों को पूरा करता है:

संलग्न पाठ में पंक्ति संख्या होनी चाहिए। आप 0- या 1-आधारित अनुक्रमण का उपयोग कर सकते हैं।
पाठ आपकी भाषा में एक टिप्पणी होनी चाहिए। एक टिप्पणी को कोड के एक क्रमिक रूप से मान्य टुकड़े के रूप में परिभाषित किया गया है जो कार्यक्रम की स्थिति में कोई बदलाव नहीं करता है। टिप्पणी को हटाने से कार्यक्रम में कोई बदलाव नहीं होना चाहिए।
टिप्पणी में इसके अंत में केवल नई सूची हो सकती है।
आपको उन पंक्तियों के लिए पंक्ति संख्या नहीं डालनी होगी जिनमें सिर्फ व्हाट्सएप और टिप्पणियां हैं।

विशेष विवरण

आप मान सकते हैं कि इनपुट आपकी भाषा में एक मान्य प्रोग्राम होगा।
पायथन जैसी संवेदनशील-संवेदनशील भाषाओं में, आप सभी इंडेंटेशन के बाद लाइन नंबर टिप्पणी रख सकते हैं। आप अपने इंडेंटेशन कैरेक्टर के लिए या तो टैब या स्पेस चुन सकते हैं, लेकिन आपको अपने पोस्ट पर निर्दिष्ट करना होगा।
आप यह मान सकते हैं कि कोड में प्रत्येक कथन 1 पंक्ति के अधिकांश भाग तक ले जाएगा; यानी कोई मल्टी-लाइन स्ट्रिंग्स या बैकस्लैश-निरंतरता नहीं।

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

अजगर:

#0
a = int(input())
#1
while a:
    #2
    print(a)

सी: (ईमानदारी से, मैं इस संकलन से हैरान हूं)

/*0 */#include <stdio.h>
/*1 */int main()
/*2 */{
/*3 */    char c;
/*4 */    c = getchar();
/*5 */    do
/*6 */    {
/*7 */        putchar(c);
/*8 */    }
/*9 */    while (c);
/*10*/}

यह कोड-गोल्फ है , इसलिए सबसे छोटा उत्तर (बाइट्स में) जीतता है।

code-golf code-generation comment

— फल तोड़ना
स्रोत

7

टिप्पणियों को भाषा-निर्भर बनाना जटिल बनाता है। आपको पहले से ही पायथन के लिए एक विशेष नियम बनाना था। उन सभी अन्य भाषाओं के बारे में क्या है जिनके पास बहु-पंक्ति टिप्पणियाँ नहीं हैं? उन भाषाओं के बारे में जो टिप्पणी नहीं करती हैं। मल्टी-लाइन स्ट्रिंग्स के बारे में क्या है जहां टिप्पणियों को साइड इफेक्ट के बिना नहीं रखा जा सकता है?

— डेनिस

4

मजेदार तथ्य: नियम "टिप्पणी को हटाने से कार्यक्रम में कोई बदलाव नहीं होना चाहिए" तुरंत किसी भी पायथन जवाब को अयोग्य घोषित कर देता है, क्योंकि कोड - टिप्पणियों सहित - को रनटाइम पर आत्मनिरीक्षण किया जा सकता है। मैंने इसे एक प्रोडक्शन सिस्टम में प्ले करके देखा है: कोड का एक टुकड़ा AssertionErrorतब तक उठता है जब तक स्टैक ट्रेस में वाक्यांश शामिल नहीं होता है foo.py, जो एक फ़ाइल नाम से आने की उम्मीद थी, लेकिन संदर्भ में एक लाइन टिप्पणी के रूप में भी प्रकट हो सकता है।

— 3

2

" टिप्पणी केवल इसके अंत में newlines शामिल कर सकते हैं " सी " परीक्षण मामले " के साथ असंगत है ।

— पीटर टेलर

2

टिप्पणियों के बिना लैंग्स के बारे में क्या?

— NoOneIsHere 7

4

संपादन असंगतता को ठीक नहीं करता है।

— पीटर टेलर

5

Pyke, 7 बाइट्स

o\Kz++r

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

o       -  o++
 \K     -  "K"
   z    -  input()
    ++  - sum(^)
      r - while no errors: GOTO start

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

— नीला
स्रोत

16

पर्ल, 8 + 1 = 9 बाइट्स

say"#$."

-p(1 बाइट पेनल्टी) के साथ चलाएं । (पीपीसीजी के नियमों से अपरिचित लोगों पर ध्यान दें; आपको पर्ल सिंटैक्स का एक आधुनिक संस्करण भी निर्दिष्ट करने की आवश्यकता है -M5.010, लेकिन हमने फैसला किया कि भाषा संस्करणों का चयन करने के विकल्प स्वतंत्र हैं और बाइट जुर्माना नहीं है, इसलिए मैंने इसमें उल्लेख नहीं किया है इस पोस्ट का मूल संस्करण।)

-pकार्यक्रम को एक अंतर्निहित लूप में रखता है; यह मूल रूप से प्रोग्राम को एक फिल्टर बनने का कारण बनता है जो प्रत्येक पंक्ति को अलग से संसाधित करता है (यानी पूरा कार्यक्रम पहली पंक्ति पर चलता है, फिर दूसरा, फिर तीसरा और इसी तरह)। पर्ल एक लाइन नंबर पर भी नज़र रखता है, जिसे कॉल किया जाता है $., जो रिकॉर्ड करता है कि इनपुट की कितनी लाइनें पढ़ी गई हैं। तो कार्यक्रम के सभी कार्य -pइनपुट की एक पंक्ति को पढ़ने दे रहे हैं; आउटपुट a #, वर्तमान लाइन नंबर ( $.), और एक नई पंक्ति ( sayडिफ़ॉल्ट रूप से एक नई पंक्ति जोड़ता है, जो इस मामले में सहायक है, और आमतौर पर देखी जाने वाली तुलना में छोटी भी है print); और फिर -pकोड की मूल पंक्ति को आउटपुट देता है जिसे वह पढ़ता है (आमतौर पर एक प्रोग्राम का उपयोग करता है-pइनपुट पर किसी प्रकार की प्रोसेसिंग करेगा, लेकिन क्योंकि हमने नहीं किया, यह सिर्फ आउटपुट अपरिवर्तित है)। Perl में टिप्पणियां #एक नईलाइन से चलती हैं ( #प्रोग्राम में स्वयं एक टिप्पणी शुरू नहीं करता है क्योंकि यह एक स्ट्रिंग शाब्दिक के अंदर है), इसलिए हम जो मूल रूप से कर रहे हैं वह फाइल में टिप्पणी लाइनों को लिखने का अवसर ले रहा है क्योंकि हम इसे संसाधित करते हैं। , बिना "प्राकृतिक" को पढ़े और लिखे चक्र को विचलित किए बिना -p।

क्या आप बता सकते हैं कि यह कैसे काम करता है?

— एडम

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

ध्यान दें कि say"$.;"यह भी काम करेगा, क्योंकि यह प्रश्न निर्दिष्ट करता है कि "आप यह मान सकते हैं कि कोड में प्रत्येक कथन 1 पंक्ति की अधिकतम संपूर्णता तक ले जाएगा"।

— msh210

हालांकि यह वास्तव में एक टिप्पणी नहीं है; यद्यपि यह उपयोगी कुछ भी नहीं करता है, यह एएसटी में समाप्त होता है (और क्योंकि पर्ल का अनुकूलक दयालु है, मुझे लगता है कि वास्तव में कार्यक्रम को धीमा करना होगा, कुछ ऐसा जो आप वास्तव में एक टिप्पणी नहीं करना चाहेंगे)।

नियम के लिए काम नहीं करने के लिए आपको उन लाइनों के लिए लाइन नंबर नहीं डालना होगा जिनमें सिर्फ व्हाट्सएप और टिप्पणियां हैं।

— डेनिस इबाव नोव

9

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

a=>a.replace(/^/gm,_=>`/*${++b}*/`,b=0)

4 बाइट बचाने के लिए ETH और कॉनर का धन्यवाद।

— SuperJedi224
स्रोत

41 बाइट्स: a => (b = 0, a.replace (/ ^ / gm, _ => /*${++b}*/)) (एक स्वरूपण स्ट्रिंग का उपयोग करें)

— Conor O'Brien

1

39 बाइट्स:a=>a.replace(/^/gm,_=>`/*${++b}*/`,b=0)

— ETHproductions

5

वी , 10 बाइट्स

O:1òYjjP

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

— जेम्स
स्रोत

3

बैच, 91 बाइट्स

@set n=
@for /f "delims= tokens=*" %%a in (%1) do @set/an+=1&call echo @rem %%n%%&echo %%a

बैच EOF तक STDIN पढ़ने का एक तरीका नहीं है, इसलिए इसके बजाय फ़ाइल नाम को कमांड-लाइन पैरामीटर के रूप में पारित करना होगा।

— नील
स्रोत

3

लुआ, 80 75 बाइट्स

लंगोटी को गाली देकर कुछ बाइट्स बचाए।

x=1print("--[[1]]"..(...):gsub("\n",load('x=x+1return"\\n--[["..x.."]]"')))

सरल पर्याप्त स्टार्टर जवाब।

अनगढ़, +

x=1                                                     -- Assign x to 1...
print(                                                  -- Print...
      "--[[1]]"                                         -- The first line number comment...
      ..                                                -- With...
      (...):gsub(                                       -- The input, replacing all...
                 "\n",                                  -- Newlines...
                    load                                -- with a string compiled function...
                    (' \
                    x=x+1                               --Increment x by one... \
                    return"\\n--[["..x.."]]"            -- And return the new linecomment. \
                    ')
                 )
      )

— Ataco
स्रोत

मैं लुआ को नहीं जानता, लेकिन क्या आपको यकीन है कि यह हमेशा ऐसी टिप्पणियां उत्पन्न करेगा जो समान लंबाई की हैं? उदाहरण के लिए यदि कोई प्रोग्राम पिछली टिप्पणी की तुलना में 10 लाइन लंबा है --[[10]]जो कि 1 वर्ण से अधिक लंबा है --[[9]]जब तक कि आप इसे सही ढंग से रिक्त स्थान के साथ पैड नहीं करते हैं।

— फल

1

ओह, मुझे वह नियम नज़र नहीं आया। ऐसा लगता है ... थोड़ा बेमानी ...

— 22

1

हाँ। शायद मैं इसे हटा दूं ... [EDIT]: हटा दिया गया।

— फल तोड़ना

3

गेमा, १६ १५ अक्षर

*\n=\!@line\n$0

गामा में केवल पंक्ति टिप्पणियाँ हैं, जिनके साथ शुरू होता है !।

नमूना रन:

bash-4.3$ cat l33t.gema 
e=3
g=9
i=1
o=0
t=7

bash-4.3$ gema -f l33t.gema <<< 'Hello World!'
H3ll0 W0rld!

bash-4.3$ gema '*\n=\!@line\n$0' < l33t.gema > l33t-nr.gema

bash-4.3$ cat l33t-nr.gema
!1
e=3
!2
g=9
!3
i=1
!4
o=0
!5
t=7

bash-4.3$ gema -f l33t-nr.gema <<< 'Hello World!'
H3ll0 W0rld!

Adám के प्रश्न का उत्तर देने के लिए निम्नलिखित हैं , क्या इस तरह के कोड को अनदेखा कोड में जोड़ना संभव है।

Gema कोड अनिवार्य रूप से = से परिवर्तन नियमों, या टेम्पलेट = Gema शब्दों में कार्रवाई का एक संग्रह है । मुझे ऐसे टेम्पलेट को परिभाषित करने का कोई तरीका नहीं दिखाई देता है जो कभी भी किसी भी चीज़ से मेल नहीं खाता हो, यह अकेले ऐसा नहीं लगता है।

गेमा, 18 वर्ण

*\n=c:\=@line\;:$0

में बदल देती e=3है c:=1;:e=3।

सौभाग्य से गीमा में डोमेन , तरह के नाम स्थान हैं। उपरोक्त कोड नामस्थान c में डमी नियमों को परिभाषित करता है, जिनका हम कभी उपयोग नहीं करते हैं। दुर्भाग्य से एक उल्लेखित डोमेन लाइन के अंत तक प्रभाव में रहता है, इसलिए हमें स्पष्ट रूप से डिफ़ॉल्ट डोमेन पर वापस स्विच करना होगा।

गेमा, 18 वर्ण

*\n=@line\=\$0\;$0

में बदल देती e=3है 1=$0;e=3।

एक कम जटिल विकल्प को अनदेखा करने के बजाय प्रभावहीन कोड का उपयोग करना है। मेरा तात्पर्य ठीक उसी तरह से है जिसे मिलान किया गया था।

— आदमी काम पर है
स्रोत

लेकिन क्या आप एक स्ट्रिंग नहीं डाल सकते हैं और इसके चारों ओर कुछ कोड हैं जो इसे अनदेखा करता है?

— आदम

आप की तरह मतलब e=3में तब्दील if (false) { 1 }; e=3वर्तमान के बजाय !1␤e=3? हाँ, इसमें 19 कैरेक्टर लंबा वर्कअराउंड होगा।

— मैनावर्क

2

Qbasic, 91 89 बाइट्स

OPEN"I",1,"i"
OPEN"O",2,"o"
DO UNTIL EOF(1)
i=i+1
INPUT#1,a$
PRINT#2,STR$(i)+"'"+a$
LOOP

इनपुट:

CLS
PRINT "Hello!"
a$="Welcome"
INPUT "Type your name: ", b$
PRINT a$; ", "; b$
END

आउटपुट:

 1'CLS
 2'PRINT "Hello!"
 3'a$="Welcome"
 4'INPUT "Type your name: ", b$
 5'PRINT a$; ", "; b$
 6'END

— anonymous2
स्रोत

1

जब से मैंने QBasic का उपयोग किया है, तब से कुछ समय हो गया है, लेकिन क्या यह प्रोग्राम पाठ को सभी टिप्पणियों के बजाय, पंक्ति संख्याओं के बजाय बना देता है? या मैं कुछ गलत कर रहा हूँ?

इनपुट के लिए धन्यवाद! असल में, 'सिर्फ टिप्पणी जो लाइन पर अनुसरण करता है।

— अनाम 2

4

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

2

BASH (+ GNU sed) 27 बाइट्स

sed 'i#
='|sed 'N;s/\n//;N'

पहला भाग ( i# \n =) लगभग जीएनयू सेड में काम करता है (4 बाइट्स के लिए), लेकिन यह एक नई लाइन डालता है #।

— रिले
स्रोत

2

awk ( 19 13 बाइट्स)

19 बाइट्स : यह कोड की प्रत्येक लाइन के ऊपर "#" + लाइन नंबर डालें

{print"#"NR"\n"$0}

13 बाइट्स : दो 13 बाइट्स समाधान के लिए @manatwork के लिए क्रेडिट और धन्यवाद

1कार्रवाई में चूक के रूप में print $0:

{print"#"NR}1

या $0सामग्री को प्रतिस्थापित करके

$0="#"NR RS$0

— एडम
स्रोत

{print"#"NR}1या $0="#"NR RS$0?

— मैनटवर्क

@manatwork मैं उन उप

— एडम

2

कोटलिन विस्तार समारोह, 69 60 बाइट्स

~~fun String.a()=lines().mapIndexed{i,s->"/*$i*/$s"}.joinToString("\n")~~

fun String.a(){lines().mapIndexed{i,s->println("/*$i*/$s")}}

उदाहरण का उपयोग:

fun main(args: Array<String>) {
  //language=kotlin
  val code = """fun main(args: Array<String>) {
  println("Hello world!")
}"""
  code.a()
}

आउटपुट:

/*0*/fun main(args: Array<String>) {
/*1*/  println("Hello world!")
/*2*/}

— एफ जॉर्ज
स्रोत

1

सीजाम, 21 बाइट्स

मैं सीजेएम में बिल्कुल भी पारंगत नहीं हूं, लेकिन मुझे इस बात की जानकारी थी कि इसमें टिप्पणियां हैं :)

qN%ee{"e#"o(oNo(oNo}/

स्पष्टीकरण जल्द ही आ रहा है।

— Kade
स्रोत

oNonTIO पर प्रतिस्थापित किया जा सकता है ।

— फल

1

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

i = 1; StringReplace[#, StartOfLine :> "(*" <> ToString@i++ <> "*)"] &

— spacemit
स्रोत

1

jq, 31 अक्षर

(27 वर्ण कोड + 4 वर्ण कमांड लाइन विकल्प।)

"#\(input_line_number)\n"+.

Jq में केवल लाइन कमेंट्स होते हैं, जिनके साथ शुरुआत होती है #।

नमूना रन:

bash-4.3$ cat l33t.jq 
gsub("e";"3")|
gsub("g";"9")|
gsub("i";"1")|
gsub("o";"0")|
gsub("t";"7")

bash-4.3$ jq -Rr -f l33t.jq <<< 'Hello World!'
H3ll0 W0rld!

bash-4.3$ jq -Rr '"#\(input_line_number)\n"+.' l33t.jq > l33t-nr.jq

bash-4.3$ cat l33t-nr.jq 
#1
gsub("e";"3")|
#2
gsub("g";"9")|
#3
gsub("i";"1")|
#4
gsub("o";"0")|
#5
gsub("t";"7")

bash-4.3$ jq -Rr -f l33t-nr.jq <<< 'Hello World!'
H3ll0 W0rld!

— आदमी काम पर है
स्रोत

प्रिय पर्ल और रूबी कोडर्स, कृपया jq का निरीक्षण करें input_line_number। धन्यवाद के रूप में, किसी विशेष भावना के लिए व्यक्त करना $.?

— manatwork

1

गोल्फस्क्रिप्ट, 23 बाइट्स

n/0:i;{"#"i):i+n+\+}%n*

"#" से शुरू होने वाली केवल टिप्पणियां हैं।

असंगठित और समझाया गया:

           # the input is pushed on the stack automatically
n          # n is a predefined variable for "\n"
/          # splits the input string with the previously pushed "\n" as delimiter
0:i;       # i = 0
{          # A code block: It is used for map here (going through the input)
    "#"    # push a "#" onto the stack
    i):i  # save i + 1 in i, the value is again not popped from the stack
    +      # implicitly converts the number i to a string and concatenates "#" with it
    n      # newline
    +      # add a newline (# introduces a *line* comment)
    \      # switch the top to elements (-> yields the comment as the bottom, and the line as the top element on the stack)
    +      # concatenate them
}          # end of the code block
%          # map
n          # newline
*          # join the list with newlines between them
           # outputs are done implicitly

मुझे पूरा यकीन है कि इसे और सरल बनाया जा सकता है, विशेष रूप से iशायद इसे छोड़ दिया जा सकता है।

आप इसे यहां पर देख सकते हैं: https://golfscript.apphb.com/ क्योंकि यह साइट इनपुट जोड़ने का समर्थन नहीं करती है, आपको कोड के सामने डबल कोट्स के साथ एक स्ट्रिंग डालनी होगी। '\n'एक नई रूपरेखा होगी। इस तथ्य से अवगत रहें, कि अन्य पलायन क्रम भी हैं। '\\'यदि आप निश्चित नहीं हैं तो उपयोगकर्ता ।

— CodenameLambda
स्रोत

1

सी # 6, 66 61 बाइट्स

आभार सीएसहरपी ने माना

~~(666, शैतान कोड ^ ^)~~ कोई और नहीं ...

यह "C शैली टिप्पणियों" (C, C ++, C #, Java, ....) का उपयोग करके सभी भाषाओं के लिए काम करता है।

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

s=>string.Join("\n",s.Split('\n').Select((l,i)=>$"/*{i}*/"+l));

पुराना संस्करण:

s=>string.Join("\n",s.Split('\n').Select((l,i)=>$"/*{i,3}*/{l}"));

— स्टीफन
स्रोत

1

तकनीकी रूप से 64 के बाद से op शून्य के साथ किसी भी गद्दी का उल्लेख नहीं किया। इसके अलावा आप 1 और बाइट को छेड़खानी करके बचा सकते हैं: $ "/ * {i} * /" + l। (एल-पैरामीटर को प्रक्षेप से बाहर ले जाना।)

— CSharpie

आप सही हैं ^ ^ लेकिन यह मेरे "बुराई स्कोर" को नष्ट कर देता है

— स्टीफन

0

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

अंतरिक्ष-केवल इंडेंटेशन के लिए काम करता है

for i,l in enumerate(input().split('\n')):print l.split(l.lstrip())[0]+'#%d\n'%i+l

56 बाइट्स के लिए इंडेंटेशन-कम संस्करण

for x in enumerate(input().split('\n')):print'#%d\n%s'%x

— छड़ी
स्रोत

उत्पन्न / * पंक्ति संख्या टिप्पणी * /

विशेष विवरण

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

Pyke, 7 बाइट्स

पर्ल, 8 + 1 = 9 बाइट्स

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

वी , 10 बाइट्स

बैच, 91 बाइट्स

लुआ, 80 75 बाइट्स

अनगढ़, +

गेमा, १६ १५ अक्षर

गेमा, 18 वर्ण

गेमा, 18 वर्ण

Qbasic, 91 89 बाइट्स

BASH (+ GNU sed) 27 बाइट्स

awk ( 19 13 बाइट्स)

कोटलिन विस्तार समारोह, 69 60 बाइट्स

सीजाम, 21 बाइट्स

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

jq, 31 अक्षर

गोल्फस्क्रिप्ट, 23 बाइट्स

सी # 6, 66 61 बाइट्स

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