एक 1 आयामी सरणी का स्थानांतरण करें, जो

Question

पर एक वर्ग का प्रतिनिधित्व नहीं करता है, यह प्रश्न this जैसा है, लेकिन एक वर्ग का प्रतिनिधित्व करने वाले सरणी के बजाय, मुझे आयताकार सरणी को स्थानांतरित करने की आवश्यकता है।

तो, चौड़ाई दी गई: x और ऊंचाई: y, मेरी सरणी में x * y तत्व हैं।

तो चौड़ाई 4 और ऊंचाई 3 है, और मेरे पास है:

{0,1,2,3,4,5,6,7,8,9,10,11} 

जो मैट्रिक्स प्रतिनिधित्व करता है:

0 1 2 3 
4 5 6 7 
8 9 10 11 

मैं चाहूँगा:

{0,4,8,1,5,9,2,6,10,3,7,11} 

मुझे पता है कि एक नई सरणी बनाकर ऐसा करने के लिए, लेकिन मैं जानना चाहता हूं कि इसे previously mentioned question के समाधान की तरह कैसे किया जाए।

Answer 1

एक तरह से, अपनी नई स्थिति के लिए मूल मैट्रिक्स के प्रत्येक मौजूदा तत्व स्थानांतरित करने के लिए, देखभाल करने के valu लेने के लिए है ई गंतव्य सूचकांक पर पहले, ताकि इसे अपनी नई स्थिति में भी स्थानांतरित किया जा सके।

X_new = ((N*X)/(M*N)) + ((N*X) % (M*N)) 

जहां "/" ऑपरेटर पूर्णांक प्रभाग (भागफल) और "%" का प्रतिनिधित्व करता है सापेक्ष ऑपरेटर (है: एक मनमाना NxM मैट्रिक्स के लिए, सूचकांक एक्स पर एक तत्व के गंतव्य सूचकांक के रूप में गणना की जा सकती शेष) - मैं यहां पाइथन सिंटैक्स का उपयोग कर रहा हूं।

समस्या यह है कि यदि आप मनमाने ढंग से स्थान शुरू करते हैं तो आपको अपने मैट्रिक्स में सभी तत्वों को पार करने की गारंटी नहीं है। इसके आस-पास काम करने का सबसे आसान तरीका है, उन तत्वों का बिटमैप बनाए रखना जो उनकी सही स्थिति में स्थानांतरित हो गए हैं।

M = 4 
N = 3 
MN = M*N 

X = range(0,MN) 

bitmap = (1<<0) + (1<<(MN-1)) 
i = 0 

while bitmap != ((1<<MN) - 1): 
    if (bitmap & (1<<i)): 
     i += 1 
     xin = X[i] 
     i = ((N*i)/MN) + ((N*i) % MN) 
    else: 
     xout = X[i] 
     X[i] = xin 
     bitmap += (1<<i) 
     i = ((N*i)/MN) + ((N*i) % MN) 
     xin = xout 

print X 

मैं यहाँ स्पष्टता के लिए कुछ अनुकूलन का बलिदान किया है:

यहाँ कुछ अजगर कोड है कि इस को प्राप्त होता है। बिटमैप से बचने के लिए अधिक जटिल एल्गोरिदम का उपयोग करना संभव है - यदि आप गणना की लागत पर स्मृति को सहेजने के लिए वास्तव में गंभीर हैं तो संबंधित Wikipedia article में संदर्भों पर नज़र डालें।

Answer 2

जगह में स्थानांतरित करने का एक आसान तरीका मैट्रिक्स के पीछे से प्रत्येक तत्व को स्थानांतरित करना है। आप केवल इतना उदाहरण के लिए, [0,1,2,3,4,5,6,7,8,9,a,b] के साथ शुरू, आप मिलता है, एक समय में जगह में एक भी तत्व बारी बारी से करने की जरूरत है: (। यह सिर्फ तत्वों हर कदम पर उनके अंतिम स्थिति में घुमाया से पता चलता)

0,1,2,3,4,5,6,7,8,9,a,b, // step 0 
        ,b, // step 1 
      ,8,9,a,7, // step 2 
     4,5,6,8,9,a,3,  // step 3 
       ,a,  // step 4 
     ,8,9,6,   // step 5 
    ,4,5,8,9,2,   // step 6 
     ,9,    // step 7 
    ,8,5,    // step 8 
,4,8,1,     // step 9 
    ,8,     // step 10 
,4,      // step 11 
0,      // step 12 

यदि आप लिखते हैं कि प्रत्येक तत्व (पीछे से आगे तक) के लिए घूमने के लिए कितने तत्व हैं, तो यह एक अच्छी प्रगति बनाता है।

1,4,7,1,3,5,1,2,3,1,1,1 

या एक थोड़ा बेहतर संरचित तरीके में,: उदाहरण (width= 4, height= 3) के लिए

1 तत्व की

1,4,7, 
1,3,5, 
1,2,3, 
1,1,1 

घुमाव को प्रभावी ढंग से कोई-ऑप्स रहे हैं, लेकिन प्रगति एक बहुत ही सरल करने के लिए सुराग (सी ++ में) कलन विधि: यह करने के लिए

void transpose(int *matrix, int width, int height) 
{ 
    int count= width*height; 

    for (int x= 0; x<width; ++x) 
    { 
     int count_adjustment= width - x - 1; 

     for (int y= 0, step= 1; y<height; ++y, step+= count_adjustment) 
     { 
      int last= count - (y+x*height); 
      int first= last - step; 

      std::rotate(matrix + first, matrix + first + 1, matrix + last); 
     } 
    } 
}