স্কালায় বোঝার জন্য এবং লুপগুলি কীভাবে অনুকূল করা যায়?

Question

সুতরাং স্কালার জাভা হিসাবে দ্রুত হওয়ার কথা। আমি কিছু প্রজেক্ট অলারের পুনর্বিবেচনা করছি সমস্যাগুলি দেখছি যা আমি জাভাতে মূলত মোকাবেলা করেছি। বিশেষত সমস্যা 5: "1 থেকে 20 পর্যন্ত সমস্ত সংখ্যার দ্বারা সমানভাবে বিভাজ্যতম ক্ষুদ্রতম ধনাত্মক সংখ্যাটি কী?"

এখানে আমার জাভা সমাধানটি রয়েছে, যা আমার মেশিনে সম্পূর্ণ হতে 0.7 সেকেন্ড সময় নেয়:

public class P005_evenly_divisible implements Runnable{
    final int t = 20;

    public void run() {
        int i = 10;
        while(!isEvenlyDivisible(i, t)){
            i += 2;
        }
        System.out.println(i);
    }

    boolean isEvenlyDivisible(int a, int b){
        for (int i = 2; i <= b; i++) {
            if (a % i != 0) 
                return false;
        }
        return true;
    }

    public static void main(String[] args) {
        new P005_evenly_divisible().run();
    }
}

এখানে স্ক্যালায় আমার "সরাসরি অনুবাদ" রয়েছে, যা 103 সেকেন্ড সময় নেয় (147 গুণ বেশি সময়!)

object P005_JavaStyle {
    val t:Int = 20;
    def run {
        var i = 10
        while(!isEvenlyDivisible(i,t))
            i += 2
        println(i)
    }
    def isEvenlyDivisible(a:Int, b:Int):Boolean = {
        for (i <- 2 to b)
            if (a % i != 0)
                return false
        return true
    }
    def main(args : Array[String]) {
        run
    }
}

পরিশেষে এখানে ফাংশনাল প্রোগ্রামিংয়ে আমার প্রয়াস রয়েছে, যা 39 সেকেন্ড সময় নেয় (55 গুণ বেশি সময়)

object P005 extends App{
    def isDivis(x:Int) = (1 to 20) forall {x % _ == 0}
    def find(n:Int):Int = if (isDivis(n)) n else find (n+2)
    println (find (2))
}

উইন্ডোজ 7 64-বিটে স্কেলা 2.9.0.1 ব্যবহার করা .1 আমি কীভাবে পারফরম্যান্সের উন্নতি করব? আমি কি ভুল কিছু করছি? নাকি জাভা কি খুব দ্রুত?

Comments

আপনি স্কেল শেল ব্যবহার করে সংকলন বা ব্যাখ্যা করেন?

— আহমেটবি - গুগল

এটি করার জন্য ট্রায়াল বিভাগ ( ইঙ্গিত ) ব্যবহার করার চেয়ে আরও ভাল উপায় আছে ।

— হামার

আপনি কীভাবে সময় কাটাচ্ছেন তা আপনি প্রদর্শন করবেন না। আপনি কি runপদ্ধতিটির সময় নির্ধারণের চেষ্টা করেছেন ?

— অ্যারন নভস্ট্রাপ

@ হ্যামার - হ্যাঁ, এটি কেবল কলম এবং কাগজের উপায়েই করেছেন: প্রতিটি সংখ্যার জন্য মূলগুলি উচ্চ দিয়ে শুরু করুন, তারপরে আপনার ইতিমধ্যে উচ্চ সংখ্যার জন্য যে কারণগুলি রয়েছে তা অতিক্রম করুন, সুতরাং আপনি শেষ করে (5 * 2 * 2) * (19) * (3 * 3) * (17) * (2 * 2) * () * (7) * (13) * () * (11) = 232792560

— লুইজি প্লিঞ্জ ২

