50

yes, कोरुटिल्स से, 91 लाइन लंबी है । उनमें से कई टिप्पणियां कर रहे हैं, लेकिन वह अब भी है रास्ता बहुत लंबा है।

सितंबर 2019 से संपादित करें: स्रोत फ़ाइल पिछले पांच वर्षों में बढ़ी और अब यह 126 लाइनों की लंबी है।

एक प्रोग्राम लिखें जो नकल करता है yes:

stdout"y \ n" s की एक अनंत धारा के लिए आउटपुट
इस प्रक्रिया को मारने के अलावा इसे रोकने का एक विकल्प होना चाहिए SIGKILL: लेकिन SIGINTऔर SIGPIPEठीक हैं
आपको "y" या "n" या उनके ASCII मान (121, 0x79, 0171, 10, 0xA या 012) का उपयोग करने की अनुमति नहीं है

सबसे छोटा जवाब जीत।

बोनस:

अपनी कोड लंबाई से 10 घटाएं, यदि आप एक वाक्यांश प्राप्त कर सकते हैं stdinऔर इसे "y" के बजाय प्रिंट कर सकते हैं (लेकिन अभी भी लाइन-ब्रेक सहित)।

code-golf restricted-source

— रेमन स्निर
स्रोत

13

" आपको" y "या" \ n " " का उपयोग करने की अनुमति नहीं है - क्या मुझे इसे " स्ट्रिंग शाब्दिक के उपयोग yया \nअंदर नहीं करना चाहिए" के रूप में पढ़ना चाहिए ?

— अप्सिलर्स

12

संबंधित नोट पर, जीएनयू true.c80 लाइनें लंबी है।

— डेनिस विलियमसन

6

@DennisWilliamson इसी तरह के संबंधित नोट पर, झूठी। 2 पंक्ति लंबी है ....; _;

— लॉर्डआरो

6

coreutils yesकमांड लाइन पर एक वैकल्पिक तर्क लेता है, नहीं stdin।

— ब्रायन मिंटन

7

@ अधिक: अन्य कार्यक्रमों में पाइप करने के लिए जो लगातार वे कर रहे विभिन्न चीजों की पुष्टि के लिए पूछ सकते हैं, इसलिए आपको yखुद को टाइप करने के लिए वहां बैठना नहीं है ।

— मर्कस एरोनियस

37

सीजाम, 13 बाइट्स - 10 = 3

l_'x)?{_oNo}h

आपको इसके लिए जावा दुभाषिया का उपयोग करने की आवश्यकता होगी , क्योंकि ऑनलाइन दुभाषिया कार्यक्रम समाप्त होने के बाद ही वापस लौटता है।

आप SIGINT (Ctrl-C दबाकर) के साथ कार्यक्रम को रद्द कर सकते हैं। यह STDIN की एक लाइन पढ़ेगा, और उस लाइन को प्रिंट करेगा, या yयदि इनपुट खाली था।

व्याख्या

l             "Read line from STDIN.";
 _            "Duplicate.";
  'x          "Push character x.";
    )         "Increment to get y.";
     ?        "Ternary operator. Replaces line with y if it was empty.";
      {    }h "Repeat while true. Leaves condition on the stack, which is the output string.";
       _o     "Duplicate line and print.";
         No   "Push string with newline and print.";

ओपी के स्पष्टीकरण के बाद, निम्नलिखित कल्पना करने के लिए अधिक लगता है:

l{_o9c)o1}g

हालांकि, जब तक ओपी मेरी टिप्पणी का जवाब नहीं देता, मैं सबमिशन अपडेट करने का इंतजार करूंगा।

— मार्टिन एंडर
स्रोत

16

मुझे पसंद है कि आपका कार्यक्रम मैच के लिए होता है /no/i, यह देखते हुए कि यह क्या चुनौती है।

— केविन - मोनिका

20

ब्रेनफक - 38 बाइट्स

++++++++++[>++++++++++++>+<<-]>+[.>.<]

यह 10 या 121 का उपयोग नहीं करता है, क्योंकि +-<>.,[]वैसे भी भाषा में सभी सार्थक अक्षर हैं, लेकिन यह उन्हें बहुत भोली (0 + 1 + 1 + 1 + 1 + 1 + 1 + 1 + 1 + 1 + 1 + 1) की गणना करता है 10, 10 * 12 + 1 = 121)।

यह संभवतः दुभाषिया पर निर्भर करता है, लेकिन यह ^Cमेरी मशीन पर मर जाता है ।

ब्रेनफक - (63-10) = 53

++++++++++[>,]<<[[<]>>[[.>]<[<]>]]>[>++++++++++++>+<<-]>+[.>.<]

— undergroundmonorail
स्रोत

@ अगर मैं इसे इस तरह से 39 से नीचे नहीं पा सका। मुझे वैसे भी 10 की आवश्यकता है, इसलिए मैं या तो 1 से 120 जोड़ रहा हूं या 11 से 1 घटा रहा हूं, और यह पूर्व करने के लिए छोटा है।

— अंडरग्राउंडोरेल

हाँ, मैंने देखा कि उसके बाद आपने 10 का पुन: उपयोग किया, क्षमा करें: P

— FryAmTheEggman

10 * 12 + 1 के बजाय, 11 * 11 क्यों नहीं? मुझे लगता है कि आप एक चार को बचा सकता है।

— प्रोग्राम फॉक्स

