पिछले सप्ताह के दौरान, कई विषय "MY_LANGUAGE> जो आपके मित्रों को प्रभावित करेगा" पर 10 वन-लाइनर्स शीर्षक के साथ दिखाई दिए, जिसमें कई सरल कार्यों के लिए एक-पंक्ति समाधान होता है जो योग्यता और लेखक की पसंदीदा प्रोग्रामिंग भाषा की "शीतलता" प्रदर्शित करते हैं। मैंने उन्हें अनुवाद करने और तुलना के लिए एक विषय में रखने का फैसला किया। स्काला के साथ पूरी लहर शुरू हुई।
तो चलिए!

स्काला

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

हम सूची में प्रत्येक आइटम को दोगुना करते हैं।

map फ़ंक्शन सूची के प्रत्येक तत्व को लेता है और इसके लिए संबंधित फ़ंक्शन को लागू करता है। इस उदाहरण में, हम प्रत्येक तत्व को लेते हैं और इसे 2 से गुणा करते हैं। परिणामस्वरूप, उसी आकार की एक सूची वापस की जाएगी, जो अन्य उदाहरणों के विपरीत, reduceLeft और foldLeft का उपयोग करते हुए, जो केवल एक गैर-सूची मान लौटाते हैं।
```
 (1 to 10) map { _ * 2 } 
```
मूल लेख पर टिप्पणी में, एक विकल्प भी सुझाया गया था:
```
 (1 to 10) map (2*) 
```
सूची में सभी संख्याओं को संक्षेप में लिखें।

कम करने के लिए सबसे आम उपयोग मामला है सूची में संख्याओं का योग। यह उदाहरण संख्याओं के हमारे अनुक्रम to बनाने और पुनरावृत्ति और reduceLeft लिए reduceLeft लिए 1 से 1000 तक संख्याओं का उपयोग करता है।
```
 (1 to 1000).reduceLeft( _ + _ ) 
```
मूल लेख पर टिप्पणियों में, सबसे अच्छा विकल्प प्रस्तावित किया गया था:
```
 (1 to 1000).sum 
```
सबस्टेशन की घटना की जाँच करना

यह उदाहरण एक बूलियन मान देता है यदि सूची में से एक शब्द निर्दिष्ट स्ट्रिंग पर है। मैंने इस उदाहरण का उपयोग यह सत्यापित करने के लिए किया कि ट्वीट में वह शब्द है जो मुझे रुचिकर बनाता है। हां, तकनीकी रूप से ये तीन लाइनें हैं, लेकिन पहले दो केवल एक चर का काम हैं।
```
 val wordlist = List("scala", "akka", "play framework", "sbt", "typesafe") val tweet = "This is an example tweet talking about scala and sbt." (words.foldLeft(false)( _ || tweet.contains(_) )) 
```
मूल लेख पर टिप्पणियों में, सबसे अच्छा विकल्प प्रस्तावित किया गया था:
```
 ... wordList.exists(tweet.contains(_)) 
```
फ़ाइल से पढ़ें

यह उदाहरण जावा की पृष्ठभूमि के खिलाफ प्रभावशाली हो सकता है, यह एक लाइन में एक फ़ाइल को पढ़ने का एक बहुत ही सामान्य उदाहरण है। यहाँ वास्तव में दो उदाहरण हैं: एक पूरी फ़ाइल को एक स्ट्रिंग में पढ़ता है, दूसरा फ़ाइल लाइन को सूची में लाइन द्वारा पढ़ता है।
```
 val fileText = io.Source.fromFile("data.txt").mkString val fileLines = io.Source.fromFile("data.txt").getLines.toList 
```
जन्मदिन मुबारक हो

एक वन-लाइनर जो "हैपी बर्थडे" गीत को प्रदर्शित करता है। यह स्काला टर्नरी ऑपरेटर के साथ-साथ map और foreach के संयोजन को दिखाता है।
```
 (1 to 4).map { i => "Happy Birthday " + (if (i == 3) "dear NAME" else "to You") }.foreach { println } 
```
नंबर सूची फ़िल्टरिंग

partition के उपयोग के आधार पर संख्याओं की सूची को दो श्रेणियों में फ़िल्टर करें। इस उदाहरण में, दो छात्रों की सूची उनके परीक्षण के परिणामों के आधार पर बनाई गई है।
```
 val (passed, failed) = List(49, 58, 76, 82, 88, 90) partition ( _ > 60 ) 
```
एक वेब सेवा से XML को पुनः प्राप्त करना और पार्स करना

चूँकि XML Scala की मूल रूपरेखा है, XML parsing सरल है। यहां ट्विटर खोज फ़ीड पुनर्प्राप्त करने का एक उदाहरण है।
```
 val results = XML.load("http://search.twitter.com/search.atom?&q=scala") 
```
सूची में न्यूनतम (या अधिकतम) खोजें

