একটি তালিকায় সদৃশ সনাক্ত করুন

Question

আমার ধরণের পূর্ণসংখ্যার একটি তালিকা রয়েছে যেমন:

[1, 1, 2, 3, 3, 3]

আমি সমস্ত নকল যেমন ফেরত দেওয়ার একটি পদ্ধতি চাই:

[1, 3]

এই কাজ করতে সবচেয়ে ভালো উপায় কি?

Comments

ইনপুট তালিকাটি বাছাই করার নিশ্চয়তা রয়েছে (যেমন আপনার উদাহরণ হিসাবে)?

— এনপিই

তালিকাটি বাছাই করুন, তারপরে বর্তমান এবং পূর্বের মানগুলি রেখে এটি চলুন। যদি বর্তমান == পূর্বে আপনার একটি সদৃশ থাকে।

— mcfinnigan

না, তালিকাটি অবশ্যই সাজানো হয় না।

— সর্বশেষতম

Answer 1

পদ্ধতি addএর Setআয় একটি বুলিয়ান একটি মান আগে থেকেই আছে কিনা (সত্য যদি এটি বিদ্যমান নয়, মিথ্যা যদি এটা আগে থেকেই আছে দেখতে সেট ডকুমেন্টেশন )।

সুতরাং সমস্ত মানগুলির মধ্যে কেবল পুনরাবৃত্তি করুন:

public Set<Integer> findDuplicates(List<Integer> listContainingDuplicates)
{ 
  final Set<Integer> setToReturn = new HashSet<>(); 
  final Set<Integer> set1 = new HashSet<>();

  for (Integer yourInt : listContainingDuplicates)
  {
   if (!set1.add(yourInt))
   {
    setToReturn.add(yourInt);
   }
  }
  return setToReturn;
}

Comments

আপনি কেন TTOReturn আছে? আপনি কি শুধু set1.add (yourInt) এবং ফিরতি সেট 1 ব্যবহার করতে পারবেন না?

— ফিল

হ্যাঁ অবশ্যই. কিন্তু যখন কোনও এলিমেন্ট নির্দিষ্ট তালিকায় একবার উপস্থিত হয় তখন উপাদানটি পাশাপাশি যুক্ত করা হয়। প্রশ্নের উদাহরণটি দেখুন: আমার সমাধানটি ফিরে আসবে [1,3] যেহেতু 2 নম্বর সেট 1 তে isোকানো হয়েছে তবে সেটটোটারনে নয়। আপনার সমাধান ফিরে আসবে [1,2,3] (যা প্রয়োজন নয়)

— লেফগ