+1 এটি সপ্তাহের মধ্যে এসও-তে আমি সবচেয়ে আকর্ষণীয় প্রশ্ন (এটির বেশিরভাগ উত্তর আমি বেশ কিছুক্ষণের মধ্যে দেখেছি)।

— মিয়া ক্লার্ক

Answer 1

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

Comments

খুব ভারী যে একটি রিটার্ন ব্যতিক্রম হয়ে যায়। আমি নিশ্চিত এটি এটি কোথাও নথিভুক্ত, তবে এটিতে অবিস্মরণীয় গোপন যাদুটির রেকর্ড রয়েছে। আসলেই কি এটাই একমাত্র উপায়?

— স্ক্রাববেল

যদি কোনও বন্ধের অভ্যন্তর থেকে ফিরে আসে, এটি সেরা উপলব্ধ বিকল্প বলে মনে হচ্ছে। বাইকোডে নির্দেশাবলী ফিরিয়ে দেওয়ার জন্য বাইরের ক্লোজার থেকে রিটার্ন অবশ্যই অনূদিত হয়।

— মার্টিন ওডারস্কি

আমি নিশ্চিত যে আমি কিছু উপেক্ষা করছি, তবে কেন এটি বন্ধ বুলিয়ান পতাকা এবং রিটার্ন-মান নির্ধারণের জন্য বন্ধের ভিতরে থেকে রিটার্নটি সংকলন করে না এবং ক্লোজার-কল রিটার্নের পরে এটি পরীক্ষা করে দেখুন?

— লুক হুটম্যান

কেন এখনও তার কার্যকরী অ্যালগরিদম 55 গুণ ধীর? দেখে মনে হচ্ছে না এরকম ভয়াবহ পারফরম্যান্স থেকে ভুগতে হবে

— এলিয়াহ

এখন, ২০১৪ সালে, আমি এটি আবার পরীক্ষা করেছি এবং আমার জন্য কর্মক্ষমতা নিম্নলিখিত: জাভা -> ০.০ সেংস; স্কেলা -> 3.6 এস; স্কেল অপ্টিমাইজড -> 3.5s; স্কেলা কার্যকরী -> 4 এস; 3 বছর আগের চেয়ে অনেক ভাল দেখাচ্ছে, কিন্তু ... তবুও পার্থক্যটি খুব বড়। আমরা আরও কর্মক্ষমতা উন্নতি আশা করতে পারি? অন্য কথায়, মার্টিন, তাত্ত্বিকভাবে, সম্ভাব্য অনুকূলকরণের জন্য কিছু আছে?

— sasha.sochka

Answer 2

সমস্যাটি সম্ভবত forপদ্ধতিটিতে কোনও বোধগম্যতার ব্যবহার isEvenlyDivisible। forসমতুল্য whileলুপ দ্বারা প্রতিস্থাপন জাভা সঙ্গে পারফরম্যান্স পার্থক্য অপসারণ করা উচিত।

জাভার forলুপগুলির বিপরীতে , স্কালার forবোঝাপড়াগুলি উচ্চতর-আদেশের পদ্ধতির জন্য আসলে সিনট্যাকটিক চিনি; এই ক্ষেত্রে, আপনি foreachকোনও Rangeবস্তুতে পদ্ধতিটি কল করছেন । স্কালাস forখুব সাধারণ, তবে কখনও কখনও বেদনাদায়ক কর্মক্ষমতা বাড়ে।

আপনি -optimizeস্কেলা সংস্করণ ২.৯-তে পতাকাটি চেষ্টা করতে চাইতে পারেন । পর্যবেক্ষণ করা পারফরম্যান্স ব্যবহারে নির্দিষ্ট জেভিএম এবং জেআইটি অপ্টিমাইজার হট স্পটগুলি সনাক্ত এবং অনুকূলকরণের জন্য পর্যাপ্ত "ওয়ার্ম আপ" থাকার উপর নির্ভর করে।

মেলিং তালিকার সাম্প্রতিক আলোচনাগুলি ইঙ্গিত দেয় যে স্কালা দল forসাধারণ ক্ষেত্রে কর্মক্ষমতা উন্নত করতে কাজ করছে :

