Удаление элемента

package p;
 
import java.util.Random;
import java.util.Scanner;
 
 
 
/**
 *
 * @author i++
 * эта програма написана в качестве извращения для тех, кто не смог осилить циклы, для этих целей почти все циклы
 * были на рекурсию. ПС - один цикл все же оставил, мож кто чего из этого полезного для себя вытащит :)
 */
public class P {
 
    private static JFrame win;
    private static int[] i;
    static int index = 0;
    static int ind = 0;
    static int indC = 0;
    static int indM = 0;
    static int min = Integer.MAX_VALUE;
    static int[] end;
 
    /**
     * @param args the command line arguments
     */
    public static void main(String[] args) {
        Random r = new Random();
        i = new int[r.nextInt(Integer.MAX_VALUE)];
        recursiveInt();
        recursivMin();
        end = new int[i.length - 1];
        System.out.println("yor name is Vasia? y/n");
        Scanner sc = new Scanner(System.in);
        String s = sc.nextLine();
        sc.close();
        if(s.equals("y")){
            recursiveCopy();
        }
        else{
            cikleCopi();
        }
    }
 
    private static void recursiveInt() {
        if(index < i.length){
            if(i[index] == 0){
                Random r = new Random();
                i[index] = r.nextInt(Integer.MAX_VALUE + 1);
                recursiveInt();
            }
            else{
                index++;
                recursiveInt();
            }
        }
    }
 
    private static void recursivMin() {
        if(ind < i.length){
            if(i[ind] < min){
                min = i[ind];
                indM = ind;
                ind++;
                recursivMin();
            }
            else if(i[ind] == min){
                indM = ind;
                ind++;
                recursivMin();
            }
            else{
                ind++;
                recursivMin();
            }
        }
    }
 
    private static void recursiveCopy() {
        if(indC < end.length){
            end[indC] = indC >= indM ? i[indC + 1] : i[indC];
            ind++;
            recursiveCopy();
        }
    }
 
    private static void cikleCopi() {
        for(int a = 0; a < end.length; a++){
            end[a] = a >= indM ? i[a + 1] : i[a];
        }
    }
    
    
}

import java.util.Random;
 
public class Start {    
    public static void main(String[] args) {
        int[] array = new int[20];
        Random random = new Random();
        int min = 100;
        int lastMinPos = 0;
        
        System.out.print("Initial array : ");
        
        for (int i = 0; i < array.length; i++) {
            array[i] = random.nextInt(15) - 5;
            
            if (array[i] <= min) {
                min = array[i];
                lastMinPos = i;
            }
            
            System.out.print(array[i] + " ");
        }
        
        System.out.println("\nMinimal: " + array[lastMinPos]);
        System.out.print("Modifyed array: ");
        
        int[] newArray = new int[array.length - 1];
        int tmp = 0;
        
        for (int i = 0; i < newArray.length; i++) {
            if (tmp == lastMinPos) {
                tmp++;
            }
            newArray[i] = array[tmp];
            
            tmp++;
            
            System.out.print(newArray[i] + " ");
        }
    }   
}

class Ideone
{
    public static void main (String[] args) throws java.lang.Exception
    {
        int arr[]={2,3,1,-2,7,7,8,8,-2,3,4};
        int res[]=action(arr);
        for (int i=0; i<res.length; i++) System.out.print(res[i]+" ");
    }
    public static int [] action(int [] inArr)
    {
        int n=inArr.length;
        int [] res = new int [n-1];
        int min=inArr[0];
        int pmin=0;
        int i,j;
        for (i=1; i<n; i++)
        {
            if (inArr[i]<=min)
            {
                min=inArr[i];
                pmin=i;
            }
        }
        for (i=j=0; i<n; i++)
            if (i!=pmin) res[j++]=inArr[i];
        return res;    
    }
}

public static int[] getWithoutLastMinimum(int[] array){
        List<Integer> list = Arrays.stream(array).boxed().collect(Collectors.toList());
        list.remove(list.lastIndexOf(list.stream().min(Integer::compareTo).get()));
        return list.stream().mapToInt(Integer::intValue).toArray();
    }

/*
  https://www.cyberforum.ru/java-j2se/thread2375199.html
Составьте программу 
удаления последнего минимального элемента одномерного массива А(N).
 */
package lastMinRemove;
 
import java.util.ArrayList;
 
import java.util.Collections;
 
import java.util.List;
 
/**
 *
 * @author vvm
 */
public class LastMinRemove {
 
    public static void main(String[] args) {
        int arr[] = {-5, 16, 4, 0, 5, 12, -3, 2, 5, 13, -5};
        // преобразовать в ArrayList
        List<Integer> arl = new ArrayList<>();
        for (int i = 0; i < arr.length; i++) {
            arl.add(arr[i]);
        }
 
        arl.remove(arl.lastIndexOf(Collections.min(arl))); // удалить последний минимальный
 
        System.out.print(arl);
        // далее можно преобразовать обратно в массив, если нужно 
    }
 
}