विकट समस्या


23

एन डिकंटर्स (0 < एन <10) को देखते हुए कि C 0 पकड़ सकते हैं ... C N-1 लीटर (0 < C <50) और एक लक्ष्य G लीटर, कृपया निर्धारित करें कि क्या केवल उस लक्ष्य का उपयोग करके उस लक्ष्य तक पहुंचना संभव है निम्नलिखित क्रियाएं:

  • एक डिकंपर भरें
  • एक डिकंपर खाली करें
  • एक डिसेंटर से दूसरे में तब तक डालें जब तक कि एक को पूरा डाला न जाए या जिस से डाला जा रहा हो वह खाली हो

लक्ष्य राशि जी अंत में एक कंटेनर में पानी की मात्रा होनी चाहिए। आपके पास 'आउटपुट डिकंटर' नहीं हो सकता।

उदाहरण

N : 2
C 0 : 5
C 1 : 12
G : 1
परिणाम: हाँ

N : 3
C 0 : 6
C 1 : 9
C 2 : 21
G : 5
परिणाम: नहीं

संकेत: यदि यह संभव है तो गणना करने के लिए, यह देखने के लिए जांचें कि क्या जी क्षमता के जीसीडी द्वारा विभाज्य है। इसके अलावा, सुनिश्चित करें कि यह एक कंटेनर में फिट होगा।

याद रखें, यह , इसलिए सबसे कम बाइट्स वाली कोड जीतता है।

लीडरबोर्ड

यहां एक नियमित लीडरबोर्ड और भाषा के अनुसार विजेताओं का अवलोकन करने के लिए एक स्टैक स्निपेट है।

यह सुनिश्चित करने के लिए कि आपका उत्तर दिख रहा है, कृपया अपना उत्तर शीर्षक मार्कडाउन टेम्पलेट का उपयोग करके शीर्षक के साथ शुरू करें:

# Language Name, N bytes

Nआपके प्रस्तुत करने का आकार कहां है। यदि आप अपने स्कोर में सुधार करते हैं, तो आप पुराने अंकों को हेडलाइन में रख सकते हैं , उनके माध्यम से स्ट्राइक करके। उदाहरण के लिए:

# Ruby, <s>104</s> <s>101</s> 96 bytes

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

# Perl, 43 + 2 (-p flag) = 45 bytes

आप भाषा के नाम को एक लिंक भी बना सकते हैं जो लीडरबोर्ड स्निपेट में दिखाई देगा:

# [><>](http://esolangs.org/wiki/Fish), 121 bytes



क्या एक "आउटपुट डिकंटर" है? अका, अगर मेरे पास आकार 1 का एक कंटर है, तो क्या कोई क्षमता संभव है?
नाथन मेरिल

@MartinEnder आह। फिक्स्ड।
ओलिवर नी

@NathanMerrill कोई "आउटपुट डिकंटर नहीं है।" आपको दिए गए डेसेंटर में से एक में इसे प्राप्त करने में सक्षम होने की आवश्यकता है।
ओलिवर नी

9
इसी चुनौती को सैंडबॉक्स किया जा रहा था ।
xnor

जवाबों:


5

जेली , 9 8 7 बाइट्स

-1 बाइट @ @ डेनिस के लिए धन्यवाद (पूर्णांक विभाजन का उपयोग करें :, बजाय कम से कम नहीं, )

Ṁ:a⁸g/ḍ

TryItOnline

कैसे?

Ṁ:a⁸g/ḍ - Main link: capacities, goal
Ṁ       - maximum capacity
 :      - integer division with goal (effectively not less than goal since non-0 is True)
  a     - and
   ⁸    - left argument (capacities)
    g/  - gcd reduce over list (gcd of capacities)
      ḍ - divides

17

हास्केल, 35 बाइट्स

l%n=n`mod`foldr1 gcd l<1&&any(>=n)l

यह पेपर एक परिणाम साबित करता है जो समस्या को बहुत सरल करता है। Prop 1 कहता है कि

जब आप दोनों हों तब आप एक लक्ष्य प्राप्त कर सकते हैं:

  • क्षमता के सबसे बड़े सामान्य भाजक (gcd) के कई,
  • अधिकतम क्षमता पर

