স্কালায় আমি কীভাবে লুপ ভাঙব?

Question

আমি কীভাবে একটি লুপ ছড়িয়ে দেব?

var largest=0
for(i<-999 to 1 by -1) {
    for (j<-i to 1 by -1) {
        val product=i*j
        if (largest>product)
            // I want to break out here
        else
           if(product.toString.equals(product.toString.reverse))
              largest=largest max product
    }
}

আমি কীভাবে লুপগুলির জন্য লেজ পুনরাবৃত্তিতে পরিণত করতে পারি?

FOSDEM 2009 এ স্কালা টক থেকে http://www.slideshare.net/Odersky/fosdem-2009-1013261 22 তম পৃষ্ঠায়:

ভাঙ্গা এবং চালিয়ে যাও স্কালায় তাদের নেই। কেন? এগুলি কিছুটা অপরিহার্য; আরও অনেক ছোট ফাংশন ব্যবহার করুন ক্লোজারগুলির সাথে কীভাবে ইন্টারঅ্যাক্ট করবেন তা জারি করুন। তাদের দরকার নেই!

এর ব্যাখ্যা কী?

Comments

আপনার তুলনাটির জন্য দ্বিতীয় সমান চিহ্নের প্রয়োজন: যদি (product.toString == product.toString.reverse) বা হতে পারে একটি সমান-পদ্ধতি-কল।

— ব্যবহারকারী অজানা

হ্যাঁ, আমি যখন এটি টাইপ করছিলাম তখন

— সেটিকে

আমি জানি আমি একটি পুরানো প্রশ্ন পুনরুত্থিত করছি তবে আমি এই কোডটির উদ্দেশ্য কী তা জানতে আগ্রহী? আমি প্রথমে যদিও আপনি প্রদত্ত সংমিশ্রণ iএবং এর সাথে সবচেয়ে বড় "প্যালিনড্রোম" পণ্য সন্ধান করার চেষ্টা করছেন j। যদি এই কোডটি লুপটি না ভেঙে সমাপ্তির দিকে চলে যায়, ফলাফলটি হয় 906609তবে তাড়াতাড়ি লুপটি ভেঙে ফেলা হয় ফলে ফলাফলটি 90909বদলানোর সাথে সাথে লুপটি ভেঙে দেওয়া কোডটি "আরও দক্ষ" তৈরি করে না।

— রায়ান এইচ।

Answer 1

লুপগুলি ভেঙে ফেলার জন্য আপনার কাছে তিনটি (বা তাই) বিকল্প রয়েছে।

ধরুন আপনি মোট সংখ্যা 1000 এর চেয়ে বেশি না হওয়া পর্যন্ত সংখ্যার যোগফল চান You আপনি চেষ্টা করুন

var sum = 0
for (i <- 0 to 1000) sum += i

আপনি (যোগফল> 1000) থামাতে চান ব্যতীত।

কি করো? বিভিন্ন বিকল্প আছে।

(1 ক) এমন কিছু কনস্ট্রাক্ট ব্যবহার করুন যাতে শর্তযুক্ত যেটি আপনি পরীক্ষা করে includes

var sum = 0
(0 to 1000).iterator.takeWhile(_ => sum < 1000).foreach(i => sum+=i)

(সতর্কতা - এটি কীভাবে পরীক্ষা নিরীক্ষণ এবং ভবিষ্যদ্বাণী মূল্যায়নের সময় আন্তঃবাহিত হয় তার বিশদগুলির উপর নির্ভর করে এবং সম্ভবত অনুশীলনে ব্যবহার করা উচিত নয়!)।

(1 খ) স্কালায় একটি নতুন পদ্ধতি লেখার পক্ষে কতটা সহজ, তার সুবিধা নিয়ে লুপের পরিবর্তে লেজের পুনরাবৃত্তি ব্যবহার করুন:

var sum = 0
def addTo(i: Int, max: Int) {
  sum += i; if (sum < max) addTo(i+1,max)
}
addTo(0,1000)

(1 সি) কিছুক্ষণ লুপ ব্যবহার করে ফিরে যান

var sum = 0
var i = 0
while (i <= 1000 && sum <= 1000) { sum += 1; i += 1 }