@ मैं इसे 39 से नीचे नहीं ला सका। मुझे वैसे भी 10 की आवश्यकता है, इसलिए मैं या तो 1 से 120 जोड़ रहा हूं या 11 से 1 घटा रहा हूं, और यह पूर्व करने के लिए छोटा है।

— अंडरग्राउंडोरेल

@undergroundmonorail आह, मैं देख रहा हूँ।

— प्रोग्राम फॉक्स

18

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

कम से कम CPython और Jython के साथ काम करता है।

while 1:print(str(help)[1])

SIGINT ने इसे रोक दिया।

— PGY
स्रोत

18

इसे python2 बनाएं और आप इसे छोटा कर सकते हैं while 1:print`help`[1]।

— अंडरग्राउंडोरेल

4

हा हा बड़िया। मैं पूरी तरह से भूल गया था कि "अजगर" में एक बैकटिक ऑपरेटर हुआ करता था :)

— pgy

आप chr(11**2)कुछ पात्रों को बचाने के लिए भी उपयोग कर सकते हैं

— user1354557

2

@RamchandraApte आपको उपयोग करने की अनुमति नहीं है 121।

— जोनाथन रेनहार्ट

17

मार्बेलस 14 बाइट्स

0978
]]/\++
!!

यह बहुत सीधा है, '/ \' डिवाइस अपने बायीं और दायीं ओर दो प्रतियाँ रखता है, दायीं ओर से बढ़ा हुआ है ++और फिर बोर्ड से गिरता है और मुद्रित होता है। ]]डिवाइस सही करने के लिए किसी भी संगमरमर धक्का अगर STDIN रिक्त है लेकिन STDIN पर पहली बाइट नीचे गिर अगर यह नहीं है की सुविधा देता है। इसके बाद !!डिवाइस को ट्रिगर किया जाएगा , जो बोर्ड से बाहर निकलता है। जब तक आप स्टड पर कुछ भी दर्ज नहीं करते हैं, तब तक यह y \ n प्रिंट करेगा।

यह केवल अजगर दुभाषिया में काम करता है।

— overactor
स्रोत

17

अजगर, 10 9 6 बाइट्स - 10 = 0 -1 -4

#|zePG

मैं उम्र के लिए कोशिश कर रहा हूँ कि मैं एक के साथ satisified हूँ। मूल रूप से करने के लिए कनवर्ट करता है:

#      = while True
(implied print)
|      = or
z      = (automatically initialized from stdin)
ePG    = second-to-last lowercase letter = 'y'

— swstephe
स्रोत

"Z" वैरिएबल को स्टैडिन से आरम्भ किया जाता है, फिर उसके बाद मान का उपयोग किया जाता है। स्पष्ट रूप से लिखे बिना आस्की मूल्य प्राप्त करने का एक संक्षिप्त तरीका मिला।

— स्वस्तिक

एक चरित्र को बचाने के लिए "^ 11 2" से "^ hT2" पर स्विच किया गया।

— स्वस्तिक

हाय स्वस्तफे, मैं भाषा के किसी अन्य उपयोगकर्ता को देखने के लिए उत्साहित हूं! गोल्फ के एक जोड़े: #की तुलना करने के लिए समान कार्यक्षमता है W1, और ePGचरित्र की yतुलना में बहुत कम तरीका है C^hT2।

— isaacg

धन्यवाद, मैं उन परिवर्तनों को लागू करूंगा। अभी भी इस गोल्फ में नया है। मुझे पाइथ पसंद है, लेकिन काश कुछ और संदर्भात्मक कार्य और बिट हेरफेर होते।

— स्वस्तिक

13

सी #, 81 78 76 बाइट्स

अन्य भाषाओं के साथ प्रतिस्पर्धा नहीं कर सकता, लेकिन यहाँ यह वैसे भी है:

class A{static void Main(){for(;;)System.Console.WriteLine((char)('x'+1));}}

Ctrl+ दबाकर SIGINT के साथ मारा जा सकता है C।

कोई बोनस नहीं, क्योंकि इसे प्राप्त करने में 10 से अधिक बाइट्स लगेंगे।

— ProgramFOX
स्रोत

क्या आप उपयोग नहीं कर सकते while(1)? दो पात्रों को बचाता है।

— टूथब्रश

@toothbrush मैंने कोशिश की है कि, लेकिन वह C # में काम नहीं करता है।

— प्रोग्राम फॉक्स

1

for(;;) काम करना चाहिए ।

— core1024

2

किसी कारण से, यह कोड अभी भी इसमें है y। कृपया जांच करें System।

— TheNumberOne

4

@ TheBestOne Systemजिसे हटाया नहीं जा सकता। यह .NET फ्रेमवर्क में शीर्ष नामस्थान है, सभी वर्ग / अन्य नामस्थान इसमें हैं, इसलिए प्रतिबिंब यहां मदद नहीं करेगा। लेकिन यह सुनिश्चित नहीं है कि यह अमान्य है। रेमन की टिप्पणी देखें: "कुछ भी नहीं जो y या \ n का मूल्यांकन करता है"। इसका मूल्यांकन नहीं होता है y। मैं रेमन से पूछने के लिए इस सवाल पर एक टिप्पणी छोड़ रहा हूं कि क्या यह वैध है।

— प्रोग्रामफॉक्स

10

जावा, 178

class C{public static void main(String[]a)throws Exception{for(char c='x'+1;;)((java.io.PrintStream)Class.forName("java.lang.S"+c+"stem").getField("out").get(null)).println(c);}}

मुद्रण की आवश्यकता है System, लेकिन yचरित्र निषिद्ध है। इसलिए, मुझे प्रतिबिंब का उपयोग करना पड़ा।