আমি আপনাকে পরামর্শ দিচ্ছি যে for (Integer yourIntঅপ্রয়োজনীয় বক্সিং এবং আনবক্সিং এড়ানোর জন্য আপনি ব্যবহার করুন , বিশেষত যেহেতু আপনার ইনপুটটিতে ইতিমধ্যে Integerএস রয়েছে ।

— হোসাম আলি

@ জোনাস টেলিমেন একটি সেট সম্পর্কে পুরো ধারণাটি হ'ল এটিতে নকল থাকতে পারে না। অতএব: আপনি 3 টি যোগ করুন কতক্ষণ তা সর্বদা কেবল একবারই শেষ হবে।

— লিফগ

যাইহোক, HashSetআপনার ক্ষেত্রে লোড ফ্যাক্টরটিও বিবেচনা করতে হবে, উদাহরণস্বরূপ যখন আপনি একটি প্রাথমিক ক্ষমতা নির্দিষ্ট করে 100, কারণ আপনি সেই সংখ্যার উপাদান যুক্ত করতে চান, এটি পরবর্তী (2 128) এর শক্তিতে গোলাকার হয়ে যায়, যা বোঝায় যে এর ডিফল্ট লোড ফ্যাক্টরের সাথে 0.75f, আকার পরিবর্তন করা হবে 96, সুতরাং আপনি 100উপাদান যুক্ত করার আগে একটি আকার পরিবর্তন হবে res ধন্যবাদ, পুনরায় আকার দেওয়া এত ব্যয়বহুল নয়। আপ টু ডেট জেআরই-র সাথে, আকার পরিবর্তন করা আর আর পুনরায় করা হচ্ছে না, উপাদানগুলি কেবল প্রাসঙ্গিক বিটের উপর ভিত্তি করে তাদের দুটি সম্ভাব্য ফলাফলের স্থানে বিতরণ করা হবে get

— হলগার

Answer 2

আমারও এর সমাধান দরকার ছিল। আমি লেফগের সমাধানটি ব্যবহার করে জেনেরিক করে তুলেছি।

private <T> Set<T> findDuplicates(Collection<T> collection) {

    Set<T> duplicates = new LinkedHashSet<>();
    Set<T> uniques = new HashSet<>();

    for(T t : collection) {
        if(!uniques.add(t)) {
            duplicates.add(t);
        }
    }

    return duplicates;
}

Comments

আমি জানি এটি 3 বছর পরে, তবে কেন একটি লিঙ্কডহ্যাশডসেট, আপনি কেন অর্ডারটি যত্ন করছেন?

— আহমদ রাগব

@ আহমাদরাগব আপনি ঠিক বলেছেন, ডুপ্লিকেটগুলি যে ক্রমানুসারে পাওয়া গেছে (যা আমি মনে করি আমি সেই সময়ে করেছি) সে সম্পর্কে যত্ন না নিলে লিঙ্কডহ্যাশসেটের প্রয়োজন হয় না

— জন স্ট্রিকলার

অনুসরণ করার জন্য ধন্যবাদ!

— আহমদ রাগাব

যদি আপনার কাছে এত বেশি ইনপুট ডেটা থাকে যে আপনি এই সর্বোত্তম সমাধানটি (ইনপুটটি বাছাই করার পরিবর্তে) ব্যবহার করতে চান তবে আপনি হ্যাশসেট () অবজেক্টগুলির আকার পূর্ব-বরাদ্দ করতে চান। পূর্বনির্ধারণ ব্যতীত, হ্যাশসেটে প্রবেশ করার সময় আপনি ও (1) সন্নিবেশের সময় পান না। এটি কারণ অভ্যন্তরীণ হ্যাশ অ্যারে বারবার আকার পরিবর্তন করা হয়। সন্নিবেশগুলি তখন ও (লগ এন) সময়ের মতো কিছু গড় করে। এর অর্থ হল সমস্ত এন আইটেমগুলি প্রক্রিয়াজাতকরণ ও (এন লগ এন) হয়ে যায় যখন এটি ও (এন) হতে পারে।

— জনস্টোশ

Answer 3

আমি জন স্ট্রিকারের সমাধান নিয়েছি এবং জেডিকে 8 তে প্রবর্তিত স্ট্রিমাল এপিআই ব্যবহার করতে এটি পুনরায় তৈরি করেছি:

private <T> Set<T> findDuplicates(Collection<T> collection) {
    Set<T> uniques = new HashSet<>();
    return collection.stream()
        .filter(e -> !uniques.add(e))
        .collect(Collectors.toSet());
}

Comments

এই ধরনের পড়া কঠিন, না? আপনি স্ট্রিম অপারেশনে একটি পার্শ্ব-প্রতিক্রিয়া করছেন, এটির বিষয়ে যুক্তিযুক্ত হওয়া শক্ত। তবে এটি কেবল আমি কার্যকরী শৈলীতে ভাবছি। এটি সংক্ষিপ্ত এবং সম্ভবত সংক্ষিপ্ততম যদিও;)।

— ব্যাঙবাঁধে

বড় তালিকাগুলির জন্য আপনি একাধিক থ্রেডে সমান্তরালে এটিকে সম্পাদন করতে পারেন?

— জনস্টোশ

@ ফ্রিজিনেভারেশন বিল্ট ইন distinct()পদ্ধতিটিও রাষ্ট্রীয় । কোনও দক্ষ (ও (এন)) স্বতন্ত্র ক্রিয়াকলাপটি যা রাষ্ট্রীয় নয় তা ভাবতে পারি না।

— উইলমল

Answer 4

এখানে জাভা 8 সহ স্ট্রিম ব্যবহার করে একটি সমাধান দেওয়া হয়েছে

// lets assume the original list is filled with {1,1,2,3,6,3,8,7}
List<String> original = new ArrayList<>();
List<String> result = new ArrayList<>();

আপনি কেবল দেখেন যে এই জিনিসের ফ্রিকোয়েন্সি আপনার তালিকায় একাধিকবার রয়েছে কিনা। তারপরে .distinct () কে শুধুমাত্র আপনার ফলাফলের অনন্য উপাদান থাকতে কল করুন

result = original.stream()
    .filter(e -> Collections.frequency(original, e) > 1)
    .distinct()
    .collect(Collectors.toList());
// returns {1,3}
// returns only numbers which occur more than once

result = original.stream()
    .filter(e -> Collections.frequency(original, e) == 1)
    .collect(Collectors.toList());
// returns {2,6,8,7}
// returns numbers which occur only once

result = original.stream()
    .distinct()
    .collect(Collectors.toList());
// returns {1,2,3,6,8,7}
// returns the list without duplicates

Comments

