जावा का उपयोग करके आदिमों की एक सरणी में अधिकतम / मिनट मूल्य का पता लगाना

Question

किसी सरणी में न्यूनतम / अधिकतम मान निर्धारित करने के लिए एक फ़ंक्शन लिखना तुच्छ है:

/**
 * 
 * @param chars
 * @return the max value in the array of chars
 */
private static int maxValue(char[] chars) {
    int max = chars[0];
    for (int ktr = 0; ktr < chars.length; ktr++) {
        if (chars[ktr] > max) {
            max = chars[ktr];
        }
    }
    return max;
}

लेकिन यह पहले से ही कहीं नहीं है?

Comments

कंटेनरों की सरणी के लिए आदिम की सरणी में मदद मिलेगी: stackoverflow.com/questions/3770289/… इसके बाद Collections.max(Arrays.asList())।

— सिरो सेंटिल्ली 郝海东 冠状 iro i 法轮功 '

मैं सिर्फ प्यार करता हूँ कि जावा कितना गूंगा है

— फरीद

Answer 1

कॉमन्स लैंग का उपयोग करना (कन्वर्ट करना) + कलेक्शन (न्यूनतम / अधिकतम)

import java.util.Arrays;
import java.util.Collections;

import org.apache.commons.lang.ArrayUtils;

public class MinMaxValue {

    public static void main(String[] args) {
        char[] a = {'3', '5', '1', '4', '2'};

        List b = Arrays.asList(ArrayUtils.toObject(a));

        System.out.println(Collections.min(b));
        System.out.println(Collections.max(b));
   }
}

ध्यान दें कि Arrays.asList()अंतर्निहित सरणी को लपेटता है, इसलिए यह बहुत स्मृति गहन नहीं होना चाहिए और इसे सरणी के तत्वों पर प्रतिलिपि नहीं करना चाहिए।

Comments

क्या हैArrayUtils

— बशीर अल-मोमानी

Arrays.asList()ठीक होना चाहिए, लेकिन नए सरणी के ArrayUtils.toObject()प्रत्येक तत्व को कॉपी करेगा । aCharacter

— ईएम

Arrays.asList(a)काम नहीं करता है। आप प्राथमिकताओं की सूची नहीं बना सकते हैं ( List<char>इस मामले में)। पहले आपको आदिम मूल्यों को वस्तुओं में बदलने की आवश्यकता है और इसीलिए ArrayUtils.toObjectइसका उपयोग किया जाता है।

— nessa.gp

Answer 2

आप बस नए जावा 8 Streamएस का उपयोग कर सकते हैं लेकिन आपको इसके साथ काम करना होगा int।

streamयूटिलिटी क्लास का तरीका Arraysआपको देता है जिस IntStreamपर आप minविधि का उपयोग कर सकते हैं । आप यह भी कर सकते हैं max, sum, average, ...

getAsIntविधि से मूल्य प्राप्त करने के लिए किया जाता हैOptionalInt

import java.util.Arrays;

public class Test {
    public static void main(String[] args){
        int[] tab = {12, 1, 21, 8};
        int min = Arrays.stream(tab).min().getAsInt();
        int max = Arrays.stream(tab).max().getAsInt();
        System.out.println("Min = " + min);
        System.out.println("Max = " + max)
    }

}

== अद्यतन ==

यदि निष्पादन समय महत्वपूर्ण है और आप केवल एक बार डेटा का उपयोग करना summaryStatistics()चाहते हैं, तो आप इस तरह की विधि का उपयोग कर सकते हैं

import java.util.Arrays;
import java.util.IntSummaryStatistics;

public class SOTest {
    public static void main(String[] args){
        int[] tab = {12, 1, 21, 8};
        IntSummaryStatistics stat = Arrays.stream(tab).summaryStatistics();
        int min = stat.getMin();
        int max = stat.getMax();
        System.out.println("Min = " + min);
        System.out.println("Max = " + max);
    }
}

यह दृष्टिकोण शास्त्रीय लूप की तुलना में बेहतर प्रदर्शन दे सकता है क्योंकि summaryStatisticsविधि एक कमी ऑपरेशन है और यह समानांतरकरण की अनुमति देता है।

