আপনি জাভাতে কোন অ্যারেতে সমস্ত সংখ্যার যোগফলটি কীভাবে খুঁজে পাবেন?


141

জাভাতে একটি অ্যারেতে পূর্ণসংখ্যার সমষ্টিগুলির সন্ধান করতে আমার সমস্যা হচ্ছে। আমি এর জন্য Mathক্লাসে কোনও দরকারী পদ্ধতি খুঁজে পাচ্ছি না ।


15
আপনার নিজের লিখুন, এটি করার কোডটি 2-3 লাইন দীর্ঘ।
wkl

2
দুর্ভাগ্যক্রমে উপরের (এবং নিম্নলিখিত) "উত্তরগুলি হ'ল " জাভা ওয়ে ": - / আপনি কার্যকরী জাভা গ্রন্থাগারটি ব্যবহার করতে পারতেন , তবে জাভা বাক্য গঠনটি মোকাবেলা করা এত জটিল।

1
আমি জানি এই প্রশ্নটি অত্যন্ত পুরানো, তবে নীচে এমসায়াগের উত্তরটি দেখে মনে হচ্ছে এটি গ্রহণযোগ্য উত্তর হিসাবে চিহ্নিত করা উচিত।
মাতসু প্র।

আপনার নিজের লেখার সমস্যাটি হ'ল এটি একটি লুপ। আপনি 3 টি সংখ্যার যোগফল নেওয়ার সময় আপনার একটি নির্দেশে তা করতে সক্ষম হওয়া উচিত।
আল জি জনস্টন

উত্তর:


269

ভিতরে আপনি স্ট্রিম ব্যবহার করতে পারেন:

int[] a = {10,20,30,40,50};
int sum = IntStream.of(a).sum();
System.out.println("The sum is " + sum);

আউটপুট:

যোগফল 150।

এটা প্যাকেজে আছে java.util.stream

import java.util.stream.*;

1
অ্যারেতে যদি বিপুল সংখ্যক থাকে এবং যোগফলের সুযোগ খুব বেশি থাকে?
Thanhbinh84

5
সেক্ষেত্রে আপনি লংস্ট্রিম ব্যবহার করতে পারেন, লম্বা যোগফল হিসাবে = IntStream.of (a) .asLongstream ()। যোগফল (); বা দীর্ঘ সমষ্টি = লংস্ট্রিম.ওফ (ক) .সুম ();
এমসায়াগ

2
স্রোত ব্যবহারে কি যথেষ্ট গতির সুবিধা রয়েছে?
মোরভিজেক

1
যদি আপনার যোগফল দীর্ঘ মাপসই না হয় তবে একটি জোড় যুক্ত যুক্ত হওয়া উচিত (বিভাজক এবং বিজয়ী করা), কারণ ছোট বিগডিসিমালগুলি যোগ করা দ্রুত হয়।
ব্যবহারকারী 482745

1
@ java.util.stream.DoubleStream.of(a).sum();
হোসেইন

48

আপনি যদি জাভা 8 ব্যবহার করছেন তবে Arraysক্লাসটি এমন একটি stream(int[] array)পদ্ধতি সরবরাহ করে যা IntStreamনির্দিষ্ট intঅ্যারে সহ একটি ক্রমিক প্রদান করে । এটি ওভারলোড হয়েছে doubleএবং longঅ্যারেগুলিও।

int [] arr = {1,2,3,4};
int sum = Arrays.stream(arr).sum(); //prints 10

এটি এমন একটি পদ্ধতিও সরবরাহ করে stream(int[] array, int startInclusive, int endExclusive)যা আপনাকে অ্যারের নির্দিষ্ট রেঞ্জ নিতে অনুমতি দেয় (যা কার্যকর হতে পারে):

int sum = Arrays.stream(new int []{1,2,3,4}, 0, 2).sum(); //prints 3

