HelolW rdlo (एक सूत्रण चुनौती)

39

मेरे पास आपके लिए एक चुनौती है:

  • किसी भी भाषा का उपयोग करके "हैलो वर्ल्ड" प्रिंट करें।
  • प्रत्येक चरित्र को अपने स्वयं के, अद्वितीय धागे से मुद्रित किया जाना चाहिए

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

और, क्योंकि यह कोड गोल्फ है, सबसे छोटा प्रोग्राम जीतता है।

अद्यतन करें:

विजेता में 34 पात्रों में मारिनस की एपीएल प्रविष्टि है । यह कम से कम पठनीय प्रविष्टि के लिए पुरस्कार भी जीतता है।

code-golf 
— Tharwen
स्रोत
10
इसके लिए एक बेहतर नाम होगाHelolW rdlo
— क्रिस्टियान लुपस्कु
हा, मुझे वह पसंद है। इसे तुरंत बदलना: डी
— थारवेन
Aww ... यह बहुत छोटा है
— थार्वेन
1
यह देखना मजेदार है कि कितने लोग "स्पष्ट रूप से अनदेखा करते हैं, क्योंकि इस बात की कोई गारंटी नहीं है कि धागे आपके द्वारा शुरू किए गए क्रम में काम करेंगे"
— जोया एबर्ट
यद्यपि यह सच है कि "इस बात की कोई गारंटी नहीं है कि थ्रेड्स आपके द्वारा शुरू किए गए क्रम में संचालित होंगे" व्यवहार में वे इस तरह के तुच्छ कार्यक्रम के लिए लगभग हमेशा करेंगे। इस भ्रम से बचने के लिए, मैं इस समस्या को जोड़ूंगा कि प्रत्येक थ्रेड को 1) मिलिसेकंड्स के एक (छोटे) यादृच्छिक संख्या की प्रतीक्षा करें 2) इसके चार आउटपुट करें) एक और यादृच्छिक (शायद लंबे समय) राशि की प्रतीक्षा करें इस तरह से लोग बता सकते हैं कि क्या कोड सिर्फ इसे एक-दो बार चलाने से काम करता है। और () समाधान बहुत बुरा प्रदर्शन करेंगे। यादृच्छिक प्रतीक्षा के बिना एक सफल रन द्वारा यह सोचने के लिए गुमराह किया जा सकता है कि उनका कार्यक्रम सही है।
— सिल्वियाट

जवाबों:

10

एपीएल (डायलॉग) ( ४४ ४३ ३ ९ ३४)

{⍞←⍺⊣⎕DL⍵}&⌿2 11⍴'Hello World',⍳11

स्पष्टीकरण:

  • 2 11⍴'Hello World',⍳11 एक मैट्रिक्स बनाता है: (एच, 1), (ई, 2), ...
  • &⌿ का अर्थ है: मैट्रिक्स के प्रत्येक कॉलम के लिए, एक अलग थ्रेड पर करें:
  • एक सूत्र में, ⍺अब चरित्र है और ⍵अब समय है
  • ⎕DL⊃⍵⍵सेकंड का इंतजार करता है ।
  • फिर, ⍞←⍺चरित्र को आउटपुट करता है।
— मारीनस
स्रोत
11
आपको पता है कि? मैं इसके लिए आपका वचन लेता हूँ ... :)
— बोलस्टर
ठीक है, यह सबसे छोटा है। बधाई हो!
— थरवीन
19

C, 61 62 वर्ण

i;main(){write(1,"Hello World\n"+i++,1);i>13||fork()||main();}

पायथ्रेड लाइब्रेरी के सभी कार्यों में लुओओन्ग नाम हैं, इसलिए इसके बजाय मैंने प्रत्येक चरित्र के लिए एक पूरी प्रक्रिया को निकाल दिया। fork()बहुत छोटा है।

इसके write()बजाय इसका उपयोग करना आवश्यक था putchar()क्योंकि stdio बफ़रिंग फ़ंक्शन थ्रेड-सुरक्षित नहीं हैं।

संपादित : 62 वर्णों तक का बैक मेरे उत्साह में, 61 चरों को छोड़ने से थ्रेड-सेफ्टी भी गिरा।