— Ypnypn
स्रोत

FileDescriptor.out का मेरा मतलब है।

— TheNumberOne

आप लूप डिक्लेरेशन में ;डालकर बचा सकते हैं , इसलिए चूंकि आपके पास वैसे भी एक खाली अर्धविराम हैchar c='x'+1;forfor(char c='x'+1;;)

— corsiKa

@corsiKa अच्छा बिंदु।

— यपनिप

10

पर्ल: 18 बाइट्स - 10 = 8

स्ट्रिंग STDIN से है।

$_=<>;{print;redo}

— core1024
स्रोत

3

क्या यह y\nबार-बार प्रिंट करता है अगर इसे STDIN से इनपुट प्राप्त नहीं होता है? यदि नहीं, तो यह ठीक से नकल नहीं करता है yes।

— vurp0

@ vurp0 सब के बाद yesसे इनपुट नहीं लेता STDIN:)

— core1024

1

यह नहीं है, लेकिन यहां कोड गोल्फ प्रश्न निर्दिष्ट करता है कि यदि इसे इनपुट प्राप्त नहीं होता है, तो इसे बार-बार प्रिंट करना चाहिए y\n।

— vurp0

2

@ vurp0 कहां है? कोई भी प्रोग्राम जो किसी स्ट्रीम से पढ़ता है, बिना इनपुट के लटका रहेगा।

— core1024

@ vurp0 प्रश्न पर ओपी की टिप्पणी देखें।

— nyuszika7h

9

रूबी, 30 23 18 बाइट्स

loop{puts ?x.succ}

Ctrl+ दबाकर SIGINT के साथ मारा जा सकता है C।

सुधारों को साझा करने के लिए मैनटवर्क का धन्यवाद !

— ProgramFOX
स्रोत

1

loop{puts [*?x..?z][1]}- 23 वर्ण, loop{puts ?x.succ}- 18 वर्ण

— manatwork

@manatwork धन्यवाद! अपडेट किया गया।

— प्रोग्रामफॉक्स

8

पर्ल, 26 बाइट्स

{print chr$=*2+1,$/;redo}

तर्क से कस्टम इनपुट (जैसे `yes`वास्तव में काम करता है), 22 बाइट्स -10 = 12

{print @ARGV,$/;redo}

स्टड से कस्टम इनपुट, 22 बाइट्स -10 = 12

while(<>){print;redo}

— Nitz
स्रोत

@mar Nitz का कार्यक्रम केवल 14 बाइट्स लंबा है और आपके लिंक पर एक बहुत ही उच्चीकृत टिप्पणी है जो कहती है कि यह फ़ाइल नाम के लिए सर्द है अगर आप उन्हें बाइटकाउंट में शामिल करते हैं। यह मुझे कानूनी लगता है।

— अंडरग्राउंडोरेल

ओह रुको, मैंने देखा कि "आप प्रश्न के" \ "y \" का उपयोग नहीं कर सकते। यह बुरा नहीं है

— भूमिगत

आप सही हैं। इसे तय किया

— Nitz

6

सी, 64 55 53 45 40 - 10 = 30

main(int c,int**a){for(;;)puts(a[c>1]);}

मैं इससे बहुत खुश नहीं हूं, क्योंकि इसके लिए कार्यक्रम को "y" नाम देने की आवश्यकता है, और केवल 'y` के साथ ही बुलाया जा सकता है, इसलिए इसे $ PATH में होना है, लेकिन हे, पहले कोडगोल्फ :)

वैकल्पिक:

सी, 30 (+ 1 फ़ाइल नाम)

main(){for(;;)puts(__FILE__);}

मेरे आदरणीय सहकर्मी @ मट विंडसर के समान तकनीक का उपयोग करना

संपादित करें: यह पता चलता है कि यह छोटा हो गया है
EDIT2: "int" "char" से छोटा है
EDIT3: उस चर की बिल्कुल जरूरत नहीं थी
EDIT4: थोड़ा अपरिभाषित व्यवहार कभी किसी को चोट नहीं पहुंचाता
EDIT5: वैकल्पिक संस्करण जोड़ें

— LordAro
स्रोत

5

लिनक्स बैश, 33-10 = 23

read a; while :; do echo $a; done

Ctrl+ दबाकर SIGINT के साथ मारा जा सकता है C।

— Orace
स्रोत

आपको केवल एक लाइन पढ़नी चाहिए और एक ही लाइन को बार-बार प्रिंट करना चाहिए। आपके कार्यक्रम नहीं yesबल्कि catकार्यक्रम हैं।

— jimmy23013

मेरा बुरा, मुझे काम के दिन के बाद इसकी कोशिश नहीं करनी चाहिए थी।

— 18

कैसे के बारे मेंread a;for((;;));{ echo $a;}

— 22:10 पर core1024

5

जंग, 52 चरस

fn main(){loop{println!("{}",'Y'.to_lowercase())}}

वहाँ बस प्रतीत होता है yकि Rust-- में चुटीले होने के बिना कंप्यूटिंग का एक अच्छा तरीका नहीं है - उन्होंने बहुत अच्छा काम किया है सुरक्षित रूप से चार्ट बनाने का। मैं:

एक गैर-शाब्दिक स्ट्रिंग की आपूर्ति नहीं कर सकता println!, इसलिए वहां कोई चाल की अनुमति नहीं है;
1 को जोड़ नहीं सकते 'x', क्योंकि रस्ट चार्ट संख्या में नहीं हैं;
ROT13 नहीं कर सकता (क्यों Rust में ROT13 नहीं है इसकी मानक लाइब्रेरी!?);
अविश्वसनीय रूप से क्रिया के बिना और 52 सी से अधिक जाने पर सी स्ट्रिंग्स को छोड़ने, संख्याओं से वर्णों में परिवर्तित करने जैसे असुरक्षित कुछ भी आसानी से नहीं कर सकते।

न ही इसके लायक कोड बोनस के लिए जा रहा है, क्योंकि पढ़ने से stdinत्रुटि हैंडलिंग = 3 की आवश्यकता होगी

कोड की बहुत सी कमी मुझे संकलक पर्यावरण के साथ तेजी से नियम-फ्लो करने वाली चीजों में शामिल हो सकती है:

जंग, 44 वर्ण (+ फ़ाइलनाम के लिए कम से कम 1 वर्ण)

fn main(){loop{println!("{:.1}", file!())}}

नीचे दिए गए। स्रोत फ़ाइल के नाम के साथ शुरू करने की आवश्यकता के रूप में यह एक गिनती नहीं है y।

संपादित करें: जंग, 36 वर्ण (35 स्रोत, 1 फ़ाइल नाम)

fn main(){loop{println!(file!())}}

जैसा कि ऊपर है, लेकिन फ़ाइल को कॉल करना होगा y(नहीं y.rs, y)। विनोदी रूप से, बस्ट के साथ स्रोत को अधिलेखित कर देगा! कम से कम मेरी मशीन पर, बाइनरी उसके बाद भी काम करती है।

जंग, 37 वर्ण (+ `env K='y'`अपने मंच पर बराबर )

fn main(){loop{println!(env!("K"))}}

यह एक और भी बदतर है: आप वातावरण चर निर्धारित करने की आवश्यकता Kकरने के लिए yपर समय संकलन ।

संपादित करें : यदि आप सेट Kकरने के लिए y\n, आप छोड़ सकता है lnमें println!से एक भव्य कुल के लिए, ~~35 वर्ण और~~ कई facepalms:

fn main(){loop{print!(env!("K"))}}

— मैट विंडसर
स्रोत

कुछ फ़ाइल नाम या संकलक झंडे की आवश्यकता के लिए हमारी सामान्य नीति बस बाइट की गिनती में शामिल करना है।

— मार्टिन एंडर

@ मार्टिनबटनर मेला पर्याप्त। अजीब तरह से पर्याप्त है, ऐसा लगेगा कि जंग कोड गोल्फ के लिए सबसे अच्छी भाषा नहीं है>: पी

— मैट विंडसर

आप एक को xएक फैशन में जोड़ सकते हैं , लेकिन यह अभी भी छोटा नहीं है:(b'x' + 1) as char

— शमपास्टर

5

लिनक्स बैश - 19 बाइट्स

यह शायद धोखा है और विफलता के अधीन है यदि आपके पास / usr / bin / yes नहीं है या आपके पास / usr / bin / xes या / usr / bin / zes है:

/usr/bin/[x-z]es $*

मुझे लगता है कि यह आवश्यकताओं को पूरा करता है, हालांकि शायद यह "कुछ भी नहीं है जो y का मूल्यांकन करता है" नियम का उल्लंघन कर रहा है। और शायद yesवास्तव में चलने yesसे नकल करना नियमों के खिलाफ है।

इसे 11 बाइट्स तक ले जाने के लिए थोड़ा (हालांकि काम करने की संभावना कम) अनुकूलित किया जा सकता है:

/*/*/?es $*

मैं यह पता नहीं लगा सका कि कोड से 10 से अधिक बाइट्स जोड़े बिना स्टिंग से एक स्ट्रिंग को पढ़कर 10 बिंदु बोनस कैसे प्राप्त करें

— छोकरा
स्रोत

2

/*/*/?es `line` , या /*/*/?es `head -n1` यदि आपके पास नहीं है /usr/bin/line।

— jimmy23013

2

या के sed qलिए line।

— jimmy23013

5

डीसी, १२

[30986Pdx]dx

केवल आउटपुट y\n। स्टड से नहीं पढ़ा, तो कोई बोनस नहीं।

30986 0x790A है (अर्थात "y \ n")। Pआदेश केवल 256 आधार पर नंबर बदल देता है, और प्रत्येक आधार 256 अंकों के लिए इसी चरित्र प्रिंट करता है।

— डिजिटल आघात
स्रोत

यह बहुत चालाक है, कैसे 30986 का मूल्यांकन करता है y\n?

— nyuszika7h

मैं जानता था Pलेकिन यह नहीं जानता था कि यह एक समय में एक से अधिक चरित्र कर सकता है।

— nyuszika7h

5

आम लिस्प: (30-10) = 20

(format t"~@{~a~%~:*~}"(read))

(read) इनपुट स्ट्रीम से
आउटपुट स्ट्रीम पर प्रिंट करें: (format t ... )
सभी formatतर्कों पर पुनरावृति (केवल यहाँ एक):~@{ ... ~}
लूप के अंदर, प्रत्येक तर्क के लिए:
- प्रिंट तर्क के ~Aबाद एक नई पंक्ति~%
- रिवाइंड वर्तमान तत्व पिछली बार की ~:*(अनंत लूप)

आप लूप को तोड़ सकते हैं Ctrl+C, जो पुनरारंभ विकल्पों (जारी / निरस्त) के साथ एक त्रुटि का संकेत देता है।

— कोर निपात
स्रोत