এই পাঠযোগ্যতা পরিপ্রেক্ষিতে ভাল জিনিস, কিন্তু এটা প্রকৃতই পারফরম্যান্সের জন্য খারাপ। Collections::frequencyও (এন) হয়। কোনও আইটেমের ফ্রিকোয়েন্সি খুঁজে পেতে এটি পুরো সংগ্রহটি অতিক্রম করতে হবে। এবং আমরা সংগ্রহের প্রতিটি আইটেমের জন্য এটি একবার কল করছি, যা এই স্নিপেটগুলি করে O(n^2)। আপনি মুষ্টিমেয় উপাদানগুলির চেয়ে বেশি যে কোনও সংগ্রহের মধ্যে পার্থক্য লক্ষ্য করবেন। আমি এটিকে কখনই আসল কোডে ব্যবহার করব না।

— পবন

Answer 5

জাভা 8 বেস সমাধান:

List duplicates =    
list.stream().collect(Collectors.groupingBy(Function.identity()))
    .entrySet()
    .stream()
    .filter(e -> e.getValue().size() > 1)
    .map(Map.Entry::getKey)
    .collect(Collectors.toList());

Comments

ইনপুট তালিকাটি মানচিত্রে ট্রান্সফর্ম হয় (একই মান অনুসারে গোষ্ঠীকরণ)। তারপরে অনন্য মান সহ মানচিত্রের মানগুলি "মুছে ফেলা হবে" তারপরে কীটি ব্যবহার করে মানচিত্রটি তৈরি করা হবে, তারপরে তালিকার তালিকাটি তালিকায় রূপান্তরিত হবে

— بلال المصمودي

সুন্দর এবং দ্রুত সমাধান, আইটেমের নির্দিষ্ট

— গ্রাহকদের

Answer 6

int[] nums =  new int[] {1, 1, 2, 3, 3, 3};
Arrays.sort(nums);
for (int i = 0; i < nums.length-1; i++) {

    if (nums[i] == nums[i+1]) {
        System.out.println("duplicate item "+nums[i+1]+" at Location"+(i+1) );
    }

}

স্পষ্টতই আপনি মুদ্রণের পরিবর্তে তাদের সাথে যা খুশি করতে পারেন (যেমন ডুপ্লিকেট মানগুলির একটি অনন্য তালিকা পেতে একটি সেট রাখুন) ... এতে নকল আইটেমগুলির অবস্থানটিও রেকর্ড করার সুবিধা রয়েছে।

Answer 7

জাভা 8 এ পেয়ারা ব্যবহার করা

private Set<Integer> findDuplicates(List<Integer> input) {
    // Linked* preserves insertion order so the returned Sets iteration order is somewhat like the original list
    LinkedHashMultiset<Integer> duplicates = LinkedHashMultiset.create(input);

    // Remove all entries with a count of 1
    duplicates.entrySet().removeIf(entry -> entry.getCount() == 1);

    return duplicates.elementSet();
}

Answer 8

এটিও কাজ করে:

public static Set<Integer> findDuplicates(List<Integer> input) {
    List<Integer> copy = new ArrayList<Integer>(input);
    for (Integer value : new HashSet<Integer>(input)) {
        copy.remove(value);
    }
    return new HashSet<Integer>(copy);
}

Comments

এটি কাজ করে, তবে এটি অ্যারে তালিকায় অপসারণ () কল করা একটি লিনিয়ার অনুসন্ধান হিসাবে এটি ধীরে ধীরে।

— জনস্টোশ

সত্য। মনে রাখবেন যে যদি আপনার ইনপুটটিতে অনেকগুলি সদৃশ থাকে তবে পারফরম্যান্স হিট যদি তার মধ্যে কয়েকটি থাকে তবে তার চেয়ে কম।

— অ্যাড্রিয়ান কোস্টার

Answer 9

আপনি এর মতো কিছু ব্যবহার করতে পারেন:

List<Integer> newList = new ArrayList<Integer>();
for(int i : yourOldList)
{
    yourOldList.remove(i);
    if(yourOldList.contains(i) && !newList.contains(i)) newList.add(i);
}

Comments

এখানে তালিকা ব্যবহার করা খুব অকার্যকর

— আলেকজান্ডার ফারবার

এবং আমাকে intএখানে ভেরিয়েবল টাইপ হিসাবে ব্যবহার করতে শুরু করবেন না । এর অর্থ হ'ল প্রতিটি একক পুনরাবৃত্তির জন্য, একটি পূর্ণসংখ্যা একবার আনবক্স করা হয় এবং চারটি বার চারটি বাক্সযুক্ত হয়!

— সান প্যাট্রিক ফ্লয়েড

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

— জাদ বি।

আপনি যদি কোনও তালিকার উপরে পুনরাবৃত্তি করেন এবং আপনি ফ্লাইয়ের উপাদানগুলি সরিয়ে দেন এটি এটি 100% সমান্তরাল পদ্ধতি পরিবর্তন is

