আমি জাভাতে কীভাবে কোন অ্যারের বিপরীত করব?

238

আমি জাভাতে একটি int অ্যারে বিপরীত করার চেষ্টা করছি।

এই পদ্ধতিটি অ্যারেটিকে বিপরীত করে না। 

for(int i = 0; i < validData.length; i++)
{
    int temp = validData[i];
    validData[i] = validData[validData.length - i - 1];
    validData[validData.length - i - 1] = temp;
}

এখানে ভূল কিসের?

java  arrays  idioms  idiomatic 
— MichaelScott
সূত্র
31
আমি দেখলাম আমি কী ভুল করেছি। বৈধতা ডেটা দৈর্ঘ্য / 2 হওয়া উচিত। অন্যথায় এটি নিজেই বিপরীত হবে তবে নিজেকে বিপরীত করবে।
— মাইকেলস্কট 6
4
En.wikedia.org/wiki/In-place_algorithm দেখুন যা এই অ্যালগরিদমের সঠিক সংস্করণ বর্ণনা রয়েছে।
— ডিন পোভে
— akhil_mittal

উত্তর:

283

কোনও আন্ত অ্যারের বিপরীতে, আপনি মিডপয়েন্টে পৌঁছা না হওয়া অবধি আইটেমগুলিকে স্যুপ আপ করবেন, এটির মতো:

for(int i = 0; i < validData.length / 2; i++)
{
    int temp = validData[i];
    validData[i] = validData[validData.length - i - 1];
    validData[validData.length - i - 1] = temp;
}

আপনি যেভাবে এটি করছেন, আপনি প্রতিটি উপাদানকে দুবার অদলবদল করেন, ফলে ফলাফলটি প্রাথমিক তালিকার মতো।

— 3lectrologos
সূত্র
এবং আমি validData.length / 2ফর-লুপের বাইরের অংশটি রাখতে চাই ।
— জিন কোওন
7
@ জিন আমি চাই না এটি কেবল অর্থটিকেই অস্পষ্ট করে, এবং আমি বাজি ধরেছি যে অনুকূলিতকরণ সংকলক যাইহোক আপনার জন্য এটি করবে। নির্বিশেষে, মাইক্রো-অপ্টিমাইজ করার কোনও অর্থ নেই যতক্ষণ না আপনার কাছে প্রয়োজনীয় / সহায়ক যে প্রোফাইলিং থেকে পরিষ্কার প্রমাণ পাওয়া যায়।
— নিকু স্টিড়কা
9
@ জিনকওয়ান এটি করার মতো হবে validData.length >> 1। এটি সমতুল্য এবং দ্রুত, তবে এটি অনেক প্রোগ্রামারকে বিভ্রান্ত করে এবং কোনও ভাল সংকলক স্বয়ংক্রিয়ভাবে এটি করবে।
— জাস্টিন
2
আপনার কেবল একবার এই গণনা করা উচিত validData.length - i - 1এবং এটি একটি ভেরিয়েবলে সংরক্ষণ করা উচিত।
আউট টেম্প ভেরিয়েবলের সাথে কি কেউ বিপরীত প্রস্তাব দিতে পারে !!
— এসজে 28
303

সঙ্গে Commons.Lang , আপনি কেবল ব্যবহার করতে পারে

ArrayUtils.reverse(int[] array)

বেশিরভাগ সময়, সহজেই উপলব্ধ গ্রন্থাগারগুলি ইতিমধ্যে ইউনিট-পরীক্ষিত এবং ব্যবহারকারী-পরীক্ষিতরা আপনার সমস্যার যত্ন নেওয়ার সাথে আটকে থাকা আরও দ্রুত এবং আরও ত্রুটি-নিরাপদ।

