संख्या

Question

से समय उत्पन्न करना मेरे पास x, y, z, और w के रूप में संख्याएं हैं। मैं 24 घंटे प्रारूप में अधिकतम संभव समय बनाने की कोशिश कर रहा हूं। उदाहरण:

मेरा दृष्टिकोण सभी संख्याओं को सॉर्ट करना है। फिर घंटों के लिए बराबर 2 से कम संख्या की जांच करें, फिर अगले अंक के लिए घंटे में, 4, के बराबर संख्या और फिर मिनटों के लिए भी कम संख्या की जांच करें। (0-60 मिनट)

ब्रूटफोर्स समाधान से कोई अन्य कुशल दृष्टिकोण है?

Answer 1

मेरे पास एक तरीका होगा जो आप एक अनुमान दे सकते हैं जो अनुमानित मिलान से उच्चतम मूल्य निकालता है।

उदा।

public static int highest(List<Integer> values, Predicate<Integer> test) { 
    Integer max = values.stream() 
         .filter(test) 
         .max(Comparator.natrualOrder()) 
         .orElseThrow(() -> new InvalidStateException()); 
    values.remove(max); 
    return max; 
} 

int digit1 = highest(list, i -> i < 3); 
int digit3 = highest(list, i -> i < 6); 
int digit2 = highest(list, i -> digit1 < 2 || i < 4); 
int digit4 = highest(list, i -> true); 

Answer 2

इनपुट 1 2 9 9 के लिए, केवल संभावना 19:29 है, लेकिन क्या आप की पसंद का वर्णन दो पहली और 21:99, गलत समय हो जाता है।

जब तक कि यह वास्तव में एक बाधा नहीं है और प्रोग्रामिंग अभ्यास नहीं है, तब तक सबसे सरल समाधान अंकों के सभी संभावित क्रमिक प्रयासों का प्रयास करना है, प्रत्येक के लिए, यह जांचें कि यह वैध समय है या नहीं, और लेक्सिकोग्राफिक रूप से अधिकतम मान्य स्ट्रिंग लेता है।

बिंदु यह है कि, तेज समाधान हैं और सही समाधान हैं। यहां, तेज़ समाधान मुश्किल है, इसलिए यदि प्रोग्राम चलने का समय महत्वपूर्ण नहीं है, तो धीमे लेकिन अधिक स्पष्ट समाधान को चुनने की संभावना पर विचार करें। यह शायद आपको प्रोग्रामर के रूप में, अन्य समस्याओं से निपटने के लिए अधिक समय देगा जहां चलने का समय मायने रखता है।

अफसोस की बात है कि जावा एक अंतर्निहित अगली पैरामिशन विधि प्रदान नहीं करता है, लेकिन स्टैक ओवरफ्लो sure does।

Answer 3

सरल दृष्टिकोण चार अंकों से सभी संख्याओं के सभी संभावित संयोजनों को बनाना होगा। फिर 235 से कम सभी मानों को क्रमबद्ध करें और चुनें (अधिकतम समय अनुमत)। इसके बाद आप अधिकतम संख्या से शुरू करते हैं और अगर यह सही समय है तो अगली सबसे बड़ी संख्या की जांच न करें।

Answer 4

मूल रूप से आप जो भी कर सकते हैं वह सभी क्रमिकताओं के बजाय है जो आप सरणी में प्रत्येक मान के लिए शर्तों को बनाते हैं। उदाहरण के लिए यदि हमारे पास 2 है तो हम जानते हैं कि हमारे दस स्थान के लिए घंटा 2 होना चाहिए, लेकिन उस समय के लिए हमारे स्थान केवल उस बिंदु पर 3 हो सकते हैं। यदि हमारे पास 1 है तो हम जानते हैं कि घंटे के लिए हमारा एक स्थान 9 हो सकता है। हम जानते हैं कि हमारा मिनट दस स्थान 5 है और हमारा अधिकतम मिनट एक स्थान 9 है। CreateTime इन स्थितियों को दिखाता है। FindMaxSpecific रिटर्न -1 यदि यह दिए गए सरणी में मान्य संख्या नहीं पा रहा है। इस तरह हम जानते हैं कि समय अमान्य है अगर हमें कभी भी इसके साथ createTime द्वारा लौटाए गए सरणी मिलती है। उदाहरण आउटपुट देखें।