3

हास्केल, 29 बाइट्स

main=putStrLn[succ 'x']>>main

मेरा मानना है कि यह दोनों द्वारा बंद कर दिया गया है SIGINTऔर SIGPIPE।

— Taneb
स्रोत

सुझाव: के '\89'बजाय का उपयोग करेंsucc 'x'

— गर्व हैस्केलर

3

रूबी, 27 बाइट्स - 10 = 17

यह बोनस के साथ सिर्फ @ ProgramFOX का समाधान है (बोनस प्रश्न को हल करने में मेरी 9 बाइट्स लगीं)।

loop{puts ARGV[0]||?x.succ}

— alexanderbird
स्रोत

3

डीसी, 21 बाइट्स - 10 = 11

C1st?st[ltP[]ps0dx]dx

ध्यान दें कि इनपुट को लिपटे जाने की आवश्यकता है [], जैसे [no], ?इनपुट लेने का एकमात्र तरीका है, जो इसे dcकोड के रूप में निष्पादित करता है ।

— nyuszika7h
स्रोत

आप उपयोग कर सकते हैं C2के बजाय 122। वास्तव में मैं तर्क था कि 122 1-साथ प्रतिस्थापित किया जा सकता है C1के रूप में C1स्पष्ट रूप से प्रश्न में प्रतिबंधित नहीं है

— डिजिटल ट्रामा

3

कमोडोर 64 बेसिक: 14 13 बाइट्स

1?C|(11↑2):R╭

हमेशा की तरह, मैंने PETSCII के पात्रों के लिए प्रतिस्थापन बनाए हैं जो यूनिकोड में मौजूद नहीं हैं। |का प्रतिनिधित्व करने के लिए उपयोग किया जाता है SHIFT+H, जबकि ╭प्रतिनिधित्व करता है SHIFT+U। ध्यान दें कि यह ASCII 'y' (बाइट वैल्यू 121) को एक कैरेक्टर के बजाय डिफॉल्ट कमोडोर कैरेक्टर सेट को 'y' के रूप में प्रदर्शित करता है।

बेसिक आसानी से सीखने वाली, अंग्रेजी जैसी प्रोग्रामिंग भाषा है। कई प्रारंभिक बोलियों में मौजूद टाइपिंग शॉर्टकट्स में फेंक दें, और आपको कुछ ऐसा मिलता है जो पर्ल से कम छोटा और पढ़ने योग्य हो।

संपादित करें : "शिफ्टेड मोड" में, यह दो बाइट्स छोटा हो जाता है, लोअरकेस "y" को दशमलव मान 89 पर एन्कोड किया जाता है। अपने ASCII मानों का उपयोग न करने के लिए सेट किए गए गैर-ASCII वर्ण का उपयोग करना "नियम" हो सकता है। धोखा, हालांकि।

1?cH(89):rU

— निशान
स्रोत

यूनिकोड में मौजूद सभी seems के साथ, यह आश्चर्यजनक लगता है कि C64 द्वारा उपयोग किया गया पूर्ण वर्ण सेट कहीं नहीं होगा।

— कैस्परल्ड

@kasperd, यूनिकोड के बॉक्स-ड्रॉइंग कैरेक्टर ज्यादातर IBM "DOS" सेट से आते हैं, और कैरेक्टर सेल के केंद्र से होकर गुजरते हैं। PETSCII में एक बहुत बड़ा सेट है, जिसमें से अधिकांश चरित्र सेल के किनारों का उपयोग करता है। U + 2502 संभवतः द्वारा निर्मित ऊर्ध्वाधर पट्टी का एक सभ्य सन्निकटन है SHIFT+H, लेकिन पाइप चरित्र टाइप करना आसान है। "SHIFT + O" द्वारा निर्मित "शीर्ष और बाएँ किनारों पर रेखाएँ" के समान कुछ भी नहीं है।

— मार्क

बहुत अच्छा है, लेकिन आप "रन 1" द्वारा "गोटो 1" की जगह एक बाइट बचा सकते हैं: "1? सीएच (89): आरयू"

— लेफॉव

@LeFauve, धन्यवाद। मैंने इसे ASCII-emitting संस्करण में भी लागू किया है।

— मार्क

3

AWK, 38 बाइट्स

BEGIN{for(;;)printf("%c%c",60+61,5+5)}

वेरिएंट जो स्टड पर स्ट्रिंग पढ़ेगा: 14 बाइट्स -10 = 4

{for(;;)print}

लेकिन चूंकि यह दोनों नहीं कर सकता (यदि कोई स्टड प्रदान नहीं किया जाता है तो "y" पर वापस लौटें), मुझे यकीन नहीं है कि यह मायने रखता है ...: ओ)

दोनों को Ctrl + C के साथ बाहर निकाला जा सकता है।

— LeFauve
स्रोत

3

विखंडन , 5 बाइट्स

Rx+!N

यह विखंडन के लिए काफी प्रतिस्पर्धी है। :)

नियंत्रण प्रवाह एक (1,0)दाएं-बाएं परमाणु से शुरू होता है R। xबड़े पैमाने पर सेट करता है 120, और +इसे देने के लिए वेतन वृद्धि करता है (121,0)। फिर !संबंधित वर्ण ( y) Nप्रिंट करता है और एक नई रेखा प्रिंट करता है । स्रोत कोड किनारों पर घूमता है, इसलिए परमाणु Rफिर से गुजरता है (जो अब कुछ भी नहीं करता है), फिर से xद्रव्यमान सेट करता है 120, +इसे बढ़ाता है और इसी तरह ...