অবশেষে, এটি ধরণের অ্যারে নিতে পারে T। সুতরাং আপনি উদাহরণস্বরূপ Stringএকটিতে একটি ইনপুট হিসাবে সংখ্যার সমন্বিত থাকতে পারে এবং আপনি যদি তাদের যোগ করতে চান তবে কেবল করুন:

int sum = Arrays.stream("1 2 3 4".split("\\s+")).mapToInt(Integer::parseInt).sum();

35

এটি স্ট্যান্ডার্ড জাভা এপিআই-তে বিদ্যমান না এমন সাধারণ জিনিসগুলির মধ্যে একটি (এএফআইকে) নেই। এটি নিজের লেখার পক্ষে যথেষ্ট সহজ।

অন্যান্য উত্তরগুলি পুরোপুরি ঠিক আছে, তবে প্রতিটি সিনট্যাকটিক চিনির জন্য এখানে কিছু রয়েছে।

int someArray[] = {1, 2, 3, 4, 5, 6, 7, 8, 9, 10};
int sum = 0;

for (int i : someArray)
    sum += i;

এছাড়াও, অ্যারের সমষ্টি একটি উদাহরণ এমনকি জাভা 7 ভাষা নির্দিষ্টকরণ দেখানো । উদাহরণটি বিভাগের 10.4 থেকে রয়েছে - অ্যারে অ্যাক্সেস

class Gauss {
    public static void main(String[] args) {
        int[] ia = new int[101];
        for (int i = 0; i < ia.length; i++) ia[i] = i;
        int sum = 0;
        for (int e : ia) sum += e;
        System.out.println(sum);
    }
}

তবে এটি একের মধ্যে সমস্ত সংখ্যা যুক্ত করে না। এটি অদক্ষ।
আল জি জনস্টন

20

আপনি পারবেন না। অন্যান্য ভাষায় পিএইচপি-তে অ্যারে_সাম () এর মতো কিছু পদ্ধতি রয়েছে তবে জাভা নেই।

শুধু ..

int[] numbers = {1,2,3,4};
int sum = 0;
for( int i : numbers) {
    sum += i;
}

System.out.println(sum);

6
আমি আপনাকে মিস করছি। নেট সমষ্টি (আইনিম্যুয়াল <Int32>) msdn.microsoft.com/en-us/library/…
আকিরা ইয়ামামোটো

15

আপাচে মঠে: আছে StatUtils.sum(double[] arr)


কেবলমাত্র স্ট্যাচুটিলেলে কেন: ডি
লোর

13

আমি পূর্ববর্তী সমাধানগুলিতে কেবলমাত্র যুক্তিটিই যুক্ত করব যে মানটির কোনও ওভারফ্লো এড়াতে আমি মোট সংগ্রহ করতে দীর্ঘ ব্যবহার করব।

int[] someArray = {1, 2, 3, 4, 5, 6, 7, 8, 9, 10, Integer.MAX_VALUE};
long sum = 0;

for (int i : someArray)
    sum += i;

6
int sum = 0;

for (int i = 0; i < yourArray.length; i++)
{
  sum = sum + yourArray[i];
}

4
আপনি প্রতিটি লুপ (জাভা 1.5 তে প্রবর্তিত) দিয়ে এটি আরও সুন্দর করতে পারেন।
wkl

6

ভিতরে Java 8

কোড :

   int[] array = new int[]{1,2,3,4,5};
   int sum = IntStream.of(array).reduce( 0,(a, b) -> a + b);
   System.out.println("The summation of array is " + sum);

  System.out.println("Another way to find summation :" + IntStream.of(array).sum());

আউটপুট :

The summation of array is 15
Another way to find summation :15

ব্যাখ্যা :

ভিতরে Java 8 , আপনি আপনার সংযোজন করতে হ্রাস ধারণাটি ব্যবহার করতে পারেন।

হ্রাস সম্পর্কে সব পড়ুন