(2) একটি ব্যতিক্রম নিক্ষেপ।

object AllDone extends Exception { }
var sum = 0
try {
  for (i <- 0 to 1000) { sum += i; if (sum>=1000) throw AllDone }
} catch {
  case AllDone =>
}

(২ এ) স্কেলে ২.৮++ তে এটি scala.util.control.Breaksসিনট্যাক্স ব্যবহার করে ইতিমধ্যে প্রাক প্যাকেজড যা দেখতে অনেকটা সি / জাভা থেকে আপনার পরিচিত পুরানো বিরতির মতো দেখাচ্ছে:

import scala.util.control.Breaks._
var sum = 0
breakable { for (i <- 0 to 1000) {
  sum += i
  if (sum >= 1000) break
} }

(3) কোডটি একটি পদ্ধতিতে রাখুন এবং রিটার্ন ব্যবহার করুন।

var sum = 0
def findSum { for (i <- 0 to 1000) { sum += i; if (sum>=1000) return } }
findSum

আমি ভাবতে পারি এমন কমপক্ষে তিনটি কারণে এটি ইচ্ছাকৃতভাবে খুব সহজ নয়। প্রথমত, বৃহত কোড ব্লকে, "চালিয়ে যাওয়া" এবং "ব্রেক" বিবৃতিগুলিকে উপেক্ষা করা সহজ মনে হয় বা আপনি সত্যের চেয়ে কম বা বেশি ভেঙে ফেলেছেন বা এমন দুটি লুপ ভাঙতে হবে যা আপনি করতে পারবেন না সহজেই যাই হোক না কেন - সুতরাং কার্যকর ব্যবহারের সুবিধার্থে এর সমস্যা রয়েছে এবং সুতরাং আপনার কোডটি অন্যরকমভাবে গঠনের চেষ্টা করা উচিত। দ্বিতীয়ত, স্কালায় এমন সমস্ত ধরণের বাসা রয়েছে যা আপনি সম্ভবত খেয়ালও করেন না, তাই যদি আপনি জিনিসগুলি ভেঙে ফেলতে পারেন তবে আপনি সম্ভবত বিস্মিত হবেন যে কোড প্রবাহটি কোথায় শেষ হয়েছে (বিশেষত বন্ধ হওয়ার সাথে)। তৃতীয়ত, স্কালার বেশিরভাগ "লুপ" আসলে স্বাভাবিক লুপ নয় - এগুলি এমন পদ্ধতি কল যা তাদের নিজস্ব লুপ রয়েছে,লুপ লাইক, "ব্রেক" এবং এর মতো কী করা উচিত তা জানার একটি ধারাবাহিক উপায় নিয়ে আসা শক্ত। সুতরাং, ধারাবাহিকভাবে থাকতে, বুদ্ধিমানের কাজটি হ'ল কোনও "ব্রেক" না হওয়া।

দ্রষ্টব্য : আপনি এখানে sumস্থান পরিবর্তন করার পরিবর্তে মানটি ফিরিয়ে দেন সেখানে এইগুলির কার্যকরী সমতা রয়েছে । এগুলি হ'ল আরও বুদ্ধিমান স্কেলা। তবে যুক্তিটি একই রয়ে গেছে remains ( returnহয়ে যায় return xইত্যাদি)।

Comments

ব্যতিক্রমগুলি পুনরায়, যদিও আপনি ব্যতিক্রম ছুঁড়ে ফেলতে পারেন তা দৃ strictly় সত্য হলেও এটি ব্যতিক্রমী ব্যতিক্রমী ব্যবস্থার অপব্যবহার (কার্যকর জাভা দেখুন)। ব্যতিক্রমগুলি সত্যই অপ্রত্যাশিত পরিস্থিতি এবং / অথবা কোড থেকে কঠোর অব্যাহতি প্রয়োজন অর্থাত্ কোনও ধরণের ত্রুটিগুলি নির্দেশ করে। এগুলি বাদে তারা অবশ্যই বেশ ধীর গতিতে ব্যবহার করত (বর্তমান পরিস্থিতি সম্পর্কে নিশ্চিত নয়) কারণ জেভিএমগুলি তাদের অনুকূল করার খুব কম কারণ রয়েছে।

