यादृच्छिक गणित अभिव्यक्ति उत्पन्न करना

Question

यादृच्छिक गणितीय अभिव्यक्तियों को उत्पन्न करने और उनका मूल्यांकन करने के लिए मेरे पास यह विचार मेरे दिमाग में घूम रहा है। इसलिए, मैंने इसे परीक्षण करने के लिए कोडिंग करने से पहले, इसे एक शॉट देने और एक एल्गोरिथ्म को विस्तृत करने का फैसला किया।

उदाहरण:

यहाँ कुछ उदाहरण अभिव्यक्तियाँ हैं जिन्हें मैं बेतरतीब ढंग से उत्पन्न करना चाहता हूँ:

4 + 2                           [easy]
3 * 6 - 7 + 2                   [medium]
6 * 2 + (5 - 3) * 3 - 8         [hard]
(3 + 4) + 7 * 2 - 1 - 9         [hard]
5 - 2 + 4 * (8 - (5 + 1)) + 9   [harder]
(8 - 1 + 3) * 6 - ((3 + 7) * 2) [harder]

आसान और मध्यम लोगों सुंदर सीधी-सपाट हैं। intबेतरतीब ऑपरेटरों द्वारा रैंडम एस को अलग किया गया, यहां कुछ भी पागल नहीं है। लेकिन मुझे कुछ परेशानी शुरू हो रही है, जो कठिन और कठिन उदाहरणों में से एक बना सकती है । मुझे यकीन नहीं है कि एक एकल एल्गोरिथ्म मुझे अंतिम दो दे सकता है।

मैं क्या विचार कर रहा हूं:

मैं यह नहीं कह सकता कि मैंने उन विचारों को आजमाया , क्योंकि मैं वास्तव में उस दिशा में जाने में ज्यादा समय बर्बाद नहीं करना चाहता था, जिसमें पहली बार काम करने का कोई मौका नहीं था। लेकिन फिर भी, मैंने कुछ समाधानों के बारे में सोचा:

• पेड़ों का उपयोग करना
• नियमित अभिव्यक्ति का उपयोग करना
• एक पागल "फॉर-टाइप" लूप का उपयोग करना (निश्चित रूप से सबसे खराब)

मैं जिस चीज़ की तलाश कर रहा हूँ:

मैं जानना चाहता हूं कि आप किस रास्ते पर जाना चाहते हैं, जो मैंने सोचा था, और आपके खुद के विचारों के बीच जाना सबसे अच्छा है।

यदि आप शुरू करने का एक अच्छा तरीका देखते हैं, तो मैं सही दिशा में एक लीड की सराहना करूँगा, जैसे कि एल्गोरिथ्म की शुरुआत, या इसकी एक सामान्य संरचना।

यह भी ध्यान दें कि मुझे उन भावों का मूल्यांकन करना होगा। यह अभिव्यक्ति उत्पन्न होने के बाद या इसके निर्माण के दौरान भी किया जा सकता है। यदि आप इसे अपने उत्तर में ध्यान में रखते हैं, तो यह बहुत अच्छा है।

मैं कुछ भी भाषा से संबंधित नहीं देख रहा हूं, लेकिन रिकॉर्ड के लिए, मैं इसे ऑब्जेक्टिव-सी में लागू करने के बारे में सोच रहा हूं, क्योंकि हाल ही में मैं जिस भाषा के साथ काम कर रहा हूं।

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

यदि मेरे प्रश्न को किसी स्पष्टीकरण की आवश्यकता है, तो कृपया टिप्पणियों में पूछें। आपकी सहायता के लिए धन्यवाद।

Comments

हम्म, एक फिटनेस फ़ंक्शन जोड़ें और ऐसा लगता है कि आप आनुवंशिक प्रोग्रामिंग की ओर जा रहे हैं ।

— फिलिप

Answer 1

यहां आपकी समस्या की एक सैद्धांतिक व्याख्या है।

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

E -> I 
E -> (E '+' E)
E -> (E '*' E)