— theo231022

Answer 10

Lambas একটি সমাধান হতে পারে

Integer[] nums =  new Integer[] {1, 1, 2, 3, 3, 3};
List<Integer> list = Arrays.asList(nums);

List<Integer> dps = list.stream().distinct().filter(entry -> Collections.frequency(list, entry) > 1).collect(Collectors.toList());

Comments

কাজ করে, তবে এটি প্রতিটি এন্ট্রির জন্য কালেকশনস-ফ্রিকোয়েন্সি চালায় এবং এইভাবে ধীর হয়।

— আরবার্গ

Answer 11

প্রতিটি মানকে কী / মান সেট হিসাবে সঞ্চয় করতে একাধিক মানচিত্র ব্যবহার করুন। তারপরে কীগুলির মাধ্যমে পুনরাবৃত্তি করুন এবং একাধিক মান সহ একটি সন্ধান করুন।

Answer 12

আপনি যদি গ্রিপস সংগ্রহগুলি ব্যবহার করেন তবে এটি কাজ করবে:

MutableList<Integer> list = Lists.mutable.with(1, 1, 2, 3, 3, 3);
Set<Integer> dupes = list.toBag().selectByOccurrences(i -> i > 1).toSet();
Assert.assertEquals(Sets.mutable.with(1, 3), dupes);

আপডেট: Eclipse সংগ্রহ হিসাবে 9.2 আপনি এখন ব্যবহার করতে পারেনselectDuplicates

MutableList<Integer> list = Lists.mutable.with(1, 1, 2, 3, 3, 3);
Set<Integer> dupes = list.toBag().selectDuplicates().toSet();
Assert.assertEquals(Sets.mutable.with(1, 3), dupes);

এটি সম্পাদন করতে আপনি আদিম সংগ্রহগুলিও ব্যবহার করতে পারেন:

IntList list = IntLists.mutable.with(1, 1, 2, 3, 3, 3);
IntSet dupes = list.toBag().selectDuplicates().toSet();
Assert.assertEquals(IntSets.mutable.with(1, 3), dupes);

দ্রষ্টব্য: আমি গ্রহগ্রাহ সংগ্রহের প্রতিশ্রুতিবদ্ধ।

Answer 13

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

           List<Integer> listOf = new ArrayList<Integer>();
           listOf.add(3);
           listOf.add(1);
           listOf.add(2);
           listOf.add(3);
           listOf.add(3);
           listOf.add(2);
           listOf.add(1);

           List<Integer> tempList = new ArrayList<Integer>();
           for(Integer obj:listOf){
                if(!tempList.contains(obj)){
                    tempList.add(obj);

                }
            }
            System.out.println(tempList);

    }

}

Comments

আমি এই উত্তরটি পছন্দ করি, অন্য তালিকায় সদৃশটি সংরক্ষণ করতে অন্য একটি যুক্ত করা দরকার। ধন্যবাদ

— টিয়াগো মাচাডো

Answer 14

এখানে কিছু উত্তরের অনুরূপ, তবে আপনি যদি কিছু সংখ্যার উপর ভিত্তি করে সদৃশ সন্ধান করতে চান:

  public static <T, R> Set<R> findDuplicates(Collection<? extends T> collection, Function<? super T, ? extends R> mapper) {
    Set<R> uniques = new HashSet<>();
    return collection.stream()
        .map(mapper)
        .filter(e -> !uniques.add(e))
        .collect(toSet());
  }

Answer 15

একটি তৈরি করুন Map<Integer,Integer>, তালিকাটি পুনরাবৃত্তি করুন, যদি কোনও উপাদান মানচিত্রে থাকে তবে এর মান বাড়ান, অন্যথায় মানকে কী = 1
দিয়ে পুনরায় পুনরায় মানচিত্রে যুক্ত করুন এবং কী> = 2 সহ সমস্ত উপাদান তালিকাগুলিতে যুক্ত করুন

public static void main(String[] args) {
        List<Integer> list = new LinkedList<Integer>();
        list.add(1);
        list.add(1);
        list.add(1);
        list.add(2);
        list.add(3);
        list.add(3);
        Map<Integer,Integer> map = new HashMap<Integer, Integer>();
        for (Integer x : list) { 
            Integer val = map.get(x);
            if (val == null) { 
                map.put(x,1);
            } else {
                map.remove(x);
                map.put(x,val+1);
            }
        }
        List<Integer> result = new LinkedList<Integer>();
        for (Entry<Integer, Integer> entry : map.entrySet()) {
            if (entry.getValue() > 1) {
                result.add(entry.getKey());
            }
        }
        for (Integer x : result) { 
            System.out.println(x);
        }

    }

Comments