— জোনাথন

@ জোনাথন - ব্যতিক্রমগুলি কেবল ধীরে ধীরে ধীরে ধীরে ধীরে ধীরে ধীরে ধীরে ধীরে ধীরে ধীরে ধীরে ধীরে ধীরে ধীরে ধীরে ধীরে ধীরে ধীরে ধীরে ধীরে ধীরে ধীরে উড়ে যায়! এবং এগুলি পুরোপুরি বৈধ নিয়ন্ত্রণ নির্মাণ; এগুলি স্কেলা লাইব্রেরির জুড়ে একাধিক জায়গায় ব্যবহার করা হয়, যেহেতু একাধিক পদ্ধতির মাধ্যমে আপনি ফিরতে পারবেন এমন একমাত্র উপায় (যা যদি আপনার কাছে ক্লোজারের স্তূপ থাকে তবে আপনাকে কখনও কখনও করার দরকার হয়)।

— রেক্স কের

@ রেক্স কের, আপনি বিরতি নির্মাণের দুর্বলতাগুলি নির্দেশ করছেন (আমি তাদের সাথে একমত নই) তবে তারপরে আপনি সাধারণ কর্মপ্রবাহের ক্ষেত্রে ব্যতিক্রমগুলি ব্যবহার করার পরামর্শ দিচ্ছেন ! একটি লুপ থেকে বের হওয়া একটি ব্যতিক্রমী মামলা নয়, এটি অ্যালগরিদমের অংশ, এটি অ-বিদ্যমান ফাইলটিতে লেখার ক্ষেত্রে নয় (উদাহরণস্বরূপ)। সুতরাং সংক্ষেপে প্রস্তাবিত "নিরাময়" "অসুস্থতা" থেকেও খারাপ। এবং যখন আমি breakableবিভাগে একটি সত্য ব্যতিক্রম ছুঁড়ে ফেলার কথা বিবেচনা করি ... এবং এই সমস্ত হুপগুলি কেবল মন্দ থেকে বাঁচার জন্য break, হুম ;-) আপনাকে স্বীকার করতে হবে, জীবন ব্যঙ্গাত্মক।

— গ্রীনল্ডম্যান

@ ম্যাকিয়াস - দুঃখিত, আমার ভুল জেভিএম নিয়ন্ত্রণ প্রবাহের জন্য থ্রোবেবলগুলি ব্যবহার করছে। উত্তম? কেবলমাত্র তারা ব্যতিক্রম হ্যান্ডলিং সমর্থন করার জন্য ব্যবহৃত হয় এর অর্থ এই নয় যে এগুলি কেবল ব্যতিক্রম হ্যান্ডলিংয়ের জন্য ব্যবহার করা যেতে পারে। বন্ধের মধ্যে থেকে কোনও সংজ্ঞায়িত স্থানে ফিরে আসা ঠিক যেমন নিয়ন্ত্রণ প্রবাহের ক্ষেত্রে ব্যতিক্রম ছোঁড়ার মতো । তবুও আশ্চর্যের কিছু নেই যে এটিই সেই প্রক্রিয়াটি ব্যবহৃত হয়।

— রেক্স কের

@ রেক্সার কের ওয়েল, এটি আপনার পক্ষে মূল্যবান বলে আমাকে বোঝানো হয়েছে। সাধারণত আমি সাধারণ প্রোগ্রাম প্রবাহের ব্যতিক্রমগুলির বিরুদ্ধে রেল হয়ে উঠতে পারি তবে দুটি মূল কারণ এখানে প্রযোজ্য নয়। সেগুলি হ'ল: (১) এগুলি ধীর হয়ে গেছে [যখন এই পদ্ধতিতে ব্যবহৃত হয় না] এবং (২) তারা আপনার কোড পড়ার সাথে ব্যতিক্রমী আচরণের পরামর্শ দেয় [যদি আপনার লাইব্রেরি আপনাকে সেগুলি কল করতে দেয় না break] যদি এটি দেখতে মতো হয় breakএবং এটি সম্পাদন করে তবে একটি মত break, যতদূর আমি উদ্বিগ্ন এটি একটি break।

— টিম গুডম্যান

Answer 2