एक सूची पर पुनरावृति करने और एक फ़ंक्शन लागू करने के लिए कम reduceLeft का उपयोग करने के कुछ और उदाहरण।
```
 List(14, 35, -7, 46, 98).reduceLeft ( _ min _ ) List(14, 35, -7, 46, 98).reduceLeft ( _ max _ ) 
```
मूल लेख पर टिप्पणियों में, सबसे अच्छा विकल्प प्रस्तावित किया गया था:
```
 List(14, 35, -7, 46, 98).min List(14, 35, -7, 46, 98).max 
```
समानांतर प्रसंस्करण

स्काला 2.9 में, एक नए प्रकार के संग्रह को "समानांतर संग्रह" कहा गया, जिसमें मल्टी-कोर प्रोसेसर का उपयोग करके बल्क ऑपरेशंस जैसे कि foreach , map , filter , इत्यादि का उपयोग किया जाता है ... यहाँ स्केल डेज़ 2010 में समानांतर संग्रह पर अलेक्जेंडर प्रोकोपेट्स से एक वीडियो है ।

यह उदाहरण समानांतर संग्रहों के उपयोग को दर्शाता है। कल्पना करें कि आपके पास डेटालिस्ट सूची में बहुत अधिक डेटा परिभाषित है और प्रोसेसर का उपयोग करने वाले प्रोसेस इटेम फ़ंक्शन बहुत भारी है। निम्नलिखित एक-लाइनर आपको समानांतर सूची प्रसंस्करण देता है।
```
 val result = dataList.par.map(line => processItem(line)) 
```
एराटोस्थनीज की छलनी

खैर, इस बार उदाहरण पूरी तरह से व्यावहारिक नहीं है और तकनीकी रूप से, एक-पंक्ति नहीं है, क्योंकि यह पहले से परिभाषित ऑपरेटर पर निर्भर करता है, लेकिन यह वैसे भी बहुत अच्छा है, भले ही यह पठनीय न हो। डैनियल सोबराल ने छलनी ऑफ एराटोस्थनीज एल्गोरिथ्म के कार्यान्वयन को लिखा, जिसका उपयोग यह निर्धारित करने के लिए किया जाता है कि क्या कोई संख्या प्रधान है ।
```
 (n: Int) => (2 to n) |> (r => r.foldLeft(r.toSet)((ps, x) => if (ps(x)) ps -- (x * x to n by x) else ps)) 
```
संचालक की परिभाषा की आवश्यकता होती है, जिसका सिंटैक्स F # से उधार लिया जाता है। उदाहरण के लिए, स्टीव गिलहम के ब्लॉग को देखें ।

मूल पोस्ट: "अपने दोस्तों को प्रभावित करने के लिए 10 स्काला वन लाइनर्स"
पोस्ट करनेवाले: Marcus Kazmierczak

CoffeScript

आपने हाल ही में HN पर पोस्ट किए गए मार्कस काज़मीरेकक ब्लॉग पर पोस्ट " 10 सिंगल लाइन ऑन स्काला टू इम्प्रेस योर फ्रेंड्स " पढ़ा होगा। हालाँकि मुझे स्काला (या जावा) का पता नहीं है, लेकिन यह बहुत अच्छा लग रहा है, इसलिए मैंने अपने दोस्तों को भी प्रभावित करने का फैसला किया - कुछ लोग जावा से स्काला में स्विच कर रहे हैं, हम जावास्क्रिप्ट से कॉफीस्क्रिप्ट जाते हैं। हम सभी उदाहरणों को चलाने के लिए एक वातावरण के रूप में नोड.जेएस का उपयोग करेंगे।

एक सूची में सभी आइटम दोहरीकरण

मार्कस map कार्य के साथ दिखाना शुरू करता है। हम एक ही range और एक अनाम फ़ंक्शन का उपयोग कर सकते हैं:
```
 [1..10].map (i) -> i*2 
```
लेकिन आप अधिक अभिव्यंजक रूप में लिख सकते हैं
```
 i * 2 for i in [1..10] 
```
संख्या सूची योग

जावास्क्रिप्ट (और इसके विस्तार के रूप में कॉफीस्क्रिप्ट) में भी अंतर्निहित map और फ़ंक्शन reduce करते हैं:
```
 [1..1000].reduce (t, s) -> t + s 
```
(कम करें == कम करें, कम करें, राइट भी उपलब्ध है)
विकल्प के लिए जाँच करें