— रोटी का डिब्बा
स्रोत
write(1,"Hello World\n",!!++i)2 बाइट्स के लिए लिखित स्टेटमेंट को बदलना संभव होना चाहिए । अच्छा समाधान अन्यथा।
— प्राइमो
आपको यह कोशिश करनी चाहिए और देखें कि यह क्या पैदा करता है।
— ब्रेडबॉक्स
मेरी गलती है, मैं मतलब!!++i
— Primo
ऐसा प्रतीत होता है कि आपने पहली बार लिखा था, इसलिए मुझे यह नहीं दिखता कि आप किस गलती को सुधारने की कोशिश कर रहे थे। और मैं स्पष्ट नहीं हो रहा था: मेरा ईमानदारी से मतलब था कि आप इसे स्वयं आजमाएँ और देखें कि क्या होता है। जोड़ को हटाकर, प्रत्येक थ्रेड स्ट्रिंग के पहले चरित्र को प्रिंट करेगा।
— ब्रेडबॉक्स
मैंने मूल रूप से लिखा था !!i++, लेकिन इसे कुछ सेकंड बाद संपादित किया, क्योंकि मुझे एहसास हुआ कि यह 0पहले पुनरावृत्ति पर मूल्यांकन करेगा । मैंने मान लिया कि आपने बिना पढ़े संस्करण देख लिया है। मैं आपके कोड का परीक्षण करने में सक्षम नहीं हूं, क्योंकि यह केवल पहले चरित्र को प्रिंट करता है, एक बार । हालांकि बहुत सारे विकल्प हैं; i++<13, का उपयोग कर !!i, या यहाँ तक किwrite(1,"Hello World\n",i++>13||fork()||main())
— प्राइमो
9

रूबी, 46 वर्ण

"Hello World".chars{|c|Thread.new{$><<c}.join}

यह इस तथ्य के कारण सिंक्रनाइज़ किया जाता है कि कार्यक्रम अगले धागे को शुरू करने से पहले समाप्त होने का इंतजार करता है और अगले चार के साथ जारी रहता है।

— हावर्ड
स्रोत
7

पायथनक्ट (35 वर्ण)

http://www.pythonect.org

"Hello World"|list|_.split()->print
— जोनाथन रोम
स्रोत
यह अब तक का सबसे छोटा है। चूंकि मुझे नहीं पता कि यह वास्तव में क्या करता है, इसलिए मैं इसे सही मानूंगा और एक या दो दिन में इसे स्वीकार करूंगा, अगर कोई भी इसके खिलाफ बोलता है या कुछ भी छोटा पोस्ट करता है।
— थारवेन
1
उदाहरणों पर बस एक संक्षिप्त नजर थी। क्या विवरण या सूची विवरण को कोष्ठक नहीं होना चाहिए [] इसके चारों ओर?
— दलिन सीवेराइट
1
हाय, im अग्रेषण Itzik है (अजगर के निर्माता) जवाब: '->' और '' | दोनों Pythonect ऑपरेटर हैं। पाइप ऑपरेटर एक आइटम पर एक आइटम पास करता है, जबकि दूसरा ऑपरेटर एक बार में सभी आइटम पास करता है। उपरोक्त कार्यक्रम क्या है, यह "हैलो वर्ल्ड" स्ट्रिंग लेता है, इसे सूची में बदल दें, सूची को वर्णों में विभाजित करें, और प्रत्येक चार्ट को प्रिंट करने के लिए भेजें। कार्यक्रम को आगे भी अनुकूलित करना संभव है, निम्न पर: iter ("हैलो वर्ल्ड") | प्रिंट यह क्या करता है, यह "हैलो वर्ल्ड" स्ट्रिंग को पुनरावृत्त करता है, और प्रत्येक चार्ट को प्रिंट करने के लिए (सिंक / अवरुद्ध तरीके से) भेजता है। सादर, इत्ज़िक कोटलर | ikotler.org
— Leon Fedotov
यहाँ कैसे किया जा रहा है थ्रेडिंग ???
— रोहित
1
जैसे @LeonFedotov का उल्लेख किया है, और pythonect स्रोत से ( pythonect पर उपलब्ध ) पार्स करने के बाद, प्रत्येक पुनरावृत्ति और '->' ऑपरेटर के लिए, थ्रेडिंग इस तरह से किया जाता है: थ्रेड = thth.Thread (लक्ष्य = __ रन, args = ([] ऑपरेटर, आइटम)] + अभिव्यक्ति [1:], copy.copy (globals_), copy.copy (locals_), return_value_queue, iterate_literal_arrays नहीं)) thread.start ()
— जोनाथन रोम
6