यहाँ, Eएक अभिव्यक्ति है (यानी, आपकी भाषा का एक शब्द) और Iएक टर्मिनल प्रतीक है (यानी, यह किसी भी आगे का विस्तार नहीं है) एक पूर्णांक का प्रतिनिधित्व करता है। उपरोक्त परिभाषा Eमें तीन उत्पादन नियम हैं । इस परिभाषा के आधार पर, हम यादृच्छिक रूप से एक मान्य अंकगणित का निर्माण इस प्रकार कर सकते हैं:

1. Eआउटपुट शब्द के एकल चिह्न के रूप में शुरू करें ।
2. गैर-टर्मिनल प्रतीकों में से एक यादृच्छिक रूप से समान रूप से चुनें।
3. उस प्रतीक के उत्पादन नियमों में से एक यादृच्छिक रूप से समान रूप से चुनें, और इसे लागू करें।
4. चरण 2 - 4 को तब तक दोहराएं जब तक कि केवल टर्मिनल चिन्ह न बचे हों।
5. सभी टर्मिनल प्रतीकों Iको यादृच्छिक पूर्णांक द्वारा बदलें ।

यहाँ इस एल्गोरिदम के आवेदन का एक उदाहरण है:

E
(E + E)
(E + (E * E))
(E + (I * E))
((E + E) + (I * E))
((I + E) + (I * E))
((I + E) + (I * I))
((I + (E * E)) + (I * I))
((I + (E * I)) + (I * I))
((I + (I * I)) + (I * I))
((2 + (5 * 1)) + (7 * 4))

मुझे लगता है कि आप एक इंटरफ़ेस के साथ एक अभिव्यक्ति का चयन करना पसंद करेंगे Expressionजो कक्षाओं द्वारा कार्यान्वित किया जाता है IntExpression, AddExpressionऔर MultiplyExpression। बाद के दो फिर एक के लिए होता है leftExpressionऔर rightExpression। सभी Expressionउपवर्गों को एक evaluateविधि को लागू करने की आवश्यकता होती है , जो इन वस्तुओं द्वारा परिभाषित पेड़ की संरचना पर पुनरावर्ती रूप से काम करता है और समग्र पैटर्न को प्रभावी ढंग से लागू करता है ।

ध्यान दें कि उपरोक्त व्याकरण और एल्गोरिथ्म के लिए, एक अभिव्यक्ति Eको एक टर्मिनल प्रतीक Iमें p = 1/3विस्तारित करने की संभावना केवल है , जबकि एक अभिव्यक्ति को दो और अभिव्यक्तियों में विस्तारित करने की संभावना है 1-p = 2/3। इसलिए, उपरोक्त एल्गोरिथ्म द्वारा निर्मित सूत्र में पूर्णांकों की अपेक्षित संख्या वास्तव में अनंत है। एक अभिव्यक्ति की अपेक्षित लंबाई पुनरावृत्ति संबंध के अधीन है

l(0) = 1
l(n) = p * l(n-1) + (1-p) * (l(n-1) + 1)
     = l(n-1) + (1-p)

जहां उत्पादन नियमों के अनुप्रयोगों के l(n)बाद अंकगणितीय अभिव्यक्ति की अपेक्षित लंबाई को दर्शाता nहै। इसलिए मेरा सुझाव है कि आप pनियम के लिए एक उच्च संभावना प्रदान करते हैं E -> Iजैसे कि आप उच्च संभावना के साथ एक काफी छोटी अभिव्यक्ति के साथ समाप्त होते हैं।

संपादित करें : यदि आप चिंतित हैं कि उपर्युक्त व्याकरण बहुत अधिक कोष्ठक का निर्माण करता है, तो सेबस्टियन नेग्रास्ज़स के उत्तर को देखें , जिसका व्याकरण इस समस्या से बहुत ही स्पष्टता से बचता है।

Comments