এটি স্কেলা ২.৮ এ পরিবর্তিত হয়েছে যা বিরতি ব্যবহারের জন্য একটি ব্যবস্থা আছে। আপনি এখন নিম্নলিখিতগুলি করতে পারেন:

import scala.util.control.Breaks._
var largest = 0
// pass a function to the breakable method
breakable { 
    for (i<-999 to 1  by -1; j <- i to 1 by -1) {
        val product = i * j
        if (largest > product) {
            break  // BREAK!!
        }
        else if (product.toString.equals(product.toString.reverse)) {
            largest = largest max product
        }
    }
}

Comments

এই ফণা অধীন ব্যতিক্রম ব্যবহার করে?

— মাইক

এটি কর্মক্ষম প্রোগ্রামিং সুবিধাগুলি (অর্থাত্ পুচ্ছ পুনরাবৃত্তি) উপেক্ষা করে একটি প্রক্রিয়াগত ভাষা হিসাবে স্কেলাকে ব্যবহার করছে। না সুন্দর.

— গ্যাল্ডার জামারিয়েও

মাইক: হ্যাঁ, স্কালা লুপ থেকে বেরিয়ে আসার জন্য একটি ব্যতিক্রম ছুঁড়ে দিচ্ছে। গাল্ডার: এটি পোস্ট করা প্রশ্নের উত্তর দেয় "আমি স্কালায় একটি লুপটি কীভাবে ভেঙে দেব?" এটি 'সুন্দর' হোক বা প্রাসঙ্গিক নয়।

— হোহনুলি

@ হোহনুলি, তাই এটি চেষ্টা করে দেখুন ব্লকটি ভাঙবে না, তাই না?

— গ্রীনল্ডম্যান

@ গ্যাল্ডার জামারিয়েও এই ক্ষেত্রে লেজ পুনরাবৃত্তি কেন একটি সুবিধা? এটি কি কেবলমাত্র একটি অপ্টিমাইজেশন নয় (যিনি নতুন আবেদনকারীর জন্য আবেদন লুকিয়ে আছেন এবং অভিজ্ঞদের জন্য বিভ্রান্তিকরভাবে আবেদন করেছেন)। এই উদাহরণে লেজ পুনরাবৃত্তি জন্য কোন সুবিধা আছে?

— ব্যবহারকারী 48956

Answer 3

লুপ থেকে বেরিয়ে আসা কখনই ভাল ধারণা নয়। আপনি যদি ফর-লুপ ব্যবহার করছেন তবে এর অর্থ হ'ল আপনি কতবার পুনরাবৃত্তি করতে চান তা আপনি জানেন। 2 শর্ত সহ একটি সময় লুপ ব্যবহার করুন।

উদাহরণ স্বরূপ

var done = false
while (i <= length && !done) {
  if (sum > 1000) {
     done = true
  }
}

Comments

স্ক্যালায় লুপগুলি ভাঙার সঠিক উপায় এটিই আমি অনুভব করি। এই উত্তরটিতে কিছু ভুল আছে? (সংখ্যার কম সংখ্যক বিবেচনা করে)।

— Jus12

সত্যই সহজ এবং আরও পাঠযোগ্য। এমনকি বিভাজ্য - বিরতিযুক্ত জিনিসটি সঠিক, এটি কুশ্রী দেখাচ্ছে এবং অভ্যন্তরীণ চেষ্টাতে সমস্যা রয়েছে। যদিও আপনার সমাধানটি ভবিষ্যদ্বাণী নিয়ে কাজ করে না, তবুও সরলতার প্রতি সম্মান জানিয়ে আমি আপনাকে ভোট দিয়ে দেব।

— yerlilbilgin

Answer 4

রেক্স কের যুক্ত করার জন্য আরও একটি উপায়:

• (1 সি) আপনি নিজের লুপে কোনও প্রহরী ব্যবহার করতে পারেন:

   var sum = 0
   for (i <- 0 to 1000 ; if sum<1000) sum += i

Comments

