मैक्रोज़

Question

के साथ सी सरणी क्रमपरिवर्तन सी में मैक्रो के साथ एक सरणी का विशिष्ट क्रमपरिवर्तन उत्पन्न करना संभव है?

यानी मैं तत्वों के साथ एक सरणी एक्स हों:

 0 1 2 3 4 5 
x = ["0","1","1","0","1","0"] 

मैं सोच रहा था कुछ इस तरह के लिए कुछ मैक्रो foo भी हो सकते हैं:

#define S_2Permute(x) = [x[5], x[3], x[4], x[2], x[1]] 

जहाँ मैं सरणी के आदेश को फिर से परिभाषित है, तो मूल स्थिति 5 में तत्व स्थिति 0.

कोई भी विचार में है?

उदाहरण का उपयोग

मैं डेस एन्क्रिप्शन एल्गोरिथ्म के एक कार्यान्वयन बनाने के लिए शुरू कर रहा हूँ। डीईएस के लिए कई क्रमपरिवर्तन/विस्तार की आवश्यकता होती है जहां मुझे सरणी में सभी तत्वों को पुन: क्रमबद्ध करना होगा, कभी-कभी सरणी को कम करना होगा और कभी-कभी इसका विस्तार करना होगा। मैं उम्मीद कर रहा था कि मेरे लिए सरणी को अनुमति देने के लिए बस एक मैक्रो को परिभाषित करने में सक्षम हो।

EDIT2

खैर डेस में पहला कदम कुछ है प्रारंभिक क्रमचय कहा जाता है।

ABCDEF 

जो करने के लिए फैलता है:

0000 0001 0010 0011 0100 0101 0110 0111 1000 1001 1010 1011 1100 1101 1110 1111 

आईपी (प्रारंभिक क्रमचय) तो यह स्ट्रिंग दूसरे स्थान पर रखना होगा तो शुरू में मैं कुछ 64-बिट कुंजी है, जो इस उदाहरण के लिए 0-15 हेक्स किया जा सकता है कि सरणी में प्रत्येक तत्व एक नई स्थिति में होगा:

IP = 
      58 50 42 34 26 18 10 2 
      60 52 44 36 28 20 12 4 
      62 54 46 38 30 22 14 6 
      64 56 48 40 32 24 16 8 
      57 49 41 33 25 17  9 1 
      59 51 43 35 27 19 11 3 
      61 53 45 37 29 21 13 5 
      63 55 47 39 31 23 15 7 

तो bitstring में नए 1st तत्व मूल bitstring से 58 वें तत्व (बिट) होगा।

तो मैं इन बिट्स पात्रों में से एक सरणी में संग्रहीत के सभी के लिए होता है:

x = [0,0,0,0,0,0,0,1,0,0,1,0,0,0,1,1,0,1,0,0,0,1,0,1,0,1,1,0,0, 
    1,1,1,1,0,0,0,1,0,0,1,1,0,1,0,1,0,1,1,1,1,0,0,1,1,0,1,1,1,1,0,1,1,1,1] 

और फिर बस फोन

IP_PERMUTE(x); 

और मैक्रो जादू नई में बिट्स के सभी स्थानांतरित कर दिया जाएगा सही पदों।

Answer 1

बिल्कुल - आप अपने उदाहरण के साथ लगभग वहीं हैं। फिर बाद में

#define S_2Permute(x) {x[5], x[3], x[4], x[2], x[1]} 

: इस प्रयास करें

int x[] = {1,2,3,4,5,6}; 
int y[] = S_2Permute(x); // y is now {6,4,5,3,2} 

दो बातें याद करने के लिए:

1) सी में, सरणियों 0 से गिने जा रहे हैं, इसलिए यह संभव है कि आप का मतलब:

#define S_2Permute(x) {x[4], x[2], x[3], x[1], x[0]} 

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

---

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

---

के बाद से आप कहते हैं कि आप इस संकलन में समस्या आ रही है, यहाँ एक परीक्षण कार्यक्रम है कि जीसीसी 4.6.1 में मेरे लिए काम करता है:

#include <stdio.h> 
#define S_2Permute(x) {x[5], x[3], x[4], x[2], x[1]} 

int main(void) { 
    int x[] = {1,2,3,4,5,6}; 
    int y[] = S_2Permute(x); 

    for(int i = 0; i < 5; i++) { 
    printf("%d,",y[i]); 
    } 
    printf("\n"); 
} 

मैं gcc test.c -std=c99 -Wall

Answer 2

साथ संकलित मैं नए माफी मांगना अगर समाधान के एक अलग माध्यम की पेशकश करना ठीक नहीं है, लेकिन क्या आपने मैक्रो के बजाय इनलाइन फ़ंक्शन का उपयोग करने पर विचार किया है?

मैं कोड के एकल लाइनों कि अगले आदमी के रूप में ज्यादा के रूप में एक बहुत कुछ कर प्यार करता हूँ, लेकिन यह मेरे लिए अधिक समझ में आता है यह इस तरह से करने के लिए:

//I would have an array that defined how I wanted to swap the positions, I'll assume 5 elements 
short reordering[5] = {4,1,3,2,0}; 

inline void permuteArray(char array[]) { 
    char swap = array[reordering[0]]; 
    array[reordering[0]] = array[reordinger[1]]; 
    array[reordering[1]] = array[reordinger[2]]; 
    array[reordering[2]] = array[reordinger[3]]; 
    array[reordering[3]] = array[reordinger[4]]; 
    array[reordering[4]] = swap; 
} 

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

Answer 3

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

public override ulong Permutation(ulong input, int[] permuation) 
     { 
      byte[] test = BitConverter.GetBytes(input); 
      BitArray test2 = new BitArray(test); 
      BitArray final = new BitArray(test); 
      ulong x = 0; 
      ulong y = 1; 
      for (int i = 0; i < permuation.Length; i++) 
      { 
       final[i] = test2[(permuation[i]-1)]; 
      } 
      for (int i = 0; i < final.Length; i++) 
      { 

       if (final[i] == true) 
       { 
        x += (1 * y); 
       } 
       else 
       { 
        x += (0 * y); 
       } 
       y = y * 2; 
      } 
      return x; 
     }