यह स्पष्ट है कि ये दोनों क्यों आवश्यक हैं: सभी मात्राएं एलसीडी के गुणकों में रहती हैं, और लक्ष्य एक कंटेनर में फिट होना चाहिए। परिणाम की कुंजी किसी भी लक्ष्य राशि का उत्पादन करने के लिए एक एल्गोरिथ्म है जो इन स्थितियों को फिट करती है।

%जैसे ऑपरेटर को बुलाओ [3,6,12]%9

एक 37-बाइट विकल्प:

l%n=elem n[0,foldr1 gcd l..maximum l]

मेरा मानना ​​है कि लक्ष्य को डिकंटर्स में से एक में फिट होना है, यह सबसे बड़े डिकंप्रेटर की मात्रा से कम होना चाहिए (@ ओलिवर की टिप्पणी के आधार पर "आपको दिए गए डिक्रिप्टरों में से एक में इसे प्राप्त करने में सक्षम होने की आवश्यकता है")।
m-chrzan

आसानी से, यह वास्तव में कागज में उपयोग की जाने वाली परिभाषा है और मुझे गलत लगता है, इसलिए यह एक आसान तरीका है।
xnor

6

05AB1E , 9 8 9 बाइट्स

CP-1252 एन्कोडिंग का उपयोग करता है

ZU¿%²X>‹‹

व्याख्या

          # true if
   %      # target size modulo
ZU¿       # gcd of decanter sizes
        ‹ # is smaller than
    ²X>‹  # target size is less than or equal to max decanter size

इसे ऑनलाइन आज़माएं!

लुइस मेंडो के MATL उत्तर से कम से कम चाल का उपयोग करके 1 बाइट को बचाया


1
चाल से कम का उपयोग ... जो मैंने डेनिस :-) से सीखा
लुइस मेंडो सेप

वास्तविक उत्तर अभी भी 9 बाइट्स; ;-)
ETHproductions

@ETHproductions उफ़! लगता है कि मैंने केवल स्पष्टीकरण और TIO लिंक को अपडेट किया है, न कि वास्तविक कोड को। धन्यवाद :)
एमिग्ना

5

MATL , 10 बाइट्स

&Zd\&G<~a<

इसे ऑनलाइन आज़माएं!

यह @ xnor के दृष्टिकोण का उपयोग करता है ।

&Zd    % Take array C as input. Compute the gcd of its elements
\      % Take number G as input. Compute that number modulo the above. Call this A
&G     % Push the two inputs again: C, then G
<~a    % Gives 1 if some element of C is at least G; 0 otherwise. Call this B
<      % Gives true if A is 0 and B is 1; otherwise gives false

5

एक्सेल: 43 बाइट्स

=AND(MOD(A10,GCD(A1:A9))=0,A10<=MAX(A1:A9))

इसे ऑनलाइन आज़माएं !

उपयोग कैसे करें:
A1-A10 को छोड़कर इस सूत्र को कहीं भी रखें।
तब सेल A1: A9 (क्योंकि decants की संख्या तय हो गई है) और A10 में लक्ष्य के लिए अपने Decant होल्डिंग वॉल्यूम इनपुट करें। बिना डिकैंट वाली कोशिकाओं को खाली छोड़ दिया जाना चाहिए। जहाँ भी आप सूत्र डालेंगे, उसमें परिणाम होगा। यदि आप लक्ष्य प्राप्त कर सकते हैं तो सही, यदि आप नहीं कर सकते तो FALSE करें।


5

जावास्क्रिप्ट (ईएस 6), 58 बाइट्स

(n,a)=>a.some(e=>n<=e)&n%a.reduce(g=(d,e)=>d?g(e%d,d):e)<1

@ Xnor के उत्तर का दूसरा पोर्ट। हाँ, मुझे reduceफिर से उपयोग करना है!


3
वैकल्पिक उप-समारोह: e=>n<=eएक दृश्य
पैलिंड्रोम है

4

रेटिना , 39 बाइट्स

\d+
$*
^(?>(1+)(,?\1)*;)(\1+)$(?<=\3.+)

इनपुट में अल्पविराम की अलग-अलग सूची होनी चाहिए, उसके बाद अर्धविराम, उसके बाद लक्ष्य आयतन। उदाहरण के लिए:

6,9,21;5

आउटपुट 0(मिथ्या) या 1(सत्य) है।

