জাভাতে অনন্য র্যান্ডম নম্বর উত্পন্ন করা হচ্ছে

Question 1

আমি 0 এবং 100 এর মধ্যে এলোমেলো সংখ্যা পাওয়ার চেষ্টা করছি But তবে আমি চাই যে সেগুলি অনন্য হোক, ক্রম হিসাবে পুনরাবৃত্তি হবে না। উদাহরণস্বরূপ যদি আমি 5 নম্বর পেয়েছি তবে সেগুলি 82,12,53,64,32 হওয়া উচিত এবং 82,12,53,12,32 নয় আমি এটি ব্যবহার করেছি, তবে এটি ক্রম অনুসারে একই সংখ্যা তৈরি করে।

Random rand = new Random();
selected = rand.nextInt(100);

Question 2

একটি তালিকা কাঠামোতে ধারাবাহিকভাবে পরিসরের প্রতিটি সংখ্যা যুক্ত করুন ।
এলোমেলো ।
প্রথম 'এন' নিন।

এখানে একটি সহজ বাস্তবায়ন। এটি 1-10 ব্যাপ্তি থেকে 3 টি অনন্য এলোমেলো সংখ্যা মুদ্রণ করবে।

import java.util.ArrayList;
import java.util.Collections;

public class UniqueRandomNumbers {

    public static void main(String[] args) {
        ArrayList<Integer> list = new ArrayList<Integer>();
        for (int i=1; i<11; i++) {
            list.add(new Integer(i));
        }
        Collections.shuffle(list);
        for (int i=0; i<3; i++) {
            System.out.println(list.get(i));
        }
    }
}

আসল পদ্ধতির সাথে ফিক্সের প্রথম অংশটি যেমন মার্ক বাইয়ার্স এখন মুছে দেওয়া উত্তরে উল্লেখ করেছেন, কেবলমাত্র একটি একক Randomউদাহরণ ব্যবহার করা ।

সংখ্যাটি অভিন্ন হওয়ার কারণেই। Randomমিলসেকেন্ডে বর্তমান সময়ের দ্বারা একটি উদাহরণ তৈরি করা হয়েছে। একটি নির্দিষ্ট বীজ মানের জন্য, 'এলোমেলো' উদাহরণটি সিউডো এলোমেলো সংখ্যার ঠিক একই ধারাটি প্রদান করবে ।

নোট করুন যে public Integer(int value)কনস্ট্রাক্টরটি deprecatedজাভা 9 এর পর থেকে।

লুপের জন্য প্রথমটি সহজেই এতে পরিবর্তন করা যেতে পারে:

for (int i = 1; i < 11; i++) {
  list.add(i);
}

Question 3

জাভা 8+ এর সাহায্যে আপনি এলোমেলো মানগুলি পেতে এবং তারপরে স্ট্রিমটিকে অনেকগুলি অনন্য এলোমেলো মানগুলিতে হ্রাস করার intsপদ্ধতিটি ব্যবহার করতে পারেন ।RandomIntStreamdistinctlimit

ThreadLocalRandom.current().ints(0, 100).distinct().limit(5).forEach(System.out::println);

Randomআপনার যদি পরিবর্তে সেগুলি প্রয়োজন হয় তবে এমন পদ্ধতি রয়েছে যা LongStreamগুলি এবং DoubleStreamগুলি তৈরি করে।

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

List<Integer> range = IntStream.range(0, 100).boxed()
        .collect(Collectors.toCollection(ArrayList::new));
Collections.shuffle(range);
range.subList(0, 99).forEach(System.out::println);

Question 4