public static int[] createTime(int[] numbers) 
{ 
    int[] time = new int[4]; 
    time[0] = findMaxSpecific(numbers, 2); 
    time[1] = time[0] == 2 ? findMaxSpecific(numbers, 3) : findMaxSpecific(numbers, 9); 
    time[2] = findMaxSpecific(numbers, 5); 
    time[3] = findMaxSpecific(numbers, 9); 

    return time; 
} 

public static int findMaxSpecific(int[] arr, int valToFind) 
{ 
    if(arr.length != 4) 
     return -1; 

    int numToFind = -1; 
    int indexToRemove = -1; 


    for(int i = 0; i < arr.length; i++) 
    { 
     if(arr[i] <= valToFind) 
     { 
      if(arr[i] > numToFind) 
      { 
       numToFind = arr[i]; 
       indexToRemove = i; 
      } 
     } 
    } 

    if(indexToRemove == -1) 
     return -1; 

    arr[indexToRemove] = -1; 

    return numToFind; 
} 

यह सब के अंत में अगर है किसी भी मूल्य वापस के रूप में -1 हम जानते हैं कि हम गलत समय हम

उदाहरण

दिया गया है आता है

 int[] time = new int[4]; 
     int[] numbers = {1,2,3,4}; 
     time = createTime(numbers); 
     System.out.println(time[0] + "" + time[1] + ":" + time[2] + "" + time[3]); 
     int[] numbers2 = {0,9,7,1}; 
     time = new int[4]; 
     time = createTime(numbers2); 
     System.out.println(time[0] + "" + time[1] + ":" + time[2] + "" + time[3]); 

     int[] numbers3 = {9,9,9,9}; 
     time = new int[4]; 
     time = createTime(numbers3); 
     System.out.println(time[0] + "" + time[1] + ":" + time[2] + "" + time[3]); 

आउटपुट

23:41 
19:07 
-19:-19 //invalid numbers 

है

Answer 5

input = (1,2,3,4) 
ans = None 
for hour in range(0, 24): 
    for minute in range(0,60): 
     if possible(hour, minute, input): 
      ans = "%s:%s" % (hour, minute) 

यहां आपके possible फ़ंक्शन को घंटे, मिनट और इनपुट में अंकों की गणना करनी चाहिए और सुनिश्चित करें कि वे समान हैं।

Answer 6

दिलचस्प समस्या। ऐसा लगता है की तुलना में थोड़ा अधिक जटिल लगता है। समस्या के लिए यहां एक पायथन लिपि है।

def getmin(num): # check if two digits are valid for minutes 
    min = -1 
    sum = num[0] * 10 + num[1] 
    if sum < 60: 
     min = sum 
    sum = num[1] * 10 + num[0] 
    if sum < 60 and min < sum: 
     min = sum 
    return min 

def maxtime(num): 
    hour = -1 
    min = -1 
    h1 = 0 
    h2 = 0 
    for i in range(4): 
     for j in range(4): # these two loops are to get maxi hour, if possible 
      if i != j: 
       sum = num[i] * 10 + num[j] 
       if hour < sum and sum < 24: 
        c = num[:]  # get a copy of input digits 
        if i > j:  # delete numbers used in hour 
         del c[i] 
         del c[j] 
        else: 
         del c[j] 
         del c[i] 
        if getmin(c) > -1: 
         h1 = i 
         h2 = j 
         hour = sum 
    if hour > -1: 
     if h2 > h1:  # delete numbers used in hour 
      del num[h2] 
      del num[h1] 
     else: 
      del num[h1] 
      del num[h2] 

     min = getmin(num) 

     if min > -1: 
      print(str(hour) + ':' + str(min)) 

    if hour < 0 or min < 0: 
     print("no solution") 

maxtime([4, 8, 1, 9]) 
maxtime([7, 3, 4, 2]) 
maxtime([9, 2, 2, 5]) 
maxtime([9, 2, 7, 3]) 

#19:48 
#23:47 
#22:59 
#no solution