No, C does not have such functionality built in. Moreover, there is no functionality to get the upper boundary of an array once you pass it to a function (so called "decaying to pointers").

There are two standard solutions to this problem:

• Pass a pointer to the first array element and the count of elements, or
• Pass a pointer to the whole array, an index to the initial element, and an index to the last element

The first approach would look like this:

int sum_array(int* array, size_t len) {
    int res = 0;
    for (size_t i = 0 ; i != len ; i++) {
        res += array[i];
    }
    return res;
}
...
int ProfitA = sum_array(array, A);
int ProfitB = sum_array(array+A, B);
int ProfitC = sum_array(array+A+B, N-A-B);

the second approach would look like this:

int sum_array(int* array, int first, int last) {
    int res = 0;
    for (int i = first ; i <= last ; i++) {
        res += array[i];
    }
    return res;
}
...
int ProfitA = sum_array(array, 0, A-1);
int ProfitB = sum_array(array, A, A+B-1);
int ProfitC = sum_array(array, A+B, N-1);

For those still looking for a solution:

In Java 8 or later, this can be answered trivially using Streams without any loops or additional libraries.

int[] range = IntStream.rangeClosed(1, 10).toArray();

This will produce an array with the integers from 1 to 10.

A more general solution that produces the same result is below. This can be made to produce any sequence by modifying the unary operator.

int[] range = IntStream.iterate(1, n -> n + 1).limit(10).toArray();

This is my take. It is a greedy algorithm that starts with a maximal B range and then starts chopping off values one after another until the result cannot be improved. It hast complexity O(n).

#include <iostream>
#include <utility>
#include <array>
#include <algorithm>
#include <cassert>

// Splits an array `arr` into three sections A,B,C.
// Returns the indices to the first element of B and C.
//    (the first element of A obviously has index 0)
template <typename T, ::std::size_t len>
::std::pair<::std::size_t,::std::size_t> split(T const (& arr)[len]) {
  assert(len > 2);
  // initialise the starting indices of section A, B, and C
  //   such that A: {0}, B: {1,...,len-2}, C: {len-1}
  ::std::array<::std::size_t,3> idx = {0,1,len-1};
  // initialise the preliminary sum of all sections
  ::std::array<T,3> sum = {arr[0],arr[1],arr[len-1]};
  for (::std::size_t i = 2; i < len-1; ++i)
    sum[1] += arr[i];
  // the preliminary maximum
  T max = ::std::max({ sum[0], sum[1], sum[2] });
  // now we iterate until section B is not empty
  while ((idx[1]+1) < idx[2]) {
    // in our effort to shrink B, we must decide whether to cut of the
    //   left-most element to A or the right-most element to C.
    //   So we figure out what the new sum of A and C would be if we
    //   did so.
    T const left = (sum[0] + arr[idx[1]]);
    T const right = (sum[2] + arr[idx[2]-1]);
    // We always fill the smaller section first, so if A would be
    //    smaller than C, we slice an element off to A.
    if (left <= right && left <= max) {
      // We only have to update the sums to the newly computed value.
      // Also we have to move the starting index of B one
      //    element to the right
      sum[0] = left;
      sum[1] -= arr[idx[1]++];
      // update the maximum section sum
      max = ::std::max(sum[1],sum[2]); // left cannot be greater
    } else if (right < left && right <= max) {
      // Similar to the other case, but here we move the starting
      //    index of C one to the left, effectively shrinking B.
      sum[2] = right;
      sum[1] -= arr[--idx[2]];
      // update the maximum section sum
      max = ::std::max(sum[1],sum[0]); // right cannot be greater
    } else break;
  }
  // Finally, once we're done, we return the first index to
  //    B and to C, so the caller knows how our partitioning looks like.
  return ::std::make_pair(idx[1],idx[2]);
}

It returns the index to the start of the B range and the index to the start of the C range.

The length of an array in Java is immutable. So, you need to copy the desired part into a new array.

Use copyOfRange method from java.util.Arrays class:

int[] newArray = Arrays.copyOfRange(oldArray, startIndex, endIndex);

startIndex is the initial index of the range to be copied, inclusive.
endIndex is the final index of the range to be copied, exclusive. (This index may lie outside the array)

E.g.:

   //index   0   1   2   3   4
int[] arr = {10, 20, 30, 40, 50};
Arrays.copyOfRange(arr, 0, 2);          // returns {10, 20}
Arrays.copyOfRange(arr, 1, 4);          // returns {20, 30, 40}
Arrays.copyOfRange(arr, 2, arr.length); // returns {30, 40, 50} (length = 5)

Im not going to give you the answer since this sounds like homework but I will help you break it down into manageable chunks.

First, generate 1000000 random numbers between 1 and 100. You were on the right track and combine it with Dawnkeepers hint. int[] randoms = new int[1000000]; is an int array with a size of 1000000. Now iterate over each index and assign it a random number(see above). Now you have an array with a million random numbers. Generating a million randoms can be a lengthy procedure depending on you machine, so yea.

Next, use the Scanner class to get the users input.(pro tip: dont use the same variable name for your scanner as your variable in the for loop lol). Now do an if check to make sure they enter a number between 1 and 100. if(val > 0 && val <= 100). If this passes, move on, else quit or prompt for user to give a new input. Using the scanner is pretty trivial so I wont go into this.

Finally, iterate through your list of randoms and keep a counter of how many numbers less then or equal to x.

int counter = 0;
for(int i = 0; i < randoms.length; i++) {
  //if randoms[i] is less then or equal x, counter++
}

Take that counter and do your math, int final_answer = counter/randoms.length;

That's all that is to it. There are more efficient ways of doing this but I tried to make it simple to follow. If I misread the question, sorry.

Use IntStream.range:

int[] result = IntStream.range(startInclusive, endExclusive).toArray();

or IntStream.rangeClosed:

int[] result = IntStream.rangeClosed(startInclusive, endInclusive).toArray();