আমি এটিকে বিকল্প হিসাবে অন্তর্ভুক্ত করিনি কারণ এটি আসলে লুপটি ভাঙে না - এটি সমস্তটির মধ্য দিয়ে চলে, তবে যোগফলটি যথেষ্ট পরিমাণে বেশি হওয়ার পরে প্রতিটি পুনরাবৃত্তিতে ব্যর্থ হয়, সুতরাং এটি কেবল যদি একটি বিবৃতি দেয় তবে প্রতিটি সময় কাজের মূল্য। দুর্ভাগ্যক্রমে, আপনি কীভাবে লুপটি লিখেছেন তার উপর নির্ভর করে এটি অনেক কাজ হতে পারে।

— রেক্স কের 13

@ রেক্সেরার: সংকলকটি কি তবে এটি অপ্টিমাইজ করবে না? প্রথম রান চলাকালীন জেআইটির সময় না হলে এটি অপ্টিমাইজড হবে না।

— ম্যাকিয়েজ পাইচোটকা

@ ম্যাসিজেপিয়োকোটকা - জেআইটি সংকলকটিতে সাধারণত পরিবর্তনশীল ভেরিয়েবলের যদি একটি বিবৃতি সর্বদা (এই বিশেষ পরিস্থিতিতে) মিথ্যা ফিরবে এবং এইভাবে বাদ দেওয়া যেতে পারে তা স্বীকার করার জন্য পর্যাপ্ত পরিশীলিত যুক্তি ধারণ করে না।

— রেক্স কের 6

Answer 5

যেহেতু breakস্কালায় এখনও নেই, আপনি একটি- returnস্ট্যাটমেন্ট ব্যবহার করে এই সমস্যাটি সমাধান করার চেষ্টা করতে পারেন । অতএব আপনাকে আপনার অভ্যন্তরীণ লুপটি কোনও ফাংশনে রাখতে হবে, অন্যথায় রিটার্নটি পুরো লুপটি এড়িয়ে যাবে।

স্কেলা ২.৮ এর মধ্যে একটি ভাঙ্গার উপায় রয়েছে

http://www.scala-lang.org/api/rc/scala/util/control/Breaks.html

Comments

দুঃখিত, তবে আমি কেবল অভ্যন্তরীণ লুপটি বের করতে চেয়েছিলাম। আপনি বোঝাচ্ছেন না যে আমি এটি একটি ফাংশন করা উচিত?

— TiansHUo

দুঃখিত, এটি স্পষ্ট করা উচিত ছিল। নিশ্চিত যে কোনও রিটার্ন ব্যবহারের অর্থ আপনার কোনও ফাংশনে লুপটি আবদ্ধ করতে হবে। আমি আমার উত্তর সম্পাদনা করেছি।

— হাম ভোক

এটি মোটেও সুন্দর নয়। দেখে মনে হচ্ছে স্কালা নেস্ট লুপ পছন্দ করে না।

— TiansHUo

এটি অন্যরকম বলে মনে হচ্ছে না। : আপনি এই কটাক্ষপাত করা করতে চাইবেন scala-lang.org/node/257

— হ্যাম Vocke

@ টিশিয়ানসুও: আপনি কেন বলেন যে স্কালা নেস্ট লুপ পছন্দ করে না ? আপনি একটি আউট বিরতি করার চেষ্টা করছেন যদি একই বিষয় আছে একক লুপ।

— রেক্স কের

Answer 6

// import following package
import scala.util.control._

// create a Breaks object as follows
val loop = new Breaks;

// Keep the loop inside breakable as follows
loop.breakable{
// Loop will go here
for(...){
   ....
   // Break will go here
   loop.break;
   }
}

ব্রেক ব্রেক মডিউলটি http://www.tutorialspPoint.com/scala/scala_break_statement.htm ব্যবহার করুন

Answer 7

কিছুক্ষণ লুপ ব্যবহার করুন:

var (i, sum) = (0, 0)
while (sum < 1000) {
  sum += i
  i += 1
}

Answer 8

প্রথমে পুরো পরিসীমা তৈরির পরিবর্তে এবং এরপরে পুনরাবৃত্তি করার পরিবর্তে, ব্যবহার করে Iterator(@RexKerr এর ব্যবহারে অনুপ্রাণিত হয়ে Stream) ব্রেকিং শর্ত পর্যন্ত আমরা পুনরাবৃত্ত হওয়ার সাথে সাথে একটি পরিসীমাতে মানগুলি উত্পন্ন করে এমন একটি পদ্ধতির

