জাভাতে অ্যারেলিস্টগুলির ছেদ এবং ইউনিয়ন

Question

এটি করার কোনও পদ্ধতি আছে? আমি খুঁজছিলাম কিন্তু কিছুই পাইনি।

আরেকটি প্রশ্ন: আমার এই পদ্ধতিগুলির দরকার তাই আমি ফাইলগুলি ফিল্টার করতে পারি। কিছু ANDফিল্টার এবং কিছু ORফিল্টার (সেট তত্ত্বের মতো), সুতরাং আমাকে সমস্ত ফাইল অনুসারে ফিল্টার করতে হবে এবং সেই ফাইলগুলি ধারণ করে এমন অ্যারেলিস্টগুলি একত্রিত / ছেদ করতে হবে।

ফাইলগুলি ধরে রাখতে আমার কি অন্য কোনও ডেটা স্ট্রাকচার ব্যবহার করা উচিত? এমন আরও কিছু আছে যা আরও ভাল রানটাইম অফার করবে?

Comments

আপনি যদি কোনও নতুন তালিকা তৈরি করতে চান না, তবে ভেক্টর.রেইনএল (ভেক্টর) আপনার অরগানাল ভেক্টরটিকে কেবল দ্বিতীয় ভেক্টরের সাথে ছেদ করে ট্রিম করে।

— ব্যবহারকারী2808054

@ ব্যবহারকারী2808054 কেন Vector? সেই শ্রেণিটি জাভা ২.২ থেকে নিরুৎসাহিত করা হয়েছে।

— dimo414

@ ডিমো 414 একটি ইন্টারফেস যা আমি ব্যবহার করছি (আমার কাছে কোনও বিকল্প নেই) জিনিসগুলি ভেক্টর হিসাবে ফিরিয়ে দেয়। আমি জানি না যে এটি নিরুৎসাহিত হয়েছে! তথ্যের জন্য ধন্যবাদ .. কার দ্বারা নিরুৎসাহিত? আমি এটি

— অবমানিত

জাভাডোকস থেকে: " জাভা 2 প্ল্যাটফর্ম v1.2 হিসাবে ... এটি ভেক্টরের জায়গায় অ্যারেলিস্ট ব্যবহার করার পরামর্শ দেওয়া হচ্ছে। " কেবলমাত্র আপনার প্রয়োজন হতে পারেVector ক্রস-থ্রেড ইন্টারঅ্যাকশনগুলির জন্য, তবে সেইগুলি ব্যবহারের ক্ষেত্রেও নিরাপদ ডেটা স্ট্রাকচার রয়েছে। আরও দেখুন এই প্রশ্নের । Vector2016 সালে এখনও যে কোনও লাইব্রেরি ব্যবহার করছে তা আমার মতে খুব সন্দেহজনক।

— dimo414

@ ডিমো 414 এটি আইবিএম গ্রন্থাগার, হাহাহা! (লোটাস ডোমিনো ডেটা এপিআই)। তথ্যের জন্য ধন্যবাদ, খুব সহায়ক

— ব্যবহারকারী 2808054

Answer 1

কোনও তৃতীয় পক্ষের লাইব্রেরি ব্যবহার না করে এখানে একটি সরল বাস্তবায়ন। প্রধান সুবিধা বেশি retainAll, removeAllএবং addAllযে এই পদ্ধতি পদ্ধতি মূল তালিকা ইনপুট পরিবর্তন না।

public class Test {

    public static void main(String... args) throws Exception {

        List<String> list1 = new ArrayList<String>(Arrays.asList("A", "B", "C"));
        List<String> list2 = new ArrayList<String>(Arrays.asList("B", "C", "D", "E", "F"));

        System.out.println(new Test().intersection(list1, list2));
        System.out.println(new Test().union(list1, list2));
    }

    public <T> List<T> union(List<T> list1, List<T> list2) {
        Set<T> set = new HashSet<T>();

        set.addAll(list1);
        set.addAll(list2);

        return new ArrayList<T>(set);
    }