• http://groups.google.com/group/scala-user/browse_thread/thread/86adb44d72ef4498
• http://groups.google.com/group/scala-language/browse_thread/thread/94740a10205dddd2

বাগ ট্র্যাকারে এখানে সমস্যাটি রয়েছে: https://issues.scala-lang.org/browse/SI-4633

5/28 আপডেট করুন :

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

Comments

দুর্দান্ত, আমি কিছুক্ষণের লুপের সাথে বোঝার জন্য প্রতিস্থাপন করেছি এবং এটি জাভা সংস্করণ হিসাবে ঠিক একই গতিতে (+/- <1%) চলে। ধন্যবাদ ... আমি এক মিনিটের জন্য স্কালায় প্রায় বিশ্বাস হারিয়ে ফেলেছি! এখন কেবল একটি ভাল কার্যকরী অ্যালগরিদম নিয়ে কাজ করতে হবে ... :)

— লুইজি প্লিঞ্জ ২

এটি লক্ষণীয় যে টেল-পুনরাবৃত্ত ফাংশনগুলি লুপগুলির মতো দ্রুতও হয় (যেহেতু উভয়ই খুব অনুরূপ বা অভিন্ন বাইটকোডে রূপান্তরিত হয়)।

— রেক্স কের

এটিও আমাকে একবার পেয়েছে। অবিশ্বাস্যরূপে ধীরগতির কারণে লুপগুলি (স্তর 6!) যখন সংগ্রহ করা ফাংশনগুলি নেস্টেডে ব্যবহার করে একটি অ্যালগরিদম অনুবাদ করতে হয়েছিল। এটি এমন একটি বিষয় যা ভারীভাবে লক্ষ্যবস্তু করা দরকার, ইমো; আমার যখন শালীনতার প্রয়োজন হয় (নোট: দ্রুত জ্বলন্ত নয়) পারফরম্যান্সের প্রয়োজন হয় তখন আমি কী ব্যবহারের একটি দুর্দান্ত প্রোগ্রামিং শৈলী?

— রাফেল

কখন forউপযুক্ত?

— অস্কাররেজ

@ অস্কাররাইজ - স্কাল ইন একটি বেশিরভাগ অংশে জাভাতে (:) এর মতো আচরণ করে।

— মাইক অ্যাক্সিয়াক

Answer 3

ফলোআপ হিসাবে, আমি পতাকাটি চেষ্টা করলাম এবং এটি চলমান সময়কে 103 থেকে 76 সেকেন্ডে হ্রাস পেয়েছে, তবে এটি এখনও জাভা বা কিছুক্ষণ লুপের চেয়ে 107x কম।

তারপরে আমি "ফাংশনাল" সংস্করণটি দেখছিলাম:

object P005 extends App{
  def isDivis(x:Int) = (1 to 20) forall {x % _ == 0}
  def find(n:Int):Int = if (isDivis(n)) n else find (n+2)
  println (find (2))
}

এবং কীভাবে সংক্ষিপ্তভাবে "ফোড়াল" থেকে মুক্তি পাবেন তা নির্ধারণের চেষ্টা করছেন trying আমি খারাপভাবে ব্যর্থ হয়ে এসেছি with

object P005_V2 extends App {
  def isDivis(x:Int):Boolean = {
    var i = 1
    while(i <= 20) {
      if (x % i != 0) return false
      i += 1
    }
    return true
  }
  def find(n:Int):Int = if (isDivis(n)) n else find (n+2)
  println (find (2))
}

যার মাধ্যমে আমার চালাকি 5-লাইন সমাধানটি 12 টি লাইনে ছড়িয়েছে। তবে, এই সংস্করণটি 0.71 সেকেন্ডে চলবে , মূল জাভা সংস্করণের মতোই গতি এবং "ফোরাস" (40.2 গুলি) ব্যবহার করে উপরের সংস্করণটির চেয়ে 56 গুণ বেশি দ্রুত! (এটি জাভা থেকে দ্রুততর কেন হয় তার জন্য নীচে সম্পাদনা দেখুন)