var sum = 0
for ( i <- Iterator.from(1).takeWhile( _ => sum < 1000) ) sum += i

Comments

হ্যাঁ আমি এটা পছন্দ করি. কোন ব্রেক-অজুহাত নয়, আমি মনে করি এটি আরও সুন্দর দেখাচ্ছে।

— ses 23

Answer 9

এখানে একটি লেজ পুনরাবৃত্তি সংস্করণ। বোধগম্যতার তুলনায় এটি কিছুটা রহস্যজনক, স্বীকারোক্তিযুক্ত, তবে আমি এটির কার্যকরী বলতে চাই :)

def run(start:Int) = {
  @tailrec
  def tr(i:Int, largest:Int):Int = tr1(i, i, largest) match {
    case x if i > 1 => tr(i-1, x)
    case _ => largest
  }

  @tailrec
  def tr1(i:Int,j:Int, largest:Int):Int = i*j match {
    case x if x < largest || j < 2 => largest
    case x if x.toString.equals(x.toString.reverse) => tr1(i, j-1, x)
    case _ => tr1(i, j-1, largest)
  }

  tr(start, 0)
}

যেমন আপনি দেখতে পাচ্ছেন, টিআর ফাংশন হ'ল বোঝার জন্য বাহ্যিকের সমকক্ষ এবং অন্তর্গতের টি 1। আপনি যদি আমার সংস্করণটিকে অনুকূলিত করার কোনও উপায় জানেন তবে আপনাকে স্বাগতম।

Answer 10

আপনার সমাধানের কাছাকাছি এটি হবে:

var largest = 0
for (i <- 999 to 1 by -1;
  j <- i to 1 by -1;
  product = i * j;
  if (largest <= product && product.toString.reverse.equals (product.toString.reverse.reverse)))
    largest = product

println (largest)

জে-ইটিগ্রেশনটি কোনও নতুন সুযোগ ছাড়াই তৈরি করা হয়েছে, এবং পণ্য-প্রজন্মের পাশাপাশি শর্তটি স্টেট-স্টেটমেন্টে করা হয় (ভাল অভিব্যক্তি নয় - আমি এর চেয়ে ভাল আর খুঁজে পাই না)। শর্তটি বিপরীত হয়েছে যা সমস্যা আকারের জন্য বেশ দ্রুত - সম্ভবত আপনি বড় লুপগুলির বিরতিতে কিছু অর্জন করতে পারেন।

স্ট্রিং.রেভার স্পষ্টভাবে রিচস্ট্রিংয়ে রূপান্তরিত করে, এই কারণেই আমি 2 টি অতিরিক্ত বিপরীত করি। :) আরও একটি গাণিতিক পদ্ধতির আরও মার্জিত হতে পারে।

Answer 11

তৃতীয় পক্ষের breakableপ্যাকেজ হল একটি সম্ভাব্য বিকল্প

https://github.com/erikerlandson/breakable

উদাহরণ কোড:

scala> import com.manyangled.breakable._
import com.manyangled.breakable._

scala> val bkb2 = for {
     |   (x, xLab) <- Stream.from(0).breakable   // create breakable sequence with a method
     |   (y, yLab) <- breakable(Stream.from(0))  // create with a function
     |   if (x % 2 == 1) continue(xLab)          // continue to next in outer "x" loop
     |   if (y % 2 == 0) continue(yLab)          // continue to next in inner "y" loop
     |   if (x > 10) break(xLab)                 // break the outer "x" loop
     |   if (y > x) break(yLab)                  // break the inner "y" loop
     | } yield (x, y)
bkb2: com.manyangled.breakable.Breakable[(Int, Int)] = com.manyangled.breakable.Breakable@34dc53d2

scala> bkb2.toVector
res0: Vector[(Int, Int)] = Vector((2,1), (4,1), (4,3), (6,1), (6,3), (6,5), (8,1), (8,3), (8,5), (8,7), (10,1), (10,3), (10,5), (10,7), (10,9))

Answer 12

import scala.util.control._