    public <T> List<T> intersection(List<T> list1, List<T> list2) {
        List<T> list = new ArrayList<T>();

        for (T t : list1) {
            if(list2.contains(t)) {
                list.add(t);
            }
        }

        return list;
    }
}

Comments

আপনি তালিকা 1 উপাদানগুলির সাহায্যে নতুন তালিকা তৈরি করতে পারেন এবং তারপরে ধরে রাখুন সমস্ত, অ্যাডএল পদ্ধতিগুলি

— lukastymo

আপনি কেন এই সমাধানে কড়া ব্যবহার করছেন?

— lukastymo

এর জন্য একটি HashSetব্যবহার করা উচিত intersectionযাতে ওপরের পরিবর্তে গড় ক্ষেত্রে পারফরম্যান্স O (n) হয় n (n ^ 2)।

— জং

এই পোস্টটি জাভা 8 স্ট্রিম এপিআই-র সুবিধাগুলি প্রদর্শনের জন্য একটি আপডেট ব্যবহার করতে পারে।

— এসএম_দেব

আমি ত্রুটি পেয়েছি যখন আমি এই মানটি নির্ধারণ করার চেষ্টা করি -> উদাহরণ: অ্যারেলিস্ট <স্ট্রিং> মোট মোট = (অ্যারেলিস্ট <স্ট্রিং>) ছেদ (তালিকা 2, তালিকা 1) ---> java.util.arraylist java.util.arraylist এ কাস্ট করতে পারবেন না < স্ট্রিং>

— ই

Answer 2

সংগ্রহ (সুতরাং অ্যারেলিস্টেও) রয়েছে:

col.retainAll(otherCol) // for intersection
col.addAll(otherCol) // for union

আপনি যদি পুনরাবৃত্তি গ্রহণ করেন তবে একটি তালিকা বাস্তবায়ন ব্যবহার করুন, যদি আপনি না করেন তবে সেট সেট:

Collection<String> col1 = new ArrayList<String>(); // {a, b, c}
// Collection<String> col1 = new TreeSet<String>();
col1.add("a");
col1.add("b");
col1.add("c");

Collection<String> col2 = new ArrayList<String>(); // {b, c, d, e}
// Collection<String> col2 = new TreeSet<String>();
col2.add("b");
col2.add("c");
col2.add("d");
col2.add("e");

col1.addAll(col2);
System.out.println(col1); 
//output for ArrayList: [a, b, c, b, c, d, e]
//output for TreeSet: [a, b, c, d, e]

Comments

একটি প্রস্তাবিত সম্পাদনা হয়েছে যে এই ইউনিয়নটি "ভুল কারণ এটিতে দু'বার সাধারণ উপাদান থাকবে" । সম্পাদনাটি HashSetপরিবর্তে ব্যবহারের জন্য প্রস্তাবিত ।

— কোস

আসলে এটি সম্পাদিত হয়েছিল, দেখুন: "যদি আপনি পুনরাবৃত্তি গ্রহণ করেন তবে একটি তালিকা বাস্তবায়ন ব্যবহার করুন, আপনি যদি না করেন তবে সেট সেট রূপায়ণ করুন:"

— lukastymo

না, ধরে রাখুন সমস্ত তালিকার জন্য ছেদ নয়। উপরের দিকে, কর্নের সমস্ত উপাদান যা অন্য কোলে নেই সেগুলি সরানো হবে। ধরা যাক অন্যরঙ হ'ল {a, b, b, c} এবং কর্ন {বি, বি, বি, সি, ডি}} তারপরে কোল {বি, বি, বি, সি with দিয়ে শেষ হয় যা দুটির কঠোরভাবে ছেদ নয়। আমি আশা করব যে এটি {বি, বি, সি} হবে} একটি ভিন্ন অপারেশন করা হচ্ছে।

— ডেমোঙ্গোলেম

