जावा में फैक्टरियल कैसे न लिखें

इस लेख का अनुवाद एक बार एक हब पर प्रकाशित हुआ था, लेकिन किसी कारण से सबसे महत्वपूर्ण हिस्सा पर्दे के पीछे रहा। नीचे पूरा अनुवाद है।



यह लेख " आप जावा में फैक्टरियल कैसे लिखेंगे? " लेख से प्रेरित था। क्षमा करें, मैं कोड में थोड़ी बात करूंगा: मेरे पास एक मुख्य विचार है, जिसे मैं अंत में व्यक्त करूंगा।



यदि आपको जावा में फैक्टरियल लिखने की आवश्यकता है, तो आप में से अधिकांश शायद कुछ के साथ शुरू करेंगे इस:

public static int factorial(int n) { if (n == 0) return 1; return n * factorial(n-1); }
      
      

        
        
        
      

    
        
        
        
      
      

        
        
        
      

    
     

चलो इसे एक कक्षा में लपेटते हैं (हम अभी भी जावा के बारे में बात कर रहे हैं), शायद यह किसी प्रकार का सहायक (* यूटिल) वर्ग होगा, उदाहरण के लिए:

 public class FactorialUtil { public static int factorial(int n) { if (n == 0) return 1; return n * factorial(n-1); } }
      
      

        
        
        
      

    
        
        
        
      
      

        
        
        
      

    
     

सरल, है ना?



गैर-पुनरावर्ती समाधान भी है:

 public class FactorialUtil { public static int factorial(int n) { int ret = 1; for (int i = 1; i <= n; ++i) ret *= i; return ret; } }
      
      

        
        
        
      

    
        
        
        
      
      

        
        
        
      

    
     

एक चौकस पाठक ध्यान देगा कि परिणाम अधिकतम स्वीकार्य पूर्णांक (प्रकार पूर्णांक) से अधिक हो सकता है, और संभवतः फ़ंक्शन को फिर से लिखना चाहेगा ताकि वह प्रोग्राम की आवश्यकताओं के आधार पर बिगइंटर या कम से कम लंबे समय का उपयोग करे। इस प्रकार,

 public class FactorialUtil { public static BigInteger factorial(int n) { BigInteger ret = BigInteger.ONE; for (int i = 1; i <= n; ++i) ret = ret.multiply(BigInteger.valueOf(i)); return ret; } }
      
      

        
        
        
      

    
        
        
        
      
      

        
        
        
      

    
     

कृपया ध्यान दें कि अभी तक मैंने इस तथ्य का उपयोग नहीं किया है कि मैं लगातार 1 से n तक समान मध्यवर्ती मूल्यों की गणना करता हूं। अगर मैंने इन मूल्यों को कैश किया, तो निश्चित रूप से, गणना बहुत तेज हो सकती है। यदि हमने एक बार मान की गणना कर ली है, तो इसे भविष्य के उपयोग के लिए सहेजें, उदाहरण के लिए, हैशपॉप में:

 public class FactorialUtil { static HashMap<Integer,BigInteger> cache = new HashMap<Integer,BigInteger>(); public static BigInteger factorial(int n) { BigInteger ret; if (n == 0) return BigInteger.ONE; if (null != (ret = cache.get(n))) return ret; ret = BigInteger.valueOf(n).multiply(factorial(n-1)); cache.put(n, ret); return ret; } }
      
      

        
        
        
      

    
        
        
        
      
      

        
        
        
      

    
     

काफी आसान है, है ना?

