Dokkan 1.8, C# - rextester

Language: Layout:

//Rextester.Program.Main is the entry point for your code. Don't change it.
//Compiler version 4.0.30319.17929 for Microsoft (R) .NET Framework 4.5

using System;
using System.Collections.Generic;
using System.Linq;
using System.Text.RegularExpressions;

namespace Rextester
{
    public class Program
    {
        public static void Main(string[] args)
        {
            //Your code goes here
            //awaken(30,30);
            //awaken(100,5);
            //awaken(100,100,30);
            //awaken(30,50);
            //awaken(30,30,30,30,30);
            awaken(100,50,50,50);
        }
        public static void awaken(int item1, int item2) {
            double p1 = Convert.ToDouble((double)item1/100);
            double p2 = Convert.ToDouble((double)item2/100);

int result0, result1, result2;
            double resultD1, resultD2;
            
            if (item1 == 100 || item2 == 100) { // either 100%
                result1 = 100;
                result2 = Math.Min(item1,item2);
                result0 = 0;
            }
            
            else if (item1 == 100 && item2 == 100) { // both 100%
                result1 = 100;
                result2 = 100;
                result0 = 0;
            }
            
            else {
                resultD1 = p1*(1-p2) + (1-p1)*p2;
                resultD2 = p1*p2;

result1 = Convert.ToInt32(resultD1*100);
                result2 = Convert.ToInt32(resultD2*100);
                result0 = 100-(result1+result2);
            }
            
            Console.WriteLine("Input: {0}%, {1}%\n******************", item1, item2);
            Console.WriteLine("0 successful: {0}%", result0);
            Console.WriteLine("1 successful: {0}%", result1);
            Console.WriteLine("2 successful: {0}%", result2);
            Console.WriteLine();
        }
        
        public static void awaken(int item1, int item2, int item3) {
            
            double resultD1, resultD2, resultD3;
            int result0, result1, result2, result3;
            double p1, p2, p3;
            
            List<int> items = new List<int>(new int[]{item1, item2, item3});
	
            /*
            foreach (int obj in items) {
                Console.WriteLine(obj);
            }
            Console.WriteLine();
            */
                
            foreach (int obj in items.Reverse<int>()) {
                if (obj==100) {
                   items.Remove(obj);
                }
            }
            
            /*
            if(items.Count>0) {
                for (int i = 0; i< items.Count; i++) {
                    Console.WriteLine("item #" + i + "; value: " + items[i]);

}
                Console.WriteLine();
            }
            else Console.WriteLine("all removed\n");
            */
            
            if (items.Count == 1) { // 2 100%
                result1 = 0;
                result2 = 100;
                result3 = items[0];
                result0 = 0;
            }
            
            else if (items.Count == 2) { // 1 100%
                result1 = 100; // just 1 success
                p1 = Convert.ToDouble((double)items[0]/100);
                p2 = Convert.ToDouble((double)items[1]/100);
                resultD2 = p1*(1-p2) + (1-p1)*p2; // 2 of the 3 successes
                resultD3 = p1*p2; // all 3 successes
                result2 = Convert.ToInt32(resultD2*100);
                result3 = Convert.ToInt32(resultD3*100);
                result0 = 0;
            }
            
            else if (items.Count == 3) { // no 100%
                p1 = Convert.ToDouble((double)items[0]/100);
                p2 = Convert.ToDouble((double)items[1]/100);
                p3 = Convert.ToDouble((double)items[2]/100);
                resultD1 = p1*(1-p2)*(1-p3) + (1-p1)*p2*(1-p3) + (1-p1)*(1-p2)*p3;
                resultD2 = p1*p2*(1-p3) + p1*(1-p2)*p3 + (1-p1)*p2*p3;
                resultD3 = p1*p2*p3;
                result1 = Convert.ToInt32(resultD1*100);
                result2 = Convert.ToInt32(resultD2*100);
                result3 = Convert.ToInt32(resultD3*100);
                result0 = 100-(result1+result2+result3);
            }
            
            else { //all 100%
                result1 = 0;
                result2 = 0;
                result3 = 100;
                result0 = 0;
            }
                        
            Console.WriteLine("Input: {0}%, {1}%, {2}%\n******************", item1, item2, item3);
            Console.WriteLine("0 successful: {0}%", result0);
            Console.WriteLine("1 successful: {0}%", result1);
            Console.WriteLine("2 successful: {0}%", result2);
            Console.WriteLine("3 successful: {0}%", result3);
            Console.WriteLine();
        } //end awaken 3
        