बहुत आसान है, क्योंकि हमारे पास some तरीका है। यह सही है अगर सरणी में कोई भी तत्व किसी फ़ंक्शन से संतुष्ट है:
```
 wordList = ["coffeescript", "eko", "play framework", "and stuff", "falsy"] tweet = "This is an example tweet talking about javascript and stuff." wordList.some (word) -> ~tweet.indexOf word 
```
लेकिन इससे संबंधित शब्द वापस आ जाएंगे:
```
 wordList.filter (word) -> ~tweet.indexOf word 
```
" ~ " CoffeeScript में एक विशेष ऑपरेटर नहीं है, लेकिन सिर्फ एक गंदा चाल है। यह बिटवाइज़ NOT ऑपरेटर है, जो अपने ऑपरेंड के बिट्स को निष्क्रिय करता है। व्यवहार में, यह -x-1 बराबर है। यहां यह इस आधार पर काम करता है कि हम -1 से अधिक के इंडेक्स के लिए चेक करना चाहते हैं, और -(-1)-1 == 0 गलत का मूल्यांकन करता है।
फ़ाइल पढ़ें

क्लाइंट-साइड जावास्क्रिप्ट उपयोगकर्ता पहले से ही इस विचार से परिचित हैं:
```
 fs.readFile 'data.txt', (err, data) -> fileText = data 
```
आप तुल्यकालिक संस्करण का भी उपयोग कर सकते हैं:
```
 fileText = fs.readFileSync('data.txt').toString() 
```
लेकिन नोड.जेएस में, यह केवल एप्लिकेशन लॉन्च प्रक्रिया के लिए स्वीकार्य है। आपको अपने कोड में एसिंक्रोनस संस्करण का उपयोग करना होगा।
जन्मदिन मुबारक हो

सबसे पहले, आप एक से एक स्केला संस्करण प्रदर्शित कर सकते हैं:
```
 [1..4].map (i) -> console.log "Happy Birthday " + (if i is 3 then "dear Robert" else "to You") 
```
लेकिन यह संभव और बेहतर है। यह लगभग छद्म कोड की तरह पढ़ता है:
```
 console.log "Happy Birthday #{if i is 3 then "dear Robert" else "to You"}" for i in [1..4] 
```
नंबर सूची फ़िल्टरिंग

संख्याओं की सूची को छानना काफी हद तक समान है:
```
 passed = [] failed = [] (if score > 60 then passed else failed).push score for score in [49, 58, 76, 82, 88, 90] 
```
(आप अभी भी फ़िल्टर का उपयोग कर सकते हैं, लेकिन तब आपको एक भी लाइन नहीं मिलेगी)
एक वेब सेवा से XML को पुनः प्राप्त करना और पार्स करना

XML क्या? मैंने इस बारे में नहीं सुना है। इसके बदले JSON प्राप्त करें:
```
 request.get { uri:'path/to/api.json', json: true }, (err, r, body) -> results = body 
```
सूची में न्यूनतम (या अधिकतम) खोजें

apply फ़ंक्शन यहां सुविधाजनक है। यह आपको तर्कों की एक सूची के रूप में एक सरणी पास करके एक फ़ंक्शन को कॉल करने की अनुमति देता है: Math.max और Math.min तर्क की एक चर संख्या प्राप्त करते हैं, अर्थात। Math.max 30, 10, 20 रिटर्न 30 । चलो एक सरणी के साथ काम करने की कोशिश करते हैं:
```
 Math.max.apply @, [14, 35, -7, 46, 98] # 98 Math.min.apply @, [14, 35, -7, 46, 98] # -7 
```
समानांतर प्रसंस्करण

यह अभी तक मौजूद नहीं है आप बच्चे की प्रक्रियाओं के साथ बना सकते हैं और बातचीत कर सकते हैं, या WebWorkers API का उपयोग कर सकते हैं । मिस।
एराटोस्थनीज की छलनी

इसे एक पंक्ति में लाने में विफल। कोई विचार?
```
 sieve = (num) -> numbers = [2..num] while ((pos = numbers[0]) * pos) <= num delete numbers[i] for n, i in numbers by pos numbers.shift() numbers.indexOf(num) > -1 
```
अपडेट (5 जून): @dionyziz ने मुझे एक कॉम्पैक्ट संस्करण भेजा:
```
 primes = [] primes.push i for i in [2..100] when not (j for j in primes when i % j == 0).length 
```
जिसे हम मूल के समान वास्तव में सिंगल-लाइन संस्करण के लिए उपयोग कर सकते हैं:
```
 (n) -> (p.push i for i in [2..n] when not (j for j in (p or p=[]) when i%j == 0)[0]) and n in p 
```
या कुछ और अधिक कुशलता से:
```
 (n) -> (p.push i for i in [2..n] when !(p or p=[]).some((j) -> i%j is 0)) and n in p 
```
बोनस