স্পষ্টতই আমার পরবর্তী পদক্ষেপটি ছিল উপরের পিছনে জাভায় অনুবাদ করা, কিন্তু জাভা এটি পরিচালনা করতে পারে না এবং 22000 চিহ্নের কাছাকাছি n দিয়ে একটি স্ট্যাকওভারফ্লো ইরর ছুড়ে দেয়।

আমি তখন আমার মাথাটি কিছুটা আঁচড়ে এলাম এবং "যখন" কিছুটা লেজ পুনরাবৃত্তির সাথে প্রতিস্থাপন করলাম, যা বেশ কয়েকটি লাইন সাশ্রয় করে, ঠিক তত দ্রুত চলে, তবে আসুন এটির মুখোমুখি হয়ে পড়ুন, এটি পড়ার জন্য আরও বিভ্রান্তিকর:

object P005_V3 extends App {
  def isDivis(x:Int, i:Int):Boolean = 
    if(i > 20) true
    else if(x % i != 0) false
    else isDivis(x, i+1)

  def find(n:Int):Int = if (isDivis(n, 2)) n else find (n+2)
  println (find (2))
}

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

সম্পাদনা : (মুছে ফেলা)

সম্পাদনার সম্পাদনা : s২-বিট বা -৪-বিট জেভিএম ব্যবহার করা হচ্ছে কিনা এর কারণে 2.5 এবং 0.7 এর রান সময়গুলির মধ্যে পূর্বের তফাতগুলি পুরোপুরি ছিল। কমান্ড লাইন থেকে স্কেল জাভাওয়াহোম দ্বারা নির্ধারিত যা কিছু ব্যবহার করে, যখন জাভা নির্বিশেষে উপলব্ধ 64৪-বিট ব্যবহার করে। আইডিইগুলির নিজস্ব সেটিংস রয়েছে। কিছু পরিমাপ এখানে: Eclipse এ স্কেল প্রয়োগের সময়

Comments

isDivis-পদ্ধতি হিসেবে লেখা যেতে পারে: def isDivis(x: Int, i: Int): Boolean = if (i > 20) true else if (x % i != 0) false else isDivis(x, i+1)। লক্ষ্য করুন যে স্কালায় যদি অন্যথায় একটি অভিব্যক্তি হয় যা সর্বদা একটি মান দেয়। এখানে রিটার্ন-কীওয়ার্ডের প্রয়োজন নেই।

— কিরিতসুকু

আপনার শেষ সংস্করণটি ( P005_V3) আরও সংক্ষিপ্ত, আরও ঘোষিত এবং আইএমএইচও পরিষ্কার করে লিখে লেখা যেতে পারে:def isDivis(x: Int, i: Int): Boolean = (i > 20) || (x % i == 0) && isDivis(x, i+1)

— ব্লেজারব্লেড

@ ব্লাইজারব্ল্যাড নং এটি পুচ্ছ-পুনরাবৃত্তিকে ভঙ্গ করবে, যা বাইটোকোডের কিছুক্ষণের লুপে অনুবাদ করতে হবে, যার ফলে কার্যকরভাবে দ্রুত কার্যকর হয় execution

— gzm0

আমি আপনার বক্তব্যটি দেখতে পাচ্ছি, তবে আমার উদাহরণটি && এবং || সাল থেকে এখনও পুচ্ছ-পুনরাবৃত্ত is শট-সার্কিট মূল্যায়ন ব্যবহার করুন, যেমনটি @

— ব্লেজারব্লেড

Answer 4

বোধগম্যতার জন্য উত্তরটি সঠিক, তবে এটি পুরো গল্প নয়। আপনার খেয়াল করা উচিত যে returnইন ব্যবহারটি isEvenlyDivisibleনিখরচায় নয়। এর অভ্যন্তরে রিটার্নের ব্যবহার for, স্কালার সংকলকটিকে একটি স্থানীয় নয় এমন স্থানীয় রিটার্ন উত্পন্ন করতে বাধ্য করে (অর্থাত্ এটির ফাংশনের বাইরে ফিরে আসতে)।