        public static void awaken(int item1, int item2, int item3, int item4) {
            
            double resultD1, resultD2, resultD3, resultD4;
            int result0, result1, result2, result3, result4;
            double p1, p2, p3, p4;
            
            List<int> items = new List<int>(new int[]{item1, item2, item3, item4});
	
            /*
            foreach (int obj in items) {
                Console.WriteLine(obj);
            }
            Console.WriteLine();
            */
                
            foreach (int obj in items.Reverse<int>()) {
                if (obj==100) {
                   items.Remove(obj);
                }
            }
            
            if (items.Count == 1) { // 3 100%
                result1 = 0;
                result2 = 0;
                result3 = 100;
                result4 = items[0];
                result0 = 0;
            }
            
            else if (items.Count == 2) { // 2 100%
                result1 = 0; // 2 of the 4
                result2 = 100; // are successes
                p1 = Convert.ToDouble((double)items[0]/100);
                p2 = Convert.ToDouble((double)items[1]/100);
                resultD3 = p1*(1-p2) + (1-p1)*p2; // 3 of the 4 successes
                resultD4 = p1*p2; // all 4 successes
                result3 = Convert.ToInt32(resultD3*100);
                result4 = Convert.ToInt32(resultD4*100);
                result0 = 0;
            }
            
            else if (items.Count == 3) { // 1 100%
                result1 = 100; // 1 of the 4 successes
                p1 = Convert.ToDouble((double)items[0]/100);
                p2 = Convert.ToDouble((double)items[1]/100);
                p3 = Convert.ToDouble((double)items[2]/100);
                resultD2 = p1*(1-p2)*(1-p3) + (1-p1)*p2*(1-p3) + (1-p1)*(1-p2)*p3; // 2 of the 4
                resultD3 = p1*p2*(1-p3) + p1*(1-p2)*p3 + (1-p1)*p2*p3; // 3 of the 4
                resultD4 = p1*p2*p3; // all 4
                result2 = Convert.ToInt32(resultD2*100);
                result3 = Convert.ToInt32(resultD3*100);
                result4 = Convert.ToInt32(resultD4*100);
                result0 = 0;
            }
            
            else if (items.Count == 4) { // no 100%
                p1 = Convert.ToDouble((double)items[0]/100);
                p2 = Convert.ToDouble((double)items[1]/100);
                p3 = Convert.ToDouble((double)items[2]/100);
                p4 = Convert.ToDouble((double)items[3]/100);
                
                resultD1 = p1*(1-p2)*(1-p3)*(1-p4) + (1-p1)*p2*(1-p3)*(1-p4) + (1-p1)*(1-p2)*p3*(1-p4) + (1-p1)*(1-p2)*(1-p3)*p4;
                resultD2 = p1*p2*(1-p3)*(1-p4) + (1-p1)*p2*p3*(1-p4) + (1-p1)*(1-p2)*p3*p4 + p1*(1-p2)*p3*(1-p4) + p1*(1-p2)*(1-p3)*p4 + (1-p1)*p2*(1-p3)*p4;
                resultD3 = p1*p2*p3*(1-p4) + (1-p1)*p2*p3*p4 + p1*(1-p2)*p3*p4 + p1*p2*(1-p3)*p4;
                resultD4 = p1*p2*p3*p4;
            
                result1 = Convert.ToInt32(resultD1*100);
                result2 = Convert.ToInt32(resultD2*100);
                result3 = Convert.ToInt32(resultD3*100);
                result4 = Convert.ToInt32(resultD4*100);
                result0 = 100-(result1+result2+result3+result4);
            }
            
            else { //all 100%
                result1 = 0;
                result2 = 0;
                result3 = 0;
                result4 = 100;
                result0 = 0;
            }
            
            Console.WriteLine("Input: {0}%, {1}%, {2}%, {3}%\n******************", item1, item2, item3, item4);
                Console.WriteLine("0 successful: {0}%", result0);
                Console.WriteLine("1 successful: {0}%", result1);
                Console.WriteLine("2 successful: {0}%", result2);
                Console.WriteLine("3 successful: {0}%", result3);
                Console.WriteLine("4 successful: {0}%", result4);
                Console.WriteLine();
            
        }
        