Answer 3

गूगल अमरूद पुस्तकालय अपने वर्ण, Ints, चाहता है, आदि कक्षाओं में न्यूनतम और अधिकतम तरीकों है।

तो आप बस का उपयोग कर सकते हैं:

Chars.min(myarray)

कोई रूपांतरण आवश्यक नहीं है और संभवतः इसे कुशलता से लागू किया गया है।

Comments

यह प्रश्न में कम या ज्यादा की तरह लागू हो जाता है सिवाय इसके कि इसे 0. (लंबाई की एक सरणी के लिए एक IllegalArgumentException फेंकता code.google.com/p/guava-libraries/source/browse/trunk/src/com/... )

— Colind

यह यहां की हर चीज का सबसे अच्छा समाधान है। सभी कि java.util से बचता है। ऐरर # asList varargs कन्फ्यूजन।

— कोंग

Answer 4

हां, यह कलेक्शन क्लास में किया जाता है । ध्यान दें कि आपको अपने आदिम वर्ण सरणी को मैन्युअल रूप से एक कैरेक्टर [] में बदलना होगा।

एक छोटा डेमो:

import java.util.*;

public class Main {

    public static Character[] convert(char[] chars) {
        Character[] copy = new Character[chars.length];
        for(int i = 0; i < copy.length; i++) {
            copy[i] = Character.valueOf(chars[i]);
        }
        return copy;
    }

    public static void main(String[] args) {
        char[] a = {'3', '5', '1', '4', '2'};
        Character[] b = convert(a);
        System.out.println(Collections.max(Arrays.asList(b)));
    }
}

Comments

Collections.min (myCollection); यदि आप इसे सरणियों के लिए उपयोग करना चाहते हैं, तो आप इसे संग्रह की तरह कर सकते हैं ।min (Arrays.asList (myArray));

— जेडएपी

एक परिवर्तित char []एक करने के लिए Character []अधिकतम निर्धारित करने के लिए केवल यह काफी अप्रभावी है - बेहतर के लिए इसी तरह प्रत्येक आदिम प्रकार के लिए स्थिर तरीकों के साथ एक उपयोगिता वर्ग बनाने java.util.Arrays: java.sun.com/javase/6/docs/api/java/util/Arrays.html

— क्रिस्टोफ़

@ क्रिसस्टोफ़: हाँ, यदि सरणी का आकार बड़ा है, तो मैं सहमत होगा। बस यह कहते हुए कि "अक्षम" कोई मतलब नहीं है यदि प्रश्न में आवेदन कई डेटाबेस कॉल और / या I / O संचालन करता है और सरणी का आकार छोटा (सापेक्ष) है।

— बार्ट कियर्स

आपको प्रदर्शन के कारणों के Character.valueOf(chars[i])बजाय उपयोग करना चाहिए new Character(chars[i]): java.sun.com/javase/6/docs/api/java/lang/…

— क्रिस्टोफ़

@ क्रिसहॉस्ट क्रिस्टोफ़ सही है, मिनिमम सर्च के लिए एरे को कलेक्शन में बदलना अक्षम्य और बेवकूफी है।

— एलेक्सवियन

Answer 5

import java.util.Arrays;

public class apples {

  public static void main(String[] args) {
    int a[] = {2,5,3,7,8};
    Arrays.sort(a);

     int min =a[0];
    System.out.println(min);
    int max= a[a.length-1];
    System.out.println(max);

  }

}

Comments

कृपया कुछ स्पष्टीकरण दें।

— माइक स्टॉकडेल

मुझे लगता है कि कहने का मतलब यह है कि यदि आप सरणी (आरोही क्रम में) को क्रमबद्ध करते हैं, तो परिभाषा में, न्यूनतम मान हमेशा पहली स्थिति में होगा, [0], और अधिकतम मूल्य हमेशा अंतिम स्थिति में रहेगा। , [a.length -1]।

— जेफ

यह समस्या को हल करने का एक वैध और उपयोगी तरीका है। अन्य लोगों की तुलना में इसका उपयोग करने का नुकसान क्या है?