100 টি সংখ্যার একটি অ্যারে তৈরি করুন, তারপরে তাদের ক্রমটি এলোমেলো করুন।
100 এর ব্যাপ্তিযুক্ত একটি সিউডো-এলোমেলো নম্বর জেনারেটর তৈরি করুন।
100 টি উপাদানের একটি বুলিয়ান অ্যারে তৈরি করুন, তারপরে আপনি এই সংখ্যাটি বাছাই করার পরে একটি উপাদানকে সত্য করে সেট করুন। আপনি যখন অ্যারের বিপরীতে পরবর্তী নম্বরটি চয়ন করেন এবং অ্যারে উপাদানটি সেট করা থাকে তবে আবার চেষ্টা করুন। (আপনি longপৃথক বিট অ্যাক্সেস করার জন্য আপনি যেখানে স্থানান্তরিত করেন এবং মাস্ক করেন তার একটি অ্যারে দিয়ে আপনি সহজেই সাবলীল বুলিয়ান অ্যারে তৈরি করতে পারেন))

Question 5

Collections.shuffle()সমস্ত 100 সংখ্যা ব্যবহার করুন এবং এখানে প্রথম হিসাবে পাঁচটি নির্বাচন করুন ।

Question 6

আমি মনে করি এই পদ্ধতিটি উল্লেখ করার মতো।

   private static final Random RANDOM = new Random();    
   /**
     * Pick n numbers between 0 (inclusive) and k (inclusive)
     * While there are very deterministic ways to do this,
     * for large k and small n, this could be easier than creating
     * an large array and sorting, i.e. k = 10,000
     */
    public Set<Integer> pickRandom(int n, int k) {
        final Set<Integer> picked = new HashSet<>();
        while (picked.size() < n) {
            picked.add(RANDOM.nextInt(k + 1));
        }
        return picked;
    }

Question 7

আমি কোনও সেটের অনন্য বৈশিষ্ট্যই ব্যবহার set.add()করতে পারি না তবে সেটটিতে একটি অ্যাড ব্যর্থ হলে ফিরিয়ে দেওয়া বুলিয়ান মিথ্যাও ব্যবহার করতে আনন্দ এর জবাবটি পুনরায় বিবৃত করি ।

import java.util.HashSet;
import java.util.Random;
import java.util.Set;

public class randomUniqueNumberGenerator {

    public static final int SET_SIZE_REQUIRED = 10;
    public static final int NUMBER_RANGE = 100;

    public static void main(String[] args) {
        Random random = new Random();

        Set set = new HashSet<Integer>(SET_SIZE_REQUIRED);

        while(set.size()< SET_SIZE_REQUIRED) {
            while (set.add(random.nextInt(NUMBER_RANGE)) != true)
                ;
        }
        assert set.size() == SET_SIZE_REQUIRED;
        System.out.println(set);
    }
}

Question 8

আমি এটি তৈরি করেছি।

    Random random = new Random();
    ArrayList<Integer> arrayList = new ArrayList<Integer>();

    while (arrayList.size() < 6) { // how many numbers u need - it will 6
        int a = random.nextInt(49)+1; // this will give numbers between 1 and 50.

        if (!arrayList.contains(a)) {
            arrayList.add(a);
        }
    }

Question 9

এটি অনন্য এলোমেলো সংখ্যা তৈরি করতে কাজ করবে ................

import java.util.HashSet;
import java.util.Random;

public class RandomExample {

    public static void main(String[] args) {
        Random rand = new Random();
        int e;
        int i;
        int g = 10;
        HashSet<Integer> randomNumbers = new HashSet<Integer>();

        for (i = 0; i < g; i++) {
            e = rand.nextInt(20);
            randomNumbers.add(e);
            if (randomNumbers.size() <= 10) {
                if (randomNumbers.size() == 10) {
                    g = 10;
                }
                g++;
                randomNumbers.add(e);
            }
        }
        System.out.println("Ten Unique random numbers from 1 to 20 are  : " + randomNumbers);
    }
}

Question 10

এটি করার একটি চতুর উপায় হ'ল মডুলাসে কোনও আদিম উপাদানটির এক্সপোনেন্ট ব্যবহার করা।