লুপ থেকে বেরিয়ে আসার জন্য ব্যতিক্রম ব্যবহারের মাধ্যমে এটি করা হয়। আপনি যদি নিজের নিয়ন্ত্রণ বিমূর্ততা তৈরি করেন তবে একই ঘটনা ঘটে:

def loop[T](times: Int, default: T)(body: ()=>T) : T = {
    var count = 0
    var result: T = default
    while(count < times) {
        result = body()
        count += 1
    }
    result
}

def foo() : Int= {
    loop(5, 0) {
        println("Hi")
        return 5
    }
}

foo()

এটি একবার "হাই" মুদ্রণ করে।

লক্ষ্য করুন returnযে fooপ্রস্থানের foo(যা আপনি আশা করবে কি যায়)। যেহেতু বন্ধনযুক্ত এক্সপ্রেশনটি একটি ফাংশন আক্ষরিক, আপনি এটির স্বাক্ষরে দেখতে পাচ্ছেন loopযে সংকলকটি একটি স্থানীয় নয় এমন রিটার্ন তৈরি করতে বাধ্য করে, যা returnআপনাকে কেবল প্রস্থান fooকরতে নয়, আপনাকে প্রস্থান করতে বাধ্য করে body।

জাভাতে (অর্থাত্ জেভিএম) এ জাতীয় আচরণ বাস্তবায়নের একমাত্র উপায় ব্যতিক্রম ছুঁড়ে ফেলা।

এখানে ফিরে যাচ্ছি isEvenlyDivisible:

def isEvenlyDivisible(a:Int, b:Int):Boolean = {
  for (i <- 2 to b) 
    if (a % i != 0) return false
  return true
}

if (a % i != 0) return falseএকটি ফাংশন আক্ষরিক একটি ফিরতি আছে, প্রতিটি সময় আগমন আঘাত তাই, রানটাইম নিক্ষেপ এবং একটি ব্যতিক্রম, যা মাথার উপরে বেশ জিসি একটি বিট কারণ ধরতে হয়েছে।

Answer 5

forallআমি যে পদ্ধতিটি আবিষ্কার করেছি তার গতি বাড়ানোর কয়েকটি উপায় :

মূল: 41.3 এস

def isDivis(x:Int) = (1 to 20) forall {x % _ == 0}

পরিসীমা প্রাক-ইনস্ট্যান্ট করা, সুতরাং আমরা প্রতিবার একটি নতুন পরিসর তৈরি করি না: 9.0 এস

val r = (1 to 20)
def isDivis(x:Int) = r forall {x % _ == 0}

একটি ব্যাপ্তির পরিবর্তে একটি তালিকায় রূপান্তর করা হচ্ছে: 4.8 এস

val rl = (1 to 20).toList
def isDivis(x:Int) = rl forall {x % _ == 0}

আমি কয়েকটি অন্যান্য সংগ্রহের চেষ্টা করেছি তবে তালিকাটি দ্রুততম ছিল (যদিও আমরা রেঞ্জ এবং উচ্চতর অর্ডার ফাংশনটি পুরোপুরি এড়িয়ে চলি তার চেয়ে এখনও 7x ধীর গতিতে)।

আমি স্কেলে নতুন থাকাকালীন, আমি অনুমান করেছিলাম যে সংকলকটি সহজেই বাহ্যিকতম স্কোজে রেঞ্জের ধ্রুবকগুলির সাথে পদ্ধতিতে (উপরে হিসাবে) রেঞ্জের লিটারালগুলি স্বয়ংক্রিয়ভাবে প্রতিস্থাপনের দ্বারা দ্রুত এবং উল্লেখযোগ্য পারফরম্যান্স লাভটি বাস্তবায়িত করতে পারে I'd বা আরও ভাল, তাদের জাভা স্ট্রিংস আক্ষরিক মত ইন্টার্ন।