— एलेक्स

@alex समय जटिलता - छँटाई सबसे अच्छा एक हे (nlogn) चक्कर है, जबकि माइकल रदरफर्ड दृष्टिकोण O (n) है।

— जजदू

हमें सूची में एकल पुनरावृत्ति की आवश्यकता नहीं है, न्यूनतम और अधिकतम खोजने के लिए सूची में पर्याप्त है।

— akhil_mittal

Answer 6

मेरे सभी अनुप्रयोगों में थोड़ा सहायक वर्ग है जैसे कि:

public static double arrayMax(double[] arr) {
    double max = Double.NEGATIVE_INFINITY;

    for(double cur: arr)
        max = Math.max(max, cur);

    return max;
}

Comments

आपको डबल अधिकतम = Double.NEGATIVE_INFINITY का उपयोग करना चाहिए; इसके बजाय डबल मैक्स = डबल।मिन_वैल्यू; डबल के लिए MIN_VALUE सकारात्मक है

— krems

... या आप सरणी में पहले आइटम पर अधिकतम सेट कर सकते हैं, और 2 आइटम से पुनरावृति, मेरा उत्तर देख सकते हैं।

— निकोलस हैमिल्टन

Answer 7

आप आसानी से एक IntStreamऔर max()विधि के साथ कर सकते हैं ।

उदाहरण

public static int maxValue(final int[] intArray) {
  return IntStream.range(0, intArray.length).map(i -> intArray[i]).max().getAsInt();
}

व्याख्या

1. range(0, intArray.length)- में उपस्थित के रूप में कई तत्वों के साथ एक धारा प्राप्त करने के लिए intArray।

2. map(i -> intArray[i])- स्ट्रीम के प्रत्येक तत्व को वास्तविक तत्व में मैप करें intArray।

3. max()- इस धारा का अधिकतम तत्व प्राप्त करें OptionalInt।

4. getAsInt()- अनपरा OptionalInt। (आप यहां भी उपयोग कर सकते हैं: orElse(0)बस OptionalIntखाली होने पर।)

Answer 8

यहाँ एक उपयोगिता वर्ग min/maxआदिम प्रकारों के लिए तरीके प्रदान कर रहा है : Primatics.java

Answer 9

import java.util.Random;

public class Main {

public static void main(String[] args) {
   int a[] = new int [100];
   Random rnd = new Random ();

    for (int i = 0; i< a.length; i++) {
        a[i] = rnd.nextInt(99-0)+0;
        System.out.println(a[i]);
    }

    int max = 0;          

    for (int i = 0; i < a.length; i++) {
        a[i] = max;


        for (int j = i+1; j<a.length; j++) {
            if (a[j] > max) {
               max = a[j];
            }

        }
    }

    System.out.println("Max element: " + max);
}
}

Answer 10

    public int getMin(int[] values){
        int ret = values[0];
        for(int i = 1; i < values.length; i++)
            ret = Math.min(ret,values[i]);
        return ret;
    }

Comments

यह संख्याओं के लिए है intलेकिन यह सवाल आदिम मूल्यों के लिए पूछ रहा हैint, long, char, byte....

— इग्नाइटेकोडर्स

Answer 11

इसके साथ एक समाधान reduce():

int[] array = {23, 3, 56, 97, 42};
// directly print out
Arrays.stream(array).reduce((x, y) -> x > y ? x : y).ifPresent(System.out::println);

// get the result as an int
int res = Arrays.stream(array).reduce((x, y) -> x > y ? x : y).getAsInt();
System.out.println(res);
>>
97
97

उपरोक्त कोड reduce()में Optional, प्रारूप में डेटा लौटाता है , जिसे आप intद्वारा परिवर्तित कर सकते हैं getAsInt()।

यदि हम एक निश्चित संख्या के साथ अधिकतम मूल्य की तुलना करना चाहते हैं, तो हम इसमें एक मूल्य शुरू कर सकते हैं reduce():

int[] array = {23, 3, 56, 97, 42};
// e.g., compare with 100
int max = Arrays.stream(array).reduce(100, (x, y) -> x > y ? x : y);
System.out.println(max);
>>
100