इसे ऑनलाइन आज़माएं!(पहली पंक्ति एक लाइनफ़ीड-पृथक परीक्षण सूट को सक्षम करती है।)

व्याख्या

\d+
$*

यह सिर्फ इनपुट को यूनरी में रूपांतरित करता है। बाद में हम केवल एकल रेगेक्स के साथ मान्य इनपुट से मेल खाते हैं:

^(?>(1+)(,?\1)*;)(\1+)$(?<=\3.+)

अंदर का हिस्सा (?>...)जीसीडी को ढूंढता है। हम ऐसा सबसे बड़ा विकल्प खोजने के 1+साथ करते हैं, जिसके साथ हम सभी डेसेंटर्स ( ,जीसीडी के पूर्ण मैच के बाद ही वैकल्पिक की अनुमति देते हुए) का मिलान कर सकते हैं । परमाणु समूह (a)(?>...) स्वयं) ताकि रेगेक्स इंजन जीसीडी के विभाजकों के लिए पीछे न हटे यदि लक्ष्य की मात्रा का मिलान नहीं किया जा सकता है (अन्यथा 1किसी बिंदु पर समूह एकल मिलान करने के लिए कम हो जाएगा1 और सभी इनपुट सत्य होंगे) ।

एक बार जब हमें GCD मिल जाता है, तो हम एक साधारण के साथ कई के रूप में लक्ष्य की मात्रा से मेल खाने की कोशिश करते हैं (\1+)$

अंत में, हम जाँचते हैं कि लक्ष्य की मात्रा सबसे बड़ी डिकंप्रेटर की क्षमता से अधिक नहीं है, यह सुनिश्चित करके कि वॉल्यूम को किसी भी डिकंटर के अंदर से मिलान किया जा सकता है (?<=\3.+)



2

PARI / GP , 31 बाइट्स

बहुत सीधा है। अधिकतम ( vecmax) की जांच करना बहुत महंगा है, मुझे आश्चर्य है कि क्या यह बेहतर किया जा सकता है।

f(c,g)=g%gcd(c)<1&&vecmax(c)>=g

2

पर्ल, 47 बाइट्स

के लिए +2 शामिल है -ap

STDIN की पहली पंक्ति पर जार के आकार के साथ और दूसरी पंक्ति पर लक्ष्य जार के साथ दौड़ें:

decanter.pl; echo
2 5 12
1
^D

decanter.pl:

#!/usr/bin/perl -p
$_=($_<@G)>$_%$=;$=--while@G[@F]=grep$_%$=,@F

यह समाधान असामान्य है कि यह इनपुट लाइन को लाइन से संसाधित करता है और उनमें से प्रत्येक के लिए कुछ आउटपुट करता है। पहली पंक्ति के लिए आउटपुट सावधानीपूर्वक तैयार किया गया था जबकि दूसरी पंक्ति समाधान को प्रिंट करती है। दो बाइट्स खो जाते हैं ()क्योंकि <और> पर्ल में गैर-सहयोगी होने के लिए डिज़ाइन किए गए हैं।

रेगेक्स समाधान भी अच्छा है, लेकिन 49 बाइट्स:

#!/usr/bin/perl -p
s/\d+/1x$&/eg;$_=/^(?>(1+)( |\1)*:)(\1+)$/&/$3./

(रेटिना समाधान से चुराए गए कुछ हिस्से)

इसके लिए STDIN पर इनपुट दें क्योंकि रिक्त स्थान और लक्ष्य द्वारा अलग किए गए जार a ::

decanter.pl <<< "2 5 12:1"

इस एक के लिए एक बेसिन gcd(21 बाइट्स) और max(7 बाइट्स) के साथ भाषाओं को हराना मुश्किल ...


0

स्काला, 90 53 बाइट्स

def h(g:Int,a:BigInt*)=a.max>g&&a.reduce(_ gcd _)%g<1

मूल रूप से अन्य उत्तरों के समान ही काम करता है, लेकिन स्कैला में बिल्ट-इन gcd फ़ंक्शन नहीं होता है। Scala में एक बिल्ट-इन gcd फंक्शन है, लेकिन केवल BigInt के लिए।

हमारी साइट का प्रयोग करके, आप स्वीकार करते हैं कि आपने हमारी Cookie Policy और निजता नीति को पढ़ और समझा लिया है।
Licensed under cc by-sa 3.0 with attribution required.