4
int sum = 0;
for (int i = 0; i < myArray.length; i++)
  sum += myArray[i];
}

4

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


3

আমি ব্যক্তিগতভাবে এই পদ্ধতিটি পছন্দ করি। আমার কোড স্টাইলটি কিছুটা অদ্ভুত।

public static int sumOf(int... integers) {
    int total = 0;
    for (int i = 0; i < integers.length; total += integers[i++]);
    return total;
}

কোডে ব্যবহার করা খুব সহজ:

int[] numbers = { 1, 2, 3, 4, 5 };
sumOf(1);
sumOf(1, 2, 3);
sumOf(numbers);

3

আমি এটি ব্যবহার:

public static long sum(int[] i_arr)
{
    long sum;
    int i;
    for(sum= 0, i= i_arr.length - 1; 0 <= i; sum+= i_arr[i--]);
    return sum;
}

1
সি-প্রোগ্রামার, আহ?
তোয়াই

2

আপনাকে নিজের রোল করতে হবে।
আপনি মোট 0 দিয়ে শুরু করেন Then তারপরে আপনি অ্যারেতে প্রতিটি পূর্ণসংখ্যার জন্য বিবেচনা করুন, এটি মোটটিতে যুক্ত করুন। তারপরে আপনি যখন পূর্ণসংখ্যার বাইরে থাকবেন তখন আপনার যোগফল হবে।

যদি কোনও পূর্ণসংখ্যা না থাকে তবে মোট 0 হয়।


2

এই অনুশীলন থেকে দুটি জিনিস শিখতে হবে:

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

int accumulator = 0;
for(int i = 0; i < myArray.length; i++) {
    accumulator += myArray[i];
}

2

আপনি আপনার কোডটি দেখতে আরও ভাল করে তুলতে পারেন:

public void someMethod(){
    List<Integer> numbers = new ArrayList<Integer>();
    numbers.addAll(db.findNumbers());
    ...
    System.out.println("Result is " + sumOfNumbers(numbers));
}

private int sumOfNumbers(List<Integer> numbers){
    int sum = 0;
    for (Integer i : numbers){
      sum += i;
    }
    return sum;
}

2

এটা নির্ভর করে. আপনি কত নম্বর যুক্ত করছেন? উপরোক্ত অনেক পরামর্শের পরীক্ষা করা:

import java.text.NumberFormat;
import java.util.Arrays;
import java.util.Locale;

public class Main {

    public static final NumberFormat FORMAT = NumberFormat.getInstance(Locale.US);

    public static long sumParallel(int[] array) {
        final long start = System.nanoTime();
        int sum = Arrays.stream(array).parallel().reduce(0,(a,b)->  a + b);
        final long end = System.nanoTime();
        System.out.println(sum);
        return  end - start;
    }

    public static long sumStream(int[] array) {
        final long start = System.nanoTime();
        int sum = Arrays.stream(array).reduce(0,(a,b)->  a + b);
        final long end = System.nanoTime();
        System.out.println(sum);
        return  end - start;
    }

    public static long sumLoop(int[] array) {
        final long start = System.nanoTime();
        int sum = 0;
        for (int v: array) {
            sum += v;
        }
        final long end = System.nanoTime();
        System.out.println(sum);
        return  end - start;
    }

    public static long sumArray(int[] array) {
        final long start = System.nanoTime();
        int sum = Arrays.stream(array) .sum();
        final long end = System.nanoTime();
        System.out.println(sum);
        return  end - start;
    }

    public static long sumStat(int[] array) {
        final long start = System.nanoTime();
        int sum = 0;
        final long end = System.nanoTime();
        System.out.println(sum);
        return  end - start;
    }


