अस्पष्ट रोमन न्यूमेरिकल मैजिक स्क्वायर

Question

प्राचीन रोम के राजा को यह निर्धारित करने में कठिनाइयों का सामना करना पड़ रहा है कि क्या एक जादू वर्ग वैध है या नहीं, क्योंकि वह जिस जादू वर्ग की जाँच कर रहा है, उसमें संख्याओं के बीच कोई विभाजक शामिल नहीं है। उन्होंने एक सॉफ्टवेयर इंजीनियर को यह निर्धारित करने में मदद करने के लिए काम पर रखा है कि क्या एक जादू वर्ग वैध है या नहीं।

इनपुट विवरण

इनपुट STDIN या कमांड लाइन के तर्कों पर आता है। आपके पास एक चर में प्रारंभिक इनपुट नहीं हो सकता है (जैसे "यह प्रोग्राम एक चर में इनपुट की उम्मीद करता है x")। इनपुट निम्न प्रारूप में है:

<top>,<middle>,<bottom>

से प्रत्येक <top>, <middle>और <bottom>एक स्ट्रिंग है ही कभी अपरकेस वर्ण हो जाएगा I, Vऔर X। इसमें रिक्त स्थान या कोई अन्य वर्ण नहीं होंगे। प्रत्येक स्ट्रिंग तीन रोमन अंकों का प्रतिनिधित्व करती है, जिसके परिणामस्वरूप संख्याओं का 3x3 मैट्रिक्स होता है। हालाँकि, ये रोमन अंक (लेकिन आवश्यक नहीं) अस्पष्ट हो सकते हैं । मुझे एक उदाहरण के साथ यह स्पष्ट करने की अनुमति दें। प्रत्येक संख्या के बीच कोई रिक्त स्थान के साथ, तीन रोमन अंकों की निम्नलिखित उदाहरण पंक्ति पर विचार करें:

IVIIIIX

क्योंकि अक्षरों के बीच कोई रिक्त स्थान नहीं है, यहाँ संख्याओं के लिए दो अधिभोग हैं:

• 1, 8, 9 ( I VIII IX)
• 4, 3, 9 ( IV III IX)

जब आप समझते हैं कि मैट्रिक्स की सभी तीन पंक्तियाँ अस्पष्ट हो सकती हैं, तो वहाँ एक इनपुट से कई अलग-अलग 3x3 मैट्रिक्स होने की संभावना है।

ध्यान दें कि 1, 7, 1, 9 ( I VII I IX) जैसे अनुक्रम संभव नहीं हैं क्योंकि प्रत्येक पंक्ति हमेशा तीन रोमन अंकों का प्रतिनिधित्व करेगी। यह भी ध्यान दें कि रोमन अंक मान्य होने चाहिए, इसलिए 1, 7, 8 ( I VII IIX) जैसे अनुक्रम भी संभव नहीं हैं।

आउटपुट विवरण

आउटपुट:

• एक पूर्णांक A, जहां Aअद्वितीय 3x3 मैट्रिक्स की संख्या है जो अस्पष्ट इनपुट से बनाई जा सकती है, और:
• एक सत्य मान यदि कोई विशिष्ट 3x3 मैट्रिक्स कोई जादू वर्ग बनाता है, या:
• एक मिथ्या मान यदि कोई विशिष्ट 3x3 मैट्रिक्स नहीं है तो एक जादू वर्ग बनता है।

सच्चाई और झूठे मूल्यों के अनुरूप होना चाहिए। उन्हें अल्पविराम द्वारा अलग कर दिया जाता है।

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

उदाहरण इनपुट और आउटपुट

इन उदाहरणों में, मैं trueअपने सत्य मूल्य के falseरूप में और अपने मिथ्या मूल्य के रूप में उपयोग करता हूं ।

इनपुट: VIIIIVI,IIIVVII,IVIXII आउटपुट: 24,true (जादू त्रिकोण 8-1-6, 3-5-7, 4-9-2 है।)

इनपुट: IIIXVIII,IVIII,VIIII आउटपुट:210,false

अतिरिक्त