উদাহরণস্বরূপ, 2 হ'ল একটি আদিম রুট মোড 101, যার অর্থ 2 মোড 101 এর শক্তি আপনাকে একটি পুনরাবৃত্তি ক্রম দেয় যা প্রতিটি সংখ্যা 1 থেকে 100 পর্যন্ত অন্তর্ভুক্ত দেখায়:

2^0 mod 101 = 1
2^1 mod 101 = 2
2^2 mod 101 = 4
...
2^50 mod 101 = 100
2^51 mod 101 = 99
2^52 mod 101 = 97
...
2^100 mod 101 = 1

জাভা কোডে, আপনি লিখবেন:

void randInts() {
int num=1;
for (int ii=0; ii<101; ii++) {
    System.out.println(num);
    num= (num*2) % 101;
    }
}

নির্দিষ্ট মডুলাসের জন্য একটি আদিম রুট সন্ধান করা জটিল হতে পারে তবে ম্যাপেলের "প্রাইমরুট" ফাংশনটি এটি আপনার জন্য করবে।

Question 11

আমি এখানে অন্য একটি প্রশ্ন থেকে এসেছি, যা এই প্রশ্নের সদৃশ হয়েছে ( জাভাতে অনন্য এলোমেলো সংখ্যা তৈরি করা )

একটি অ্যারেতে 1 থেকে 100 সংখ্যা সঞ্চয় করুন।
অবস্থান হিসাবে 1 থেকে 100 এর মধ্যে এলোমেলো সংখ্যা তৈরি করুন এবং মানটি পেতে অ্যারে [পজিশন -1] হিসাবে রিটার্ন করুন
একবার আপনি অ্যারেতে একটি নম্বর ব্যবহার করলে, মানটি -1 হিসাবে চিহ্নিত করুন (এই নম্বরটি ইতিমধ্যে ব্যবহৃত হয়েছে কিনা তা পরীক্ষা করতে অন্য অ্যারে বজায় রাখার দরকার নেই)
অ্যারের মান যদি -1 হয় তবে অ্যারেতে নতুন অবস্থান আনতে আবার এলোমেলো নম্বর পান।

Question 12

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

for(int i=0;i<4;i++)
        {
            rn[i]= GenerateRandomNumber();
            for (int j=0;j<i;j++)
            {
                if (rn[i] == rn[j])
                {
                    i--;
                }
            }
        }

Question 13

যদিও এটি একটি পুরানো থ্রেড, তবে অন্য বিকল্প যুক্ত করা ক্ষতিগ্রস্থ হতে পারে না। (জেডিকে ১.৮ লাম্বদা ফাংশনগুলি এটিকে সহজ করে তোলে বলে মনে হয়);

সমস্যাটি নিম্নলিখিত পদক্ষেপগুলিতে বিভক্ত হতে পারে;

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

এখানে কিছু বিবরণ সহ ফাংশন:

/**
 * Provided an unsequenced / sequenced list of integers, the function returns unique random IDs as defined by the parameter
 * @param numberToGenerate
 * @param idList
 * @return List of unique random integer values from the provided list
 */
private List<Integer> getUniqueRandomInts(List<Integer> idList, Integer numberToGenerate) {

    List<Integer> generatedUniqueIds = new ArrayList<>();

    Integer minId = idList.stream().mapToInt (v->v).min().orElseThrow(NoSuchElementException::new);
    Integer maxId = idList.stream().mapToInt (v->v).max().orElseThrow(NoSuchElementException::new);

            ThreadLocalRandom.current().ints(minId,maxId)
            .filter(e->idList.contains(e))
            .distinct()
            .limit(numberToGenerate)
            .forEach(generatedUniqueIds:: add);

    return generatedUniqueIds;

}

যাতে 'AllIntegers' তালিকা অবজেক্টের জন্য 11 টি অনন্য এলোমেলো নম্বর পেতে, আমরা এই ফাংশনটিকে কল করব;

    List<Integer> ids = getUniqueRandomInts(allIntegers,11);