— मार्टिन एंडर
स्रोत

3

सी, 32 बाइट्स

-O2 के साथ थोड़ा एंडियन मशीन और संकलन की आवश्यकता है (स्टैक ओवरफ्लो से बचने के लिए)।

a=11*11;main(){main(puts(&a));}

— nutki
स्रोत

2

पॉवरशेल, 27 - 10 = 17

param($s=$Host[1])for(){$s}

पश में काम नहीं हो सकता। अधिक मजबूत विकल्प होना चाहिए

param($s="$(gal gh*)"[2])for(){$s}

— एक छोटा सा सिक्का
स्रोत

2

लुआ, 42 बाइट्स - 10 = 32

while 1 do print(...or('').char(90+31))end

लुआ, 49 बाइट्स - 10 = 39

y=...or(string.char(60+61))while 1 do print(y)end

दोनों का परीक्षण Lua 5.1.4 के साथ किया गया था और इसे SIGINT ( Ctrl+ C) के साथ मारा जा सकता है ।

— Digpoe
स्रोत

बहुत बढ़िया! मेरी माँ ने लुआ में लिखा है, मैंने इसे पहले कभी जंगली में नहीं देखा था। ( हे माँ! मैंने जो देखा! अनुमान करें! )

— सिग्नल १५

2

पर्ल, 31

यहाँ एक पर्ल संस्करण है जो वास्तव में GNU की तरह व्यवहार करता है yes, जहाँ तक मैं बता सकता हूँ:

{print "@ARGV"||chr 11**2;redo}

यह काम करता है अगर यह पर्ल की कमांड लाइन स्विच ( -lन्यूलाइन के लिए) का उपयोग करने के लिए ठीक है , अन्यथा यह 3 अक्षर लंबा हो जाएगा:

{print "@ARGV"||chr 11**2,$/;redo}

— xebtl
स्रोत

टाइपो: नई लाइन के लिए स्विच है -l(नहीं -e)।

— क्रिस-एल

इसके अलावा, बोनस केवल तभी है जब आपकी स्क्रिप्ट स्टड से पढ़ सकती है । हाँ, मुझे पता है कि असली हाँ स्टड से नहीं पढ़ता है, लेकिन एक तर्क से, लेकिन यह ओपी का नियम है; यह स्टड से लेकर बोनस तक होना है।

— क्रिस-एल

@ क्रिस-एल ने प्रकार तय किया, धन्यवाद। मैंने बोनस के संबंध में दावा भी हटा दिया है, लेकिन मैं अपना उत्तर छोड़ दूंगा क्योंकि यह है :-P

— xebtl

हे यकीन है, मेरा अपना जवाब तुम्हारे जैसा है; यह स्टड के बजाय एक तर्क का उपयोग करता है। IMHO, ऑप को बोनस देना चाहिए जो वास्तव में वही करता है जो वास्तविक हाँ करता है।

— क्रिस-एल

2

सीएपीएल 1.5+; बिना इनपुट के 6; इनपुट के साथ 10 - 10 = 0

सिडेनोट
मैंने कहीं पढ़ा है [लिंक?] कि कस्टम भाषा गोल्फिंग सवालों की अनुमति नहीं है, क्योंकि वे बिल्ट-इन फ़ंक्शंस कर सकते हैं जो वास्तव में सवाल पूछ रहे हैं, लेकिन मैंने सामान्य रूप से गोल्फिंग को आसान बनाने के लिए CAPL किया । अगर आपको लगता है कि यहां इसकी अनुमति नहीं है, तो मुझे बताएं!

मुझे कुछ विचार मिले > <> और बेफंगे (आप संख्याओं को आगे बढ़ाने के लिए लाइनों के बीच ले जा सकते हैं और हेक्साडेसिमल वर्णों का उपयोग कर सकते हैं), कुछ रूबी से और कुछ मेरे खुद से गोल्फ को आसान बनाने के लिए।
सीएपीएल बाएं से दाएं पढ़ता है, और लाइन के अंत में एक पंक्ति नीचे जाती है। यदि यह अंतिम पंक्ति के रूप में है, तो प्रोग्राम छोड़ देगा।

जैसा कि कोई भी इस भाषा को नहीं जानता है, मैं जितना संभव हो उतना समझाने की कोशिश करूंगा।

आउटपुट वाई। 6 बाइट्स

bb*.n<

bb* bके लिए हेक्साडेसिमल है 11, इसलिए bb*है 11*11= 121जिनमें से UTF-8 बराबर है, y। यह मान स्टैक पर धकेल दिया जाता है।
.स्टैक से शीर्ष मान, और UTF-8 के रूप में आउटपुट देता है। जैसा 121कि स्टैक के शीर्ष पर है, सूचकांक को यहां अनदेखा किया गया है।
nएक नई लाइन आउटपुट
<को सूचक को लाइन की शुरुआत में वापस भेजती है, इस प्रकार उस लाइन को दोहराता है। जैसा कि हम इनपुट की उम्मीद नहीं करते हैं, हम इनपुट के लिए फिर से पूछे बिना इसे सुरक्षित रूप से कर सकते हैं।

इनपुट से आउटपुट। 10 बाइट्स, बोनस के बाद 0

i~a&{X:.)}