    public static void test(int[] nums) {
        System.out.println("------");
        System.out.println(FORMAT.format(nums.length) + " numbers");
        long p = sumParallel(nums);
        System.out.println("parallel " + FORMAT.format(p));
        long s = sumStream(nums);
        System.out.println("stream " +  FORMAT.format(s));
        long ar = sumArray(nums);
        System.out.println("arrays " +  FORMAT.format(ar));
        long lp = sumLoop(nums);
        System.out.println("loop " +  FORMAT.format(lp));

    }

    public static void testNumbers(int howmany) {
        int[] nums = new int[howmany];
        for (int i =0; i < nums.length;i++) {
            nums[i] = (i + 1)%100;
        }
        test(nums);
    }

    public static void main(String[] args) {
        testNumbers(3);
        testNumbers(300);
        testNumbers(3000);
        testNumbers(30000);
        testNumbers(300000);
        testNumbers(3000000);
        testNumbers(30000000);
        testNumbers(300000000);
    }
}

আমি পেয়েছি, একটি 8 কোর, 16 জি উবুন্টু 18 মেশিন ব্যবহার করে লুপটি ছোট মানগুলির জন্য দ্রুত এবং বৃহত্তর সমান্তরাল ছিল। তবে অবশ্যই এটি আপনি যে হার্ডওয়্যারটি চালাচ্ছেন তার উপর নির্ভর করবে:

------
3 numbers
6
parallel 4,575,234
6
stream 209,849
6
arrays 251,173
6
loop 576
------
300 numbers
14850
parallel 671,428
14850
stream 73,469
14850
arrays 71,207
14850
loop 4,958
------
3,000 numbers
148500
parallel 393,112
148500
stream 306,240
148500
arrays 335,795
148500
loop 47,804
------
30,000 numbers
1485000
parallel 794,223
1485000
stream 1,046,927
1485000
arrays 366,400
1485000
loop 459,456
------
300,000 numbers
14850000
parallel 4,715,590
14850000
stream 1,369,509
14850000
arrays 1,296,287
14850000
loop 1,327,592
------
3,000,000 numbers
148500000
parallel 3,996,803
148500000
stream 13,426,933
148500000
arrays 13,228,364
148500000
loop 1,137,424
------
30,000,000 numbers
1485000000
parallel 32,894,414
1485000000
stream 131,924,691
1485000000
arrays 131,689,921
1485000000
loop 9,607,527
------
300,000,000 numbers
1965098112
parallel 338,552,816
1965098112
stream 1,318,649,742
1965098112
arrays 1,308,043,340
1965098112
loop 98,986,436


1

যুক্তির নীচে ব্যবহার করুন:

static int sum()
     {
         int sum = 0; // initialize sum
         int i;

         // Iterate through all elements summing them up
         for (i = 0; i < arr.length; i++)
            sum +=  arr[i];

         return sum;
     }

0

এই জাতীয় জিনিসের জন্য কোনও গণিত শ্রেণিতে কোনও পদ্ধতি নেই। এটি এর স্কোয়ার রুট ফাংশন বা এর মতো কিছু নয়।

আপনার যোগফলের জন্য কেবল একটি ভেরিয়েবল থাকা দরকার এবং অ্যারের মধ্য দিয়ে লুপটি আপনার প্রতিটি যোগফলকে যোগ করে adding


0
class Addition {

     public static void main() {
          int arr[]={5,10,15,20,25,30};         //Declaration and Initialization of an Array
          int sum=0;                            //To find the sum of array elements
          for(int i:arr) {
              sum += i;
          }
          System.out.println("The sum is :"+sum);//To display the sum 
     }
} 

বিদ্যমান উত্তরের অনুলিপি।
james.garriss

0

আমরা ব্যবহারকারীর সংজ্ঞায়িত ফাংশন ব্যবহার করতে পারি। প্রথমে শূন্যের সমান ভেরিয়েবল আরম্ভ করুন। তারপরে অ্যারেটি অতিক্রম করুন এবং যোগফলের সাথে উপাদান যুক্ত করুন। তারপরে যোগফলের পরিবর্তনশীল আপডেট করুন।