— Manur
সূত্র
3
আমি অগ্রাধিকার দিতাম এটি কার্যকরী-মত শৈলীর জন্য বিপরীত (পাস) অ্যারে ফিরিয়েছিল।
— লরেন্ট জি
2
@ লরেন্ট-জি ন্যায্য হতে হবে: এইভাবে অ্যারেটি বিপরীত করা আরও মেমরির দক্ষ, সম্ভবত এই কারণেই তারা এটি এটি করেছিলেন।
— সিরমিয়েলস
4
আমার বক্তব্যটি অনুলিপি বা অনুলিপি ছিল না। আমার বার্তাটি "(উত্তীর্ণ)" ফেরত (উল্টে যাওয়ার পরে) বলেছে যাতে এটি আলাদাভাবে বিবৃতি দেওয়ার প্রয়োজন না করে একটি অভিব্যক্তিতে পাস করা যায়।
— লরেন্ট জি
52 
public class ArrayHandle {
    public static Object[] reverse(Object[] arr) {
        List<Object> list = Arrays.asList(arr);
        Collections.reverse(list);
        return list.toArray();
    }
}
— তারিক
সূত্র
11
অবশ্যই হবে। একটি তালিকা কেবলমাত্র বস্তুগুলিকে ধারণ করতে পারে, আদিম নয়, সুতরাং সমস্ত আদিম ( intগুলি এই ক্ষেত্রে) তাদের নিজ নিজ মোড়কে (এই ক্ষেত্রে) আবৃত Integerকরে তালিকায় রাখবে। আপনি দেখুন Integers গুলি অবজেক্টস। @ টম
— 11684
6
সতর্কতা: আমি যদি ভুল না করি তবে মূল অ্যারেটি সংশোধন করা হয়েছে। এটি পরিষ্কার করার জন্য আপনি কেবল কিছু ফেরত দিতে চাইবেন না।
— Andrea Zilio
3
@ 11684 হ্যাঁ, জেনেরিক তালিকাগুলি কেবল অবজেক্টগুলিকে ধারণ করতে পারে। কিন্তু পদ্ধতিটি একটি অ্যারে বাদ দেয়। অ্যারে আদিমকে ধরে রাখতে পারে। সুতরাং int[]থেকে পৃথক Integer[]। এটি ব্যবহার করে দেখুন: Integer[] array = new int[5]। আপনি একটি সংকলন ত্রুটি পাবেন। এ কারণেই জাভা Arraysক্লাস আদিম অ্যারেগুলির সাথে কাজ করার জন্য একগুচ্ছ পদ্ধতিগুলি সংজ্ঞায়িত করে। int[]উপরোক্ত পদ্ধতিতে পাস করার চেষ্টা করার ফলে এরকম কিছু হবে The method reverse(Object[]) in the type MakeSimple is not applicable for the arguments (int[])। @ ফিলিপ - একটি স্থানের অ্যালগরিদম কম মেমরি ব্যবহার করে এবং দ্রুত চালায়।
— ব্রায়ান ম্যাকচাটন
3
@ আন্ড্রেয়া আসলে, তা নয়। ফেরত দেওয়া তালিকাটি Arrays.asList()মূল অ্যারের উল্লেখ করে না বা অ্যারেও ফিরে আসে না। এই পদ্ধতির সাথে এটি অন্যতম সমস্যা: এটি ট্রিপল মেমরিটি ব্যবহার করে এবং স্থানটিতে অ্যালগরিদম হিসাবে ট্রিপলটি কাজ করে।
— ব্রায়ান ম্যাকচটন
4
এই পদ্ধতিটি নিজেই কাজ করতে পারে তবে int[]এই পদ্ধতির পক্ষে আর্গুমেন্ট হিসাবে একটি সহজেই পাস করতে পারে না ( "বেমানান ধরণের: int [] অবজেক্ট []" তে রূপান্তর করা যায় না )।
— এমসি সম্রাট
47 
Collections.reverse(Arrays.asList(yourArray));

java.util.Collections.reverse()বিপরীত করতে পারে java.util.Listএবং java.util.Arrays.asList()একটি তালিকা দেয় যা আপনার কাছে নির্দিষ্ট নির্দিষ্ট অ্যারেটিকে আবৃত করে, সুতরাং yourArrayএর অনুরোধের পরে বিপরীত হয় Collections.reverse()।

ব্যয়টি কেবল একটি তালিকা-অবজেক্টের তৈরি এবং অতিরিক্ত লাইব্রেরিগুলির প্রয়োজন হয় না।

তারিক এবং তাদের ভাষ্যকারদের উত্তরে অনুরূপ একটি সমাধান উপস্থাপন করা হয়েছে, তবে আমি মনে করি এই উত্তরটি আরও সংক্ষিপ্ত এবং আরও সহজেই বিশ্লেষণযোগ্য হবে।