iउपयोगकर्ता से इनपुट लेता है, स्टैक के शीर्ष पर UTF-8 के रूप में धक्का देता है, और उसके बाद की लंबाई को धक्का देता है। यानी [72,101,108,108,111,5]
~स्टैक से एक नंबर पॉप करता है, फिर बाइट्स की मात्रा को उलट देता है। यानी [111,108,108,101,72]
aहेक्साडेसिमल 10, न्यूलाइन वर्ण
&{...}अनंत लूप बनाता है। हमारे पास इनपुट है, इसलिए हम सूचक को लाइन में वापस नहीं भेज सकते हैं। मैं फ़ंक्शन को नीचे दी गई पंक्ति पर रख सकता हूं, जो मुझे एक बाइट सुरक्षित करेगा, लेकिन इस चुनौती में नए अंक की अनुमति नहीं है।
Xस्टैक से शीर्ष मान निकालता है (लूप से सूचकांक)
:.शीर्ष मूल्य को दोहराता है, फिर UTF-8
)टर्न स्टैक दाएं के रूप में आउटपुट करता है । ( [1,2,3,4,5]-> [5,1,2,3,4])

होवर, इसका मतलब है कि हम एक नई रेखा के साथ शुरू करते हैं, फिर इनपुट को आउटपुट करना शुरू करते हैं, फिर एक नई लाइन, फिर इनपुट इत्यादि। यदि हमें नई लाइन के साथ शुरुआत करने की अनुमति नहीं है, तो 12 बाइट्स के साथ निम्नलिखित कोड का उपयोग करें, या 2 घटाना के बाद बोनस।

iXa#~&{X:.)}

यहां केवल नया कमांड है #, जो स्टैक पर आइटम की मात्रा को स्टैक पर धकेलता है।
मैंने लंबाई को हटा दिया i, क्योंकि 1 को जोड़ने पर, फिर से नई लाइन के साथ स्वैप करना लंबाई को हटाने और फिर से प्राप्त करने से अधिक है।

सिर्फ मनोरंजन के लिए, यहां "हैलो वर्ल्ड" कार्यक्रम है

"Hello World"#~
#?!;.<

?!आपरेशन> <> के रूप में ही है

— चार्ली
स्रोत

वास्तव में प्रतिबंध कस्टम भाषाओं / पुस्तकालयों / सुविधाओं पर लागू होता है जो प्रश्न पोस्ट किए जाने के बाद प्रकाशित होते हैं ।

— manatwork

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

— चार्ली

मेरी राय में यह अमान्य नहीं है, सिर्फ जीतने के योग्य नहीं है। प्रतिबंध का लक्ष्य धोखाधड़ी को रोकना था, लेकिन जैसा कि आपने भाषा की ताजगी के बारे में बयान को शामिल किया है, इसे शायद ही धोखा देने का प्रयास माना जा सकता है।

— मैनटवर्क

2

एपीएल (डायलॉग एपीएल) , 5 - 10 = -5 बाइट्स

चेतावनी: एक अनिर्दिष्ट और असमर्थित सुविधा / बग पर निर्भर करती है।

⎕←⍣≢⍞

खाली STDIN खाली लाइनें प्रिंट करता है ("y" नहीं), जिसे अनुमति दी गई है और सुझाव दिया गया है ।

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

⎕ नई अनुगामी के साथ STDOUT,

← हो जाता है

⍣ बार-बार

≢ इससे अलग है

⍞ STDIN

कभी नहीं, लेकिन थ्रेड को रोककर अबाधित।

— एडम
स्रोत

हम्म। गालियाँ देना .. रोचक।

— मैथ्यू रो

@MatthewRoh का उपयोग करना, गाली देना नहीं। "सुविधा" ऑपरेटर ⍣को असाइनमेंट पर उपयोग कर रही है ←, भले ही ←वह वास्तविक फ़ंक्शन उचित नहीं है, और इस तरह वास्तव में ऑपरेंड होने के योग्य नहीं है। अभी भी काम करता है ...

— Adám

2

> <>, 6 बाइट्स

b:*oao

;अंत में शामिल नहीं होने से, > <> तैराकी जारी रखेगा जब तक कि वह एक संकेत द्वारा जारी न हो जाए।

व्याख्या

b:*oao
b         Push 11
 :        Duplicate
  *       Multiply top elements to get 121
   o      Print as character
    a     Push 10
     o    Print as character (yielding '\n')
          No program terminator, so our ><> will 
          keep on swimming this path forever.
^----'

> <>, 17 - 10 = 7 बाइट्स

पिछला काफी उबाऊ समाधान है, इसलिए यहां एक है जो स्टड से इनपुट लेता है। यह इस तथ्य का दुरुपयोग करता है कि इनपुट का आपूर्ति करने का डिफ़ॉल्ट तरीका > <> प्रोग्राम है echo 'input' | fish.py yes.fish, जहां चरित्र echoप्रदान करता है \n।

 i:0)?!v
0r}o:r~<

व्याख्या

 i:0)?!v     Load STDIN into the stack (reversed)

             NOP           <----------,
 i           Push a byte from STDIN   |
  :          Duplicate top element    |
   0         Push 0                   |
    )?       If (i > 0):              |
      !        Wrap around  ----------'
             Else:
       v       Move to the second part

0r}o:r~<     Print STDIN until halted

       <     Go right         <---------------,
      ~      Remove top element (duplicated   |
                -1 from EOF)                  |
     r       Reverse stack                    |
    :        Duplicate top element            |
   o         Output as character              |
  }          Rotate stack to right (go to     |
                next character)               |
 r           Reverse the stack                |
0            Push 0                           |
             Wrap around       ---------------'