वाह .. यह बहुत अच्छा है, मुझे बहुत पसंद है, धन्यवाद! मुझे अभी भी सही विकल्प बनाने के लिए सुझाए गए सभी समाधानों में थोड़ा और देखना होगा। फिर से धन्यवाद, शानदार जवाब।

— रदुरंड

आपके संपादन के लिए धन्यवाद, यह कुछ ऐसा है जिसके बारे में मैंने नहीं सोचा था। क्या आपको लगता है कि कदम 2-4 से गुजरने की संख्या को सीमित करने से काम चल सकता है? 4, (या जो भी) कदम 2-4 की पुनरावृत्ति के बाद, केवल नियम E-> I की अनुमति दें ?

— रदुरंड

@ श्रद्धानंद: हां, बिल्कुल। m2-4 के पुनरावृत्तियों के बाद कहें , आप पुनरावर्ती उत्पादन नियमों की उपेक्षा करते हैं। इससे अपेक्षित आकार की अभिव्यक्ति होगी l(m)। हालाँकि, ध्यान दें कि यह (सैद्धांतिक रूप से) आवश्यक नहीं है, क्योंकि अनंत अभिव्यक्ति उत्पन्न करने की संभावना शून्य है, भले ही अपेक्षित आकार अनंत हो। हालाँकि, आपका दृष्टिकोण अभ्यास के बाद से अनुकूल है, स्मृति न केवल परिमित है, बल्कि छोटी भी है

— blubb

आपके समाधान के साथ, मुझे ऐसा कोई रास्ता नहीं दिखाई दे रहा है जिसे बनाते समय मैं अभिव्यक्ति को हल कर सकूं। क्या वहाँ कोई ? मैं अभी भी बाद में इसे हल कर सकता हूं, लेकिन मैं नहीं कर सकता।

— रदुरंद

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

— 12 फरवरी को मिक्लोकाक

Answer 2

सबसे पहले मैं वास्तव में पोस्टफिक्स नोटेशन में अभिव्यक्ति उत्पन्न करूंगा , आप अपनी यादृच्छिक अभिव्यक्ति को उत्पन्न करने के बाद आसानी से इन्फिक्स में बदल सकते हैं या मूल्यांकन कर सकते हैं, लेकिन इसे पोस्टफिक्स में करने का मतलब है कि आपको कोष्ठक या पूर्वता के बारे में चिंता करने की आवश्यकता नहीं है।

मैं आपकी अभिव्यक्ति में अगले ऑपरेटर के लिए उपलब्ध शब्दों की संख्या का एक कुल भाग भी रखूंगा (यह मानकर कि आप ऐसे भाव उत्पन्न करने से बचना चाहते हैं जो विकृत हैं) अर्थात कुछ इस तरह से:

string postfixExpression =""
int termsCount = 0;
while(weWantMoreTerms)
{
    if (termsCount>= 2)
    {
         var next = RandomNumberOrOperator();
         postfixExpression.Append(next);
         if(IsNumber(next)) { termsCount++;}
         else { termsCount--;}
    }
    else
    {
       postfixExpression.Append(RandomNumber);
       termsCount++;
     }
}

स्पष्ट रूप से यह छद्म कोड है इसलिए परीक्षण नहीं किया गया है / इसमें गलतियाँ हो सकती हैं और आप शायद स्ट्रिंग का उपयोग नहीं करेंगे लेकिन कुछ भेदभावपूर्ण संघ का एक प्रकार

Comments

वर्तमान में यह माना जाता है कि सभी ऑपरेटर द्विआधारी हैं, लेकिन विभिन्न एरिटी

— jk के

बहुत बहुत धन्यवाद। मैंने RPN के बारे में नहीं सोचा, यह एक अच्छा विचार है। मैं एक को स्वीकार करने से पहले सभी उत्तरों पर ध्यान दूंगा, लेकिन मुझे लगता है कि मैं यह काम कर सकता हूं।

— रदुरंड

फिक्स के बाद के लिए +1। आप एक स्टैक से अधिक कुछ भी उपयोग करने की आवश्यकता को समाप्त कर सकते हैं, जो मुझे लगता है कि एक पेड़ बनाने की तुलना में सरल है।

