एसएएस

Question

में किसी सरणी के सभी अद्वितीय क्रमपरिवर्तन उत्पन्न एसएएस में अगर मैं एक स्ट्रिंग या निम्नलिखित की तरह एक सरणी है,

array x[4] $1 ('A' 'B' 'C' 'D'); 

मैं निम्नलिखित जैसे तत्वों के सभी "अद्वितीय" क्रमपरिवर्तन उत्पन्न करने के लिए की जरूरत है,

[ABCD] 
[ABC] 
[BCD] 
[ACD] 
[ABD] 
[AB] 
[AC] 
[AD] 
[BC] 
[BD] 
[CD] 
[A] 
[B] 
[C] 
[D] 

क्या एसएएस में सरणी के सभी संभावित संयोजन उत्पन्न करने के लिए कोई फ़ंक्शन है?

Answer 1

एसएएस में संयोजन & क्रमपरिवर्तन, allcomb और allperm की गणना करने के लिए अंतर्निहित कार्य हैं। ALLCOMB समारोह के लिए

एसएएस प्रलेखन: http://support.sas.com/documentation/cdl/en/lrdict/64316/HTML/default/viewer.htm#a003112305.htm

Answer 2

धारणा: मेरा मानना ​​है कि आप combinations और नहीं permutations लिए देख रहे हैं, तो आदेश कोई फर्क नहीं पड़ता, BA और AB एक ही बात कर रहे हैं।

संभव संयोजनों को जानने के लिए call allcomb सबराउटिन और comb फ़ंक्शन का उपयोग करें।

और पढ़ें के बारे में allcomb और comb यहाँ

• http://support.sas.com/documentation/cdl/en/lefunctionsref/63354/HTML/default/viewer.htm#p0yx35py6pk47nn1vyrczffzrw25.htm

और यहाँ

• http://support.sas.com/documentation/cdl/en/lrdict/64316/HTML/default/viewer.htm#a001009658.htm

शोर में टी -

• call allcomb सबरूटीन n तत्वों से बाहर संभव संयोजनों देता है जब उनमें से r लिया जाता है और
• comb समारोह आप देता है जब n तत्वों से बाहर उनमें से r एक में लिया जाता है कितने संयोजनों का यह होगा पहर।

---

data test(keep=my_string); 
length my_string $50.; 
    array a[4] $ ('A' 'B' 'C' 'D'); 

    n = dim(a); 

    do k=1 to n; 
     do j=1 to comb(n,k); 
      call allcomb(j,k,of a[*]); 
       do i = 1 to k; 
        if i=1 then do; my_string="";counter=0;end; 
        counter=counter+1; 
        my_string=cat(compress(my_string),compress(a[i])); 
       if counter=k then output; 

       end; 
      end; 
    end; 
run; 

Answer 3

यहां एक त्वरित स्क्रिप्ट है कि एक स्ट्रिंग के भीतर अलग-अलग पात्रों के संयोजन मिल जाएगा है। यदि आप चाहें तो इसे आसानी से सरणी के साथ काम करने के लिए अनुकूलित किया जा सकता है। संयोजन कार्यों और कॉल दिनचर्या (all*, lex*, ran*) का उपयोग करने के बजाय यह दृष्टिकोण 2**len तक पूर्णांक के द्विआधारी प्रतिनिधित्व का उपयोग करके क्रमपरिवर्तन बनाता है। मैं इस दृष्टिकोण को पसंद करता हूं क्योंकि मुझे लगता है कि यह दिखाता है कि क्या हो रहा है, अधिक पारदर्शी है और सरणी असाइनमेंट के क्रम को नहीं बदलता है।

data have; 
    str = "123456"; output; 
    str = "ABCD"; output; 
run; 
data want; 
    set have; 
    length comb $20.; 
    len = length(str); 
    /* Loop through all possible permutations */ 
    do _i = 0 to 2**len - 1; 
     /* Store the current iteration number in binary */ 
     _bin = putn(_i, "binary" || put(len, best.) || "."); 
     /* Initialise an empty output variable */ 
     comb = ""; 
     /* Loop through each value in the input string */ 
     do _k = 1 to len; 
      /* Check if the kth digit of the binary representation is 1 */ 
      /* And if so add the kth input character to the output */ 
      if substr(_bin, _k, 1) = "1" then 
       comb = cats(comb, substr(str, _k, 1)); 
     end; 
     output; 
    end; 
    /* Clean up temporary variables, commented so you can see what's happening */ 
/* drop _:; */ 
run; 

---

तुम क्या हैं क्रमपरिवर्तन तो चाहते हैं एक similar approach संख्या के factoradic अभ्यावेदन का उपयोग कर सकता है।लेकिन, मैं अनुशंसा करता हूं कि आप एक संयोजन समारोह का उपयोग करें क्योंकि रूपांतरण अधिक शामिल होंगे। यह शायद सीखने के लिए काफी अच्छा कोडिंग अभ्यास है।

---

यह अगर एसएएस बूलियन पैटर्न से तार को कम करने के लिए एक समारोह था बहुत अच्छा होगा, लेकिन यह शायद ज्यादा उपयोग नहीं मिलेगा।

bsubstr("ABCD", "1010") --> "AC" 
bsubstr("ABCD", "1110") --> "ABC" 
bsubstr("ABCD", "0001") --> "D" 

Answer 4

proc summary का उपयोग करने के लिए थोड़ा अलग लेना है।

एक डमी डेटासेट बनाएं। एक चर के लिए सरणी के प्रत्येक तत्व सौंपें ताकि हम इसे proc summary में फ़ीड कर सकते हैं:

data tmp; 
    array arr[*] a b c d (1 1 1 1); 
run; 

भागो proc summary।

proc summary data=tmp noprint missing; 
    class a b c d; 
    output out=combinations; 
run; 

तुम भी proc summary में ways या types बयानों का उपयोग किसी भी संयोजन आप चाहते हो सकता है सीमित करने के लिए कर सकते हैं।

अब ऐसा करने का दिलचस्प पक्ष प्रभाव यह है कि आपको आउटपुट डेटासेट में _type_ कॉलम भी मिलता है। निम्न मान ऊपर के उदाहरण में निर्दिष्ट किया जाएगा:

D = 1 
C = 2 
B = 4 
A = 8 

तो अगर उत्पादन डेटासेट में _type_ मूल्य 13 है, तो हम जानते हैं कि पंक्ति के संयोजन ए, बी और डी (8 4 द्वारा उत्पन्न की गई + 1)।