• यदि आपकी चुनी हुई भाषा में एक है तो आपको इनबिल्ट रोमन न्यूमेरल रूपांतरण कार्यों का उपयोग करने की अनुमति नहीं है।

Comments

"प्राचीन रोम का राजा" ... सम्राट?

— डिजिटल ट्रामा

@DigitalTrauma यह एक वैकल्पिक ब्रह्मांड में स्थापित है जहां प्राचीन रोम में एक राजा, जादू वर्ग और सॉफ्टवेयर इंजीनियर थे। या ऐसा ही कुछ ...

— absinthe

इसके अलावा, आपको अल्पविराम ( en.wikipedia.org/wiki/Interpunct#Latin ) के बजाय एक इंटरपंक्चर (·) का उपयोग करना चाहिए

— coredump

मेरे पास पहले के लिए "24, सच" है, लेकिन दूसरे उदाहरण के लिए "210, गलत" है। मैं जांच करूंगा।

— coredump

@DigitalTrauma रोम में लगभग 509BC राजा थे।

— जॉन बी

Answer 1

पर्ल, 219 237

स्पष्टता के लिए लाइन ब्रेक जोड़े गए।

#!perl -p
%x=(I,1,IV,4,V,5,IX,9,X,10);
$a="(X{0,3}(?:V?I{1,3}|I?V|IX)|X{1,3})"x3;
m*^$a,$a,$a$(?{
  @z=map"$$_",0..9;
  $r|=!grep$x-$_,map{$x=eval s/./ $z[$&]/gr=~s/IX|IV|\S/+$x{$&}/gr}123,456,789,147,258,369,159,357;
  ++$-
})^*;
$_="$-,$r"

मुझे परखो ।

Answer 2

प्रस्तावना - 686

:-lib(util),lib(sd). r(S,R):-string_list(S,L),g(L,R). g(L,[N1,N2,N3]):-append(L1,X,L),append(L2,L3,X),n(L1,N1),n(L2,N2),n(L3,N3). n([73,86],4). n([73,88],9). n([73,73,73],3). n([73,73],2). n([73],1). n([86],5). n([86|N],D):-n(N,E),E<4,D is E+5. n([88|N],D):-n(N,E),D is E+10. n([88],10). m(M,[X1,X2,X3,Y1,Y2,Y3,Z1,Z2,Z3]):-split_string(M,",","",[X,Y,Z]),r(X,[X1,X2,X3]),r(Y,[Y1,Y2,Y3]),r(Z,[Z1,Z2,Z3]). a(L):-alldifferent(L),L=[X1,X2,X3,Y1,Y2,Y3,Z1,Z2,Z3],l(X1,X2,X3,T),l(Y1,Y2,Y3,T),l(Z1,Z2,Z3,T),l(X1,Y1,Z1,T),l(X2,Y2,Z2,T),l(X3,Y3,Z3,T). l(A,B,C,T):-T is A+B+C. p:-read_line(S),findall(L,m(S,L),A),length(A,C),findall(L,(member(L,A),a(L)),B),(B=[_|_]->R=true;R=false),writeln((C,R)).

Ungolfed

% I : 73
% V : 86
% X : 88
:-lib(util).
:-lib(sd).
r(S,R) :- string_list(S,L), g(L,R).
g(L,[N1,N2,N3]):-
    append(L1,X,L),
    append(L2,L3,X),
    n(L1,N1),n(L2,N2),n(L3,N3).
n([73,86],4).
n([73,88],9).
n([73,73,73],3).
n([73,73],2).
n([73],1).
n([86],5).
n([86|N],D):-n(N,E),E<4,D is E+5.
n([88|N],D):-n(N,E), D is E+10.
n([88],10).
m(M,[X1,X2,X3,Y1,Y2,Y3,Z1,Z2,Z3]) :-
    split_string(M,",","",[X,Y,Z]),
    r(X,[X1,X2,X3]),
    r(Y,[Y1,Y2,Y3]),
    r(Z,[Z1,Z2,Z3]).
a(L) :-
    alldifferent(L),
    L=[X1,X2,X3,Y1,Y2,Y3,Z1,Z2,Z3],
    l(X1,X2,X3,T),
    l(Y1,Y2,Y3,T),
    l(Z1,Z2,Z3,T),
    l(X1,Y1,Z1,T),
    l(X2,Y2,Z2,T),
    l(X3,Y3,Z3,T).
l(A,B,C,T):-T is A+B+C.
p :- read_line(S),
     findall(L,m(S,L),A),
     length(A,C),
     findall(L,(member(L,A),a(L)),B),
     (B=[_|_]->R=true;R=false),
     writeln((C,R)).

बेशक, के pरूप में भी परिभाषित किया जा सकता है:

p :- read_line(S),
     findall(L,m(S,L),A),
     length(A,C),
     findall(L,(member(L,A),a(L)),B),
     writeln(C),
     B=[_|_].

उस स्थिति में, वर्ग की संख्या लिखने के बाद पर्यावरण 'हाँ' या 'नहीं' कहेगा।

उदाहरण

ग्रहण का उपयोग करना ।

[eclipse 105]: p.
 VIIIIVI,IIIVVII,IVIXII
24, true

[eclipse 106]: p.
 IIIXVIII,IVIII,VIIII
210, false

दूसरे के लिए उदाहरण परिणाम यहां चिपकाए गए हैं ।

Answer 3

पायथन, 442 चार्ट

R=range
L=len
S=sum
N={}
for i in R(40):
 r="";j=i
 while j>9:r+="X";j-=10
 if j>8:r+="IX";j-=9
 if j>4:r+="V";j-=5
 if j>3:r+="IV";j-=4
 N[r+"III"[:j]]=i
a,b,c=map(lambda x:sum([[Z]*all(Z)for i in R(L(x))for j in R(L(x))for Z in[map(N.get,(x[:i],x[i:j],x[j:]))]],[]),raw_input().split(","))
print L(a)*L(b)*L(c),any(S(x)==S(y)==S(z)==S(q[::3])==S(q[1::3])==S(q[2::3])==S(q[::4])==S(q[2:-1:2])for x in a for y in b for z in c for q in[x+y+z])

कोड पहले बनाता है Nजो रोमन संख्या स्ट्रिंग से उसके मूल्य के लिए सभी संभव संख्याओं के लिए मानचित्रण है जो हमें आवश्यकता हो सकती है। प्रत्येक पंक्ति को हर संभव तरीके से तीन में विभाजित करता है और जाँच करता है कि सभी परिणामी त्रिगुणों में से कौन सा मैपिंग है N। अंतिम anyदेखता है कि क्या कोई संयोजन एक जादू वर्ग है।

Answer 4

हास्केल, 451 429 423 बाइट्स

import Data.List
(#)=splitAt
(%)=map
w=length
r"X"=10
r('X':a)=10+r a
r a=case elemIndex a["I","II","III","IV","V","VI","VII","VIII","IX"]of Just i->i+1;_->0
s l=[r%[a,b,c]|x<-[2..w l],y<-[1..x],let(d,c)=x#l;(a,b)=y#d,r a*r b*r c>0]
e[a,b,c]=a==b&&a==c
p[l,m,n]=[1|a<-l,b<-m,c<-n,e$sum%[a,b,c],e$sum%(transpose[a,b,c])]
f i=(show$product$w%(s%i))++","++(show$0<(w$p$s%i))
q ','='\n'
q a=a
i=getLine>>=putStrLn.f.lines.map q

उपयोग:

*Main> i                           -- repl prompt, call i
VIIIIVI,IIIVVII,IVIXII             -- input via STDIN    
24,True                            -- output
*Main> i
IIIXVIII,IVIII,VIIII
210,False

लगभग 70 बाइट्स सिर्फ इनपुट और आउटपुट फॉर्मेट को सही पाने के लिए।

फ़ंक्शन rएक पूर्णांक (एक स्ट्रिंग के रूप में दिया गया) एक रोमन नंबर को धर्मान्तरित करता है (यदि यह एक वैध रोमन संख्या नहीं 0है)। ) और कॉल के साथ बदलकर मदद करता हैs3 सबस्ट्रिंग में रोमन अंकों की एक स्ट्रिंग को विभाजित करता है और उन ट्रिपल को वैध रोमन संख्याओं के साथ रखता है और rपूर्णांक के माध्यम से परिवर्तित करता है । eजांचें कि क्या तीन तत्व सूची के सभी पूर्णांक समान हैं। pरोमन अंकों के तीन तार लेता है, उन्हें sपूर्णांक की सूची में विभाजित करता है, प्रत्येक सूची के एक पूर्णांक को त्रिगुणों में जोड़ता है और उन सभी दिशाओं में समान राशि रखता है। खाली सूची (कोई वैध समाधान) या नहीं (वैध समाधान मौजूद है) लौटाता है, fतो वैध मैट्रिक्स और चेक की संख्या की गणना करता pहै। मुख्य कार्य iSTDIN से इनपुट को पढ़ता है, इसे स्ट्रिंग्स की सूची में परिवर्तित करता है (q,\np ।

Answer 5

आर, 489 474 464

यह मेरी इच्छा से बहुत बड़ा था, लेकिन मुझे संदेह है कि मैं इसे थोड़ा नीचे कर सकता हूं।

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

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

वहाँ से यह संख्या के प्रत्येक मैट्रिक्स के माध्यम से जाता है और जादू वर्ग के लिए परीक्षण करता है, अंत में परिणाम का उत्पादन करता है।

s=strsplit;e=expand.grid;P=paste0;d=do.call;i=readline();i=s(i,',');n=1:39;r=c(t(outer(c('','X','XX','XXX'),c('I','II','III','IV','V','VI','VII','VIII','IX','X'),P)))[n];p=d(P,e(r,r,r));n=d(paste,e(n,n,n));m=lapply(i[[1]],function(x)which(p==x));C=e(s(n[m[[1]]],' '),s(n[m[[2]]],' '),s(n[m[[3]]],' '));E=F;N=nrow(C);for(n in 1:N){T=matrix(strtoi(unlist(C[n,])),nr=3);E=E||length(unique(c(rowSums(T),colSums(T),sum(diag(T)),sum(diag(T[3:1,])))))==1};P(N,',',any(E))

परीक्षण चालन। यह RGui में चिपकाए जाने के बाद इनपुट की प्रतीक्षा करता है।

> e=expand.grid;l=length;s=strsplit;P=paste0;i=readline();i=s(i,',');n=1:39;r=c(t(outer(c('','X','XX','XXX'),c('I','II','III','IV','V','VI','VII','VIII','IX','X'),P)))[-40];p=do.call(P,e(r,r,r));n=do.call(paste,e(n,n,n));m=lapply(i[[1]],function(x)which(p==x));C=e(s(n[m[[1]]],' '),s(n[m[[2]]],' '),s(n[m[[3]]],' '));E=c();N=nrow(C);for(n in 1:N){T=matrix(as.integer(unlist(C[n,])),nr=3);E=c(E,length(unique(c(rowSums(T),colSums(T),sum(diag(T)),sum(diag(T[3:1,])))))==1)};paste(N,',',any(E))
VIIIIVI,IIIVVII,IVIXII
[1] "24 , TRUE"
> e=expand.grid;l=length;s=strsplit;P=paste0;i=readline();i=s(i,',');n=1:39;r=c(t(outer(c('','X','XX','XXX'),c('I','II','III','IV','V','VI','VII','VIII','IX','X'),P)))[-40];p=do.call(P,e(r,r,r));n=do.call(paste,e(n,n,n));m=lapply(i[[1]],function(x)which(p==x));C=e(s(n[m[[1]]],' '),s(n[m[[2]]],' '),s(n[m[[3]]],' '));E=c();N=nrow(C);for(n in 1:N){T=matrix(as.integer(unlist(C[n,])),nr=3);E=c(E,length(unique(c(rowSums(T),colSums(T),sum(diag(T)),sum(diag(T[3:1,])))))==1)};paste(N,',',any(E))
IIIXVIII,IVIII,VIIII
[1] "210 , FALSE"
>