এটি বেশ ভাল। আপনার যদি সেখানে কতটি নকল ছিল তা জানতে হলে এটি সেরা সমাধান। কিছু নোট: (1) আপনার পূর্বে () লাগানোর আগে () অপসারণ কল করতে হবে না। (২) আপনি বারবার যুক্ত () কলগুলি ব্যবহার না করে অ্যারে থেকে লিঙ্কডলিস্ট সেট আপ করতে পারেন। (3) যখন ভাল! = নাল, আপনি অবিলম্বে ফলাফল এক্স যোগ করতে পারে। আপনি নকলের সংখ্যা গণনা রাখতে চান কিনা তার উপর নির্ভর করে ফলাফলটি একটি সেট বা একটি তালিকা হতে পারে।

— জনস্টোশ

Answer 16

শীর্ষ উত্তরের কমপ্যাক্ট জেনারাইড সংস্করণ, খালি চেক এবং প্রিলোক্যাটেড সেট আকার যুক্ত করেছে:

public static final <T> Set<T> findDuplicates(final List<T> listWhichMayHaveDuplicates) {
    final Set<T> duplicates = new HashSet<>();
    final int listSize = listWhichMayHaveDuplicates.size();
    if (listSize > 0) {
      final Set<T> tempSet = new HashSet<>(listSize);
      for (final T element : listWhichMayHaveDuplicates) {
        if (!tempSet.add(element)) {
          duplicates.add(element);
        }
      }
    }
    return duplicates;
  }

Comments

আপনার কি শূন্য চেক দরকার? নতুন হ্যাশসেট <> (0) কি বুদ্ধিমান খালি সেটটি ফেরত দেবে?

— জনস্টোশ

@ জোহনস্টোশ এই কোডটি সরল করা যেতে পারে তবে শূন্যের জন্য পরীক্ষা tempSetকরা listSizeযখন প্রয়োজন হয় কেবল তখনই থ্রিকে অনুমতি দেয় । এটি একটি গৌণ অপ্টিমাইজেশন তবে আমি এটি পছন্দ করি।

— ক্রিস্টোফ রাউসি

Answer 17

আমি সেবাস্তিয়ানের উত্তর নিয়েছি এবং এতে একটি কী-এক্সট্রাক্টর যুক্ত করেছি -

    private <U, T> Set<T> findDuplicates(Collection<T> collection, Function<? super T,? extends U> keyExtractor) {
        Map<U, T> uniques = new HashMap<>(); // maps unique keys to corresponding values
        return collection.stream()
            .filter(e -> uniques.put(keyExtractor.apply(e), e) != null)
            .collect(Collectors.toSet());
    }

Answer 18

একটি থ্রেড-নিরাপদ বিকল্প হ'ল:

/**
 * Returns all duplicates that are in the list as a new {@link Set} thread-safe.
 * <p>
 * Usually the Set will contain only the last duplicate, however the decision
 * what elements are equal depends on the implementation of the {@link List}. An
 * exotic implementation of {@link List} might decide two elements are "equal",
 * in this case multiple duplicates might be returned.
 * 
 * @param <X>  The type of element to compare.
 * @param list The list that contains the elements, never <code>null</code>.
 * @return A set of all duplicates in the list. Returns only the last duplicate.
 */
public <X extends Object> Set<X> findDuplicates(List<X> list) {
    Set<X> dups = new LinkedHashSet<>(list.size());
    synchronized (list) {
        for (X x : list) {
            if (list.indexOf(x) != list.lastIndexOf(x)) {
                dups.add(x);
            }
        }
    }
    return dups;
}

Answer 19

তালিকায় নকল আইটেমগুলি সন্ধান করতে এটি চেষ্টা করুন:

ArrayList<String> arrayList1 = new ArrayList<String>(); 

arrayList1.add("A"); 
arrayList1.add("A"); 
arrayList1.add("B"); 
arrayList1.add("B"); 
arrayList1.add("B"); 
arrayList1.add("C"); 

for (int x=0; x< arrayList1.size(); x++) 
{ 
System.out.println("arrayList1 :"+arrayList1.get(x)); 
} 
Set s=new TreeSet(); 
s.addAll(arrayList1); 
Iterator it=s.iterator(); 
while (it.hasNext()) 
{ 
System.out.println("Set :"+(String)it.next()); 
} 

Comments

হ্যাঁ, এটি সেটটি সন্ধান করে তবে এটি নকল হওয়া আইটেমগুলির তালিকা বা সেট খুঁজে পায় না।

— জনস্টোশ

Answer 20

এটি বাছাই করা এবং সাজানো বাছাইয়ের জন্য কাজ করা উচিত।