पायथन ( 101 93 98)

यह पीटर टेलर का समाधान है। यह एन सेकंड द्वारा एन-वें चरित्र को प्रिंट करने में देरी करके काम करता है। टिप्पणी देखो।

import sys.threading as t
for x in range(11):t.Timer(x,sys.stdout.write,"Hello World"[x]).start()

यह मूल है:

import sys,threading as t
for x in "Hello World":t.Thread(None,sys.stdout.write,x,x).start()

इसने काम किया क्योंकि किसी एक पात्र को प्रिंट करने में लगने वाला समय उस समय से कम होता है, जब पाइथन को एक नए धागे को इनिशियलाइज़ करने में समय लगता है, इसलिए एन + 1-थ्रेड बनाने से पहले एन-थ्रेड समाप्त हो जाएगा। जाहिर तौर पर इस पर भरोसा करना नियमों के खिलाफ है।

— मारीनस
स्रोत
आप को बदलने के द्वारा 3 वर्ण बचा सकते हैं import sys,threadingकरने के लिए import sys,threading as tऔर आप 2 अधिक बचा सकता है तर्क नहीं बल्कि कीवर्ड तर्क से, स्थितीय args के रूप में थ्रेड को पास करके,।
— जोएल कॉर्नेट
2
धागा सुरक्षा से संबंधित कोड कहां है? आप बस धागे की उम्मीद कर रहे हैं कि वे उसी क्रम में चलेंगे जो आप उन्हें शुरू करते हैं। यह हमेशा सच नहीं होगा और वास्तव में इस समस्या का "कठिन हिस्सा" है। अपने कार्यक्रम के आकार को अनुकूलित करने के बजाय आपको समस्या पर फिर से विचार करना चाहिए: आपको यह पहली जगह में नहीं मिला। एक प्रमाण के लिए gist.github.com/2761278 देखें कि यह कोड काम नहीं करता है।
— सिल्वियोट
जल्दी ठीक। के threading.Timerबजाय का उपयोग करें threading.Thread। xस्लीप पैरामीटर के रूप में पास करें ।
— जोएल कॉर्नेट
1
जोएल के सुझाव में 4 से सुधार किया जा सकता हैfor x in range(11):t.Timer(x,sys.stdout.write,"Hello World"[x]).start()
— पीटर टेलर
1
@ सिलविओट: मैं इस तथ्य का फायदा उठा रहा था कि थ्रेड क्रिएशन में किसी ऑब्जेक्ट को तत्काल शामिल करना शामिल है, और इस तरह मैंने जिन सिस्टमों का परीक्षण किया है, उनमें से एक से दो-तिहाई मिलीसेकंड लेता है। चरित्र उत्पादन में यह ओवरहेड नहीं होता है, इस समय का केवल दसवां हिस्सा लेता है। इसलिए, यह "हमेशा" काम करेगा, जब तक आप कुछ भी ओवरराइड नहीं करते हैं। स्टडआउट बफ़र किया गया है ताकि कभी भी समस्या न हो।
— मारीनस
4

सी # 73

"hello world".ToList().ForEach(c=>Task.Run(()=>Console.Write(c)).Wait());
— JJoos
स्रोत
सुनिश्चित नहीं है कि यह आवश्यकता को संतुष्ट करता है कि प्रत्येक पत्र अपने स्वयं के धागे के माध्यम से मुद्रित किया जाता है क्योंकि tpl धागे का पुन: उपयोग कर सकता है।
— स्टेटिचिप्पो
सिद्धांत रूप में आप सही कह रहे हैं, लेकिन मेरे पीसी थ्रेडपूल.गेटमैक्सट्रेड्स या थ्रेडपूल.गेटअवैलट्रेड्स पर IO और वर्कर थ्रेड्स दोनों के लिए लगभग 1000 का मान है।
— जेजो
4