— escitalopram
সূত্র
14
বস্তুর অ্যারেগুলির জন্য, এটি একটি ভাল সমাধান। তবে এটি আদিমদের অ্যারেগুলির জন্য কাজ করে না। E. g। একটি পাস int[]করার ফলে একটি asList(...)নয় List<Integer>, তবে একটি List<int[]>উপাদান থাকবে containing সেখানে AFAICS কোন বিল্ট-ইন উপায় হল একটি রূপান্তর করতে সহজ int[]একটি থেকে Integer[]।
— মার্টিন জং
4
এটি আদিম অ্যারেগুলির সাথে কাজ করবে না ... সংগ্রহগুলি কোনও মূল্য ফেরত দেবে না এখন আপনার মেমরির তালিকার হিসাবে অকেজো অ্যারে রয়েছে
— নাইটস্কাইকোড
@ মার্টিনরোস্ট জাভা 8+: Arrays.stream(arr).boxed().collect(Collectors.toList())বাArrays.stream(arr).boxed().toArray(Integer[]::new)
— সাইমন
39

আমি মনে করি আপনি লুপের প্রতিটি পুনরাবৃত্তিতে স্বপন করছেন এমন সূচকগুলির উপর নজর রাখতে যদি আপনি সুস্পষ্ট ভেরিয়েবল ঘোষণা করেন তবে অ্যালগরিদমের যুক্তি অনুসরণ করা কিছুটা সহজ।

public static void reverse(int[] data) {
    for (int left = 0, right = data.length - 1; left < right; left++, right--) {
        // swap the values at the left and right indices
        int temp = data[left];
        data[left]  = data[right];
        data[right] = temp;
    }
}

আমি আরও মনে করি এটি কিছুটা লুপের মধ্যে করা আরও পঠনযোগ্য।

public static void reverse(int[] data) {
    int left = 0;
    int right = data.length - 1;

    while( left < right ) {
        // swap the values at the left and right indices
        int temp = data[left];
        data[left] = data[right];
        data[right] = temp;

        // move the left and right index pointers in toward the center
        left++;
        right--;
    }
}
— টিকটিকিকে বিল দাও
সূত্র
পুরাতন স্কুলের অদলবদল আরও সহজ দেখায় তবে হ্যাঁ, বামে, ডানদিকে অ্যারে সূচি মানগুলি অন্তর্ভুক্ত করার সাথে সাথে ... ডিবাগিংয়ের জন্য সহায়ক হবে
— শ্রীননাথ গণেশ
আপনি 'পাবলিক স্ট্যাটিক অকার্যকর অদলবদল (int [] ডেটা, ইনড ইনডেক্স 1, ইনড ইনডেক্স 2) {...}' যুক্ত করতে পারেন এবং এটি 'বিপরীত' থেকে এটি ব্যবহার করতে পারেন: অদলবদল (ডেটা, বাম, ডান)।
— পিএম_
13

এখানে ইতিমধ্যে প্রচুর উত্তর রয়েছে, বেশিরভাগ জায়গায় জায়গায় অ্যারে সংশোধন করার দিকে দৃষ্টি নিবদ্ধ করে। তবে সম্পূর্ণতার জন্য, মূল অ্যারেটি সংরক্ষণ এবং একটি নতুন বিপরীত অ্যারে তৈরি করতে জাভা স্ট্রিমগুলি ব্যবহার করে এখানে আরও একটি পদ্ধতি রয়েছে:

    int[] a = {8, 6, 7, 5, 3, 0, 9};
    int[] b = IntStream.rangeClosed(1, a.length).map(i -> a[a.length-i]).toArray();
— প্যাট্রিক পার্কার
সূত্র
10

পেয়ারা সহ:

Collections.reverse(Ints.asList(array));
— ZhekaKozlov
সূত্র
4
এটা অসাধারণ! সংক্ষিপ্ত এবং কার্যকর। সমস্ত asListপদ্ধতির মতো , এটি এমন একটি দৃষ্টিভঙ্গি তৈরি করে যা সরাসরি ব্যাকিং (আদিম) অ্যারেতে সরাসরি লিখে। আমি মনে করি যে এখানে ভোটাররা ভুল করে ভেবেছিল যে এটি একটি বাক্সযুক্ত তালিকা বা অন্য কিছু ফিরিয়ে দিয়েছে।
— লুক উশরউড
@ লুকউশারউড সম্ভবতঃ বক্সিং এবং আনবক্সিং থেকে কিছু এলিমিট থাকবে যখন প্রতিটি এলিমেন্টকে কল করুন এবং সেট করবেন। তবে আমি আপনার সাথে একমত যে এটি একটি উজ্জ্বল সমাধান।
— প্যাট্রিক পার্কার
আসলে, এটি সম্পর্কে সচেতন হওয়া মূল্যবান। আমি ব্যক্তিগতভাবে যে সংখ্যাগরিষ্ঠ কোডের সাথে কাজ করি তা বড় চুক্তি বলে মনে হয় না - আমাদের 'হট' অঞ্চলগুলি ভালভাবে সংজ্ঞায়িত করা হয়েছে, বাকিটি হ'ল আঠার কোড code একই সাথে আমি সন্তুষ্ট যে মেমোরি মন্থ একটি অতিরিক্ত "লুকানো" ব্যয়ও তৈরি করে যা প্রকৃত ফাংশনগুলিতে প্রোফাইলাররা দায়ী করে না।
— লুক উশরউড
@ লুক ইউশারউড এটি এখনও একটি প্রাইম অ্যারের পরিবর্তে একটি বক্সের তালিকা ফিরিয়ে দেয়
— অ্যান্টনি জে ক্লিঙ্ক
2
@ অ্যান্থনি জে ক্লিঙ্ক "এটি" কী বোঝায় তা নিশ্চিত নয়, তবে জেডিকে ইউটিলিটি Collections.reverseএকটি শূন্য পদ্ধতি। এটি একটি পেয়ারা অভ্যন্তরীণ ক্লাসে জায়গা করে নিয়ে কাজ করে যা একটি জড়ো করে int[](যেহেতু এটি কখনই বাক্সযুক্ত কোনও তালিকা সঞ্চয় করে না Integerআমি ক্লাসটিকে "বক্সযুক্ত তালিকা" বলব না, বরং "অ্যারের তালিকার ভিউ" বলব)। তবে হ্যাঁ এটি একটি ইন্টারফেস পাসিং Integerঅবজেক্টের মাধ্যমে পরিচালিত হয় , সুতরাং এটি উল্লিখিত হিসাবে অনেকগুলি অস্থায়ী বস্তুর মন্থকতা এবং বক্সিং তৈরি করবে। IntStreamপারফরম্যান্সের জন্য গুরুত্বপূর্ণ যে কোনও বা একটি আদিম-সংগ্রহ গ্রন্থাগার চেষ্টা করুন । (ট্র্যাভ, কোলোবোক, এক্সপ্লিস কালেকশন, ...)
— লূক উশারউড
9

জাভা 8 এর ক্ষেত্রে আমরা IntStreamপূর্ণসংখ্যার অ্যারেটিকে বিপরীত করতেও ব্যবহার করতে পারি :

int[] sample = new int[]{1,2,3,4,5};
int size = sample.length;
int[] reverseSample = IntStream.range(0,size).map(i -> sample[size-i-1])
                      .toArray(); //Output: [5, 4, 3, 2, 1]
— akhil_mittal
সূত্র
7

লুপ জন্য সহজ!

for (int start = 0, end = array.length - 1; start <= end; start++, end--) {
    int aux = array[start];
    array[start]=array[end];
    array[end]=aux;
}
— অপেত্রেই আয়নুত
সূত্র
4
ভবিষ্যতে, দয়া করে প্রশ্নকারীকে বিশেষত তারা কীভাবে ভুল করেছে এবং আপনি সঠিকভাবে কী করেছেন তা জানান।
— কার্তিক চুগ
1
পরিবর্তন start <= endকরুনstart < end
— লিওনার্ড পাওলি
5 
for(int i=validData.length-1; i>=0; i--){
  System.out.println(validData[i]);
 }
— দীপক সিং
সূত্র
দুর্ভাগ্যক্রমে, এটি এখানে সর্বাধিক পরিষ্কার উত্তর, কারণ প্রতিটি বিকাশকারী কীভাবে এটি করতে হবে তা জানবে এবং এটির জন্য কোনও বর্ধিত প্যাকেজ ইনস্টলসের প্রয়োজন নেই।
— হোল্ডঅফহাঙ্গার
4

আমি ব্যক্তিগতভাবে এটি সমাধান করব। প্যারামিট্রাইজড পদ্ধতি তৈরির পিছনে কারণটি হ'ল যে কোনও অ্যারে বাছাই করা যায় ... কেবল আপনার পূর্ণসংখ্যা নয়।

আমি আশা করি আপনি এটি থেকে কিছু সংগ্রহ করুন।

@Test
public void reverseTest(){
   Integer[] ints = { 1, 2, 3, 4 };
   Integer[] reversedInts = reverse(ints);

   assert ints[0].equals(reversedInts[3]);
   assert ints[1].equals(reversedInts[2]);
   assert ints[2].equals(reversedInts[1]);
   assert ints[3].equals(reversedInts[0]);

   reverseInPlace(reversedInts);
   assert ints[0].equals(reversedInts[0]);
}