ফাংশনটি নতুন অ্যারেলিস্ট 'উত্পন্ন ইউনিক আইডস' ঘোষণা করে এবং প্রত্যাবর্তনের পূর্বে প্রতিটি অনন্য এলোমেলো পূর্ণসংখ্যার সাথে প্রয়োজনীয় নম্বর পর্যন্ত পপুলেট করে।

পিএস থ্রেডলোক্যালর্যান্ডম ক্লাস সহবর্তী থ্রেডগুলির ক্ষেত্রে সাধারণ বীজের মান এড়ায়।

Question 14

এটি চেষ্টা করে দেখুন

public class RandomValueGenerator {
    /**
     * 
     */
    private volatile List<Double> previousGenValues = new ArrayList<Double>();

    public void init() {
        previousGenValues.add(Double.valueOf(0));
    }

    public String getNextValue() {
        Random random = new Random();
        double nextValue=0;
        while(previousGenValues.contains(Double.valueOf(nextValue))) {
            nextValue = random.nextDouble();
        }
        previousGenValues.add(Double.valueOf(nextValue));
        return String.valueOf(nextValue);
    }
}

Question 15

এটি অন্যান্য উত্তরের চেয়ে উল্লেখযোগ্যভাবে পৃথক নয়, তবে শেষ পর্যন্ত আমি পূর্ণসংখ্যার অ্যারেটি চেয়েছিলাম:

    Integer[] indices = new Integer[n];
    Arrays.setAll(indices, i -> i);
    Collections.shuffle(Arrays.asList(indices));
    return Arrays.stream(indices).mapToInt(Integer::intValue).toArray();

Question 16

আপনি যদি বুলিয়ান অ্যারে ব্যবহার করে অন্যটি নীচে দেওয়া মান অনুসারে বুলিয়ান অ্যারে নেভিগেট করে নেন তবে সত্যটি পূরণ করতে পারবেন

package study;

import java.util.ArrayList;
import java.util.Arrays;
import java.util.List;

/*
Created By Sachin  Rane on Jul 18, 2018
*/
public class UniqueRandomNumber {
    static Boolean[] boolArray;
    public static void main(String s[]){
        List<Integer> integers = new ArrayList<>();


        for (int i = 0; i < 10; i++) {
            integers.add(i);
        }


        //get unique random numbers
        boolArray = new Boolean[integers.size()+1];
        Arrays.fill(boolArray, false);
        for (int i = 0; i < 10; i++) {
            System.out.print(getUniqueRandomNumber(integers) + " ");

        }

    }

    private static int  getUniqueRandomNumber(List<Integer> integers) {
        int randNum =(int) (Math.random()*integers.size());
        if(boolArray[randNum]){
            while(boolArray[randNum]){
                randNum++;
                if(randNum>boolArray.length){
                    randNum=0;
                }
            }
            boolArray[randNum]=true;
            return randNum;
        }else {
            boolArray[randNum]=true;
            return randNum;
        }

    }

}

Question 17

0 টি থেকে এম -1 এ অনন্য এলোমেলো সংখ্যা চয়ন করুন।

int[] uniqueRand(int n, int m){
    Random rand = new Random();
    int[] r = new int[n];
    int[] result = new int[n];
    for(int i = 0; i < n; i++){
        r[i] = rand.nextInt(m-i);
        result[i] = r[i];
        for(int j = i-1; j >= 0; j--){
            if(result[i] >= r[j])
                result[i]++;
        }
    }
    return result;
}