        public static void awaken(int item1, int item2, int item3, int item4, int item5) {
            double p1 = Convert.ToDouble((double)item1/100);
            double p2 = Convert.ToDouble((double)item2/100);
            double p3 = Convert.ToDouble((double)item3/100);
            double p4 = Convert.ToDouble((double)item4/100);
            double p5 = Convert.ToDouble((double)item5/100);
            
            double resultD1 = p1*(1-p2)*(1-p3)*(1-p4)*(1-p5) + (1-p1)*p2*(1-p3)*(1-p4)*(1-p5) + (1-p1)*(1-p2)*p3*(1-p4)*(1-p5) + (1-p1)*(1-p2)*(1-p3)*p4*(1-p5) + (1-p1)*(1-p2)*(1-p3)*(1-p4)*p5;
            
            double resultD2 = p1*p2*(1-p3)*(1-p4)*(1-p5) + (1-p1)*p2*p3*(1-p4)*(1-p5) + (1-p1)*(1-p2)*p3*p4*(1-p5) + (1-p1)*(1-p2)*(1-p3)*p4*p5
                            + p1*(1-p2)*p3*(1-p4)*(1-p5) + (1-p1)*p2*(1-p3)*p4*(1-p5) + (1-p1)*(1-p2)*p3*(1-p4)*p5
                            + p1*(1-p2)*(1-p3)*p4*(1-p5) + (1-p1)*p2*(1-p3)*(1-p4)*p5 + p1*(1-p2)*(1-p3)*(1-p4)*p5;
            double resultD3 = (1-p1)*(1-p2)*p3*p4*p5 + p1*(1-p2)*(1-p3)*p4*p5 + p1*p2*(1-p3)*(1-p4)*p5 + p1*p2*p3*(1-p4)*(1-p5) 
                            + (1-p1)*p2*(1-p3)*p4*p5 + p1*(1-p2)*p3*(1-p4)*p5 + p1*p2*(1-p3)*p4*(1-p5)
                            + (1-p1)*p2*p3*(1-p4)*p5 + p1*(1-p2)*p3*p4*(1-p5) + (1-p1)*p2*p3*p4*(1-p5);
            double resultD4 = p1*p2*p3*p4*(1-p5) + p1*p2*p3*(1-p4)*p5 + p1*p2*(1-p3)*p4*p5 + p1*(1-p2)*p3*p4*p5 + (1-p1)*p2*p3*p4*p5;
            double resultD5 = p1*p2*p3*p4*p5;
            
            int result1 = Convert.ToInt32(resultD1*100);
            int result2 = Convert.ToInt32(resultD2*100);
            int result3 = Convert.ToInt32(resultD3*100);
            int result4 = Convert.ToInt32(resultD4*100);
            int result5 = Convert.ToInt32(resultD5*100);
            
            Console.WriteLine("Input: {0}%, {1}%, {2}%, {3}%, {4}%\n******************", item1, item2, item3, item4, item5);
            Console.WriteLine("0 successful: {0}%", 100-(result1+result2+result3+result4+result5));
            Console.WriteLine("1 successful: {0}%", result1);
            Console.WriteLine("2 successful: {0}%", result2);
            Console.WriteLine("3 successful: {0}%", result3);
            Console.WriteLine("4 successful: {0}%", result4);
            Console.WriteLine("5 successful: {0}%", result5);
            Console.WriteLine();
            
            
        }
    }
}

Show compiler warnings [ + ] Show input
Compilation time: 0,19 sec, absolute running time: 0,11 sec, cpu time: 0,09 sec, average memory usage: 14 Mb, average nr of threads: 3, absolute service time: 0,34 sec