addAll()তালিকার জন্য ইউনিয়ন কীভাবে হয় তাও আমি দেখতে পাই না ; এটি কেবল প্রথমের শেষে দ্বিতীয় তালিকার সাথে সংযোগ দিচ্ছে। ইউনিয়ন অপারেশন কোনও উপাদান যুক্ত করা এড়াতে পারে যদি প্রথম তালিকায় ইতিমধ্যে এটি থাকে।

— dimo414

Answer 3

এই পোস্টটি বেশ পুরানো, তবে তা সত্ত্বেও গুগলে এই বিষয়টির সন্ধান করার সময় এটিই প্রথম ছিল।

আমি জাভা 8 স্ট্রিমগুলি একক লাইনে একই জিনিস করায় (মূলত) ব্যবহার করে একটি আপডেট দিতে চাই:

List<T> intersect = list1.stream()
    .filter(list2::contains)
    .collect(Collectors.toList());

List<T> union = Stream.concat(list1.stream(), list2.stream())
    .distinct()
    .collect(Collectors.toList());

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

Comments

ওহুফ, এটি একটি দুর্দান্ত এক-লাইনার হতে পারে তবে এটি O (n ^ 2) সময় নেয়। তালিকার একটিতে রূপান্তর করুন Setতারপরে সেটের containsপদ্ধতিটি ব্যবহার করুন । জীবনের প্রতিটি কিছুই স্ট্রিম দিয়ে করা উচিত নয়।

— dimo414

Answer 4

list1.retainAll(list2) - is intersection

ইউনিয়ন হবে removeAllএবং তারপর addAll।

সংগ্রহ ডকুমেন্টেশন আরও খুঁজুন (ArrayList একটি সংগ্রহ) http://download.oracle.com/javase/1.5.0/docs/api/java/util/Collection.html

Comments

উভয় retainAll()এবং তালিকায় removeAll()O (n ^ 2) অপারেশন। আমরা আরও ভাল করতে পারি

— dimo414