0 থেকে এম -1 পর্যন্ত সংখ্যাযুক্ত একটি তালিকা কল্পনা করুন। প্রথম সংখ্যাটি চয়ন করতে, আমরা কেবল ব্যবহার করি rand.nextInt(m)। তারপরে তালিকা থেকে নম্বরটি সরিয়ে ফেলুন। এখন এম -১ নম্বর রয়েছে, তাই আমরা কল করিrand.nextInt(m-1) । আমরা যে নম্বর পেয়েছি তা তালিকার অবস্থানটি উপস্থাপন করে। যদি এটি প্রথম সংখ্যার চেয়ে কম হয় তবে এটি দ্বিতীয় সংখ্যা, যেহেতু প্রথম সংখ্যাটির পূর্বে তালিকার অংশটি প্রথম সংখ্যাটি অপসারণের মাধ্যমে পরিবর্তন করা হয়নি। পজিশনটি যদি প্রথম সংখ্যার চেয়ে বড় বা সমান হয় তবে দ্বিতীয় সংখ্যাটি অবস্থান + 1। আরও কিছু ডেরাইভেশন করুন, আপনি এই অ্যালগরিদম পেতে পারেন।

ব্যাখ্যা

এই অ্যালগরিদমের ও (এন ^ 2) জটিলতা রয়েছে। সুতরাং এটি একটি বড় সেট থেকে স্বল্প পরিমাণে অনন্য সংখ্যা উত্পন্ন করার জন্য ভাল। শফল ভিত্তিক অ্যালগরিদমকে সাফ করার জন্য কমপক্ষে ও (এম) প্রয়োজন।

এলোমেলোভাবে তৈরি অ্যালগরিদমের শ্যাফেল করতে প্রতিটি সম্ভাব্য ফলাফল সংরক্ষণ করার জন্য মেমরি দরকার, এই অ্যালগরিদমের প্রয়োজন নেই।

Question 18

আপনি সংগ্রহ ক্লাস ব্যবহার করতে পারেন।

সংগ্রহ নামে পরিচিত একটি ইউটিলিটি শ্রেণি বিভিন্ন ক্রিয়াকলাপ সরবরাহ করে যা একটি অ্যারেলিস্টের মতো সংগ্রহের উপর সঞ্চালিত হতে পারে (উদাহরণস্বরূপ, উপাদানগুলি সন্ধান করুন, সর্বাধিক বা ন্যূনতম উপাদান সন্ধান করুন, উপাদানগুলির ক্রমকে বিপরীত করুন) ইত্যাদি। এটি সম্পাদন করতে পারে এমন একটি ক্রিয়াকলাপ হল উপাদানগুলিকে বদলানো। এলোমেলোভাবে এলোমেলোভাবে প্রতিটি উপাদানকে তালিকার আলাদা অবস্থানে নিয়ে যাবে। এটি একটি এলোমেলো বস্তু ব্যবহার করে এটি করে। এর অর্থ এটি নির্বিচারে এলোমেলো, তবে এটি বেশিরভাগ পরিস্থিতিতেই ঘটবে।

অ্যারেলিস্টটি বদল করতে, সংগ্রহের আমদানিটি প্রোগ্রামের শীর্ষে যুক্ত করুন এবং তারপরে শাফল স্ট্যাটিক পদ্ধতিটি ব্যবহার করুন। এটি প্যারামিটার হিসাবে পরিবর্তন হতে অ্যারেলিস্ট লাগে:

import java.util.Collections;
import java.util.ArrayList;
public class Lottery {
public static void main(String[] args) {
//define ArrayList to hold Integer objects
ArrayList numbers = new ArrayList();
for(int i = 0; i < 100; i++)
{
numbers.add(i+1);
}
Collections.shuffle(numbers);
System.out.println(numbers);
}
}

Question 19

আপনি জাভাতে 0 থেকে এন -1 এর মধ্যে এন অনন্য এলোমেলো সংখ্যা তৈরি করতে পারেন

public static void RandomGenerate(int n)
{
     Set<Integer> st=new HashSet<Integer>();
     Random r=new Random();
     while(st.size()<n)
     {
        st.add(r.nextInt(n));
     }

}

Question 20

একটি ব্যাপ্তিতে বা একটি অ্যারের থেকে অনন্য এলোমেলো মান উত্পন্ন করার জন্য এটি সবচেয়ে সহজ পদ্ধতি ।