@SuppressWarnings("unchecked")
private static <T> T[] reverse(T[] array) {
    if (array == null) {
        return (T[]) new ArrayList<T>().toArray();
    }
    List<T> copyOfArray = Arrays.asList(Arrays.copyOf(array, array.length));
    Collections.reverse(copyOfArray);
    return copyOfArray.toArray(array);
}

private static <T> T[] reverseInPlace(T[] array) {
    if(array == null) {
        // didn't want two unchecked suppressions
        return reverse(array);
    }

    Collections.reverse(Arrays.asList(array));
    return array;
}
— AnthonyJClink
সূত্র
2
প্রাথমিকগুলি ব্যবহার করে মূল সমস্যাটি সমাধান করে না।
— মেলিন্ডা সবুজ
প্রাইমগুলিকে বস্তুতে রূপান্তর করার বিভিন্ন উপায় রয়েছে are আমি সর্বদা জাভা যেখানেই সম্ভব prims এড়ানো পরামর্শ দেয় এবং আমি বিশ্বাস করি যে এটি উত্সাহিত করা উচিত।
— অ্যান্থনিজেসিঙ্ক লিঙ্ক
অজানা দৈর্ঘ্যের আদিম অ্যারেগুলিকে একটি অ্যারেতে রূপান্তর করা খুব খারাপ ধারণা হতে পারে, বিশেষত যদি এটি উপলব্ধি না করেই করা হয়। জাভা স্মলটাল্ক নয়। আদিমরা ভাষার অংশ এবং তাদের স্থান আছে। আমরা তাদের পছন্দ না করি তা বিবেচ্য নয়, তাদের অবশ্যই আমাদের গ্রহণ করা উচিত এবং যেখানে উপযুক্ত হবে সেগুলি ব্যবহার করুন।
— মেলিন্ডা সবুজ
1
ঠিক আপনার অ্যারে অনুলিপি করার দরকার নেই Collections.reverse(asList(arraytoReverse)); return arrayToReverse;। asListঅ্যারের চারদিকে কেবল একটি মোড়ক, সুতরাং মূল অ্যারেটি বিপরীত হয়।
— রেডিওডেফ
3

আপনার প্রোগ্রামটি কেবল কাজের জন্য কাজ করবে length = 0, 1। আপনি চেষ্টা করতে পারেন :

int i = 0, j = validData.length-1 ; 
while(i < j)
{
     swap(validData, i++, j--);  // code for swap not shown, but easy enough
}
— fastcodejava
সূত্র
3
সম্ভবত আপনি একটি পদ্ধতি কলের পরিবর্তে একটি ইনলাইন অদলবদলের জন্য সিউডো কোড হিসাবে অদলবদল বোঝাতে চেয়েছিলেন তবে তা যদি কাজ না করে। জাভা রেফারেন্স দিয়ে যায় তাই ভেরিয়েবলের জন্য অদলবদল লেখা সম্ভব নয়।
— ডিন পোভে
আপনি যেভাবেই v [i] এবং v [j] কে অদলবদল করতে পারবেন তা বোঝাতে চেয়েছি। আমি জানি যে পদ্ধতি কলগুলি জাভাতে কীভাবে কাজ করে। পদ্ধতির জন্য, আপনি অদলবদলের মতো কিছু করতে পারেন (v, i ++, j--);
— ফাস্টকোডাজভা
1
ডিন, অ্যারে ভ্যালিডেটা হ'ল একটি অবজেক্ট, রেফারেন্স দ্বারা পাস করা, সুতরাং স্ব্যুপ () পদ্ধতিটি পুরোপুরি কার্যকর হবে।
— গাল ওবারসন
3

যদি আরও আদিম (যেমন চর, বাইট, ইনট, ইত্যাদি) ডেটা নিয়ে কাজ করা থাকে তবে আপনি কিছু মজার এক্সওআর ক্রিয়াকলাপ করতে পারেন।