आपने कभी देखा है fizzbuzz का सबसे अधिक पढ़ा गया संस्करण:
```
 "#{if i%3 is 0 then 'fizz' else ''}#{if i%5 is 0 then 'buzz' else ''}" or i for i in [1..100] 
```
यहां तक कि सरल, लेकिन मुश्किल, व्यंग्य से थोड़ा संकेत के साथ:
```
 ['fizz' unless i%3] + ['buzz' unless i%5] or i for i in [1..100] 
```

मूल पोस्ट: "अपने दोस्तों को प्रभावित करने के लिए 10 कॉफीस्क्रिप्ट एक लाइनर
"
द्वारा पोस्ट किया गया: रिकार्डो टोमासी

एफ #

अपने दोस्तों को प्रभावित करने के लिए स्काला पर 10 " 10 सिंगल-लाइनर्स की भावना में" यहां एफ # पर कुछ एकल-लाइनर हैं:

एक सूची में सभी नंबरों का दोहरीकरण

यह सरल है, एफ # में एक map भी है:
```
 [1 .. 4] |> Seq.map (fun x -> x * x);; 
```
संख्या सूची योग

यह उतना ही सरल है, जितना F # में sum :
```
 [1 .. 4] |> Seq.sum;; 
```
विकल्प के लिए जाँच करें

और यह सरल है, क्योंकि हमारे पास find :
```
 ["f#"; "scala"] |> Seq.find(fun w -> "this tweet contains f#".Contains(w));; 
```
फ़ाइल पढ़ना (उबाऊ!)

F # में सभी लाइब्रेरी हैं। नेट। अनुक्रम के रूप में फ़ाइल की सभी पंक्तियों को पढ़ना बहुत आसान है:
```
 File.ReadLines(@"file.txt") |> Seq.map(fun l -> l.Length) |> Seq.sum;; 
```

जन्मदिन मुबारक हो

इसके अलावा उबाऊ ... इस तरह:

 [1 .. 4] |> Seq.map (fun i -> "Happy Birthday " + (if i = 3 then "dear NAME" else "to you")) |> Seq.iter Console.WriteLine;;

फ़िल्टरिंग (वास्तव में विभाजन) की सूची

अंतर्निहित partition फ़ंक्शन का उपयोग करके, हम आसानी से सूची को विभाजित कर सकते हैं:
```
 [49; 58; 76; 82; 88; 90] |> List.partition (fun i -> i > 60);; 
```
XML प्राप्त करना और पार्स करना

फिर से, .NET लाइब्रेरी काम में आती हैं। दुर्भाग्य से, यह एफ # में एक-लाइनर नहीं है। लेकिन डॉन सिमे दिखाता है कि यह कैसे और तुल्यकालिक रूप से करना है ।
सूची में अधिकतम और न्यूनतम खोजें

ऐसा करने के लिए, F # नेटवर्क में निर्मित कार्य:
```
 [49; 58; 76; 82; 88; 90] |> Seq.min;; [49; 58; 76; 82; 88; 90] |> Seq.max;; 
```
समानांतर प्रसंस्करण

यह जे रोशा का एक उदाहरण है। मान लीजिए कि हमारे पास isprime विधि है, और हम 1 से 50,000 तक उनके अंतिम अंक द्वारा समूहीकृत primes की संख्या प्राप्त करना चाहते हैं। PSeq समानांतर में अनुक्रमों को संसाधित करता है:
```
 [|1 .. 50000|] |> PSeq.filter isprime |> PSeq.groupBy (fun i -> i % 10) |> PSeq.map (fun (k, vs) -> (k, Seq.length vs)) |> Seq.toArray |> Seq.sort |> Seq.toList;; 
```

मूल पोस्ट: "F # वन लाइनर्स अपने दोस्तों को प्रभावित करने के लिए"
द्वारा पोस्ट किया गया: विल फिजराल्ड़

गहरे लाल रंग का

स्काला की स्पष्टता दिखाने के लिए 10 सिंगल-लाइन उदाहरणों की एक सूची प्रकाशित की गई है। कॉफीस्क्रिप्ट संस्करण जल्दी से दिखाई दिया, इसलिए मुझे लगा कि मैंने अकेले रूबी संस्करण प्रकाशित किया है। मुझे स्कैला की तुलना में रूबी सिंटैक्स थोड़ा साफ लगता है, लेकिन संक्षेप में (कम से कम जहां तक ये उदाहरण दिखाते हैं) अपेक्षाकृत समान है।

एक सूची में सभी नंबरों का दोहरीकरण
```
 (1..10).map { |n| n * 2 } 
```
संख्या सूची योग
```
 (1..1000).inject { |sum, n| sum + n } 
```
या (अंतर्निहित) Symbol#to_proc , जो रूबी संस्करण 1.8.7 के बाद से उपलब्ध है:
```
 (1..1000).inject(&:+) 
```
या इस तरह भी:
```
 (1..1000).inject(:+) 
```