টুকিটাকি সংকেতলিপি :

import java.util.*;   
import java.lang.*;  
import java.io.*;


class Sum
{
    public static int sum(int arr[])
    {
        int sum=0;

        for(int i=0; i<arr.length; i++)
        {
            sum += arr[i];
        }
        return sum;
    }

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

          int total = sum(arr);

          System.out.printf("%d", total);
    }
}

0
/**
 * Sum of all elements from 1 to 1000
 */
final int sum = Stream.iterate(1, n -> n + 1).limit(1000).mapToInt(el -> el).sum();

0

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

তাই দ্রুততম সংক্ষিপ্ত এবং মিষ্টি কোডের জন্য পুরষ্কারটি যায় -

int[] nums = {1,2,3};
int sum =  Arrays.stream(nums).parallel().reduce(0, (a,b)-> a+b);

বলুন যে আপনি করতে চান sum of squares, তারপরে অ্যারেস স্ট্রিম (সংখ্যাগুলি) সমান্তরাল () মানচিত্র (x-> x * x) .ড্রেস (0, (ক, খ) -> এ + বি)। আইডিয়া হল আপনি মানচিত্র ছাড়াই এখনও হ্রাস সম্পাদন করতে পারেন।


অগত্যা দ্রুততম নয়। লুপটি ছোট এন এর চেয়ে বেশি কার্যকর হবে details বিশদ সহ আমার দীর্ঘ পোস্টটি দেখুন।
gerardw

-1
 public class Num1
 {
     public static void main ()
     {
          //Declaration and Initialization
          int a[]={10,20,30,40,50}

          //To find the sum of array elements
          int sum=0;
          for(int i=0;i<a.length;i++)
          {
              sum=sum+i;
          }

          //To display the sum
          System.out.println("The sum is :"+sum);

     }
  } 

1
বউ এটি যোগফল = যোগ + এ [i];
মাকসিম নিয়াজেভ

-1
public class AddDemo {

    public static void main(String[] args) {

        ArrayList <Integer>A = new ArrayList<Integer>();

        Scanner S = new Scanner(System.in);

        System.out.println("Enter the Numbers: ");

        for(int i=0; i<5; i++){

            A.add(S.nextInt());
        }

        System.out.println("You have entered: "+A);

        int Sum = 0;

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

            Sum = Sum + A.get(i);

        }

        System.out.println("The Sum of Entered List is: "+Sum);

    }

}

-3

জাভা 8 হিসাবে ল্যাম্বডা এক্সপ্রেশন ব্যবহার উপলব্ধ হয়েছে।

এটা দেখ:

int[] nums = /** Your Array **/;

কম্প্যাক্ট:

int sum = 0;
Arrays.asList(nums).stream().forEach(each -> {
    sum += each;
});

পছন্দ:

int sum = 0;

ArrayList<Integer> list = new ArrayList<Integer>();

for (int each : nums) { //refer back to original array
     list.add(each); //there are faster operations…
}

list.stream().forEach(each -> {
    sum += each;
});

রিটার্ন বা মুদ্রণের যোগফল।


1
কাজগুলি: int [] সংখ্যা = {1,2}; চূড়ান্ত int [] যোগ = {0}; অ্যারেলিস্ট <Integer> তালিকা = নতুন অ্যারেলিস্ট <Integer> (); (প্রতিটি প্রত্যেকে: সংখ্যা) {list.add (প্রতিটি); । list.stream ()। forEach (প্রতিটি -> {যোগ [0] + = প্রতিটি;;);
ঝুরভ কনস্ট্যান্টিন
আমাদের সাইট ব্যবহার করে, আপনি স্বীকার করেছেন যে আপনি আমাদের কুকি নীতি এবং গোপনীয়তা নীতিটি পড়েছেন এবং বুঝতে পেরেছেন ।
Licensed under cc by-sa 3.0 with attribution required.