दिलचस्प पोस्ट
विंडो सेवा के रूप में node.js कैसे स्थापित करें? एफ़एलएफ निष्पादन प्रवेश बिंदु फार्म 0x80xxxxx के आभासी पते और 0x0 शून्य क्यों नहीं है? एंड्रॉइड सॉफ्ट कीबोर्ड को बंद / छुपाएं कैसे गोल बटन बनाने के लिए? WPF में कंबोडिया नियंत्रण के लिए कैसे एक enum बाँध? गतिशील स्क्रिप्ट लदान सिंक्रनाइज़ेशन आर में दशमलव (मिमी: एसएस) दशमलव रूप में कैसे परिवर्तित करें एक बंद स्पिनर का पाठ रंग ऑर्डर आइटम और WC_Order_Item_Product को Woocommerce 3 में प्राप्त करें जीआईटी एक साथ दो शाखाओं पर काम कर रहा है सभी छवियों को दिखाने के लिए JLbel के साथ जेएलैबल को जोड़ें एक ग्राफ बनाने के लिए जावा में उपकरणों की तरह साइटोस्केप जावा जेनेरिक्स और एक साथ नंबर जोड़ना ये संख्याएं समान क्यों नहीं हैं? एब्स्ट्रैक्ट बेस कक्षा से मॉडल फ़ील्ड के डिफ़ॉल्ट मान को ओवरराइड कैसे करें

मैं NSArray को उद्देश्य-सी में कैसे बदल सकता हूँ?

मुझे अपने NSArray को उलटा देना होगा

उदहारण के लिए:

[1,2,3,4,5] बनना चाहिए: [5,4,3,2,1]

इस लक्ष्य को हासिल करने का सबसे अच्छा तरीका क्या है?

Solutions Collecting From Web of "मैं NSArray को उद्देश्य-सी में कैसे बदल सकता हूँ?"

किसी सरणी की एक प्रतिलिपि प्राप्त करने के लिए, danielpunkass के समाधान को देखें, रिवर्स ऑब्जेक्ट एननरेटर का उपयोग करके

एक अस्थायी सरणी को पीछे करने के लिए, आप अपने कोड में निम्न श्रेणी जोड़ सकते हैं:

 @implementation NSMutableArray (Reverse) - (void)reverse { if ([self count] <= 1) return; NSUInteger i = 0; NSUInteger j = [self count] - 1; while (i < j) { [self exchangeObjectAtIndex:i withObjectAtIndex:j]; i++; j--; } } @end 

अगर आप NSArray पर अंतर्निहित reverseObjectEnumerator विधि का लाभ उठाते हैं, और allObjects की allObjects विधि बहुत आसान समाधान है:

 NSArray* reversedArray = [[startArray reverseObjectEnumerator] allObjects]; 

allObjects ऑब्जेक्ट्स को एक allObjects लौटने के रूप में प्रलेखित किया गया है, ऑब्जेक्ट के साथ जो अभी तक ऑब्जेक्ट ऑब्जेक्ट के साथ नहीं nextObject , क्रम में:

इस सरणी में गणक के सभी शेष वस्तुओं को एन्यूमरेटेड क्रम में शामिल किया गया है

कुछ मानक

1. रिवर्स ऑब्जेक्ट अंकीयकरण सभी ऑब्जेक्ट्स