— नील

@rdurand पोस्ट-फ़िक्स के लाभ का मतलब है कि आपको पूर्व-निर्धारण के बारे में चिंता करने की ज़रूरत नहीं है (इसे पहले से ध्यान में रखा गया है कि इसे पोस्ट-फ़िक्स स्टैक में जोड़ने से पहले)। जिसके बाद, आप बस तब तक मिलने वाले सभी ऑपरेशंस को पॉप करते हैं जब तक कि आप स्टैक पर मिलने वाले पहले ऑपरेटर को पॉप नहीं कर लेते हैं और फिर स्टैक पर परिणाम को धक्का देते हैं और जब तक आप स्टैक से अंतिम मान नहीं निकालते हैं तब तक आप इस तरह से जारी रखते हैं।

— नील

@rdurand अभिव्यक्ति 2+4*6-3+7पोस्ट-फिक्स स्टैक में परिवर्तित हो जाती है + 7 - 3 + 2 * 4 6( स्टैक का शीर्ष दाईं ओर सबसे अधिक)। आप 4 और 6 को धक्का देते हैं और ऑपरेटर को लागू करते हैं *, फिर आप 24 को पीछे धकेलते हैं। आप फिर 24 और 2 पॉप करते हैं और ऑपरेटर + लगाते हैं, फिर आप 26 को पीछे धकेलते हैं। आप इस तरह से जारी रखते हैं और आप पाएंगे कि आपको सही उत्तर मिल जाएगा। सूचना है कि * 4 6कर रहे हैं पहली स्टैक पर शर्तों। इसका मतलब है कि यह किया जाता है पहले क्योंकि आपने पहले से ही बिना किसी कोष्ठक की आवश्यकता के पूर्व निर्धारित किया है।

— नील

Answer 3

ब्लूब का जवाब एक अच्छी शुरुआत है, लेकिन उनका औपचारिक व्याकरण बहुत सारे परांठे बनाता है।

यहाँ पर इसे ले रहा हूँ:

E -> I
E -> M '*' M
E -> E '+' E
M -> I
M -> M '*' M
M -> '(' E '+' E ')'

Eएक अभिव्यक्ति है, Iएक पूर्णांक है और Mएक अभिव्यक्ति है जो एक गुणन ऑपरेशन के लिए एक तर्क है।

Comments

अच्छा विस्तार, यह निश्चित रूप से कम बरबाद दिखता है!

— ब्लूब

जैसा कि मैंने ब्लूब के उत्तर पर टिप्पणी की है, मैं कुछ अवांछित कोष्ठक रखूंगा। शायद रैंडम "कम यादृच्छिक";) ऐड-ऑन के लिए धन्यवाद!

— रदुरंद

Answer 4

"कठिन" अभिव्यक्ति में कोष्ठक मूल्यांकन के आदेश का प्रतिनिधित्व करते हैं। सीधे प्रदर्शित रूप को उत्पन्न करने की कोशिश करने के बजाय, बस यादृच्छिक क्रम में ऑपरेटरों की एक सूची के साथ आते हैं, और उस से अभिव्यक्ति के प्रदर्शन रूप को प्राप्त करते हैं।

नंबर: 1 3 3 9 7 2

ऑपरेटर: + * / + *

परिणाम: ((1 + 3) * 3 / 9 + 7) * 2

प्रदर्शन फ़ॉर्म को प्राप्त करना अपेक्षाकृत सरल पुनरावर्ती एल्गोरिदम है।

अद्यतन: यहाँ प्रदर्शन फॉर्म जनरेट करने के लिए पर्ल में एक एल्गोरिथ्म है। क्योंकि +और *वितरण योग्य हैं, यह उन ऑपरेटरों के लिए शर्तों के क्रम को यादृच्छिक करता है। यह एक तरफ से सभी कोष्ठक को बनाए रखने में मदद करता है।

use warnings;
use strict;