object demo_brk_963 
{
   def main(args: Array[String]) 
   {
      var a = 0;
      var b = 0;
      val numList1 = List(1,2,3,4,5,6,7,8,9,10);
      val numList2 = List(11,12,13);

      val outer = new Breaks; //object for break
      val inner = new Breaks; //object for break

      outer.breakable // Outer Block
      {
         for( a <- numList1)
         {
            println( "Value of a: " + a);

            inner.breakable // Inner Block
            {
               for( b <- numList2)
               {
                  println( "Value of b: " + b);

                  if( b == 12 )
                  {
                      println( "break-INNER;");
                       inner.break;
                  }
               }
            } // inner breakable
            if( a == 6 )
            {
                println( "break-OUTER;");
                outer.break;
            }
         }
      } // outer breakable.
   }
}

ব্রেক ক্লাস ব্যবহার করে লুপ ভাঙার প্রাথমিক পদ্ধতি। লুপটিকে ব্রেকযোগ্য হিসাবে ঘোষণা করে।

Answer 13

সহজভাবে আমরা স্কেল করতে পারি

scala> import util.control.Breaks._

scala> object TestBreak{
       def main(args : Array[String]){
       breakable {
       for (i <- 1 to 10){
       println(i)
       if (i == 5){
       break;
       } } } } }

আউটপুট:

scala> TestBreak.main(Array())
1
2
3
4
5

Answer 14

হাস্যকরভাবে স্কেল বিরতি scala.util.control.Breaksব্যতিক্রম:

def break(): Nothing = { throw breakException }

সর্বোত্তম পরামর্শটি হ'ল: বিরতি, চালিয়ে যান এবং গোটো ব্যবহার করবেন না! আইএমও তারা একই, খারাপ অনুশীলন এবং সমস্ত ধরণের সমস্যার (এবং উষ্ণ আলোচনার) একটি দুষ্ট উত্স এবং শেষ পর্যন্ত "ক্ষতিকারক হিসাবে বিবেচিত"। কোড ব্লক কাঠামোগত, উদাহরণস্বরূপ বিরতিগুলি অতিমাত্রায় হয়। আমাদের এডজার ডাব্লু ডিজকস্ট্র † লিখেছেন:

প্রোগ্রামারগুলির গুণমান হ'ল তারা যে প্রোগ্রামগুলি উত্পন্ন করে সেগুলিতে বিবৃতিতে যাওয়ার ঘনত্বের ক্রমহ্রাসমান কাজ।

Answer 15

আমি নীচের কোড মত একটি পরিস্থিতি পেয়েছি

 for(id<-0 to 99) {
    try {
      var symbol = ctx.read("$.stocks[" + id + "].symbol").toString
      var name = ctx.read("$.stocks[" + id + "].name").toString
      stocklist(symbol) = name
    }catch {
      case ex: com.jayway.jsonpath.PathNotFoundException=>{break}
    }
  }

আমি একটি জাভা lib ব্যবহার করছি এবং প্রক্রিয়াটি হ'ল ctx.read কোনও ব্যতিক্রম ছুঁড়ে ফেলে যখন এটি কিছুই পায় না। আমি এমন পরিস্থিতিতে আটকা পড়েছিলাম যে: যখন কোনও এক্সেপশন নিক্ষেপ করা হয়েছিল তখন আমাকে লুপটি ভেঙে ফেলতে হবে, তবে লুপটি ভাঙ্গার জন্য ব্যাতিক্রম ব্যবহার করে স্কেলা.ইটিল.কন্ট্রোল.ব্রেকস.ব্রেক, এবং এটি ক্যাচ ব্লকে ছিল এইভাবে এটি ধরা পড়ে।

এটি সমাধানের জন্য আমি কুৎসিত উপায় পেয়েছি: প্রথমবারের জন্য লুপটি করুন এবং আসল দৈর্ঘ্যের গণনা পান। এবং এটি দ্বিতীয় লুপের জন্য ব্যবহার করুন।

স্কালা থেকে বিরতি নেওয়া খুব ভাল নয়, যখন আপনি কিছু জাভা পাছা ব্যবহার করছেন।

Answer 16

আমি স্কেলে নতুন, তবে ব্যতিক্রম ছুঁড়ে ফেলা এবং পুনরাবৃত্তি করার পদ্ধতিগুলি এড়াতে কীভাবে এটি করা যায়:

object awhile {
def apply(condition: () => Boolean, action: () => breakwhen): Unit = {
    while (condition()) {
        action() match {
            case breakwhen(true)    => return ;
            case _                  => { };
        }
    }
}
case class breakwhen(break:Boolean);

এটি এর মতো ব্যবহার করুন:

var i = 0
awhile(() => i < 20, () => {
    i = i + 1
    breakwhen(i == 5)
});
println(i)

যদি আপনি ব্রেক করতে না চান:

awhile(() => i < 20, () => {
    i = i + 1
    breakwhen(false)
});

Answer 17

findসংগ্রহের জন্য পদ্ধতির চতুর ব্যবহার আপনার জন্য কৌশলটি করবে।

var largest = 0
lazy val ij =
  for (i <- 999 to 1 by -1; j <- i to 1 by -1) yield (i, j)

val largest_ij = ij.find { case(i,j) =>
  val product = i * j
  if (product.toString == product.toString.reverse)
    largest = largest max product
  largest > product
}

println(largest_ij.get)
println(largest)

Answer 18

নীচে একটি সহজ উপায়ে একটি লুপ বিরতি কোড দেওয়া হয়

import scala.util.control.Breaks.break

object RecurringCharacter {
  def main(args: Array[String]) {
    val str = "nileshshinde";

    for (i <- 0 to str.length() - 1) {
      for (j <- i + 1 to str.length() - 1) {

        if (str(i) == str(j)) {
          println("First Repeted Character " + str(i))
          break()     //break method will exit the loop with an Exception "Exception in thread "main" scala.util.control.BreakControl"

        }
      }
    }
  }
}

Answer 19

আমি জানি না যে গত 9 বছরে স্কালার স্টাইলটি কতটা পরিবর্তিত হয়েছে, তবে আমি এটি আকর্ষণীয় বলে মনে করেছি যে বিদ্যমান উত্তরগুলির বেশিরভাগ ব্যবহার করা হয় vars, বা পুনরাবৃত্তি পড়া শক্ত। আপনার সম্ভাব্য প্রার্থীদের উত্সাহ দেওয়ার জন্য অলস সংগ্রহটি ব্যবহার করা তাড়াতাড়ি প্রস্থান করার মূল চাবিকাঠি, তারপরে শর্তটি আলাদাভাবে পরীক্ষা করুন। পণ্য উত্পাদন করতে:

val products = for {
  i <- (999 to 1 by -1).view
  j <- (i to 1 by -1).view
} yield (i*j)

তারপরে প্রতিটি সংমিশ্রণ তৈরি না করেই সেই দৃশ্য থেকে প্রথম প্যালিনড্রোমটি সন্ধান করতে:

val palindromes = products filter {p => p.toString == p.toString.reverse}
palindromes.head

বৃহত্তম প্যালিনড্রোমটি সন্ধান করতে (যদিও আলস্যতা আপনাকে বেশি পরিমাণে কিনে না কারণ আপনাকে যাইহোক পুরো তালিকাটি পরীক্ষা করতে হবে):

palindromes.max

আপনার আসল কোডটি আসলে পরবর্তী প্যালিনড্রোমের জন্য যা পরবর্তী পণ্যগুলির চেয়ে বড় যাচাই করছে যা একটি অদ্ভুত সীমানা শর্ত ব্যতীত প্রথম প্যালিনড্রোমের জন্য যাচাই করার মতো যা আমি মনে করি না যে আপনি উদ্দেশ্য করে। পণ্যগুলি কঠোরভাবে একঘেয়েভাবে হ্রাস পাচ্ছে না। উদাহরণস্বরূপ, এর 998*998চেয়ে বড় 999*997তবে লুপগুলিতে অনেক পরে প্রদর্শিত হয়।

যাইহোক, বিচ্ছিন্ন অলস প্রজন্মের এবং শর্ত পরীক্ষার সুবিধাটি হ'ল আপনি এটি পুরোপুরি ব্যবহার করছেন ঠিক তেমন এটি লিখেছেন তবে এটি কেবল আপনার প্রয়োজন হিসাবে উত্পন্ন করে। আপনি বাছাই উভয় বিশ্বের সেরা পেতে।