public static void reverseArray4(int[] array) {
    int len = array.length;
    for (int i = 0; i < len/2; i++) {
        array[i] = array[i] ^ array[len - i  - 1];
        array[len - i  - 1] = array[i] ^ array[len - i  - 1];
        array[i] = array[i] ^ array[len - i  - 1];
    }
}
— AbsoluteBlue
সূত্র
1
আসলে প্রোডাকশন কোড ব্যবহার করা খুব সুন্দর কিন্তু তবুও মজা। সর্বাধিক খাঁটিতার জন্য,% = ক্রিয়াকলাপটি এটির মতো ব্যবহার করুন: অ্যারে [i]% = অ্যারে [লেন - i - 1], ইত্যাদি
— মেলিন্ডা গ্রিন
অনুরূপ, তবে কিছুটা খাটো:for (int m = x.length, i = --m / 2; ++i <= m;) { x[i] ^= x[m - i]; x[i] ^= x[m - i] ^= x[i]; }
— থমাস মুলার
2

এটি কেবল পিছনে পিছনে অ্যারে পুনরাবৃত্তি করা সবচেয়ে দক্ষ।

আমি নিশ্চিত নই যে হারুনের সমাধানটি এই ভিটি করে Collections.reverse(list);কি কেউ কল করে ?

— নিক স্ট্রুপ্যাট
সূত্র
অ্যারের উপরে পেছনের দিকে ইট্রেটেড করার জন্য একটি নতুন অ্যারের প্রয়োজন। আমি উপরে পোস্ট করা সমাধানটি পছন্দ করি যা কোনও নতুন অ্যারে তৈরি না করে ইনলাইনটি বিপরীত হয়।
— মিমকডোল
1
@ সিমুকাল কেন নতুন অ্যারে তৈরি করবেন? কেবল এটি পিছনের দিকে পুনরাবৃত্তি করুন।
— ট্রেজকাজ
2 
public void getDSCSort(int[] data){
        for (int left = 0, right = data.length - 1; left < right; left++, right--){
            // swap the values at the left and right indices
            int temp = data[left];
            data[left]  = data[right];
            data[right] = temp;
        }
    }
