स्केला नीचे की तरफ या लूप के लिए कम?


115

स्काला में, आप अक्सर forबढ़ते क्रम में एक लूप करने के लिए एक पुनरावृत्ति का उपयोग करते हैं:

for(i <- 1 to 10){ code }

आप इसे कैसे करेंगे ताकि यह 10 से 1 हो जाए? मुझे लगता है 10 to 1कि एक खाली पुनरावृत्ति देता है (सामान्य श्रेणी के गणित की तरह)?

मैंने एक स्कैला लिपि बनाई, जो इसे पुनरावृत्त पर रिवर्स कॉल करके हल करती है, लेकिन यह मेरी राय में अच्छा नहीं है, क्या निम्नलिखित तरीका है?

def nBeers(n:Int) = n match {

    case 0 => ("No more bottles of beer on the wall, no more bottles of beer." +
               "\nGo to the store and buy some more, " +
               "99 bottles of beer on the wall.\n")

    case _ => (n + " bottles of beer on the wall, " + n +
               " bottles of beer.\n" +
               "Take one down and pass it around, " +
              (if((n-1)==0)
                   "no more"
               else
                   (n-1)) +
                   " bottles of beer on the wall.\n")
}

for(b <- (0 to 99).reverse)
    println(nBeers(b))

जवाबों:


229
scala> 10 to 1 by -1
res1: scala.collection.immutable.Range = Range(10, 9, 8, 7, 6, 5, 4, 3, 2, 1)

2
@ फेलिक्स: आपका स्वागत है। मुझे यह भी ध्यान देना चाहिए कि ऐसा भी है untilकि आप toदाएं हाथ के अंत-बिंदु को सीमा से बाहर करने के स्थान पर उपयोग कर सकते हैं । बाएं हाथ का समापन बिंदु हमेशा शामिल होता है।
रान्डेल शुल्ज़

मुझे पहले से ही इसके बारे में पता था, जब तक कि इंटेगर पर एक फ़ंक्शन भी है, हालांकि, "द्वारा" रेंज पर एक फ़ंक्शन होना चाहिए / पुनरावृत्त जो "से" और "जब तक" कार्यों से वापस आ जाता है। वैसे भी धन्यवाद :)
फेलिक्स

5
रान्डेल का उत्तर सबसे अच्छा है, लेकिन मुझे लगता है Range.inclusive(10, 1, -1)कि उल्लेख योग्य है।
जॉन सुलिवन

37

@ रैंडल से उत्तर सोने के रूप में अच्छा है, लेकिन पूरा होने के लिए मैं कुछ रूपों को जोड़ना चाहता था:

scala> for (i <- (1 to 10).reverse) {code} //Will count in reverse.

scala> for (i <- 10 to(1,-1)) {code} //Same as with "by", just uglier.

9
पहले एक के लिए +1, लेकिन दूसरा एक बुराई है - से कम पठनीय byऔर IMO किसी भी परिस्थिति में इस्तेमाल नहीं किया जाना चाहिए
om-nom-nom

4
दूसरा एक दुष्ट है लेकिन जो उपलब्ध है उस पर अंतर्ज्ञान बनाता है
ज़हीर

10

स्काला लूप में नीचे की ओर काम करने के कई तरीके प्रदान करता है।

पहला समाधान: "से" और "द्वारा"

//It will print 10 to 0. Here by -1 means it will decremented by -1.     
for(i <- 10 to 0 by -1){
    println(i)
}

दूसरा समाधान: "टू" और "रिवर्स" के साथ

for(i <- (0 to 10).reverse){
    println(i)
}

तीसरा समाधान: "से" केवल

//Here (0,-1) means the loop will execute till value 0 and decremented by -1.
for(i <- 10 to (0,-1)){
    println(i)
}

6

पास्कल में क्रमादेशित होने के बाद, मुझे यह परिभाषा अच्छी लगती है:

implicit class RichInt(val value: Int) extends AnyVal {
  def downto (n: Int) = value to n by -1
  def downtil (n: Int) = value until n by -1
}

इस तरह से इस्तेमाल किया:

for (i <- 10 downto 0) println(i)

उत्तर के लिए आपका धन्यवाद। मुझे इस समाधान का उपयोग करने में परेशानी हो रही है। यहाँ मेरा स्टैकट्रेस है:Error:(57, 17) value class may not be a member of another class implicit class RichInt(val value: Int) extends AnyVal { ^
robert

जैसा कि त्रुटि संदेश (स्टैक ट्रेस नहीं) बताता है, आप दूसरे वर्ग के अंदर मूल्य वर्ग को परिभाषित नहीं कर सकते। या तो इसके बाहर इसे परिभाषित करें, एक वस्तु में ओइक, या extends AnyValभाग को हटा दें (जो केवल कुछ ओवरहेड को हटाने का कार्य करता है)।
LP_

1

आप श्रेणी वर्ग का उपयोग कर सकते हैं:

val r1 = new Range(10, 0, -1)
for {
  i <- r1
} println(i)


0
for (i <- 10 to (0,-1))

लूप मान == 0 तक निष्पादित करेगा, प्रत्येक बार -1 से घटाया जाएगा।

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