ऊपर दिए गए कोड में, जब reduce()पहले पैरामीटर के रूप में एक पहचान (प्रारंभ मान) के साथ, यह पहचान के साथ उसी प्रारूप में डेटा लौटाता है। इस संपत्ति के साथ, हम इस समाधान को अन्य सरणियों पर लागू कर सकते हैं:

double[] array = {23.1, 3, 56.6, 97, 42};
double max = Arrays.stream(array).reduce(array[0], (x, y) -> x > y ? x : y);
System.out.println(max);
>>
97.0

Answer 12

फ्लोट के साथ उदाहरण:

public static float getMaxFloat(float[] data) {

    float[] copy = Arrays.copyOf(data, data.length);
    Arrays.sort(copy);
    return copy[data.length - 1];
}

public static float getMinFloat(float[] data) {

    float[] copy = Arrays.copyOf(data, data.length);
    Arrays.sort(copy);
    return copy[0];
}

Comments

जबकि आपका समाधान काम करेगा, लेकिन यह O (nlogn) के लिए समय की जटिलता को बढ़ाएगा, जबकि मिनट अन्य उत्तर का उपयोग करके आसानी से O (n) में पाया जा सकता है।

— प्रमोद

बस इस स्थिति में एक तरह का उपयोग करने के लिए पागल।

— निकोलस हैमिल्टन

यह उपयोगी हो सकता है जब कुछ मरम्मत के साथ पहले n> 1 सबसे छोटा / सबसे बड़ा मूल्य की आवश्यकता होती है।

— biziclop

Answer 13

यहां लगभग 99% रनों में अधिकतम मूल्य प्राप्त करने के लिए एक समाधान है (बेहतर परिणाम प्राप्त करने के लिए 0.01 बदलें):

public static double getMax(double[] vals){
    final double[] max = {Double.NEGATIVE_INFINITY};

    IntStream.of(new Random().ints((int) Math.ceil(Math.log(0.01) / Math.log(1.0 - (1.0/vals.length))),0,vals.length).toArray())
            .forEach(r -> max[0] = (max[0] < vals[r])? vals[r]: max[0]);

    return max[0];
}

(पूरी तरह से गंभीर नहीं)

Comments

;-) यह "पूरी तरह से गंभीर नहीं" ठीक है। अपवित्र करने के लिए घृणा…

— ओले वीवी

Answer 14

सरणी को किसी ऐसी विधि से पास करें जो उसके साथ छँटती है Arrays.sort()इसलिए यह केवल उस सरणी को छाँटता है जिस पद्धति का उपयोग कर रहा है और फिर से और अधिकतम के लिए न्यूनतम सेट करता है ।array[0]array[array.length-1]

Comments

यह शायद ध्यान देने योग्य है कि a) यह सरणी को संशोधित करता है, और b) बड़े सरणियों के लिए यह O (n) के बजाय एक अधिक महंगा समाधान O (nlog n) है

— davidsheldon

Answer 15

एक ऐरे का न्यूनतम / अधिकतम मान प्राप्त करने का मूल तरीका। यदि आपको अनसोल्ड सरणी की आवश्यकता है, तो आप एक प्रति बना सकते हैं या इसे एक विधि में पास कर सकते हैं जो मिन या अधिकतम लौटाता है। यदि नहीं, तो कुछ मामलों में तेजी से प्रदर्शन करने के बाद सॉर्ट किया गया सरणी बेहतर है।

public class MinMaxValueOfArray {
    public static void main(String[] args) {
        int[] A = {2, 4, 3, 5, 5};
        Arrays.sort(A);
        int min = A[0];
        int max = A[A.length -1];
        System.out.println("Min Value = " + min);        
        System.out.println("Max Value = " + max);
    }
}

Comments

छँटाई के साथ समस्या यह है कि इसमें O (n) समस्या के लिए O (n log n) ओवरहेड है। लेकिन यह पहले से दिए गए अन्य तीन "सरणी क्रमबद्ध" उत्तरों से बेहतर है।

— तेईपेम्म