इनमें से प्रत्येक विधि के अपने फायदे और नुकसान हैं, इसलिए, यह देखते हुए कि यह पुस्तकालय भविष्य में हमारे लिए एक से अधिक बार उपयोगी होने की संभावना है, यह जावा पुस्तकालयों में लोकप्रिय मानक तंत्र का उपयोग करने के लायक है। मैं एक प्लग करने योग्य मॉड्यूल सिस्टम के बारे में बात कर रहा हूं जो आपको रनटाइम पर निर्णय लेने की अनुमति देता है कि कौन सा एल्गोरिदम का उपयोग करना है: धीमा, लेकिन कम मेमोरी, या तेज, लेकिन अधिक मेमोरी का उपभोग करना। शुरू करने के लिए, हमें अपनी कक्षा को सिंगलटन में रीमेक करने की आवश्यकता है, क्योंकि किसी भी प्लग-इन गिज़्म को प्रारंभिक कक्षाओं और सिग्लटन की आवश्यकता होती है, जो डिफ़ॉल्ट कार्यान्वयन को वापस करता है।



इसलिए, हम एक ऐसा वर्ग बना रहे हैं, जिसका काम हमारे कारखाने (फैक्ट्री क्लास) के लिए एक सिंगलटन का समर्थन करना है, और एक एल्गोरिथ्म से लिंक करना है जो विधि को लागू करता है। यह वर्ग पुराना इंटरफ़ेस प्रदान करता है, जो ऊपर दिखाया गया था, और आपको एक नए, बेहतर एल्गोरिथ्म का उपयोग करने की भी अनुमति देता है:

 public class FactorialUtil { private static FactorialUtil singleton; private FactorialAlgorithm algorithm; /** * Default (internal) constructor constructs our default algorithm. */ private FactorialUtil() { algorithm = new CachedFactorialImplementation(); } /** * New initializer which allows selection of the algorithm mechanism * @param algorithm */ public FactorialUtil(FactorialAlgorithm a) { algorithm = a; } /** * Default public interface for handling our factorial algorithm. Uses * the old standard established earlier for calling into our utility class. * @param n * @return */ public static BigInteger factorial(int n) { if (singleton == null) { // Use default constructor which uses default algorithm singleton = new FactorialUtil(); } return singleton.doFactorial(n); } /** * New mechanism which allows us to instantiate individual factorial * utilitiy classes and invoke customized factorial algorithms directory. * @param n * @return */ private BigInteger doFactorial(int n) { // Defer to our algorithm return algorithm.factorial(n); } }
      
      

        
        
        
      

    
        
        
        
      
      

        
        
        
      

    
     

ध्यान दें कि उपरोक्त वर्ग एक सिंगलटन बनाने और एल्गोरिथ्म वर्ग पर नियंत्रण पारित करने के लिए जिम्मेदार है। यहां तक ​​कि एक निजी कंस्ट्रक्टर भी है जो एल्गोरिथ्म वर्ग को आरंभीकृत करता है, साथ ही एक अन्य एल्गोरिथ्म बनाने और उपयोग करने की क्षमता भी।



यह एल्गोरिथ्म इंटरफ़ेस पर निर्भर करता है:

 public interface FactorialAlgorithm { BigInteger factorial(int n); }
      
      

        
        
        
      

    
        
        
        
      
      

        
        
        
      

    
     

और यहाँ मध्यवर्ती परिणाम कैशिंग का उपयोग करते हुए एक कार्यान्वयन है जो हमने पहले उल्लेख किया था:

 public class CachedFactorialImplementation implements FactorialAlgorithm { static HashMap<Integer,BigInteger> cache = new HashMap<Integer,BigInteger>(); @Override public BigInteger factorial(int n) { BigInteger ret; if (n == 0) return BigInteger.ONE; if (null != (ret = cache.get(n))) return ret; ret = BigInteger.valueOf(n).multiply(factorial(n-1)); cache.put(n, ret); return ret; } }
      
      

        
        
        
      

    
        
        
        
      
      

        
        
        
      

    
     

देखो यह संरचना कितनी सुंदर है! मेरा मतलब है, हम आसानी से एक गैर-कैशिंग गैर-पुनरावर्ती कार्यान्वयन जोड़ सकते हैं:

 public class LoopedFactorialImplementation implements FactorialAlgorithm { @Override public BigInteger factorial(int n) { BigInteger ret = BigInteger.ONE; for (int i = 1; i <= n; ++i) ret = ret.multiply(BigInteger.valueOf(i)); return ret; } }
      
      

        
        
        
      

    
        
        
        
      
      

        
        
        
      

    
     

जावा के दृष्टिकोण से, इस डिज़ाइन की कमी स्पष्ट होनी चाहिए: यह हमें रनटाइम पर एक एल्गोरिथ्म चुनने की अनुमति नहीं देता है - और यह मूल रूप से हमारा मुख्य विचार था। यही है, जाहिर है, हमें कॉन्फ़िगरेशन को लोड करने और उसके अनुसार एल्गोरिदम का चयन करने की आवश्यकता है। उदाहरण के लिए, हम कुछ सिस्टम प्रॉपर्टी को पढ़ सकते हैं, जिसमें एल्गोरिथ्म को लागू करने वाले वर्ग का नाम होता है। आदर्श रूप से, हमारी मुख्य विधि कुछ इस तरह दिखनी चाहिए:

  public static void main(String[] args) { System.getProperties().setProperty("com.chaosinmotion.factorialalgorithm", "cachedAlgorithm"); System.out.println("5! = " + FactorialUtil.factorial(5)); }
      
      

        
        
        
      

    
        
        
        
      
      

        
        
        
      

    
     

जिसका अर्थ है कि हमें सभी मौजूदा कार्यान्वयन वाले एक सहयोगी सरणी की आवश्यकता है। इससे, हम फैक्ट्री विधि के अंदर अपना सिंगलटन बनाने से पहले वांछित एल्गोरिदम ले सकते थे।



इसलिए हमें एक ऐसी फैक्टरी की आवश्यकता है जो एल्गोरिदम उत्पन्न कर सके। हम निर्मित सिंगलटन फैक्ट्रियों की एक श्रेणी और क्लासमैपिंग में क्लास नाम और कार्यान्वयन मैपिंग के एक सरणी को संग्रहीत करते हैं। इस प्रकार, हम एल्गोरिथम वर्ग का एक ऑब्जेक्ट नहीं बनाते हैं जब तक कि हमें वास्तव में इसकी आवश्यकता नहीं होती है (बिना किसी लाभ के अनावश्यक निर्माणकर्ताओं और अपशिष्ट संसाधनों को कॉल करने के लिए कुछ भी नहीं है)।

 /** * Factory class manages the factorial algorithms in our system. * @author wwoody * */ public class FactorialAlgorithmFactory { private static HashMap<String,FactorialAlgorithm> mapping = new HashMap<String,FactorialAlgorithm>(); private static HashMap<String,Class<? extends FactorialAlgorithm>> classMapping = new HashMap<String,Class<? extends FactorialAlgorithm>>(); private static FactorialAlgorithm defaultAlgorithm = new CachedFactorialImplementation(); /** Static initializer registers some of my known classes */ static { try { Class.forName("com.chaosinmotion.factorial.LoopedFactorialImplementation"); Class.forName("com.chaosinmotion.factorial.CachedFactorialImplementation"); } catch (ClassNotFoundException e) { // Should never happen. } } /** Get the default algorithm for computing factorials */ public static FactorialAlgorithm getDefaultAlgorithm() { if (defaultAlgorithm == null) { // Warning: this will fail if for whatever reason CachedFactorialImplementation // is not in the class path. defaultAlgorithm = getAlgorithm("cachedAlgorithm"); } return defaultAlgorithm; } /** Get the factorial algorithm specified by name */ public static FactorialAlgorithm getAlgorithm(String name) { FactorialAlgorithm f = mapping.get(name); if (f == null) { // We haven't created an instance yet. Get it from the class mapping. Class<? extends FactorialAlgorithm> c = classMapping.get(name); if (c != null) { // Create a new instance of the factorial algorithm specified try { f = c.newInstance(); mapping.put(name, f); return f; } catch (Exception e) { // Log the error Logger.getLogger("com.chaosinmotion.factorial"). warning("Unable to instantiate algorithm " + c.getCanonicalName() + ", named " + name); } } return getDefaultAlgorithm(); // return something. } else return f; } /** Register the class so we can construct a new instance if not already initialized */ public static void registerAlgorithm(String name, Class<? extends FactorialAlgorithm> f) { classMapping.put(name, f); } }
      
      

        
        
        
      

    
        
        
        
      
      

        
        
        
      

    
     

हम FactorialUtil वर्ग को फिर से लिखते हैं ताकि यह हमारे नामांकित एल्गोरिदम का उपयोग करे:

 public class FactorialUtil { private static FactorialUtil singleton; private FactorialAlgorithm algorithm; /** * Default (internal) constructor constructs our default algorithm. */ private FactorialUtil() { String name = System.getProperty("com.chaosinmotion.factorialalgorithm", "cachedAlgorithm"); if (name == null) { algorithm = FactorialAlgorithmFactory.getDefaultAlgorithm(); } else { algorithm = FactorialAlgorithmFactory.getAlgorithm(name); } } /** * New initializer which allows selection of the algorithm mechanism * @param algorithm */ public FactorialUtil(FactorialAlgorithm a) { algorithm = a; } /** * Utility to create by name. Calls into FactorialAlgorithmFactory to * actually get the algorithm. * @param name */ public FactorialUtil(String name) { algorithm = FactorialAlgorithmFactory.getAlgorithm(name); } /** * Default public interface for handling our factorial algorithm. Uses * the old standard established earlier for calling into our utility class. * @param n * @return */ public static BigInteger factorial(int n) { if (singleton == null) { // Use default constructor which uses default algorithm singleton = new FactorialUtil(); } return singleton.doFactorial(n); } /** * New mechanism which allows us to instantiate individual factorial * utilitiy classes and invoke customized factorial algorithms directory. * @param n * @return */ private BigInteger doFactorial(int n) { // Defer to our algorithm return algorithm.factorial(n); } }
      
      

        
        
        
      

    
        
        
        
      
      

        
        
        
      

    
     

हमें स्थिर वर्ग के इनिशियलाइज़र को कैश्डफैक्टोरियल इम्प्लीमेंटेशन और लूपेड फ़ैक्टीरियल इम्प्लीमेंटेशन क्लासेस से जोड़ना होगा जो उन्हें फैक्ट्री में पंजीकृत करते हैं:

 public class CachedFactorialImplementation implements FactorialAlgorithm { static HashMap<Integer,BigInteger> cache = new HashMap<Integer,BigInteger>(); static { FactorialAlgorithmFactory.registerAlgorithm("cachedAlgorithm", CachedFactorialImplementation.class); } @Override public BigInteger factorial(int n) { BigInteger ret; if (null != (ret = cache.get(n))) return ret; ret = BigInteger.valueOf(n).multiply(factorial(n-1)); cache.put(n, ret); return ret; } }
      
      

        
        
        
      

    
        
        
        
      
      

        
        
        
      

    
     

और

 public class LoopedFactorialImplementation implements FactorialAlgorithm { static { FactorialAlgorithmFactory.registerAlgorithm("loopedAlgorithm", LoopedFactorialImplementation.class); } @Override public BigInteger factorial(int n) { BigInteger ret = BigInteger.ONE; for (int i = 1; i <= n; ++i) ret = ret.multiply(BigInteger.valueOf(i)); return ret; } }
      
      

        
        
        
      

    
        
        
        
      
      

        
        
        
      

    
     

इस आर्किटेक्चर की सबसे बड़ी खूबी यह है कि हम अपने खुद के फैक्टरियल इंप्लीमेंटेशन को फ्लाई टू फैक्टोरियलयूटिल से जोड़ सकते हैं। ऐसा करने के लिए, बस अपना स्वयं का वर्ग बनाएं जो FactorialAl एल्गोरिदम इंटरफ़ेस को लागू करता है और इसे FactorialAlgorithmFactory के माध्यम से स्थैतिक आरंभीकरण ब्लॉक में पंजीकृत करता है:

 public class RecursiveFactorialImplementation implements FactorialAlgorithm { static { FactorialAlgorithmFactory.registerAlgorithm("recursiveAlgorithm", RecursiveFactorialImplementation.class); } @Override public BigInteger factorial(int n) { if (n == 0) return BigInteger.ONE; return BigInteger.valueOf(n).multiply(factorial(n-1)); } }
      
      

        
        
        
      

    
        
        
        
      
      

        
        
        
      

    
     

अंत में, मुख्य विधि में, हम यह सुनिश्चित करते हैं कि हमारी कक्षा भरी हुई है, और सिस्टम गुण सेट करें।

  public static void main(String[] args) { try { Class.forName("com.chaosinmotion.factorial.RecursiveFactorialImplementation"); } catch (ClassNotFoundException e) { // if this fails, no matter; we'll still use the default implementation. } System.getProperties().setProperty("com.chaosinmotion.factorialalgorithm", "recursiveAlgorithm"); System.out.println("5! = " + FactorialUtil.factorial(5)); }
      
      

        
        
        
      

    
        
        
        
      
      

        
        
        
      

    
     

कोई बात नहीं! इसके अलावा, यह वास्तुकला आपको कनेक्ट करने और अधिक परिष्कृत समाधानों की अनुमति देता है, जैसे कि ये ।











मुझे यकीन है कि कई जावा प्रोग्रामर, इस स्थान पर पहुंचकर अपने सिर हिलाते हैं और इस वास्तुकला की भव्यता की प्रशंसा करते हैं। ऐसे लोग हैं जो पहले से ही "एक टिप्पणी छोड़ें" बटन दबा रहे हैं और लिखते हैं: "लानत है, आप सिस्टम गुण को इतनी दूर स्थापित करना बेहतर होगा।" उदाहरण के लिए, मैं गुणक (* .properties) या एक XML फ़ाइल वाली फ़ाइल में विभिन्न वर्गों के लिए इनिशलाइज़र लगा सकता हूं। या शायद यह बेहतर होगा यदि सिस्टम संपत्ति का मूल्य वर्ग का पूरा नाम है।



और निश्चित रूप से, ऐसे लोग हैं जिन्होंने अपनी नोटबुक में पूरे तरीके से नोट्स लिखे हैं और पहले से ही इस ब्लॉग से कोड के टुकड़े कॉपी कर रहे हैं (हाँ, यह सब कोड काम कर रहा है, मैंने इसे अपने मशीन पर परीक्षण किया है)।



लेकिन हे, यहाँ अंत में मेरा मुख्य बिंदु है



यह सब बकवास है।



प्रत्येक और हर पंक्ति।



निस्संदेह, कुछ परिस्थितियों में, एक प्लग-इन आर्किटेक्चर उपयोगी और आवश्यक भी है। लेकिन यह काफी दुर्लभ है - इतना दुर्लभ कि यह हास्यास्पद नहीं है। 99% मामलों में, जब मैंने ऐसा कोड देखा, तो यह पूरी तरह से और पूरी तरह से बेकार था। यह कोड के वास्तविक उद्देश्य को छुपाता है, दो-तीन-पंक्ति सहायक विधि की जगह दर्जनों और यहां तक ​​कि जावा में स्व-धार्मिक धूमधाम के सैकड़ों पंक्तियों के साथ। यह आपको अच्छा महसूस करने में मदद कर सकता है, लेकिन यह एक बदसूरत गड़बड़ बनाता है कि भविष्य के डेवलपर्स को प्लेग की तरह साफ करना होगा, या सबसे अधिक संभावना से बचना होगा।



और सबसे दिलचस्प, क्या आपने कुछ देखा है? इस चर्चा के दौरान, क्या आपने कुछ देखा है?



हमने कभी भी ऋणात्मक संख्याओं का ध्यान नहीं रखा है।











एक स्मार्ट जावा डेवलपर जानता है कि कब रोकना है। बादलों में महल बनाने के लिए जीवन बहुत छोटा है। वह जानता है कि एक लूप के साथ एक सरल समाधान पर्याप्त से अधिक है, और निश्चित रूप से, वह नकारात्मक संख्याओं का ध्यान रखेगा। (ठीक है, आप जानते हैं, हाँ? हमारे पुनरावर्ती समाधान एक अनंत लूप में जाएंगे यदि हम इनपुट पर एक नकारात्मक संख्या देते हैं।)



वास्तव में स्मार्ट जावा डेवलपर समस्या में गहराई से उतर सकता है और यह पता लगा सकता है कि तथ्यात्मक गामा फ़ंक्शन का एक विशेष मामला है। शायद सही समाधान कोड के उपरोक्त टुकड़ों में से कोई नहीं है, लेकिन गामा फ़ंक्शन के लिए स्टर्लिंग सन्निकटन :

 static double Gamma(double z) { double tmp1 = Math.sqrt(2*Math.PI/z); double tmp2 = z + 1.0/(12 * z - 1.0/(10*z)); tmp2 = Math.pow(z/Math.E, z); // ooops; thanks hj tmp2 = Math.pow(tmp2/Math.E, z); return tmp1 * tmp2; }
      
      

        
        
        
      

    
        
        
        
      
      

        
        
        
      

    
     

लेकिन यह पहले से ही समस्या क्षेत्र पर निर्भर करता है - जिसे हमने वास्तव में हमारे सभी कारखानों को बनाने के बारे में भी नहीं सोचा था।











जावा डेवलपर्स के लिए मेरी सबसे बड़ी शिकायत यह है कि वे वास्तव में बुरी आदतों का एक पूरा गुच्छा विकसित करते हैं। विनिर्देशों स्पष्ट नहीं हैं। उन्हें लगता है कि किसी दिन कोड को एक अलग दिशा में बढ़ाया जा सकता है। इसलिए, वे फूला हुआ वास्तु बकवास का एक पूरा गुच्छा लिखते हैं, यह विश्वास करते हुए कि एक दिन यह अतिरिक्त कचरा अचानक उनकी मदद करेगा और उनके जीवन को आसान बना देगा। और एक भाषा के रूप में जावा आपको यह जल्दी और आसानी से करने की अनुमति देता है, इसलिए हमारे लिए एक वास्तुकला का निर्माण करना आसान है जो भविष्य में किसी दिन हमारे जीवन को सरल बनाएगा।



लेकिन भविष्य कभी आसान नहीं होता, है ना?



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



और इस ढेर के माध्यम से जाने के बजाय गाँठ को खोलना या कम से कम यह समझना कि यह तंत्र कैसे काम करता है, वे वास्तुकला के ऊपर पैच को थप्पड़ मारते हैं, जैसे कि लावा प्रवाह के क्लासिक उदाहरण में । उदाहरण के लिए, वे समझ नहीं पा रहे हैं कि प्लग-इन एल्गोरिथ्म कैसे बनाया जाए, और इसलिए वे FactoryUtil क्लास को फिर से परिभाषित करते हैं या केवल FactoryUtil क्लास को फिर से लिखते हैं और वहाँ एक और सौ या दो (अ-गर्भित) कोड जोड़ते हैं, बस पिछली सौ लाइनों की गलतफहमी को भरने के लिए (अनुचित तरीके से) ) कोड।











तो कृपया हम सभी पर एक एहसान करें: यदि आपको ऐसा लगता है कि आप जटिलता को केवल इसलिए जोड़ सकते हैं क्योंकि "किसी दिन यह काम आएगा" या "सिस्टम अभी तक पर्याप्त लचीला नहीं है" या "हमारे कोड में पुन: प्रयोज्यता होनी चाहिए" या (मत देना भगवान!) क्योंकि "यह अच्छा है" - बस घर जल्दी जाओ। कार्टून देखें। या " प्रारंभ " किराए पर लें।



बिना किसी अच्छे कारण के हमें अतिरिक्त काम करने से रोकें।