---

পাদটীকা : অ্যারেগুলি রেঞ্জের মতোই ছিল, তবে মজার বিষয় হল একটি নতুন forallপদ্ধতি ফুটিয়ে তোলার ফলে (নীচে দেখানো হয়েছে)%%-বিটের উপর ২৪% দ্রুত মৃত্যুদন্ড কার্যকর হয়েছিল এবং ৩২-বিটের উপর ৮% দ্রুত গতিবেগ এসেছে। আমি যখন 20 থেকে 15 এর কারণগুলির সংখ্যা হ্রাস করে গণনার আকার হ্রাস করলাম তখন তফাতটি অদৃশ্য হয়ে গেল, সুতরাং এটি কোনও আবর্জনা সংগ্রহের প্রভাব। কারণ যাই হোক না কেন, বর্ধিত সময়কালের জন্য পুরো বোঝার অধীনে কাজ করার সময় তা উল্লেখযোগ্য।

তালিকার জন্য অনুরূপ একটি পিম্প প্রায় 10% ভাল পারফরম্যান্সের ফলস্বরূপ।

  val ra = (1 to 20).toArray
  def isDivis(x:Int) = ra forall2 {x % _ == 0}

  case class PimpedSeq[A](s: IndexedSeq[A]) {
    def forall2 (p: A => Boolean): Boolean = {      
      var i = 0
      while (i < s.length) {
        if (!p(s(i))) return false
        i += 1
      }
      true
    }    
  }  
  implicit def arrayToPimpedSeq[A](in: Array[A]): PimpedSeq[A] = PimpedSeq(in)  

Answer 6

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

আমি জানি এটি দুর্ভাগ্যজনক যে এফপিগুলি এখনও এমন পর্যায়ে অনুকূলিত হয়নি যেখানে আমাদের এই জাতীয় জিনিসগুলি নিয়ে ভাবার দরকার নেই, তবে এটি স্ক্যালার বিশেষত কোনও সমস্যা নয়।

Answer 7

স্কেলা সম্পর্কিত নির্দিষ্ট সমস্যাগুলি ইতিমধ্যে আলোচনা করা হয়েছে, তবে মূল সমস্যাটি হ'ল ব্রুট-ফোর্স অ্যালগরিদম ব্যবহার করা খুব শীতল নয়। এটি বিবেচনা করুন (মূল জাভা কোডের চেয়ে অনেক দ্রুত):

def gcd(a: Int, b: Int): Int = {
    if (a == 0)
        b
    else
        gcd(b % a, a)
}
print (1 to 20 reduce ((a, b) => {
  a / gcd(a, b) * b
}))

Comments

প্রশ্নগুলি ভাষা জুড়ে একটি নির্দিষ্ট যুক্তির পারফরম্যান্সের তুলনা করে। সমস্যার জন্য অ্যালগরিদম সর্বোত্তম কিনা তা অবিরাম।

— স্মার্টনাট 700

Answer 8

প্রজেক্ট অয়লারের জন্য স্কেল সমাধানে প্রদত্ত ওয়ান-লাইনার ব্যবহার করে দেখুন

প্রদত্ত সময়টি আপনার চেয়ে কমপক্ষে দ্রুত, যদিও লুপ থেকে অনেক দূরে .. :)

Comments

এটি আমার ক্রিয়ামূলক সংস্করণের সাথে বেশ মিল। আপনি আমার হিসাবে লিখতে পারেন def r(n:Int):Int = if ((1 to 20) forall {n % _ == 0}) n else r (n+2); r(2), যা পাভেলের চেয়ে 4 টি অক্ষর সংক্ষিপ্ত। :) তবে আমি আমার কোডটি কোনও ভাল তা ভান করি না - যখন আমি এই প্রশ্নটি পোস্ট করি তখন আমি স্কালার প্রায় 30 টি লাইনকে কোড করেছিলাম।

— লুইজি প্লিঞ্জ