एपीएल (Dyalog यूनिकोड) , 28 बाइट्स SBCS

पूरा कार्यक्रम। स्टेटर को प्रिंट करता है। मारिनस के समाधान से प्रेरित ।

'Hello World'{⍞←⍺⊣⎕DL⍵}&¨⍳11

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

⍳11 पहले 11 पूर्णांक

'Hello World'{… }&¨ सही तर्क के रूप में प्रत्येक पूर्णांक के लिए ( ⍵), बाएं तर्क के रूप में इसी चरित्र के साथ निम्नलिखित फ़ंक्शन को स्पॉन करें ( ⍺):

 ⎕DL⍵ d e l ay सही-तर्क सेकंड

 ⍺⊣ वाम-तर्क चरित्र के पक्ष में (प्रभावी विलंब) को त्यागें

 ⍞← प्रिंट करें कि रेखा को तोड़ने के बिना टालने के लिए

— एडम
स्रोत
कैसे के बारे में ⍞∘←&¨'dlroW olleH'? - मुझे नहीं पता कि यह सैद्धांतिक रूप से गारंटीकृत है, लेकिन यह हमेशा उन्हें सही क्रम में प्रिंट करने के लिए लगता है
— ngn
@ngn जाहिर है, कोई गारंटी नहीं कि धागे के क्रम में आप उन्हें शुरू में संचालित होगा घटती है, तो आप यह सुनिश्चित करना उत्पादन सही क्रम में छपा है अपने कार्यक्रम धागा सुरक्षित करना है।
— आदम जूल
वह बाधा जिसे मैं संबोधित करने की कोशिश कर रहा था, इसकी गारंटी हो सकती है। मैंने इसे 100 बार चलाया और ऐसा लगता है कि थ्रेड शेड्यूलर हमेशा थ्रेड को रिवर्स ऑर्डर में उठाता है। या कम से कम यही स्थिति है जब case11 कार्य हैं। AFAIK ⍞∘←रुकावट नहीं है (या यह है? शायद आप एक सी डेवलपर पूछ सकते हैं?)। Dyalog औजार हरे धागे - 1 असली धागा कई होने का नाटक है, इसलिए यदि एक (हरा) धागा स्विच नहीं हो सकता है, क्रम में है उम्मीद के मुताबिक।
— ngn
3

जावा (160 वर्ण)

class A{static int i;public static void main(String...a){new Thread(){public void run(){System.out.print("Hello World".charAt(i++));if(i<11)main();}}.start();}}

हाँ, मुझे पता है कि यह कोड गोल्फ के लिए गलत भाषा है, मैं इसे मज़े के लिए करता हूं।

— मैल्कम
स्रोत
class A{public static void main(String[]args){new B(0).start();}}class B extends Thread{int i;B(int j){i=j;}public void run(){System.out.print("Hello World".charAt(i));if(i<10)new B(i+1).start();}}-197 वर्ण
— राजकुमार जॉन वेस्ले
@Prince हाँ, सुधार के लिए धन्यवाद!
— मैल्कम
class A extends Thread{static int i;public static void main(String[]args){System.out.print("Hello World".charAt(i++));if(i<11)new A().start();}public void run(){main(null);}}- 174 वर्ण
— राउटर कोकेटर्ट्स
@ बहुत अच्छा! मैं पूरी तरह से चूक गया।
— मैल्कम
1
@ मैल्कम, @ bkil, @ राउटर: class A{static int i;public static void main(String...a){new Thread(){public void run(){System.out.print("Hello World".charAt(i++));if(i<11)main();}}.start();}}- 160 चार्ट
— प्रिंस जॉन वेस्ले
2

बैश (64)

:(){ [ "$1" ]&&(echo -n "${1:0:1}"&: "${1:1}")};: "Hello World"
— मारीनस
स्रोत
@ मॉरिनस गोल्‍ड डोएन 3 चरस::()([ "$1" ]&&(printf "${1:0:1}"&: "${1:1}"));: Hello\ World
— डिजिटल ट्रॉमा
@fossilet मेरे लिए लिनक्स और OSX, कई बैश संस्करणों पर काम करता है। अंतिम एक या दो अक्षर कभी-कभी शेल प्रॉम्प्ट के बाद मुद्रित होते हैं।
— डिजिटल ट्रॉमा
2