public void testFindDuplicates() {

    List<Integer> list = new ArrayList<Integer>();
    list.add(1);
    list.add(1);
    list.add(2);
    list.add(3);
    list.add(3);
    list.add(3);

    Set<Integer> result = new HashSet<Integer>();
    int currentIndex = 0;
    for (Integer i : list) {
        if (!result.contains(i) && list.subList(currentIndex + 1, list.size()).contains(i)) {
            result.add(i);
        }
        currentIndex++;
    }
    assertEquals(2, result.size());
    assertTrue(result.contains(1));
    assertTrue(result.contains(3));
}

Comments

অ্যারেলিস্টের সাবলিস্টে কল রয়েছে () এতে ব্যয়বহুল কারণ এটি লিনিয়ার অনুসন্ধান। সুতরাং এটি 10 ​​আইটেমের জন্য ঠিক আছে, তবে 1 মিলিয়ন এর জন্য নয়।

— জনস্টোশ

Answer 21

এটি এমন একটি সমস্যা যেখানে কার্যকরী কৌশলগুলি চকমক করে। উদাহরণস্বরূপ, নীচের এফ # দ্রবণটি উভয়ই সেরা জাগ্রত জাভা সমাধানের তুলনায় পরিষ্কার এবং কম ত্রুটিযুক্ত উভয় (এবং আমি জাভা এবং এফ # উভয়ের সাথেই প্রতিদিন কাজ করি)।

[1;1;2;3;3;3] 
|> Seq.countBy id 
|> Seq.choose (fun (key,count) -> if count > 1 then Some(key) else None)

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

Seq.of(1,1,2,3,3,3)
.groupBy(new Func1<Integer,Integer>() {
    public Integer call(Integer key) {
        return key;
    }
}).filter(new Predicate<Grouping<Integer,Integer>>() {
   public Boolean call(Grouping<Integer, Integer> grouping) {
        return grouping.getGrouping().count() > 1;
   }
}).map(new Func1<Grouping<Integer,Integer>,Integer>() {
    public Integer call(Grouping<Integer, Integer> grouping) {
        return grouping.getKey();
    }
});

Comments

এবং তারপরে আপনি দেখতে পাবেন যে জাভা আসলে এখনও ফাংশনাল প্রোগ্রামিংয়ে কতটা চুষছে। এ জাতীয় একটি সহজ সমস্যা, জাভাতে আপনি যা চান তা প্রকাশ করা খুব শক্ত।

— ব্যাঙবাঁধে

Answer 22

public class DuplicatesWithOutCollection {

    public static void main(String[] args) {

        int[] arr = new int[] { 2, 3, 4, 6, 6, 8, 10, 10, 10, 11, 12, 12 };

        boolean flag = false;
        int k = 1;
        while (k == 1) {

            arr = removeDuplicate(arr);
            flag = checkDuplicate(arr, flag);
            if (flag) {
                k = 1;
            } else {
                k = 0;
            }

        }

    }

    private static boolean checkDuplicate(int[] arr, boolean flag) {
        int i = 0;

        while (i < arr.length - 1) {

            if (arr[i] == arr[i + 1]) {

                flag = true;

            } else {
                flag = false;
            }
            i++;

        }

        return flag;
    }

    private static int[] removeDuplicate(int[] arr) {

        int i = 0, j = 0;
        int[] temp = new int[arr.length];
        while (i < arr.length - 1) {

            if (arr[i] == arr[i + 1]) {

                temp[j] = arr[i + 1];
                i = i + 2;

            } else {

                temp[j] = arr[i];
                i = i + 1;

                if (i == arr.length - 1) {
                    temp[j + 1] = arr[i + 1];
                    break;
                }

            }
            j++;

        }
        System.out.println();
        return temp;
    }

}

Comments

সংগ্রহের ক্লাস ব্যবহার না করেই বাস্তবায়ন করা তবে লুপে সামান্য উন্নতির প্রয়োজন olআলভাস্বর সাহায্যের জন্য প্রশংসনীয় above উপরের চেহারাটির জন্য আউটপুট -> 2 3 4 6 8 10 11 12

— সম্রাট রায়

অল্প সময়ের মধ্যে এটিকে কার্যকর করতে, নকলের খোঁজ রাখতে আপনাকে একটি হ্যাশ ভিত্তিক ডেটা স্ট্রাকচার ব্যবহার করতে হবে to এজন্য আপনি অন্যান্য সমাধান হ্যাশসেট () ব্যবহার করে দেখেন - এটি জাভাতে নির্মিত।

— জনস্টোশ