0rअंत में अनुमति देने के sfor पाश, चारों ओर लपेटकर जहां हम अभी भी ढेर मान लें कि एक साथ ही उल्टा हो करने के लिए से होने -1चोटी पर।

— PidgeyUsedGust
स्रोत

1

जाहिरा तौर पर यह पूरी तरह से पोर्टेबल नहीं है। मेरा sys.version है 2.7.9 (default, Dec 11 2014, 04:42:00) \n[GCC 4.9.2], इसलिए अगर तुम्हारा अलग है यह काम नहीं हो सकता है मुझे लगता है।

पायथन 2 - (76-10) = 66

import sys
s=sys.stdin;a=`help`[1]if s.isatty()else s.read()
while 1:print a

बहुत लंबा है, लेकिन मैं बोनस के लिए जाना चाहता था (भले ही इसकी लागत 10 बाइट से अधिक हो)। जाँच हो रही है कि इनपुट के लिए संकेत दिए बिना स्टड खाली है या नहीं, जाहिर है।

सबसे पहले, मैं स्टड के बजाय एक तर्क लेने के रूप में बोनस को गलत तरीके से बताता हूं। मुझे उस पर अपने समाधान पर गर्व है, इसलिए मैं इसे वैसे भी पोस्ट कर रहा हूं;)

अजगर 2 - (52-10 + ∞) = invalid (अमान्य!)

import sys
while 1:print(sys.argv+[0])[1]or`help`[1]

sys.argvएक सूची है जहाँ शून्य तत्व फ़ाइल नाम है और प्रत्येक तत्व afterwords कार्यक्रम के लिए दिया गया एक तर्क है। मैं सूची के अंत में एक गलत मूल्य जोड़ता हूं; अगर कोई तर्क नहीं है, पहला तत्व यह है कि गलत मूल्य है, अन्यथा यह पहला तर्क है। a or bपायथन में पहला मूल्य है जो पुष्टि करता है कि परिणाम क्या होगा: यदि aसत्य है, तो हम पहले से ही जानते हैं कि पूरी बात सच होगी, इसलिए यह बस वापस आ जाता है। यदि यह गलत है, bतो लौटा दिया जाता है ( False or b== के बाद से b)।

— undergroundmonorail
स्रोत

@ यदि मैं कर सकता था, लेकिन यह उपयोगकर्ता को संकेत देगा। मैं चाहता था कि y\nअगर स्टड खाली था तो तुरंत बाहर थूकना शुरू कर दूं ।

— अंडरग्राउंडोरेल

@ अगर यह अजीब है, तो यह मेरे लिए काम करता है। यह cPython पर निर्भर हो सकता है? मेरे पास कोई अन्य विचार नहीं है।

— भूमिगत

अच्छा विचार है, इस पर

— भूमिगत

r=raw_input();p=r if r else`help`[1]\nwhile 1:print p ५२ अक्षर

— ग्लोबबाई

1

हम्म, पहले से ही पहली पंक्ति yमें एक लगता है , दूसरा भी।

— पाओलो एबरमन 12

हाँ 91 लाइन लंबी है

सीजाम, 13 बाइट्स - 10 = 3

व्याख्या

ब्रेनफक - 38 बाइट्स

ब्रेनफक - (63-10) = 53

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

मार्बेलस 14 बाइट्स

अजगर, 10 9 6 बाइट्स - 10 = 0 -1 -4

सी #, 81 78 76 बाइट्स

जावा, 178

पर्ल: 18 बाइट्स - 10 = 8

रूबी, 30 23 18 बाइट्स

पर्ल, 26 बाइट्स

तर्क से कस्टम इनपुट (जैसे yesवास्तव में काम करता है), 22 बाइट्स -10 = 12

स्टड से कस्टम इनपुट, 22 बाइट्स -10 = 12

सी, 64 55 53 45 40 - 10 = 30

सी, 30 (+ 1 फ़ाइल नाम)

लिनक्स बैश, 33-10 = 23

जंग, 52 चरस

जंग, 44 वर्ण (+ फ़ाइलनाम के लिए कम से कम 1 वर्ण)

संपादित करें: जंग, 36 वर्ण (35 स्रोत, 1 फ़ाइल नाम)

जंग, 37 वर्ण (+ env K='y'अपने मंच पर बराबर )

लिनक्स बैश - 19 बाइट्स

डीसी, १२

आम लिस्प: (30-10) = 20

हास्केल, 29 बाइट्स

रूबी, 27 बाइट्स - 10 = 17

डीसी, 21 बाइट्स - 10 = 11

कमोडोर 64 बेसिक: 14 13 बाइट्स

AWK, 38 बाइट्स

विखंडन , 5 बाइट्स

सी, 32 बाइट्स

पॉवरशेल, 27 - 10 = 17

लुआ, 42 बाइट्स - 10 = 32

लुआ, 49 बाइट्स - 10 = 39

पर्ल, 31

सीएपीएल 1.5+; बिना इनपुट के 6; इनपुट के साथ 10 - 10 = 0

एपीएल (डायलॉग एपीएल) , 5 - 10 = -5 बाइट्स

> <>, 6 बाइट्स

व्याख्या

> <>, 17 - 10 = 7 बाइट्स

व्याख्या

पायथन 2 - (76-10) = 66

अजगर 2 - (52-10 + ∞) = invalid (अमान्य!)

तर्क से कस्टम इनपुट (जैसे `yes`वास्तव में काम करता है), 22 बाइट्स -10 = 12

जंग, 37 वर्ण (+ `env K='y'`अपने मंच पर बराबर )