सकारात्मक पूर्णांकों के साथ तुलना में कम-असमानताओं को हल करना

Question

एक प्रोग्राम या फ़ंक्शन लिखें जो गणितीय असमानताओं की गैर-रिक्त सूची में लेता है जो ऑपरेटर ( <) से कम का उपयोग करते हैं । सूची में प्रत्येक पंक्ति में फॉर्म होगा

[variable] < [variable]

जहां [variable]लोअरकेस ऐज़ अक्षरों का कोई भी गैर-रिक्त स्ट्रिंग हो सकता है। सामान्य गणित और प्रोग्रामिंग में, समान नाम वाले चर समान हैं।

यदि एक सकारात्मक पूर्णांक प्रत्येक चर को सौंपा जा सकता है जैसे कि सभी असमानताएं संतुष्ट हैं, तो ऐसे असाइनमेंट के साथ चर की सूची को प्रिंट या वापस करें। इस सूची की प्रत्येक पंक्ति में फॉर्म होना चाहिए

[variable] = [positive integer]

और सभी चर किसी भी क्रम में एक बार बिल्कुल होने चाहिए।

ध्यान दें कि असमानताओं के सेट के लिए कई संभावित सकारात्मक पूर्णांक समाधान हो सकते हैं। उनमें से कोई भी मान्य आउटपुट है।

यदि असमानताओं का कोई समाधान नहीं है, तो या तो कुछ भी आउटपुट न करें या एक गलत मान का उत्पादन न करें (यह आपके ऊपर है)।

बाइट्स में सबसे छोटा कोड जीतता है।

उदाहरण

अगर इनपुट थे

mouse < cat
mouse < dog

तब ये सभी मान्य आउटपुट होंगे:

mouse = 1
cat = 2
dog = 2

mouse = 37
cat = 194
dog = 204

mouse = 2
cat = 2000000004
dog = 3

अगर इनपुट थे

rickon < bran
bran < arya
arya < sansa
sansa < robb
robb < rickon

तब कोई असाइनमेंट संभव नहीं है क्योंकि यह उबलता है rickon < rickon, इसलिए या तो कोई आउटपुट नहीं है या गलत आउटपुट नहीं है।

समाधान के साथ और उदाहरण:

x < y

x = 90
y = 91

---

p < q
p < q

p = 1
q = 2

---

q < p
q < p

p = 2
q = 1

---

abcdefghijklmnopqrstuvwxyz < abcdefghijklmnopqrstuvwxyzz

abcdefghijklmnopqrstuvwxyz = 123456789
abcdefghijklmnopqrstuvwxyzz = 1234567890

---

pot < spot
pot < spot
pot < spots

pot = 5
spot = 7
spots = 6

---

d < a
d < b
d < c
d < e

d = 1
a = 4
b = 4
c = 5
e = 4

---

aa < aaaaa
a < aa
aaa < aaaa
aa < aaaa
a < aaa
aaaa < aaaaa
aaa < aaaaa
a < aaaaa

aaaa = 4
aa = 2
aaaaa = 5
a = 1
aaa = 3

---

frog < toad
frog < toaster
toad < llama
llama < hippo
raccoon < science
science < toast
toaster < toad
tuna < salmon
hippo < science
toasted < toast

raccoon = 1
frog = 2
toaster = 3
toasted = 4
toad = 5
llama = 6
hippo = 7
science = 8
toast = 9
tuna = 10
salmon = 11

कोई समाधान नहीं के साथ अधिक उदाहरण: (खाली लाइनों द्वारा अलग)

z < z

ps < ps
ps < ps

q < p
p < q

p < q
q < p

a < b
b < c
c < a

d < a
d < b
d < c
d < d

abcdefghijklmnopqrstuvwxyz < abcdefghijklmnopqrstuvwxyz

bolero < minuet
minuet < bolero

aa < aaaaa
a < aa
aaa < aaaa
aa < aaaa
aaaaa < aaaa
a < aaa
aaaa < aaaaa
aaa < aaaaa
a < aaaaa

g < c
a < g
b < a
c < a

g < b
a < g
b < a
c < a

g < b
a < g
b < a
c < b

g < c
a < g
b < a
c < b

geobits < geoborts
geobrits < geoborts
geology < geobits
geoborts < geology

Comments

बहुत बारीकी से संबंधित

— पीटर टेलर

रनटाइम पर कोई सीमा?

— 20

@ V @ नहीं lmits।

— केल्विन के शौक

इनपुट समाप्त होने पर हमें कैसे पता चलेगा? खाली लाइन है या कुछ और है?

— हनीस करप्पिला

@हाँ। आप मान सकते हैं कि एक अनुगामी न्यूलाइन है।

— केल्विन के शौक

Answer 1

पायथ, 39 बाइट्स

V>1f.A<MxMLTN.pS{s=Nm%2cd).zVNjd[H\==hZ

इसे ऑनलाइन आज़माएँ: प्रदर्शन

सभी संभावित क्रमपरिवर्तन (और उन्हें छंटनी के रूप में व्याख्या) के माध्यम से ब्रूट-फोर्स करें, जांचें कि क्या वे असमानताओं से मेल खाते हैं, और उन्हें मान प्रदान करते हैं 1, 2, ...., n।

व्याख्या

f.A<MxMLTN.pS{s=Nm%2cd).z  
                 m     .z  map each input line d to:
                    cd)       split d by spaces
                  %2          and remove the second element
               =N          save this list of pairs to N
              s            combine these pairs to a big list of variable names
             {             set (remove duplicates)
          .pS              generate all permutations
f                          filter for permutations T, which satisfy:
     xMLTN                    replace each variable in N by their index in T
 .A<M                         check if each pair is ascending

V>1...VNjd[H\==hZ          implicit: Z = 0
 >1                        remove all but the last filtered permutation (if any)
V                          for each permutation N in ^ (runs zero times or once):
      VN                      for each variable H in N:
          [                      generate a list containing:
           H                        H
            \=                      "="
              =hZ                   Z incremented by 1 (and update Z)
        jd                       join this list by spaces and print

Answer 2

CJam ( 53 52 49 बाइट्स)

qS-N/'<f/:A:|e!{A{1$1$&=!},!*},:ee{()" = "\N}f%1<

ऑनलाइन डेमो

यह क्रूर संख्या के उन असाइनमेंट के लिए फ़िल्टरिंग, अलग टोकन के सभी क्रमपरिवर्तन को बाध्य करता 0हैn-1 जो बाधाओं के सभी का पालन करना, और फिर उन्हें स्वरूपों, संख्याओं, और प्रस्तुत करता है पहले एक incrementing। यह एक समाधान खोजने के लिए निश्चित है अगर वहाँ एक है, क्योंकि यह अनिवार्य रूप से एक सामयिक प्रकार है।

के लिए धन्यवाद रीटो कोराडी 3 वर्ण के लिए और मार्टिन Büttner 1 के लिए।

Comments

@RetoKoradi, दोह! वास्तव में।

— पीटर टेलर

Answer 3

मैथेमेटिका, 83 बाइट्स

Quiet@Check[Equal@@@FindInstance[Join[#,#>0&/@(v=Sequence@@@#)],v,Integers][[1]],]&

इनपुट को असमानताओं की सूची के रूप में लेता है। या तो असाइनमेंट की सूची तैयार करता है या Nullयदि यह असंभव है।