विकल्प के लिए जाँच करें

 words = ["scala", "akka", "play framework", "sbt", "typesafe"] tweet = "This is an example tweet talking about scala and sbt." words.any? { |word| tweet.include?(word) }

फाइलें पढ़ना
```
 file_text = File.read("data.txt") file_lines = File.readlines("data.txt") 
```
उत्तरार्द्ध में सरणी के प्रत्येक तत्व के अंत में "\ n" शामिल है, जिसे जोड़कर अलग किया जा सकता है .map { |str| str.chop } .map { |str| str.chop } या वैकल्पिक संस्करण का उपयोग कर:
```
 File.read("data.txt").split(/\n/) 
```

जन्मदिन मुबारक हो

 4.times { |n| puts "Happy Birthday #{n==2 ? "dear Tony" : "to You"}" }

नंबर सूची फ़िल्टरिंग

 [49, 58, 76, 82, 88, 90].partition { |n| n > 60 }

एक वेब सेवा से XML को पुनः प्राप्त करना और पार्स करना
```
 require 'open-uri' require 'hpricot' results = Hpricot(open("http://search.twitter.com/search.atom?&q=scala")) 
```
इस उदाहरण के लिए ओपन-यूरी और श्रीकोर्ट या समकक्ष पुस्तकालयों (आप अंतर्निहित उपयोग कर सकते हैं) की आवश्यकता होती है। यह बहुत अधिक कोड नहीं है, लेकिन स्काला स्पष्ट रूप से यहां जीतती है।
सूची में न्यूनतम (या अधिकतम) खोजें
```
 [14, 35, -7, 46, 98].min [14, 35, -7, 46, 98].max 
```
समानांतर प्रसंस्करण
```
 require 'parallel' Parallel.map(lots_of_data) do |chunk| heavy_computation(chunk) end 
```
स्काला के विपरीत, मल्टी-कोर समर्थन अंतर्निहित नहीं है। इस उदाहरण के लिए समानांतर या समान रत्न की आवश्यकता होती है।
एराटोस्थनीज की छलनी

स्काला पर वन-लाइनर बहुत ही अपमानजनक है, लेकिन पूरी तरह से अपठनीय है। रूबी में एक से अधिक लाइन की आवश्यकता के लिए एक सरल कार्यान्वयन:
```
 index = 0 while primes[index]**2 <= primes.last prime = primes[index] primes = primes.select { |x| x == prime || x % prime != 0 } index += 1 end p primes 
```
यह उदाहरण StackOverflow के साथ है।

मूल पोस्ट: "अपने दोस्तों को प्रभावित करने के लिए 10 रूबी वन लाइनर्स"
द्वारा पोस्ट किया गया: एंटोनियो Cangiano

Clojure

मैंने आज देखा कि " 10 सिंगल-लाइन ऑन स्काला ऑन इम्प्रेस योर फ्रेंड्स " नामक एक दिलचस्प पोस्ट , और फिर किसी दूसरे पोस्ट पर पोस्ट किया गया जिसका शीर्षक था " 10 सिंगल-लाइन ऑन कॉफ़ीस्क्रिप्ट ऑन इम्प्रेस योर फ्रेंड्स "। ये दो पोस्ट छोटे कार्य दिखाते हैं (उनमें से अधिकांश में आधुनिक प्रोग्रामिंग भाषाओं में तुच्छ समाधान हैं), जिनमें से प्रत्येक को लगभग 1 पंक्ति के कोड में निष्पादित किया जाता है।

मुझे लगता है कि मेरी पसंदीदा प्रोग्रामिंग भाषा - क्लोजर के लिए भी ऐसा करना उचित होगा।

एक सूची में सभी नंबरों का दोहरीकरण
```
 (map #(* % 2) (range 1 11)) 
```
संख्या सूची योग
```
 (reduce + (range 1 1001)) 
```
विकल्प के लिए जाँच करें