@ জোহনস্টোষ হ্যাঁ আমি সে সম্পর্কে জানি কিন্তু আমি কেন আমার মন্তব্যে উল্লেখ করেছি তা সংগ্রহগুলি ব্যবহার না করেই এটি তৈরি করার চিন্তাভাবনা করেছি A আপনি দেখতে পাচ্ছেন যে ফেব্রুয়ারী 2017 এর আগে আমি মন্তব্য করেছি, [এমন কৌশল রয়েছে যেখানে আপনাকে সংগ্রহগুলি ব্যবহার করতে হবে না কম সময়ের জটিলতার সাথে] geeksforgeeks.org/… । ডিএস ও অ্যালগো অনুশীলনগুলি না জেনে আমি এই প্রোগ্রামটি চেষ্টা করে এসেছি that আপনার জন্য আমাকে হতাশ করতে হবে না..হেতু ধন্যবাদ।

— সম্রাট রায়

Answer 23

import java.util.Scanner;

public class OnlyDuplicates {
    public static void main(String[] args) {
        System.out.print(" Enter a set of 10 numbers: ");
        int[] numbers = new int[10];
        Scanner input = new Scanner(System.in);
        for (int i = 0; i < numbers.length; i++) {
            numbers[i] = input.nextInt();
        }
        numbers = onlyDuplicates(numbers);
        System.out.print(" The numbers are: ");
        for (int i = 0; i < numbers.length; i++) {
            System.out.print(numbers[i] + "");
        }
    }

    public static int[] onlyDuplicates(int[] list) {
        boolean flag = true;
        int[] array = new int[0];
        array = add2Array(array, list[0]);
        for (int i = 0; i < list.length; i++) {
            for (int j = 0; j < array.length; j++) {
                if (list[i] == array[j]) {
                    flag = false;
                    break;
                }
            }
            if (flag) {
                array = add2Array(array, list[i]);
            }
            flag = true;
        }
        return array;
    }
    // Copy numbers1 to numbers2
    // If the length of numbers2 is less then numbers2, return false
    public static boolean copyArray(int[] source, int[] dest) {
        if (source.length > dest.length) {
            return false;
        }

        for (int i = 0; i < source.length; i++) {
            dest[i] = source[i];
        }
        return true;
    }
    // Increase array size by one and add integer to the end of the array
    public static int[] add2Array(int[] source, int data) {
        int[] dest = new int[source.length + 1];
        copyArray(source, dest);
        dest[source.length] = data;
        return dest;
    }
}

Comments

নকলগুলি ফেরত দেওয়ার জন্য আমার কী পরিবর্তন করতে হবে?

— ব্রেন্ডেন

এটি একটি নতুন প্রশ্ন হিসাবে জিজ্ঞাসা করা উচিত।

— উইলিয়েন

Answer 24

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

public static <T> List<T> findDuplicates(List<T> list){

List<T> nonDistinctElements = new ArrayList<>();

  for(T s : list)
    if(list.indexOf(s) != list.lastIndexOf(s))
      if(!nonDistinctElements.contains(s))
        nonDistinctElements.add(s);

  return nonDistinctElements;
}

এবং বলুন যে আপনি এমন একটি পদ্ধতি চান যা আপনাকে একটি স্বতন্ত্র তালিকা ফিরিয়ে দেয়, যেমন আপনি যদি এমন একটি তালিকা পাস করেন যেখানে উপাদানগুলি একাধিকবার ঘটছে, আপনি স্বতন্ত্র উপাদানগুলির সাথে একটি তালিকা পাবেন get

public static <T> void distinctList(List<T> list){

List<T> nonDistinctElements = new ArrayList<>();
for(T s : list)
  if(list.indexOf(s) != list.lastIndexOf(s))
    nonDistinctElements.add(s);

for(T nonDistinctElement : nonDistinctElements)
  if(list.indexOf(nonDistinctElement) != list.lastIndexOf(nonDistinctElement))
    list.remove(nonDistinctElement);
}

Answer 25

এবং সংস্করণ যা commons-collections CollectionUtils.getCardinalityMapপদ্ধতি ব্যবহার করে :

final List<Integer> values = Arrays.asList(1, 1, 2, 3, 3, 3);
final Map<Integer, Integer> cardinalityMap = CollectionUtils.getCardinalityMap(values);
System.out.println(cardinalityMap
            .entrySet()
            .stream().filter(e -> e.getValue() > 1)
            .map(e -> e.getKey())
            .collect(Collectors.toList()));

``

Answer 26

এই কোড সম্পর্কে -

