सह-पुनरावृत्ति

कार्यात्मक प्रोग्रामिंग में, कोरकर्सन पहले चरण से शुरू होने वाले अगले चरण के इनपुट के रूप में एक चरण के आउटपुट का उपयोग करके चरण बनाने के बारे में है। यह बेस केस से शुरू होकर कृत्रिम रूप से काम करता है। यह एक बॉटम अप एप्रोच है जो बेस केस से डेटा उत्पन्न करता है। इसका उपयोग मनमाने ढंग से जटिल और अनंत संरचनाओं जैसे परिमित चरणों के अनुक्रम में धाराएं बनाने के लिए किया जाता है। यह अक्सर एक संभावित अनंत संरचना का एक सीमित हिस्सा उत्पन्न करने के लिए आलसी मूल्यांकन के साथ प्रयोग किया जाता है।

प्रत्यावर्तन

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

रिकर्सन के भाग।

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

यह किसी भी पुनरावर्ती विधि के लिए मूल सिंटैक्स है।

<access-specifier> <modifier> <return-type> methodName(formal-arguments-list) {
 if(base condition)
  return something..
 return methodName(simpler-formal-arguments-list);
}

public int fibonacciSeries(int n) {
 if(n <= 1)
  return 1;
 return fibonacciSeries(n-1) + fibonacciSeries(n-2);
}

फ्रैक्टल पेड़ एक प्रकार का पैटर्न है जो स्वयं समानता प्रदर्शित करता है जिसका अर्थ है कि वे विभिन्न पैमानों पर एक ही आकार या पैटर्न को दोहराते हैं। ऐसे कई एल्गोरिदम हैं जो फ्रैक्टल पेड़ उत्पन्न करने में आपकी सहायता कर सकते हैं लेकिन हमेशा की तरह, सबसे सरल पुनरावर्ती दृष्टिकोण है।

पुनरावर्तन अधिक से अधिक चर परिभाषित करने के प्रयास को कम करता है और स्पेगेटी कोड बनाने से बचता है।

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

आगे बढ़ने के लिए आपको क्या चाहिए?

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

शुरू करना..

आइए फ्रैक्टल ट्री बनाने के लिए एल्गोरिथम को समझते हैं और लिखना शुरू करते हैं।

कलन विधि

1. एक विधि drawFractalTree(int, int, int, int) को परिभाषित करें जो शाखा के प्रारंभिक निर्देशांक (x,y) लेता है, शाखाओं के बीच का कोण ऊर्ध्वाधर के संबंध में कोण, और फ्रैक्टल पेड़ की ऊंचाई की ऊंचाई ।
2. बेस केस: हमें यह समझना चाहिए कि यदि कोई उपयोगकर्ता पेड़ की ऊंचाई 0 के रूप में निर्दिष्ट करता है, तो हमें दूसरी शाखा बनाने के लिए आगे नहीं बढ़ना चाहिए। और इसलिए यह हमारे प्रोग्राम का बेस केस बन जाता है। यहीं पर हमारी पुनरावर्ती कॉलें समाप्त होंगी।
3. रेडियन में कोण दिए जाने पर पूर्वनिर्धारित गणित कार्यों की मदद से फ्रैक्टल ट्री शाखा के अगले निर्देशांक की गणना करें ।

y-coord = sin(angleRad) * ऊँचाई * गहराई

4. यह भग्न शाखा के अन्य दो निर्देशांक उत्पन्न करने का एकमात्र तरीका है। दो x निर्देशांक और दो y-निर्देशांक दिए गए हैं, हम ग्राफिक्स वर्ग के ड्रॉलाइन (int, int, int, int) फ़ंक्शन का उपयोग करके दो बिंदुओं को जोड़ सकते हैं।

5. अब हम drawFractalTree विधि को फिर से लागू करते हैं लेकिन कुछ संशोधित कोण और कम ऊंचाई के साथ।

कार्यक्रम।

प्रोग्रामिंग समस्या का हर स्पष्टीकरण छद्म कोड के बिना कुछ भी नहीं है। यहां बताया गया है कि आप ड्राफ्रैक्टलट्री विधि को कैसे लागू करेंगे।

void drawFractalTree( x, y, angle, height) :
 if height == 0
  return
 
 x2 = cos( toRadians(angle) ) * height * depth
 y2 = sin( toRadians(angle) ) * height * depth
 
 drawLine(x, y, x2, y2)

 drawFractalTree(x2, y2, angle - 10, height - 1)

1. चालक वर्ग बनाना: यह अनुप्रयोग वर्ग में रन विधि को लागू करके अनुप्रयोग प्रारंभ करेगा।

package com.projectjava;

public class Main {
 public static void main(String[] args) {
  Application.run(args);
 }
}

package com.projectjava;

import java.swing.JFrame;

public class Application extends JFrame {
 ...
}

public static void run(String[] args) {
 var app = new Application();
 app.setSize(700, 700);
 app.setVisible(true);
 app.setTitle("Fractal Trees");
}

public Application() {
  this.setDefaultCloseOperation(JFrame.EXIT_ON_CLOSE);
  this.setResizable(false);
}

@Override
public void paint(Graphics g) {
 drawFractalTree(250, 650, -90, 10);
}

public void drawFractalTree(int x, int y, int angle, int height, Graphics g) {
 if (height == 0)
  return;
 
 int x2 = (int)Math.cos(Math.toRadians(angle)) * height * 10;
 int y2 = (int)Math.sin(Math.toRadians(angle)) * height * 10;
 g.setColor(Color.WHITE);
 g.drawLine(x, y, x2, y2);

 drawFractalTree(x2, y2, angle-20, height-1);
 drawFractalTree(x2, y2, angle+20, height-1);

}

if(height == 0) {
 g.setColor(Color.RED);
 g.fillOval(x-2, y, 5, 5);
}

https://youtu.be/R0ePX8UO52w

इस पोस्ट के लिए बस इतना ही, इसे पढ़ने के लिए धन्यवाद। मुझे आशा है कि आप रिकर्सन के अनुप्रयोगों को समझ गए होंगे। धन्यवाद!!