मुझे यहां नियमित अभिव्यक्तियों का उपयोग करना उचित लगता है:
```
 (def tweet "This is an example tweet talking about clojure and emacs.") (def regex (re-pattern (apply str (interpose "|" ["clojure" "logic" "compojure" "emacs" "macros"])))) (re-seq regex tweet) ;   ,   true/false 
```
जैसा कि टिप्पणीकारों ने सुझाव दिया है, क्लोज़र सेट का उपयोग करके नियमित अभिव्यक्ति का उपयोग किए बिना इस समस्या को हल किया जा सकता है।
```
 (def tweet "This is an example tweet talking about clojure and emacs.") (def is-word? (set ["clojure" "logic" "compojure" "emacs" "macros"])) (not (nil? (some is-word? (.split tweet " ")))) ;  true/false 
```
फ़ाइल पढ़ें
```
 (def file-text (slurp "data.txt")) ;    (def file-lines (clojure.contrib.io/read-lines "data.txt")) ;    
```
Clojure Contrib को Clojure की भविष्य की रिलीज़ में clojure.contrib.io/read-lines किया जाएगा, clojure.contrib.io/read-lines को (line-seq (clojure.java.io/reader (clojure.java.io/file “data.txt”))) रूप में लिखा जा सकता है। (line-seq (clojure.java.io/reader (clojure.java.io/file “data.txt”))) क्लोजर में 1.3 और बाद में। इसे इंगित करने के लिए हारून का धन्यवाद।