— amicos
সূত্র
1 
public void display(){
  String x[]=new String [5];
  for(int i = 4 ; i > = 0 ; i-- ){//runs backwards

    //i is the nums running backwards therefore its printing from       
    //highest element to the lowest(ie the back of the array to the front) as i decrements

    System.out.println(x[i]);
  }
}
— ভূত প্রোগ্রামার
সূত্র
1
হ্যাঁ, আমি আউটপুট সহ একই এবং পরিষ্কার কোডটি চেষ্টা করেছি int [] a = {1,3,5,2,6,7}; (int i = a.leight-1; i> = 0; i--) {System.out.print (a [i] + "");} `এটি শেষ সূচী থেকে প্রথম সূচীতে অ্যারেটিকে বিপরীত করবে
— রকেট 3 ই
1

এইভাবে এটি করা ভুলের পক্ষে খুব বেশি সম্ভাবনাযুক্ত হবে না?

    int[] intArray = {1, 2, 3, 4, 5, 6, 7, 8, 9, 10};
    int[] temp = new int[intArray.length];
    for(int i = intArray.length - 1; i > -1; i --){
            temp[intArray.length - i -1] = intArray[i];
    }
    intArray = temp;
— ModDL
সূত্র
1

ও (এন) সময় জটিলতা এবং ও (1) স্থান জটিলতার সাথে সমাধান।

void reverse(int[] array) {
    int start = 0;
    int end = array.length - 1;
    while (start < end) {
        int temp = array[start];
        array[start] = array[end];
        array[end] = temp;
        start++;
        end--;
    }
}
— user11016
সূত্র
শুধুমাত্র FYI, এই লুপ জন্য একটি জটিল মধ্যে সরলীকৃত করা যেতে পারে: for (int start = 0, end = array.length - 1; start < end; start++, end--) { ... }।
— টিম কুক
1

একটি অ্যারে বিপরীত 2 উপায়।

  1. ল (লুপ) এর জন্য ও এর সময় জটিলতার সাথে মিড পয়েন্ট অবধি উপাদানগুলিকে অদলবদল করুন (n / 2)।

    private static void reverseArray() {
int[] array = new int[] { 1, 2, 3, 4, 5, 6 };

for (int i = 0; i < array.length / 2; i++) {
    int temp = array[i];
    int index = array.length - i - 1;
    array[i] = array[index];
    array[index] = temp;
}
System.out.println(Arrays.toString(array));

    }

  2. বিল্ট ইন ফাংশন (কালেকশন.প্রিয় ()) ব্যবহার করে

    private static void reverseArrayUsingBuiltInFun() {
int[] array = new int[] { 1, 2, 3, 4, 5, 6 };

Collections.reverse(Ints.asList(array));
System.out.println(Arrays.toString(array));

    }

    আউটপুট: [6, 5, 4, 3, 2, 1]

— সমীর শ্রেষ্ঠ
সূত্র
3
কী Ints?
— কোডিংনিউ
@ কোডিংএখন এটি পেয়ারা ইউটিলিটি হেল্পার ক্লাসগুলির মধ্যে একটি - এখানে দেখুন
— মেরেক
0

নীচে আপনার মেশিনে চালানোর সম্পূর্ণ প্রোগ্রাম রয়েছে।

public class ReverseArray {
    public static void main(String[] args) {
        int arr[] = new int[] { 10,20,30,50,70 };
        System.out.println("reversing an array:");
        for(int i = 0; i < arr.length / 2; i++){
            int temp = arr[i];
            arr[i] = arr[arr.length - i - 1];
            arr[arr.length - i - 1] = temp;
        }
        for (int i = 0; i < arr.length; i++) {
            System.out.println(arr[i]);
        }   
    }
}

অ্যারে ব্যবহার করে ম্যাট্রিক্সের প্রোগ্রামগুলির জন্য এটি ভাল উত্স হবে the লিঙ্কটির মাধ্যমে যান।

— Mdhar9e
সূত্র
0

টেম্পোরাল ভেরিয়েবল এড়ানোর জন্য এক্সওআর সমাধানটি ব্যবহার করা আপনার কোডটির মতো হওয়া উচিত

for(int i = 0; i < validData.length; i++){
    validData[i] = validData[i] ^ validData[validData.length - i - 1];
    validData[validData.length - i - 1] = validData[i] ^ validData[validData.length - i - 1];
    validData[i] = validData[i] ^ validData[validData.length - i - 1];
}

আরও ভাল ব্যাখ্যার জন্য এই লিঙ্কটি দেখুন:

http://betterexplained.com/articles/swap-two-variables-using-xor/

— vikarjramun
সূত্র
0 
private static int[] reverse(int[] array){
    int[] reversedArray = new int[array.length];
    for(int i = 0; i < array.length; i++){
        reversedArray[i] = array[array.length - i - 1];
    }
    return reversedArray;
}
— স্টুয়ার্ট ক্লার্ক
সূত্র
4
আপনার উত্তরের একটি ব্যাখ্যা যোগ বিবেচনা করুন। কোড-কেবলমাত্র উত্তরগুলি কিছুই ব্যাখ্যা করে না।
— rgettman
0

যে কোনও ধরণের অ্যারে , সম্পূর্ণ পূর্ণ / আংশিক সমর্থন বিপরীত করতে এখানে একটি সাধারণ বাস্তবায়ন ।

import java.util.logging.Logger;

public final class ArrayReverser {
 private static final Logger LOGGER = Logger.getLogger(ArrayReverser.class.getName());

 private ArrayReverser () {

 }

 public static <T> void reverse(T[] seed) {
    reverse(seed, 0, seed.length);
 }

 public static <T> void reverse(T[] seed, int startIndexInclusive, int endIndexExclusive) {
    if (seed == null || seed.length == 0) {
        LOGGER.warning("Nothing to rotate");
    }
    int start = startIndexInclusive < 0 ? 0 : startIndexInclusive;
    int end = Math.min(seed.length, endIndexExclusive) - 1;
    while (start < end) {
        swap(seed, start, end);
        start++;
        end--;
    }
}

 private static <T> void swap(T[] seed, int start, int end) {
    T temp =  seed[start];
    seed[start] = seed[end];
    seed[end] = temp;
 }  

}

এখানে সংশ্লিষ্ট ইউনিট পরীক্ষা দেওয়া হচ্ছে 

import static org.hamcrest.CoreMatchers.is;
import static org.junit.Assert.assertThat;

import org.junit.Before;
import org.junit.Test;

public class ArrayReverserTest {
private Integer[] seed;

@Before
public void doBeforeEachTestCase() {
    this.seed = new Integer[]{1,2,3,4,5,6,7,8};
}

@Test
public void wholeArrayReverse() {
    ArrayReverser.<Integer>reverse(seed);
    assertThat(seed[0], is(8));
}

 @Test
 public void partialArrayReverse() {
    ArrayReverser.<Integer>reverse(seed, 1, 5);
    assertThat(seed[1], is(5));
 }
}
— craftsmannadeem
সূত্র
0

এখানে আমি যা নিয়ে এসেছি:

// solution 1 - boiler plated 
Integer[] original = {100, 200, 300, 400};
Integer[] reverse = new Integer[original.length];

int lastIdx = original.length -1;
int startIdx = 0;

for (int endIdx = lastIdx; endIdx >= 0; endIdx--, startIdx++)
   reverse[startIdx] = original[endIdx];

System.out.printf("reverse form: %s", Arrays.toString(reverse));

// solution 2 - abstracted 
// convert to list then use Collections static reverse()
List<Integer> l = Arrays.asList(original);
Collections.reverse(l);
System.out.printf("reverse form: %s", l);
— সহজেই সমাধান
সূত্র
0

সমস্যার সমাধানের জন্য দুটি উপায় রয়েছে:

1. মহাকাশে একটি অ্যারে বিপরীত।

পদক্ষেপ 1. শুরুতে এবং শেষের সূচকে উপাদানগুলিকে অদলবদল করুন।

পদক্ষেপ 2. প্রারম্ভ সূচক হ্রাস শেষ সূচক বৃদ্ধি।

পদক্ষেপ 3. সূচনা <শেষ সূচক শুরু হওয়া অবধি পদক্ষেপ 1 এবং দ্বিতীয় ধাপ Iterate

এর জন্য সময় জটিলতা ও (এন) হবে এবং স্থান জটিলতা হবে ও (1)

মহাকাশে কোনও অ্যারের বিপরীত করার জন্য নমুনা কোডটি হ'ল:

public static int[] reverseAnArrayInSpace(int[] array) {
    int startIndex = 0;
    int endIndex = array.length - 1;
    while(startIndex < endIndex) {
        int temp = array[endIndex];
        array[endIndex] = array[startIndex];
        array[startIndex] = temp;
        startIndex++;
        endIndex--;
    }
    return array;
}

2. সহায়ক অ্যারে ব্যবহার করে একটি অ্যারের বিপরীত করুন।

পদক্ষেপ 1. প্রদত্ত অ্যারের সমান আকারের একটি নতুন অ্যারে তৈরি করুন।

পদক্ষেপ 2. শেষ সূচী থেকে শুরু করা সূচি থেকে শুরু সূচক থেকে শুরু করে নতুন অ্যারেতে উপাদান সন্নিবেশ করান।

এর জন্য সময় জটিলতা ও (এন) হবে এবং স্থান জটিলতা ও (এন) হবে

সহায়ক অ্যারের সাথে কোনও অ্যারের বিপরীত করার জন্য নমুনা কোডটি হ'ল:

public static int[] reverseAnArrayWithAuxiliaryArray(int[] array) {
    int[] reversedArray = new int[array.length];
    for(int index = 0; index < array.length; index++) {
        reversedArray[index] = array[array.length - index -1]; 
    }
    return reversedArray;
}

এছাড়াও, আমরা এটি করতে জাভা থেকে সংগ্রহগুলি API ব্যবহার করতে পারি।

সংগ্রহের এপিআই অভ্যন্তরীণভাবে স্থান ব্যবস্থায় একই বিপরীত ব্যবহার করে।

সংগ্রহগুলি API ব্যবহারের জন্য নমুনা কোডটি হ'ল:

public static Integer[] reverseAnArrayWithCollections(Integer[] array) {
    List<Integer> arrayList = Arrays.asList(array);
    Collections.reverse(arrayList);
    return arrayList.toArray(array);
}
— করণ খান্না
সূত্র
0 
 public static int[] reverse(int[] array) {

    int j = array.length-1;
    // swap the values at the left and right indices //////
        for(int i=0; i<=j; i++)
        {
             int temp = array[i];
                array[i] = array[j];
                array[j] = temp;
           j--;
        }

         return array;
    }

      public static void main(String []args){
        int[] data = {1,2,3,4,5,6,7,8,9};
        reverse(data);

    }
— রোশন পোসক্যা
সূত্র
0

উপরে কয়েকটি দুর্দান্ত উত্তর রয়েছে তবে আমি এটি এটি করেছিলাম:

public static int[] test(int[] arr) {

    int[] output = arr.clone();
    for (int i = arr.length - 1; i > -1; i--) {
        output[i] = arr[arr.length - i - 1];
    }
    return output;
}
— আহমদ দালাও
সূত্র
আমাদের সাইট ব্যবহার করে, আপনি স্বীকার করেছেন যে আপনি আমাদের কুকি নীতি এবং গোপনীয়তা নীতিটি পড়েছেন এবং বুঝতে পেরেছেন ।
Licensed under cc by-sa 3.0 with attribution required.