sub build_expression
{
    my ($num,$op) = @_;

    #Start with the final term.
    my $last_num = pop @$num; 
    my $last_op = pop @$op;

    #Base case: return the number if there is just a number 
    return $last_num unless defined $last_op;

    #Recursively call for the expression minus the final term.
    my $rest = build_expression($num,$op); 

    #Add parentheses if there is a bare + or - and this term is * or /
    $rest = "($rest)" if ($rest =~ /[+-][^)]+$|^[^)]+[+-]/ and $last_op !~ /[+-]/);

    #Return the two components in a random order for + or *.
    return $last_op =~ m|[-/]| || rand(2) >= 1 ? 
        "$rest $last_op $last_num" : "$last_num $last_op $rest";        
}

my @numbers   = qw/1 3 4 3 9 7 2 1 10/;
my @operators = qw|+ + * / + * * +|;

print build_expression([@numbers],[@operators]) , "\n";

Comments

यह एल्गोरिदम हमेशा असंतुलित पेड़ों को उत्पन्न करने के लिए लगता है: बाईं शाखा गहरी है, जबकि दाईं ओर केवल एक ही संख्या है। प्रत्येक अभिव्यक्ति की शुरुआत में बहुत अधिक खुलने वाले परान होंगे, और संचालन का क्रम हमेशा दाएं से बाएं होता है।

— स्क्रिप्टिन

आपके उत्तर के लिए धन्यवाद, डैन, यह मदद करता है। लेकिन @ सिस्क्रिप्टिन, मुझे समझ नहीं आ रहा है कि आपको इस उत्तर में क्या पसंद नहीं है? क्या आप थोड़ा समझा सकते हैं?

— रदुरंड

@ सिस्क्रिप्टिन, जिसे प्रदर्शन क्रम के सरल यादृच्छिककरण के साथ तय किया जा सकता है। अद्यतन देखें।

@rdurand @ dan1111 मैंने स्क्रिप्ट की कोशिश की है। बड़े बाएँ सबट्री का मुद्दा तय हो गया है, लेकिन उत्पन्न पेड़ अभी भी बहुत असंतुलित है। यह तस्वीर दिखाती है कि मेरा क्या मतलब है। यह एक समस्या माना नहीं किया जा सकता है, लेकिन यह स्थिति है जहाँ subexpressions पसंद की ओर जाता है (A + B) * (C + D)कर रहे हैं कभी नहीं उत्पन्न भाव में प्रस्तुत किया, और वहाँ भी नेस्टेड कोष्ठक के एक बहुत हैं।

— पटकथा

@ सिस्क्रिप्टिन, इस बारे में सोचने के बाद, मैं मानता हूं कि यह एक समस्या है।

Answer 5

पेड़ के दृष्टिकोण पर विस्तार करने के लिए, मान लें कि प्रत्येक नोड या तो एक पत्ती या एक द्विआधारी अभिव्यक्ति है:

Node := Leaf | Node Operator Node

ध्यान दें कि एक पत्ता सिर्फ एक यादृच्छिक रूप से उत्पन्न पूर्णांक है।

अब, हम बेतरतीब ढंग से एक पेड़ उत्पन्न कर सकते हैं। पत्ती होने के कारण प्रत्येक नोड की संभावना तय करना हमें अपेक्षित गहराई को नियंत्रित करने की अनुमति देता है, हालांकि आप एक अधिकतम अधिकतम गहराई भी चाहते हैं:

Node random_tree(leaf_prob, max_depth)
    if (max_depth == 0 || random() > leaf_prob)
        return random_leaf()

    LHS = random_tree(leaf_prob, max_depth-1)
    RHS = random_tree(leaf_prob, max_depth-1)
    return Node(LHS, RHS, random_operator())

फिर, पेड़ को छापने का सबसे सरल नियम ()प्रत्येक गैर-पत्ती की अभिव्यक्ति के चारों ओर लपेटना और ऑपरेटर पूर्वता के बारे में चिंता करने से बचना है।

---