जन्मदिन मुबारक हो

 (doseq [l (map #(str "Happy Birthday " (if (= % 2) "dear Rich" "to You")) (range 4))] (println l))

वैकल्पिक संस्करण:

 (dotimes [n 4] (println "Happy Birthday " (if (= n 2) "dear Rich" "to You")))

नंबर सूची फ़िल्टरिंग

 (partition-by #(> % 60) [49 58 76 82 88 90])

एक वेब सेवा से XML को पुनः प्राप्त करना और पार्स करना
```
 (clojure.xml/parse "http://search.twitter.com/search.atom?&q=clojure") 
```

सूची में न्यूनतम और अधिकतम खोजें

 (reduce max [14 35 -7 46 98]) (reduce min [14 35 -7 46 98]) ;;     ((juxt #(reduce max %) #(reduce min %)) [14 35 -7 46 98]) ;  [98 -7]

समानांतर प्रसंस्करण

 ;; ,  process-line -     ,    (pmap process-line lines) ;    "p"  map

एराटोस्थनीज की छलनी

मैं "एराटोस्थनीज की छलनी" के लिए एक लाइन समाधान के लिए (प्रदर्शन और सुंदरता के मामले में) पर्याप्त नहीं हूं। मैं इस समस्या को हल करने के लिए "सभी को चलनी की खातिर प्यार करता हूं " शीर्षक से इस विषय पर क्रिस्टोफ ग्रांड के काम की जांच करने की सलाह देता हूं।

FizzBuzz समाधान

 (map #(cond (zero? (mod % 15)) "FizzBuzz" (zero? (mod % 3)) "Fizz" (zero? (mod % 5)) "Buzz" :else %) (range 1 101))

मूल पोस्ट: "अपने दोस्तों को प्रभावित करने के लिए 10 क्लोजर वन लाइनर्स"
पोस्ट करनेवाले: बैशम्पायन

अजगर

Scala / Ruby / Clojure / CoffeeScript में 10 अद्भुत वन-लाइनर्स के बाद, मैंने सोचा कि पायथन में भी ऐसा करना दिलचस्प होगा।

बिना ज्यादा शोर किए ... चलो चलें। ध्यान दें कि चर घोषणाएं और आयात आवश्यकतानुसार अलग-अलग लाइनों पर हैं। इसके अलावा, प्रत्येक पंक्ति को लिखा जाता है ताकि परिणाम त्वरित सत्यापन के लिए मानक आउटपुट पर आ जाए।

यह पोस्ट शायद सबसे तेज में से एक है जो मैंने लिखा था।

एक सूची में सभी नंबरों का दोहरीकरण
```
 print map(lambda x: x * 2, range(1,11)) 
```
संख्या सूची योग
```
 print sum(range(1,1001)) 
```

विकल्प के लिए जाँच करें

 wordlist = ["scala", "akka", "play framework", "sbt", "typesafe"] tweet = "This is an example tweet talking about scala and sbt." print map(lambda x: x in tweet.split(),wordlist)

फ़ाइल पढ़ें

 print open("ten_one_liners.py").readlines()

जन्मदिन मुबारक हो

 print map(lambda x: "Happy Birthday to " + ("you" if x != 2 else "dear Name"),range(4))

नंबर सूची फ़िल्टरिंग

 print reduce(lambda(a,b),c: (a+[c],b) if c > 60 else (a,b + [c]), [49, 58, 76, 82, 88, 90],([],[]))

एक वेब सेवा से XML को पुनः प्राप्त करना और पार्स करना

 from xml.dom.minidom import parse, parseString import urllib2 # note - i convert it back into xml to pretty print it print parse(urllib2.urlopen("http://search.twitter.com/search.atom?&q=python")).toprettyxml(encoding="utf-8")

सूची में न्यूनतम और अधिकतम खोजें
```
 print min([14, 35, -7, 46, 98]) print max([14, 35, -7, 46, 98]) 
```

समानांतर प्रसंस्करण

 import multiprocessing import math print list(multiprocessing.Pool(processes=4).map(math.exp,range(1,11)))

एराटोस्थनीज की छलनी

 n = 50 #      2  50 print sorted(set(range(2,n+1)).difference(set((p * f) for p in range(2,int(n**0.5) + 2) for f in range(2,(n/p)+1))))

मूल पोस्ट: "अपने दोस्तों को प्रभावित करने के लिए 10 अजगर एक लाइनर"
पोस्ट करनेवाले: धनंजय नेने

C #

एक सूची में सभी नंबरों का दोहरीकरण

 Print("Multiple each item in a list by 2", Enumerable.Range(1, 10).Select(i => i * 2));

संख्या सूची योग

 Print("Sum a list of numbers", Enumerable.Range(1, 1000).Sum());

विकल्प के लिए जाँच करें

 var wordlist = new[] { "C#", "and stuff" }; var tweet = "This is an example tweet talking about C# and stuff"; Print("Verify if a word exists in string", wordlist.Any(word => tweet.IndexOf(word) > -1)); Print("Show matched words in string", wordlist.Where(word => tweet.IndexOf(word) > -1));

फ़ाइल पढ़ें

 Print("Read in a File", File.ReadAllBytes("oneliners.exe").Length);

जन्मदिन मुबारक हो

 Print("Happy Birthday", Enumerable.Range(1, 4).Select((i) => string.Format("Happy Birthday {0} ", i == 3 ? "dear NAME" : "to You")));

नंबर सूची फ़िल्टरिंग

 var passed = new List<int>(); var failed = new List<int>(); (from bucket in new[] { passed, failed } from i in new[] { 49, 58, 76, 82, 88, 90 } select new { bucket, i }).ToList().ForEach((tuple) => tuple.bucket.AddRange(Enumerable.Repeat(tuple, 1).Where((tup) => (tup.bucket == passed && tup.i > 60) || (tup.bucket == failed && tup.i <= 60)).Select((tup) => tup.i))); Print("Filter list of numbers >60", (IEnumerable<int>)passed); Print("Filter list of numbers <=60", (IEnumerable<int>)failed);

एक वेब सेवा से XML को पुनः प्राप्त करना और पार्स करना
```
 Print("Fetch and Parse an XML web service", XDocument.Load("http://search.twitter.com/search.atom?&q=scala")); 
```

सूची में न्यूनतम और अधिकतम खोजें

 Print("Find minimum in a list", Enumerable.Min(new[] { 14, 35, -7, 46, 98 })); Print("Find maximum in a list", Enumerable.Max(new[] { 14, 35, -7, 46, 98 }));

समानांतर प्रसंस्करण

 Print("Parallel Processing", Enumerable.Range(1, 10).AsParallel().Select((i)=>i*2).AsEnumerable());

FizzBuzz

 Print("Fizzbuzz", Enumerable.Range(1, 15).Select((i)=>i + (i%3==0?"fizz":"") + (i%5==0?"buzz":"")));

मूल पोस्ट: "10 सी # एक लाइनर अपने दोस्तों को प्रभावित करने के लिए"
द्वारा पोस्ट किया गया: रिचर्ड बिर्कबी

हास्केल

मेमे ( स्केला , रूबी , क्लोजर , पाइथन , एफ # , कॉफिसस्क्रिप्ट , सी # ) के बाद।

एक सूची में सभी नंबरों का दोहरीकरण
```
 map (*2) [1..10] 
```

संख्या सूची योग

 foldl (+) 0 [1..1000] --   sum [1..1000]

विकल्प के लिए जाँच करें

 import Data.List let wordlist = ["monad", "monoid", "Galois", "ghc", "SPJ"] let tweet = "This is an example tweet talking about SPJ interviewing with Galois" or $ map (flip isInfixOf tweet) wordlist --   any (flip isInfixOf tweet) wordlist

फ़ाइल पढ़ें

 fileText <- readFile "data.txt" let fileLines = lines fileText --   let fileLines = fmap lines $ readFile "data.txt"

जन्मदिन मुबारक हो

 mapM_ putStrLn ["Happy Birthday " ++ (if x == 3 then "dear NAME" else "to You") | x <- [1..4]]

नंबर सूची फ़िल्टरिंग

 let (passed, failed) = partition (>60) [49, 58, 76, 82, 88, 90]

एक वेब सेवा से XML को पुनः प्राप्त करना और पार्स करना

इस उदाहरण के लिए, curl और xml पैकेजों की आवश्यकता है। उनकी स्थापना के लिए RWH देखें।
```
 import Network.Curl import Text.XML.Light import Control.Monad let results = liftM parseXMLDoc $ liftM snd (curlGetString "http://search.twitter.com/search.atom?&q=haskell" []) --   Control.Applicative let results = parseXMLDoc . snd <$> curlGetString "http://search.twitter.com/search.atom?&q=haskell" [] 
```

सूची में न्यूनतम और अधिकतम खोजें

 foldl1 min [14, 35, -7, 46, 98] foldl1 max [14, 35, -7, 46, 98] --   minimum [14, 35, -7, 46, 98] maximum [14, 35, -7, 46, 98]

समानांतर प्रसंस्करण

इस उदाहरण के लिए, एक parallel पैकेज की आवश्यकता है।
```
 import Control.Parallel import Control.Parallel.Strategies parMap rseq (*2) [1..100] 
```

प्राइम नंबर जनरेशन

 let pgen (p:xs) = p : pgen [x|x <- xs, x `mod` p > 0] take 40 (pgen [2..])

मूल पोस्ट: "अपने दोस्तों को प्रभावित करने के लिए 10 हास्केल वन लाइनर्स"
द्वारा पोस्ट किया गया: माइकल फोगस

और अब आपके विकल्प, ~~और होलीवर शुरू हो सकते हैं!~~ )

10 "वन-लाइनर्स" जो आपके दोस्तों को प्रभावित करेंगे

स्काला

हम सूची में प्रत्येक आइटम को दोगुना करते हैं।

सूची में सभी संख्याओं को संक्षेप में लिखें।

सबस्टेशन की घटना की जाँच करना

फ़ाइल से पढ़ें

जन्मदिन मुबारक हो

नंबर सूची फ़िल्टरिंग

एक वेब सेवा से XML को पुनः प्राप्त करना और पार्स करना

सूची में न्यूनतम (या अधिकतम) खोजें

समानांतर प्रसंस्करण

एराटोस्थनीज की छलनी

CoffeScript

एक सूची में सभी आइटम दोहरीकरण

संख्या सूची योग

विकल्प के लिए जाँच करें

फ़ाइल पढ़ें

जन्मदिन मुबारक हो

नंबर सूची फ़िल्टरिंग

एक वेब सेवा से XML को पुनः प्राप्त करना और पार्स करना

सूची में न्यूनतम (या अधिकतम) खोजें

समानांतर प्रसंस्करण

एराटोस्थनीज की छलनी

बोनस

एफ #

एक सूची में सभी नंबरों का दोहरीकरण

संख्या सूची योग

विकल्प के लिए जाँच करें

फ़ाइल पढ़ना (उबाऊ!)

जन्मदिन मुबारक हो

फ़िल्टरिंग (वास्तव में विभाजन) की सूची

XML प्राप्त करना और पार्स करना

सूची में अधिकतम और न्यूनतम खोजें

समानांतर प्रसंस्करण

गहरे लाल रंग का

एक सूची में सभी नंबरों का दोहरीकरण

संख्या सूची योग

विकल्प के लिए जाँच करें

फाइलें पढ़ना

जन्मदिन मुबारक हो

नंबर सूची फ़िल्टरिंग

एक वेब सेवा से XML को पुनः प्राप्त करना और पार्स करना

सूची में न्यूनतम (या अधिकतम) खोजें

समानांतर प्रसंस्करण

एराटोस्थनीज की छलनी

Clojure

एक सूची में सभी नंबरों का दोहरीकरण

संख्या सूची योग

विकल्प के लिए जाँच करें

फ़ाइल पढ़ें

जन्मदिन मुबारक हो

नंबर सूची फ़िल्टरिंग

एक वेब सेवा से XML को पुनः प्राप्त करना और पार्स करना

सूची में न्यूनतम और अधिकतम खोजें

समानांतर प्रसंस्करण

एराटोस्थनीज की छलनी

FizzBuzz समाधान

अजगर

एक सूची में सभी नंबरों का दोहरीकरण

संख्या सूची योग

विकल्प के लिए जाँच करें

फ़ाइल पढ़ें

जन्मदिन मुबारक हो

नंबर सूची फ़िल्टरिंग

एक वेब सेवा से XML को पुनः प्राप्त करना और पार्स करना

सूची में न्यूनतम और अधिकतम खोजें

समानांतर प्रसंस्करण

एराटोस्थनीज की छलनी

C #

एक सूची में सभी नंबरों का दोहरीकरण

संख्या सूची योग

विकल्प के लिए जाँच करें

फ़ाइल पढ़ें

जन्मदिन मुबारक हो

नंबर सूची फ़िल्टरिंग

एक वेब सेवा से XML को पुनः प्राप्त करना और पार्स करना

सूची में न्यूनतम और अधिकतम खोजें

समानांतर प्रसंस्करण

FizzBuzz

हास्केल