यह सबसे तेज़ तरीका है:

 NSArray *anArray = @[@"aa", @"ab", @"ac", @"ad", @"ae", @"af", @"ag", @"ah", @"ai", @"aj", @"ak", @"al", @"am", @"an", @"ao", @"ap", @"aq", @"ar", @"as", @"at", @"au", @"av", @"aw", @"ax", @"ay", @"az", @"ba", @"bb", @"bc", @"bd", @"bf", @"bg", @"bh", @"bi", @"bj", @"bk", @"bl", @"bm", @"bn", @"bo", @"bp", @"bq", @"br", @"bs", @"bt", @"bu", @"bv", @"bw", @"bx", @"by", @"bz", @"ca", @"cb", @"cc", @"cd", @"ce", @"cf", @"cg", @"ch", @"ci", @"cj", @"ck", @"cl", @"cm", @"cn", @"co", @"cp", @"cq", @"cr", @"cs", @"ct", @"cu", @"cv", @"cw", @"cx", @"cy", @"cz"]; NSDate *methodStart = [NSDate date]; NSArray *reversed = [[anArray reverseObjectEnumerator] allObjects]; NSDate *methodFinish = [NSDate date]; NSTimeInterval executionTime = [methodFinish timeIntervalSinceDate:methodStart]; NSLog(@"executionTime = %f", executionTime); 

परिणाम: executionTime = 0.000026

2. एक रिवर्स ऑब्जेक्ट अंकीयकरण पर फेरबदल करना

यह धीमे 1.5x और 2.5x के बीच है:

 NSDate *methodStart = [NSDate date]; NSMutableArray *array = [NSMutableArray arrayWithCapacity:[anArray count]]; NSEnumerator *enumerator = [anArray reverseObjectEnumerator]; for (id element in enumerator) { [array addObject:element]; } NSDate *methodFinish = [NSDate date]; NSTimeInterval executionTime = [methodFinish timeIntervalSinceDate:methodStart]; NSLog(@"executionTime = %f", executionTime); 

परिणाम: executionTime = 0.000071

3. सॉर्ट किए गएअरेरेउपयोगकर्ता

यह 30x और 40x धीमी (कोई आश्चर्य नहीं है) के बीच है:

 NSDate *methodStart = [NSDate date]; NSArray *reversed = [anArray sortedArrayUsingComparator: ^(id obj1, id obj2) { return [anArray indexOfObject:obj1] < [anArray indexOfObject:obj2] ? NSOrderedDescending : NSOrderedAscending; }]; NSDate *methodFinish = [NSDate date]; NSTimeInterval executionTime = [methodFinish timeIntervalSinceDate:methodStart]; NSLog(@"executionTime = %f", executionTime); 

परिणाम: executionTime = 0.001100

इसलिए [[anArray reverseObjectEnumerator] allObjects] यह स्पष्ट विजेता है जब यह गति और आसानी से आता है।

दासबूट का सही दृष्टिकोण है, लेकिन उनके कोड में कुछ गलतियाँ हैं यहां एक पूरी तरह से सामान्य कोड स्निपेट है जो किसी भी NSMutableArray को स्थानांतरित कर देगा:

 /* Algorithm: swap the object N elements from the top with the object N * elements from the bottom. Integer division will wrap down, leaving * the middle element untouched if count is odd. */ for(int i = 0; i < [array count] / 2; i++) { int j = [array count] - i - 1; [array exchangeObjectAtIndex:i withObjectAtIndex:j]; } 

आप इसे C फ़ंक्शन में, या बोनस अंक के लिए लपेट कर सकते हैं, श्रेणियों का इस्तेमाल एनएमयूटीबलएरेरे में जोड़ने के लिए करें। (उस स्थिति में, 'सरणी' 'स्वयं' बन जाएगा।) आप लूप से पहले एक चर में [array count] निर्दिष्ट करके और उस वेरिएबल का उपयोग करके भी अनुकूलित कर सकते हैं, यदि आप चाहें

यदि आपके पास केवल एक नियमित एनएसएआरआर है, तो इसे जगह में बदलने का कोई तरीका नहीं है, क्योंकि NSArrays को संशोधित नहीं किया जा सकता है। लेकिन आप एक उलट प्रति बना सकते हैं:

 NSMutableArray * copy = [NSMutableArray arrayWithCapacity:[array count]]; for(int i = 0; i < [array count]; i++) { [copy addObject:[array objectAtIndex:[array count] - i - 1]]; } 