हास्केल ( 120 118)

import Control.Concurrent
t=threadDelay.(*3^8)
main=(\(x,y)->forkIO$t x>>putChar y)`mapM_`zip[0..]"Hello World">>t 99

मैं 9999 से गुणा करने के बारे में निश्चित नहीं हूं - मेरे पास एक 2Ghz Xeon है जिस पर यह ठीक काम करेगा भले ही आप नहीं करते हैं, लेकिन मेरे पास एक पेंटियम 4 भी है जिसकी आवश्यकता है (999 ने गार्बल्ड आउटपुट दिया और 99 डिड्यूएन ' t कुछ भी करो।)

— मारीनस
स्रोत
के (*5^6)बजाय का (*9999)उपयोग करके और नहीं के लिए उपयोग करके 2 वर्ण सहेजें mapM_।
— मेकैनिकल घोंघा
@ मेकैनिकल मेल यदि आप बैकटीक्स को हटाते हैं, तो आपको अतिरिक्त जोड़ी ब्रेस की आवश्यकता होती है, अन्यथा यह उस तरह से पार्स करता है जैसा (((mapM_ (\(x,y) ... )) zip) [0..]) ...आप नहीं चाहते हैं।
— मारीनस
के रूप में 999, यह ऑपरेटिंग सिस्टम सीमाओं के कारण 0 से छोटा हो सकता है, लेकिन मैं गलत हो सकता है। आप कौन सा ओएस उपयोग कर रहे हैं?
— जॉय एडम्स
1

डी (135 वर्ण)

import std.concurrency,std.stdio;
void main(){
    p("Hello World");
}
void p(string h){
    write(h[0]);
    if(h.length>1)spawn(&p,h[1..$]);
}

मैं केवल अगले धागे को शुरू करता हूं जब मैंने पहले से ही वर्तमान चार्ट मुद्रित किया है

बेहतर बाउंड चेक के लिए +2 चार्ट संपादित करें

— शाफ़्ट सनकी
स्रोत
मुझे core.exception.RangeError@test.d(6): Range violationत्रुटि मिलती है।
— फिश मॉनिटर
@ फॉस्फेट मैंने इसे ठीक किया
— शाफ़्ट फ्रीक
1

स्काला 74

"Hello World".zipWithIndex.par.map(x=>{Thread.sleep(x._2*99);print(x._1)})
  • zipWithIndex ((एच, 0), (ई, 1), (एल, 2) ...) का उत्पादन करता है।
  • बराबर इसे एक समानांतर संग्रह बनाता है।

टेस्ट:

(1 to 10).foreach {_ => "Hello World".zipWithIndex.par.map(x=>{Thread.sleep(x._2*99);print(x._1)});println()}
Hello World
Hello World
Hello World
...
Hello World
— अज्ञात उपयोगकर्ता
स्रोत
scala> "Hello World".zipWithIndex.par.foreach(x=>{Thread.sleep(x._2*99);print(x._1)}) Hel lWrolod- मुझे यह मिला
— प्रिंस जॉन वेस्ले
यह भी println(Thread.currentThread.getName)दर्शाता है कि धागे अद्वितीय नहीं हैं।
— प्रिंस जॉन वेस्ले
@PrinceJohnWesley: मुझे लगता है कि आपको प्रति अक्षर एक कोर की आवश्यकता है, ताकि बराबर सभी कोर पर काम वितरित करेगा।
— उपयोगकर्ता अज्ञात
मैं समझ गया। इसलिए प्रति अक्षर एक कोर + सिस्टम क्लॉक का उच्च रिज़ॉल्यूशन आवश्यक है।
— प्रिंस जॉन वेस्ले
के mapबजाय का उपयोग करें foreach। आप 4 वर्णों को बचा सकते हैं।
— प्रिंस जॉन वेस्ले
1

जावास्क्रिप्ट (72)

(function f(){console.log("Hello world"[i++]);i<11&&setTimeout(f)})(i=0)
— एरिक
स्रोत
1

यह मेरा एफ # प्रयास है। मेरा पहला गंभीर एफ # कार्यक्रम। कृप्या दयालु बनें।

let myprint c = async {
        printfn "%c"c
}
"Hello World"|>Seq.map myprint|>Async.Parallel|>Async.RunSynchronously|>ignore
— स्मिताड अनारकिस्ट
स्रोत
0

एर्लैंग (90)

-module(h).
r()->r("Hello World").
r([])->'';r([H|T])->spawn(h,r,[T]),io:format("~c",[H]).

संकलन erlc +export_all h.erl

— Nik
स्रोत
0

अजगर: बहुत सारे पात्र, लेकिन यह काम करता है।

# Ok. First we patch Threading.start to test wether our solution actually works

import threading
import random, time
original_run = threading.Thread.run


def myRun(self):
    tosleep = random.randint(0,200)/1000.0
    time.sleep(tosleep)
    original_run(self)

threading.Thread.run = myRun

# And now the real code:
import time, sys, threading
string_to_write = "Hello World\n"
current_char_index = 0 # This integer represents the index of the next char to be written
# It will act as a semaphore: threads will wait until it reaches
# the index of the single char that particular thread is due to output

class Writer(threading.Thread):
    def __init__(self, char_to_write, index_to_write):
        self.char_to_write, self.index_to_write = char_to_write, index_to_write
        super(Writer, self).__init__()
    def run(self):
        ch = globals()['current_char_index']
        while not self.index_to_write == ch:
            time.sleep(0.005)
        sys.stdout.write(self.char_to_write)
        # This will be atomic because no other thread will touch it while it has "our" index
        globals()['current_char_index'] += 1

for i, char in enumerate(string_to_write):
    Writer(char, i).start()
— silviot
स्रोत
मुझे समझ में नहीं आता कि नींद के समय को यादृच्छिक बनाने का उद्देश्य क्या है।
— जोएल कॉर्नेट
@ जॉयल यह सुनिश्चित करने के लिए कि जब वह काम करता है, तो यह उसी क्रम में निष्पादित किए जा रहे थ्रेड्स का भाग्यशाली संयोग नहीं है जैसा कि उन्हें निकाल दिया गया था।
— silviot
0

सी # 90 84

foreach(var c in"Hello World"){var t=new Thread(Console.Write);t.Start(c);t.Join();}

रनिंग संस्करण: http://ideone.com/0dXNw

— क्रिस्टियन लुपस्कू
स्रोत
कंसोल। राइट बहुत तेज़ है यही कारण है कि यह आपके लिए काम कर सकता है लेकिन निश्चित रूप से थ्रेड सुरक्षित नहीं है!
— स्टेटिचिप्पो
@statichippo आप सही कह रहे हैं; मैंने तय किया कि
— क्रिस्टियान लुपस्क्यू
0

उद्देश्य-सी (183 वर्ण)

-(void) thread {[self performSelectorInBackground:@selector(printC) withObject:nil];}
-(void) printC {char *c = "Hello World"; for(int i = 0; c[i] != '\0'; i++) {printf("%c", c[i]);}}
— मर्ज़ सॉर्ट
स्रोत
0

हास्केल 99 वर्ण

import Control.Concurrent
f[]=return()
f(x:xs)=(putChar x)>>(forkIO$f xs)>>f[]
main=f"Hello World"

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

— PyRulez
स्रोत
0

बैश , 43 बाइट्स

xargs -n1 printf<<<'H e l l o \  W o r l d'

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

xargsprintfप्रत्येक चरित्र के लिए एक अलग प्रक्रिया की तलाश है (और इसके बाहर निकलने का इंतजार करता है)।

बैश , 45 बाइट्स, कोई बाहरी उपयोगिताओं नहीं

eval \(printf\ {H,e,l,l,o,\\\ ,W,o,r,l,d}\)\;

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

(printf H); (printf e); (printf l); (printf l); (printf o); (printf \ ); (printf W); (printf o); (printf r); (printf l); (printf d);मूल्यांकन से पहले का विस्तार । कोष्ठक प्रत्येक अक्षर के लिए बैश कांटा बनाते हैं (और इसके बाहर निकलने की प्रतीक्षा करते हैं), लेकिन इस बार printfबैश बिलियन है।

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