public static void main(String[] args) {

    //Lets say we have a elements in array
    int[] a = {13,65,13,67,88,65,88,23,65,88,92};

    List<Integer> ls1 = new ArrayList<>();
    List<Integer> ls2 = new ArrayList<>();
    Set<Integer> ls3 = new TreeSet<>();

    //Adding each element of the array in the list      
    for(int i=0;i<a.length;i++) {
     {
    ls1.add(a[i]);
    }
    }

    //Iterating each element in the arrary
    for (Integer eachInt : ls1) {

    //If the list2 contains the iterating element, then add that into set<> (as this would be a duplicate element)
        if(ls2.contains(eachInt)) {
            ls3.add(eachInt);
        }
        else {ls2.add(eachInt);}

    }

    System.out.println("Elements in array or ls1"+ls1); 
    System.out.println("Duplicate Elements in Set ls3"+ls3);


}

Answer 27

কেবলমাত্র তাদের ক্ষেত্রে যা সদৃশ এবং অলিপি উভয়ই অন্তর্ভুক্ত করতে চায়। মূলত উত্তরটি সঠিক উত্তরটির সাথে মিল থাকে তবে অংশ না দিয়ে ফিরে আসার পরিবর্তে আপনি অন্য অংশটি ফেরত দেন

এই কোডটি ব্যবহার করুন (আপনার যে ধরণের প্রয়োজন তা পরিবর্তন করুন)

public Set<String> findDup(List<String> Duplicates){
    Set<String> returning = new HashSet<>();
    Set<String> nonreturning = new HashSet<>();
    Set<String> setup = new HashSet<>();
    for(String i:Duplicates){
        if(!setup.add( i )){
            returning.add( i );
        }else{
            nonreturning.add( i );
        }
    }
    Toast.makeText( context,"hello set"+returning+nonreturning+" size"+nonreturning.size(),Toast.LENGTH_SHORT ).show();
    return nonreturning;
}

Answer 28

Https://stackoverflow.com/a/52296246 এর বৈকল্পিক হিসাবে আরও জেনেরিক পদ্ধতি

    /**
     * Returns a duplicated values found in given collection based on fieldClassifier
     *
     * @param collection given collection of elements
     * @param fieldClassifier field classifier which specifies element to check for duplicates(useful in complex objects).
     * @param <T> Type of element in collection
     * @param <K> Element which will be returned from method in fieldClassifier.
     * @return returns list of values that are duplocated.
     */
    public static <T, K> List<K> lookForDuplicates(List<T> collection, Function<? super T, ? extends K> fieldClassifier) {

        return collection.stream().collect(Collectors.groupingBy(fieldClassifier))
                         .entrySet()
                         .stream()
                         .filter(e -> e.getValue().size() > 1)
                         .map(Map.Entry::getKey)
                         .collect(Collectors.toList());
    }

Answer 29

আপনি যদি সর্বোচ্চ মান জানেন (উদাহরণস্বরূপ <10000) আপনি গতির জন্য স্থান ত্যাগ করতে পারেন। আমি এই কৌশলটির সঠিক নামটি মনে করতে পারি না।

সুডোকোড:

//does not handle case when mem allocation fails 
//probably can be extended to unknown values /larger values .
maybe by sorting first
public List<int> GetDuplicates(int max)
{   
    //allocate and clear memory to 0/false
    bit[] buckets=new bit[max]
    memcpy(buckets,0,max);
    //find duplicates
    List<int> result=new List<int>();
    foreach(int val in List)
    {
        if (buckets[val])
        {
            result.add(value);
        }
        else
        {
            buckets[val]=1;
        }
    }
    return  result
}

Comments

আমার মনে হয় আপনি "বিট" এর পরিবর্তে "বুলিয়ান" চান? আপনি কি পোস্ট দেওয়ার আগে আপনার কোডটি কার্যকর করেছিলেন? এটি একটি ভাল শুরু। যদি আপনি হ্যাশসেট () দেখে থাকেন তবে দেখতে পাবেন এটি আপনার পছন্দসই 'বালতি' বাস্তবায়ন।

— জনস্টোষ

Answer 30

শুধু এটি চেষ্টা করুন:

তালিকার মানগুলি হ'ল উদাহরণ: [1, 2, 3, 4, 5, 6, 4, 3, 7, 8] নকল আইটেম [3, 4]।

Collections.sort(list);
        List<Integer> dup = new ArrayList<>();
        for (int i = 0; i < list.size() - 1; i++) {
            if (list.get(i) == list.get(i + 1)) {
                if (!dup.contains(list.get(i + 1))) {
                    dup.add(list.get(i + 1));
                }
            }
        }
        System.out.println("duplicate item " + dup);

Comments

আমন্ত্রণ করা () একটি অ্যারেলিস্টে থাকে () একটি ব্যয়বহুল ক্রিয়াকলাপ, সুতরাং পরিবর্তে আপনার সেটটি ব্যবহার করা উচিত। আপনি হ্যাশসেট () বা এর লিঙ্কযুক্ত সংস্করণ ব্যবহার করে অন্যান্য সমাধান দেখতে পাবেন।

— জনস্টোষ