এই উদাহরণে, আমি একটি পূর্বনির্ধারিত অ্যারে ব্যবহার করব তবে আপনি এলোমেলো সংখ্যাও তৈরি করতে এই পদ্ধতিটি মানিয়ে নিতে পারেন। প্রথমত, আমরা আমাদের ডেটা পুনরুদ্ধার করতে একটি নমুনা অ্যারে তৈরি করব।

একটি এলোমেলো সংখ্যা তৈরি করুন এবং এটিকে নতুন অ্যারে যুক্ত করুন।
অন্য এলোমেলো সংখ্যা তৈরি করুন এবং এটি ইতিমধ্যে নতুন অ্যারেতে সঞ্চিত আছে কিনা তা পরীক্ষা করুন।
যদি না হয় তবে এটি যুক্ত করুন এবং চালিয়ে যান
অন্যথায় পদক্ষেপ পুনরাবৃত্তি।

ArrayList<Integer> sampleList = new ArrayList<>();
sampleList.add(1);
sampleList.add(2);
sampleList.add(3);
sampleList.add(4);
sampleList.add(5);
sampleList.add(6);
sampleList.add(7);
sampleList.add(8);

এখন থেকে sampleListআমরা পাঁচটি এলোমেলো সংখ্যা প্রস্তুত করব যা অনন্য।

int n;
randomList = new ArrayList<>();
for(int  i=0;i<5;i++){
    Random random = new Random();
    n=random.nextInt(8);     //Generate a random index between 0-7

    if(!randomList.contains(sampleList.get(n)))
    randomList.add(sampleList.get(n));
    else
        i--;    //reiterating the step
}

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

যদি আপনি এই উত্তরটি দরকারী বলে মনে করেন তবে অন্যান্য উত্তরগুলির তুলনায় ধারণাটিতে এটি অনেক সহজ বলে আপনি এটিতে ভোট দিতে পারেন ।

Question 21

এটা যাচাই কর

public class RandomNumbers {

    public static void main(String[] args) {
        // TODO Auto-generated method stub
        int n = 5;
        int A[] = uniqueRandomArray(n);
        for(int i = 0; i<n; i++){
            System.out.println(A[i]);
        }
    }
    public static int[] uniqueRandomArray(int n){
        int [] A = new int[n];
        for(int i = 0; i< A.length; ){
            if(i == A.length){
                break;
            }
            int b = (int)(Math.random() *n) + 1;
            if(f(A,b) == false){
                A[i++] = b;
            } 
        }
        return A;
    }
    public static boolean f(int[] A, int n){
        for(int i=0; i<A.length; i++){
            if(A[i] == n){
                return true;
            }
        }
        return false;
    }
}

Question 22

নীচে আমি সর্বদা অনন্য নম্বর উত্পন্ন করতে ব্যবহার করি। র্যান্ডম ফাংশনটি সংখ্যা উত্পন্ন করে এটি পাঠ্য ফাইলটিতে সংরক্ষণ করে তার পরের বার এটি ফাইলের মধ্যে এটি পরীক্ষা করে এটির তুলনা করে এবং নতুন অনন্য নম্বর উত্পন্ন করে তাই এইভাবে সর্বদা একটি নতুন অনন্য নম্বর থাকে।

public int GenerateRandomNo()
{
    int _min = 0000;
    int _max = 9999;
    Random _rdm = new Random();
    return _rdm.Next(_min, _max);
}
public int rand_num()
{
    randnum = GenerateRandomNo();
    string createText = randnum.ToString() + Environment.NewLine;
    string file_path = System.IO.Path.GetDirectoryName(System.Windows.Forms.Application.ExecutablePath) + @"\Invoices\numbers.txt";
    File.AppendAllText(file_path, createText);
    int number = File.ReadLines(file_path).Count(); //count number of lines in file
    System.IO.StreamReader file = new System.IO.StreamReader(file_path);
    do
    {
        randnum = GenerateRandomNo();
    }
    while ((file.ReadLine()) == randnum.ToString());
    file.Close();
    return randnum;

}