उदाहरण के लिए, यदि मैं आपकी अंतिम नमूना अभिव्यक्ति को छोटा करता हूं:

(8 - 1 + 3) * 6 - ((3 + 7) * 2)
((((8 - 1) + 3) * 6) - ((3 + 7) * 2))

आप उस पेड़ को पढ़ सकते हैं जो इसे उत्पन्न करेगा:

                    SUB
                  /      \
               MUL        MUL
             /     6     /   2
          ADD          ADD
         /   3        3   7
       SUB
      8   1

Answer 6

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

Comments

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

— रदुरंड

Answer 7

यहाँ Blubb के उत्कृष्ट उत्तर को थोड़ा अलग लिया गया है:

यहां आप जो बनाने की कोशिश कर रहे हैं, वह अनिवार्य रूप से एक पार्सर है जो रिवर्स में संचालित होता है। आपकी समस्या और पार्सर आम तौर पर एक संदर्भ-मुक्त व्याकरण है , यह बैकस-नौर रूप में है :

digit ::= '0' | '1' | '2' | '3' | '4' | '5' | '6' | '7' | '8' | '9'
number ::= <digit> | <digit> <number>
op ::= '+' | '-' | '*' | '/'
expr ::= <number> <op> <number> | '(' <expr> ')' | '(' <expr> <op> <expr> ')'

पार्सर्स टर्मिनलों की धारा के साथ शुरू होते हैं (जैसे कि शाब्दिक टोकन 5या *) और उन्हें नॉनटर्मल (टर्मिनलों और अन्य गैर-वैमानिकों से बनी चीजें, जैसे numberयाop ) । आपकी समस्या नॉनटर्मनल के साथ शुरू होती है और रिवर्स में काम करती है, "या" (पाइप) प्रतीकों के बीच कुछ भी उठाती है जब एक सामना करना पड़ता है और टर्मिनल तक पहुंचने तक प्रक्रिया को दोहराता है।

अन्य उत्तरों में से एक जोड़े ने सुझाव दिया है कि यह एक पेड़ की समस्या है, जो कि एक निश्चित संकीर्ण वर्ग के मामलों के लिए है, जहां कोई भी गैर-विधर्मी नहीं है जो खुद को प्रत्यक्ष या अप्रत्यक्ष रूप से एक और गैर-माध्यम से संदर्भित करता है। चूंकि व्याकरण अनुमति देता है कि, यह समस्या वास्तव में एक निर्देशित ग्राफ है । (अप्रत्यक्ष संदर्भ के माध्यम से एक और nonterminals के रूप में अच्छी तरह से इस ओर)

1980 के दशक के उत्तरार्ध में यूज़नेट पर प्रकाशित स्प्यू नामक एक कार्यक्रम था, जो मूल रूप से यादृच्छिक टैलोइड सुर्खियां उत्पन्न करने के लिए बनाया गया था और इन "रिवर्स ग्रामर" के साथ प्रयोग करने के लिए एक महान वाहन भी होता है। यह एक टेम्पलेट को पढ़कर संचालित होता है जो टर्मिनलों की एक यादृच्छिक धारा के उत्पादन को निर्देशित करता है। इसके मनोरंजन मूल्य से परे (सुर्खियों में, देश के गीतों, उच्चारण योग्य अंग्रेजी जिबरिश), मैंने कई टेम्प्लेट्स लिखे हैं जो टेस्ट डेटा जनरेट करने के लिए उपयोगी हैं जो कि सादे पाठ से XML से लेकर सिंटैक्टली-सही-लेकिन-असंगत सी। 26 साल की उम्र के बावजूद हैं। और K & R C में लिखा है और एक बदसूरत टेम्पलेट प्रारूप है, यह सिर्फ ठीक संकलित करता है और विज्ञापित के रूप में काम करता है। मैंने एक खाका तैयार किया है जो आपकी समस्या को हल करता है और इसे पास्टबिन पर पोस्ट करता है चूँकि यहाँ बहुत अधिक पाठ जोड़ना उचित नहीं है।