আমি ভোট দিয়েছি তবে এখন আমার একটি প্রশ্ন আছে। retainAll{1, 2, 2, 3, 4, 5} এর উপরে {1, 2, 3} এর ফলাফল {1, 2, 2, 3}} ছেদ হওয়ার জন্য {1, 2, 3 be হওয়া উচিত নয়?

— GyuHyeon Choi

Answer 5

ইউনিয়ন এবং ছেদগুলি কেবল সেটগুলির জন্য সংজ্ঞায়িত করা হয়, তালিকা নয়। যেমনটি আপনি উল্লেখ করেছেন।

ফিল্টারগুলির জন্য পেয়ারা লাইব্রেরি পরীক্ষা করুন । এছাড়াও পেয়ারা সত্যিকারের ছেদ এবং ইউনিয়ন সরবরাহ করে

 static <E> Sets.SetView<E >union(Set<? extends E> set1, Set<? extends E> set2)
 static <E> Sets.SetView<E> intersection(Set<E> set1, Set<?> set2)

Answer 6

আপনি অ্যাপাচি কমন্সCollectionUtils থেকে ব্যবহার করতে পারেন ।

Comments

যদি কেউ এই উত্তরটিকে কিছুটা সংক্ষিপ্ত মনে করে: 'কালেকশন ইউটিলস.কন্টেইনস'ই' এবং 'কালেকশন ইউটিলস.কন্টেইনস' সমস্ত পদ্ধতি।

— সেবাস্তিয়ান

এটি

— আশ্চর্যের বিষয় যে অ্যাপাচি

Answer 7

চিহ্নিত সমাধানটি কার্যকর নয়। এটিতে ও (এন ^ 2) সময়ের জটিলতা রয়েছে। আমরা যা করতে পারি তা হ'ল উভয় তালিকাগুলি বাছাই করা এবং একটি ছেদটি অ্যালগরিদমকে নীচের মতটি কার্যকর করা।

private  static ArrayList<Integer> interesect(ArrayList<Integer> f, ArrayList<Integer> s) { 
    ArrayList<Integer> res = new ArrayList<Integer>();

    int i = 0, j = 0; 
    while (i != f.size() && j != s.size()) { 

        if (f.get(i) < s.get(j)) {
            i ++;
        } else if (f.get(i) > s.get(j)) { 
            j ++;
        } else { 
            res.add(f.get(i)); 
            i ++;  j ++;
        }
    }


    return res; 
}

এটির ও (এন লগ এন + এন) এর জটিলতা রয়েছে যা ও (এন লগ এন) এ রয়েছে। ইউনিয়নটি একই পদ্ধতিতে করা হয়। কেবলমাত্র নিশ্চিত হয়ে নিন যে আপনি যদি-ifif-else বিবৃতিতে উপযুক্ত পরিবর্তনগুলি করেন।

আপনি চাইলে পুনরুক্তিও ব্যবহার করতে পারেন (আমি জানি তারা সি ++ এ আরও দক্ষ,

Comments

জেনারিক পর্যাপ্ত নয়, টি তুলনামূলক হতে পারে না এবং কিছু ক্ষেত্রে তুলনা করা ব্যয়বহুল ...

— বরিস চুরজিন

জেনেরিক নয়, আমি সম্পূর্ণ একমত তুলনা কি ব্যয়বহুল? কীভাবে সমাধান করবেন?

— আজেদ

দুঃখজনকভাবে - ও (এন ^ 2) এ এটি করা সস্তা হবে :) সংখ্যাগুলির জন্য এই সমাধানটি ভাল ...

— বোরিস চুরজিন

দুঃখের সাথে - আপনি আমার প্রশ্নের উত্তর দেন নি। আমাকে এটি আবার নতুন করে বলা যাক, সি (এন) এর তুলনা ফাংশনটি কীভাবে ও (এন ^ 2) দিয়ে দেওয়া ভাল?

— আজেদ

একটি ইনপুটকে একটি সেটে রূপান্তর করা contains()এবং একটি লুপে কল করা (দেবেনভ পরামর্শ হিসাবে) ও (এন + এম) সময় নিতে পারে। বাছাই অযথা জটিল এবং ও (এন লগ এন + এম লগ এন + এন) সময় নেয়। অনুমোদিত যে ও (এন লগ এন) সময়কে হ্রাস করে তবে এটি লিনিয়ার সময়ের চেয়ে আরও খারাপ এবং আরও জটিল।

— dimo414

Answer 8

আমার মনে হয় আপনি Setযদি ফাইলগুলিকে ছেদ করতে এবং তাদের সাথে ইউনিয়ন করতে চান তবে ফাইলগুলি ধরে রাখতে আপনার ব্যবহার করা উচিত । তারপর আপনি ব্যবহার করতে পারেন পেয়ারা এর সেট বর্গ করতে union, intersectionএকটি দ্বারা এবং ফিল্টারিং Predicateপাশাপাশি। এই পদ্ধতির এবং অন্যান্য পরামর্শগুলির মধ্যে পার্থক্য হ'ল এই সমস্ত পদ্ধতির দুটি সেটগুলির ইউনিয়ন, ছেদ ইত্যাদির অলস দৃষ্টিভঙ্গি তৈরি করে। অ্যাপাচি কমন্স একটি নতুন সংগ্রহ তৈরি করে এবং এতে ডেটা অনুলিপি করে। retainAllএটি থেকে উপাদানগুলি সরিয়ে আপনার সংগ্রহগুলির মধ্যে একটি পরিবর্তন করে।

Answer 9

এখানে কীভাবে আপনি স্ট্রিমগুলির সাথে ছেদটি করতে পারেন তা মনে রাখবেন (মনে রাখবেন যে আপনাকে স্ট্রিমের জন্য জাভা 8 ব্যবহার করতে হবে):

List<foo> fooList1 = new ArrayList<>(Arrays.asList(new foo(), new foo()));
List<foo> fooList2 = new ArrayList<>(Arrays.asList(new foo(), new foo()));
fooList1.stream().filter(f -> fooList2.contains(f)).collect(Collectors.toList());

বিভিন্ন ধরণের তালিকাগুলির জন্য একটি উদাহরণ। যদি আপনার foo এবং বারের মধ্যে রিয়েলেশন থাকে এবং আপনি নিজের স্ট্রিমটি পরিবর্তন করতে পারেন তার চেয়ে foo থেকে একটি বার-অবজেক্ট পেতে পারেন:

List<foo> fooList = new ArrayList<>(Arrays.asList(new foo(), new foo()));
List<bar> barList = new ArrayList<>(Arrays.asList(new bar(), new bar()));

fooList.stream().filter(f -> barList.contains(f.getBar()).collect(Collectors.toList());

Answer 10

• ধরে রাখুন সমস্ত আপনার তালিকা পরিবর্তন করবে
• পেয়ারার তালিকার জন্য এপিআই নেই (কেবলমাত্র সেট জন্য)

আমি ব্যবহারের ক্ষেত্রে লিস্ট ইউটিসকে খুব দরকারী বলে মনে করেছি।

আপনি যদি বিদ্যমান তালিকাটি সংশোধন করতে না চান তবে org.apache.commons.colલેક્શન থেকে তালিকা ব্যবহার করুন।

ListUtils.intersection(list1, list2)

Answer 11

আপনি কমন্স-কালেকশন 4 কালেকশন ইউটিস ব্যবহার করতে পারেন

Collection<Integer> collection1 = Arrays.asList(1, 2, 4, 5, 7, 8);
Collection<Integer> collection2 = Arrays.asList(2, 3, 4, 6, 8);

Collection<Integer> intersection = CollectionUtils.intersection(collection1, collection2);
System.out.println(intersection); // [2, 4, 8]

Collection<Integer> union = CollectionUtils.union(collection1, collection2);
System.out.println(union); // [1, 2, 3, 4, 5, 6, 7, 8]

Collection<Integer> subtract = CollectionUtils.subtract(collection1, collection2);
System.out.println(subtract); // [1, 5, 7]

Answer 12

জাভা 8-তে আমি এর মতো সহজ সহায়ক পদ্ধতি ব্যবহার করি:

public static <T> Collection<T> getIntersection(Collection<T> coll1, Collection<T> coll2){
    return Stream.concat(coll1.stream(), coll2.stream())
            .filter(coll1::contains)
            .filter(coll2::contains)
            .collect(Collectors.toSet());
}

public static <T> Collection<T> getMinus(Collection<T> coll1, Collection<T> coll2){
    return coll1.stream().filter(not(coll2::contains)).collect(Collectors.toSet());
}

public static <T> Predicate<T> not(Predicate<T> t) {
    return t.negate();
}

Answer 13

যদি তালিকার অবজেক্টগুলি হ্যাশযোগ্য হয় (যেমন একটি শালীন হ্যাশকোড এবং সমান ফাংশন রয়েছে), সারণীর মধ্যে প্রায় দ্রুততম পদ্ধতির। আকার> 20 দুটি তালিকার বৃহত্তর জন্য একটি হ্যাশসেট তৈরি করতে হবে।

public static <T> ArrayList<T> intersection(Collection<T> a, Collection<T> b) {
    if (b.size() > a.size()) {
        return intersection(b, a);
    } else {
        if (b.size() > 20 && !(a instanceof HashSet)) {
            a = new HashSet(a);
        }
        ArrayList<T> result = new ArrayList();
        for (T objb : b) {
            if (a.contains(objb)) {
                result.add(objb);
            }
        }
        return result;
    }
}

Answer 14

আমিও একই পরিস্থিতিতে কাজ করছিলাম এবং সাহায্যের সন্ধানে এখানে পৌঁছেছি। অ্যারেগুলির জন্য আমার নিজের সমাধানটি সন্ধান করে শেষ হয়েছিল। অ্যারেলিস্ট অনুপস্থিত তারিখগুলি = নতুন অ্যারেলিস্ট (); // অ্যারে 1-অ্যারে 2 সঞ্চয় করবে

দ্রষ্টব্য: এটি পোস্ট করা যদি এটি কাউকে সহায়তার জন্য এই পৃষ্ঠায় পৌঁছাতে সহায়তা করে।

ArrayList<String> AbsentDates = new ArrayList<String>();//This Array will store difference
      public void AbsentDays() {
            findDates("April", "2017");//Array one with dates in Month April 2017
            findPresentDays();//Array two carrying some dates which are subset of Dates in Month April 2017

            for (int i = 0; i < Dates.size(); i++) {

                for (int j = 0; j < PresentDates.size(); j++) {

                    if (Dates.get(i).equals(PresentDates.get(j))) {

                        Dates.remove(i);
                    }               

                }              
                AbsentDates = Dates;   
            }
            System.out.println(AbsentDates );
        }

Answer 15

সাধারণ কী এর উপর ভিত্তি করে দুটি পৃথক বস্তুর দুটি তালিকা ছেদ করে - জাভা 8

 private List<User> intersection(List<User> users, List<OtherUser> list) {

        return list.stream()
                .flatMap(OtherUser -> users.stream()
                        .filter(user -> user.getId()
                                .equalsIgnoreCase(OtherUser.getId())))
                .collect(Collectors.toList());
    }

Comments

কিভাবে এই 2 তালিকার মধ্যে পার্থক্য সেট সম্পর্কে?

— জিন

Answer 16

public static <T> Set<T> intersectCollections(Collection<T> col1, Collection<T> col2) {
    Set<T> set1, set2;
    if (col1 instanceof Set) {
        set1 = (Set) col1;
    } else {
        set1 = new HashSet<>(col1);
    }

    if (col2 instanceof Set) {
        set2 = (Set) col2;
    } else {
        set2 = new HashSet<>(col2);
    }

    Set<T> intersection = new HashSet<>(Math.min(set1.size(), set2.size()));

    for (T t : set1) {
        if (set2.contains(t)) {
            intersection.add(t);
        }
    }

    return intersection;
}

জেডিকে 8 + (সম্ভবত সেরা পারফরম্যান্স)

public static <T> Set<T> intersectCollections(Collection<T> col1, Collection<T> col2) {
    boolean isCol1Larger = col1.size() > col2.size();
    Set<T> largerSet;
    Collection<T> smallerCol;

    if (isCol1Larger) {
        if (col1 instanceof Set) {
            largerSet = (Set<T>) col1;
        } else {
            largerSet = new HashSet<>(col1);
        }
        smallerCol = col2;
    } else {
        if (col2 instanceof Set) {
            largerSet = (Set<T>) col2;
        } else {
            largerSet = new HashSet<>(col2);
        }
        smallerCol = col1;
    }

    return smallerCol.stream()
            .filter(largerSet::contains)
            .collect(Collectors.toSet());
}

আপনি যদি পারফরম্যান্সের বিষয়ে চিন্তা না করেন এবং ছোট কোডটি পছন্দ করেন তবে কেবল ব্যবহার করুন:

col1.stream().filter(col2::contains).collect(Collectors.toList());

Answer 17

চূড়ান্ত সমাধান:

//all sorted items from both
public <T> List<T> getListReunion(List<T> list1, List<T> list2) {
    Set<T> set = new HashSet<T>();
    set.addAll(list1);
    set.addAll(list2);
    return new ArrayList<T>(set);
}

//common items from both
public <T> List<T> getListIntersection(List<T> list1, List<T> list2) {
    list1.retainAll(list2);
    return list1;
}

//common items from list1 not present in list2
public <T> List<T> getListDifference(List<T> list1, List<T> list2) {
    list1.removeAll(list2);
    return list1;
}

Answer 18

প্রথমে, আমি অ্যারের সমস্ত মান একক অ্যারে অনুলিপি করছি তারপরে আমি নকল মানগুলিকে অ্যারেতে সরিয়ে দিচ্ছি। লাইন 12, ব্যাখ্যা করে যদি একই সংখ্যা সময়ের চেয়ে বেশি ঘটে থাকে তবে কিছু জঞ্জাল মান "জে" অবস্থানে রাখুন। শেষে, প্রারম্ভ-প্রান্ত থেকে অতিক্রম করে পরীক্ষা করুন এবং একই আবর্জনার মান হয় কিনা তা বাতিল করুন।

public class Union {
public static void main(String[] args){

    int arr1[]={1,3,3,2,4,2,3,3,5,2,1,99};
    int arr2[]={1,3,2,1,3,2,4,6,3,4};
    int arr3[]=new int[arr1.length+arr2.length];

    for(int i=0;i<arr1.length;i++)
        arr3[i]=arr1[i];

    for(int i=0;i<arr2.length;i++)
        arr3[arr1.length+i]=arr2[i];
    System.out.println(Arrays.toString(arr3));

    for(int i=0;i<arr3.length;i++)
    {
        for(int j=i+1;j<arr3.length;j++)
        {
            if(arr3[i]==arr3[j])
                arr3[j]=99999999;          //line  12
        }
    }
    for(int i=0;i<arr3.length;i++)
    {
        if(arr3[i]!=99999999)
            System.out.print(arr3[i]+" ");
    }
}   
}

Comments

স্ট্যাক ওভারফ্লোতে স্বাগতম! দয়া করে নোট করুন যে প্রশ্নটি অ্যারেলিস্ট সম্পর্কে। এছাড়াও, আমি ভয় করি যে এই নির্দিষ্ট প্রয়োগটি জিনিসগুলি পছন্দসই হতে পারে। মান 99999999, যা সেন্ডিনেল হিসাবে ব্যবহৃত হয়, ইনপুটটিতে হতে পারে। ArrayListইউনিয়নের ফলাফল সংরক্ষণ করার জন্য একটি গতিশীল কাঠামো ব্যবহার করা ভাল ।

— এসএল বার্থ - মনিকা

দয়া করে একটি কোড উত্তরের পরিবর্তে আপনি উপস্থাপিত কোডটি ব্যাখ্যা করুন।

— tmarois

আমি কেবল একটি ক্লু দিচ্ছি আপনাকে কোনও আবর্জনা মূল্য দিতে হবে

— আশুতোষ

আপনি একটি ব্যাখ্যা যুক্ত দেখে খুশি। দুর্ভাগ্যক্রমে, উত্তরটি এখনও খারাপ। অ্যারে ব্যবহার করার কোনও কারণ নেই। আপনার অ্যারেলিস্টের মতো একটি গতিশীল কাঠামো ব্যবহার করা উচিত। যদি (কোনও কারণে) আপনাকে অবশ্যই অ্যারে ব্যবহার করা উচিত তবে আপনার Integerপরিবর্তে অ্যারে ব্যবহার করা উচিত int। তারপরে আপনি nullআপনার "আবর্জনা মান" এর পরিবর্তে ব্যবহার করতে পারেন । "আবর্জনা মান" বা "সেন্ডিনেল মান" সাধারণত একটি খারাপ ধারণা, কারণ ইনপুটটিতে এই মানগুলি এখনও ঘটতে পারে।

— এসএল বার্থ - মনিকা

Answer 19

পরীক্ষার পরে, এটি আমার সেরা ছেদ পদ্ধতির।

খাঁটি হ্যাশসেট পদ্ধতির তুলনায় দ্রুত গতি। নীচে হ্যাশসেট এবং হ্যাশম্যাপে 1 মিলিয়নেরও বেশি রেকর্ড সহ অ্যারেগুলির জন্য একই রকম পারফরম্যান্স রয়েছে।

জাভা 8 স্ট্রিম পদ্ধতির হিসাবে, 10k এর চেয়ে বড় অ্যারের আকারের জন্য গতি বেশ ধীর।

আশা করি এটি সাহায্য করতে পারে।

public static List<String> hashMapIntersection(List<String> target, List<String> support) {
    List<String> r = new ArrayList<String>();
    Map<String, Integer> map = new HashMap<String, Integer>();
    for (String s : support) {
        map.put(s, 0);
    }
    for (String s : target) {
        if (map.containsKey(s)) {
            r.add(s);
        }
    }
    return r;
}
public static List<String> hashSetIntersection(List<String> a, List<String> b) {
    Long start = System.currentTimeMillis();

    List<String> r = new ArrayList<String>();
    Set<String> set = new HashSet<String>(b);

    for (String s : a) {
        if (set.contains(s)) {
            r.add(s);
        }
    }
    print("intersection:" + r.size() + "-" + String.valueOf(System.currentTimeMillis() - start));
    return r;
}

public static void union(List<String> a, List<String> b) {
    Long start = System.currentTimeMillis();
    Set<String> r= new HashSet<String>(a);
    r.addAll(b);
    print("union:" + r.size() + "-" + String.valueOf(System.currentTimeMillis() - start));
}

Answer 20

সাধারণ উপাদান সনাক্তকরণের জন্য সমস্ত () পদ্ধতি ব্যবহার করুন..একটি ছেদ তালিকার তালিকা 1.রেইনএল (তালিকা 2)

Answer 21

যদি আপনার ডেটা সেটে থাকে তবে আপনি পেয়ারার Setsক্লাসটি ব্যবহার করতে পারবেন ।

Answer 22

যদি আমি যাচাই করে যাচ্ছি তার চেয়ে বেশি সংখ্যাটি যদি প্রথমবারের মতো দেখা যায় বা "ইন্ডেক্সআফ ()" এর সাহায্যে না হয় তবে যদি সংখ্যাটি প্রথমবারের সাথে মেলে তবে মুদ্রণ করে একটি স্ট্রিংয়ে সংরক্ষণ করুন, যাতে পরের বারের মতো একই সংখ্যার মিল হয় তবে তা জিতেছে ' t মুদ্রণ কারণ "indexOf ()" এর কারণে শর্তটি মিথ্যা হবে।

class Intersection
{
public static void main(String[] args)
 {
  String s="";
    int[] array1 = {1, 2, 5, 5, 8, 9, 7,2,3512451,4,4,5 ,10};
    int[] array2 = {1, 0, 6, 15, 6, 5,4, 1,7, 0,5,4,5,2,3,8,5,3512451};


       for (int i = 0; i < array1.length; i++)
       {
           for (int j = 0; j < array2.length; j++)
           {
               char c=(char)(array1[i]);
               if(array1[i] == (array2[j])&&s.indexOf(c)==-1)
               {    
                System.out.println("Common element is : "+(array1[i]));
                s+=c;
                }
           }
       }    
}

}

Comments

উত্তর হিসাবে কেবল কোড পোস্ট করবেন না, আপনি কী করছেন তার কিছুটা ব্যাখ্যা দিন

— ব্র্যান্ডন জামুদিও

এটি আমার প্রথম প্রোগ্রাম যা আমি আপলোড করেছি

— আশুতোষ

যদিও এই কোডটি সমস্যা সমাধানে সহায়তা করতে পারে তবে এটি কেন এবং / বা কীভাবে প্রশ্নের উত্তর দেয় তা ব্যাখ্যা করে না । এই অতিরিক্ত প্রসঙ্গ সরবরাহ করা তার দীর্ঘমেয়াদী মানকে উল্লেখযোগ্যভাবে উন্নতি করবে। দয়া করে সম্পাদনা ব্যাখ্যা যোগ করার জন্য সহ সীমাবদ্ধতা এবং অনুমানের কি প্রয়োগ আপনার উত্তর।

— টবি স্পাইট