या इस छोटी सी चाल का उपयोग एक पंक्ति में करें:

 NSArray * copy = [[array reverseObjectEnumerator] allObjects]; 

यदि आप किसी सरणी पर पीछे की तरफ लूप चाहते हैं, तो आप [array reverseObjectEnumerator] साथ / in लूप के for उपयोग कर सकते हैं, लेकिन इसका उपयोग करने के लिए थोड़ा और अधिक कुशल है -enumerateObjectsWithOptions:usingBlock: का उपयोग -enumerateObjectsWithOptions:usingBlock: ::

 [array enumerateObjectsWithOptions:NSEnumerationReverse usingBlock:^(id obj, NSUInteger idx, BOOL *stop) { // This is your loop body. Use the object in obj here. // If you need the index, it's in idx. // (This is the best feature of this method, IMHO.) // Instead of using 'continue', use 'return'. // Instead of using 'break', set '*stop = YES' and then 'return'. // Making the surrounding method/block return is tricky and probably // requires a '__block' variable. // (This is the worst feature of this method, IMHO.) }]; 

( ध्यान दें : फाउंडेशन अनुभव के पांच और साल, एक नया उद्देश्य-सी फीचर या दो और टिप्पणियों से कुछ युक्तियां 2014 में पर्याप्त रूप से अपडेट किए गए हैं।)

इसके बाद के दूसरे जवाबों की समीक्षा करने और मैट गैलाघर की चर्चा को देखने के बाद

मैं यह प्रस्ताव:

 NSMutableArray * reverseArray = [NSMutableArray arrayWithCapacity:[myArray count]]; for (id element in [myArray reverseObjectEnumerator]) { [reverseArray addObject:element]; } 

जैसा मैट देखता है:

उपरोक्त मामले में, आपको आश्चर्य हो सकता है कि – [एनएसएआरआरई रिवर्स ऑब्जेक्ट एनामेटर] को लूप के प्रत्येक चलना पर चलाना होगा – संभावित रूप से कोड को धीमा करना <…>

इसके तुरंत बाद, वह इस प्रकार उत्तर देता है:

<…> "संग्रह" अभिव्यक्ति का केवल एक बार मूल्यांकन किया जाता है, जब लूप के लिए शुरू होता है। यह सबसे अच्छा मामला है, क्योंकि आप लूप के प्रति-इटोरेशन प्रदर्शन को प्रभावित किए बिना "संग्रह" अभिव्यक्ति में एक महंगी कार्य को सुरक्षित रूप से रख सकते हैं।

Georg Schölly की श्रेणियां बहुत अच्छी हैं हालांकि, NSMutableArray के लिए, सूचकांक के लिए NSUIntegers का उपयोग करते हुए क्रैश में परिणाम जब सरणी खाली है सही कोड है:

 @implementation NSMutableArray (Reverse) - (void)reverse { NSInteger i = 0; NSInteger j = [self count] - 1; while (i < j) { [self exchangeObjectAtIndex:i withObjectAtIndex:j]; i++; j--; } } @end 

रिवर्स में एक सरणी की गणना करने का सबसे कारगर तरीका:

enumerateObjectsWithOptions:NSEnumerationReverse usingBlock उपयोग enumerateObjectsWithOptions:NSEnumerationReverse usingBlock उपयोग कर रहा है। ऊपर @ [[array reverseObjectEnumerator] allObjects]; के बेंचमार्क का उपयोग करना, इसने [[array reverseObjectEnumerator] allObjects]; से 8x तेज किया [[array reverseObjectEnumerator] allObjects]; :

 NSDate *methodStart = [NSDate date]; [anArray enumerateObjectsWithOptions:NSEnumerationReverse usingBlock:^(id obj, NSUInteger idx, BOOL *stop) { // }]; NSDate *methodFinish = [NSDate date]; NSTimeInterval executionTime = [methodFinish timeIntervalSinceDate:methodStart]; NSLog(@"executionTime = %f", executionTime); 
 NSMutableArray *objMyObject = [NSMutableArray arrayWithArray:[self reverseArray:objArrayToBeReversed]]; // Function reverseArray -(NSArray *) reverseArray : (NSArray *) myArray { return [[myArray reverseObjectEnumerator] allObjects]; } 

सरणी रिवर्स और इसके माध्यम से पाशन:

 [[[startArray reverseObjectEnumerator] allObjects] enumerateObjectsUsingBlock:^(id obj, NSUInteger idx, BOOL *stop) { ... }]; 

इसे अपडेट करने के लिए, स्विफ्ट में इसे आसानी से किया जा सकता है:

 array.reverse() 

मेरे लिए, क्या आपने यह विचार किया है कि सरणी पहले स्थान पर कैसे आबादी थी? मैं एक सरणी में कई वस्तुओं को जोड़ने की प्रक्रिया में था, और शुरुआत में हर एक को सम्मिलित करने का निर्णय लिया, किसी मौजूदा ऑब्जेक्ट्स को एक करके इस मामले में, एक अस्थायी सरणी की आवश्यकता है

 NSMutableArray *myMutableArray = [[NSMutableArray alloc] initWithCapacity:1]; [myMutableArray insertObject:aNewObject atIndex:0]; 

या स्कला-रास्ता:

 -(NSArray *)reverse { if ( self.count < 2 ) return self; else return [[self.tail reverse] concat:[NSArray arrayWithObject:self.head]]; } -(id)head { return self.firstObject; } -(NSArray *)tail { if ( self.count > 1 ) return [self subarrayWithRange:NSMakeRange(1, self.count - 1)]; else return @[]; } 

मुझे किसी भी तरीके से निर्मित तरीके से नहीं पता है लेकिन, हाथ से कोडिंग बहुत मुश्किल नहीं है आप जिस एआरएआर के साथ काम कर रहे हैं, उसके तत्वों को मानते हुए एनएसएनम्बर पूर्णांक प्रकार के ऑब्जेक्ट्स हैं, और 'एआरएम' NSMutableArray है जिसे आप रिवर्स करना चाहते हैं।

 int n = [arr count]; for (int i=0; i<n/2; ++i) { id c = [[arr objectAtIndex:i] retain]; [arr replaceObjectAtIndex:i withObject:[arr objectAtIndex:ni-1]]; [arr replaceObjectAtIndex:ni-1 withObject:c]; } 

चूंकि आप NSArray के साथ शुरू करते हैं, तो आपको पहले मूल एनएसएरेय ('ऑरराय्रे') की सामग्री के साथ अस्थिर सरणी बनाना होगा।

 NSMutableArray * arr = [[NSMutableArray alloc] init]; [arr setArray:origArray]; 

संपादित करें: फिक्स्ड एन -> एन / 2 लूप गिनती में और एनएसएनम्बर को ब्रेंट के उत्तर में सुझावों के कारण अधिक जेनेरिक आईडी में परिवर्तित किया गया।

यदि आप जो करना चाहते हैं, तो उल्टा दोहराएं, यह कोशिश करें:

 // iterate backwards nextIndex = (currentIndex == 0) ? [myArray count] - 1 : (currentIndex - 1) % [myArray count]; 

आप [myArrayCount] को एक बार कर सकते हैं और इसे स्थानीय चर में सहेज सकते हैं (मुझे लगता है कि इसकी महंगी है), लेकिन मैं यह भी अनुमान लगा रहा हूं कि कंपाइलर ऊपर लिखे गए कोड के साथ बहुत कुछ करना होगा।

स्विफ्ट 3 सिंटैक्स:

 let reversedArray = array.reversed() 

इसे इस्तेमाल करे:

 for (int i = 0; i < [arr count]; i++) { NSString *str1 = [arr objectAtIndex:[arr count]-1]; [arr insertObject:str1 atIndex:i]; [arr removeObjectAtIndex:[arr count]-1]; }