गोल्फ एक वेन आरेख जनरेटर

26

गोल्फ एक वेन आरेख जनरेटर

यहाँ छवि विवरण दर्ज करें

जॉन वेन के 180 वें जन्मदिन को ठीक से मनाने के लिए , आज आपका काम एक कार्यक्रम बनाना होगा जो वेन आरेख का आउटपुट देता है !

इनपुट:

एक सकारात्मक पूर्णांक Nजो आरेख में (शून्य से N) और सकारात्मक पूर्णांक के तीन सेट में दिखाई देने वाली संख्या की सीमा को परिभाषित करेगा ।

आउटपुट:

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

टिप्पणियाँ

  1. उपयोग stdin(या जो भी अपनी भाषा के बराबर है) मूल्यों को प्राप्त करने के लिए।
  2. आप सेट के लिए और के लिए इनपुट प्रारूप को परिभाषित कर सकते हैं N(अल्पविराम से अलग, आपके लिए सबसे अच्छा काम करता है)।
  3. संख्याएँ जो किसी भी सेट में नहीं दिखती हैं, लेकिन निर्दिष्ट सीमा के भीतर आरेख पर दिखनी चाहिए, किसी भी क्षेत्र के अंदर नहीं।
  4. सेट को नाम देने की आवश्यकता नहीं है।
  5. आउटपुट एक ड्राइंग या अस्की-आर्ट हो सकता है।
  6. आरेख का कोई भी आकार हो सकता है जब तक कि सीमाएं स्पष्ट रूप से भिन्न न हों (यदि आपने ASCII कला को चुना है, तो सीमाओं को पार करने के लिए + (या समान) का उपयोग करना आवश्यक है, उदाहरण के लिए)।
  7. क्षेत्रों में छायांकित नहीं किया जा सकता है।
  8. वेन आरेख बनाने वाले किसी भी अंतर्निहित कार्य या तीसरे पक्ष के पुस्तकालय को बंद कर दिया जाता है।
  9. मानक खामियां लागू होती हैं ।

यह कोड-गोल्फ है , इसलिए बाइट्स में सबसे छोटा कोड, जीत है।

code-golf  graphical-output  set-theory 
— विलियम बारबोसा
स्रोत
ऐसा लगता है कि आपको एक नोट जोड़ना चाहिए था कि समाधानों को मनमाने ढंग से इनपुट आकारों के लिए पैमाने पर करना पड़ता है। वर्तमान में उनमें से केवल कुछ ही ऐसा करते हैं (जहाँ तक मैं केवल ASCII वाले ही बता सकता हूँ)। प्रतियोगिता शुरू होने के बाद मुझे नियम बदलना पसंद नहीं है, लेकिन इस आवश्यकता के बिना, कोई व्यक्ति वास्तव में इसे एक सरल लेआउट के साथ दुरुपयोग कर सकता है जो केवल प्रत्येक सेट में एक चरित्र के लिए काम करता है (यदि मैंने ऐसा किया तो मैं शायद कोड आकार में कटौती करूंगा। एक तिहाई या तो)।
— मार्टिन एंडर
@ MartinBüttner हाँ, उनमें से कुछ पैमाने बहुत खराब हैं। लेकिन अब एक नोट जोड़ना कि 7 उत्तर हैं एक बुरा विचार जैसा लगता है। क्या नोट जोड़ना चाहिए और उन्हें हर किसी के पोस्ट पर टिप्पणी करनी चाहिए ताकि उन्हें पता चल सके कि आरेख एक्स तक अच्छी तरह से स्केल होना चाहिए?
— विलियम बारबोसा 10
एक सीमा निर्धारित करना अभी भी उस सीमा को केवल हार्ड-कोडिंग की अनुमति देगा। मुझे लगता है कि उचित स्केलिंग वास्तव में चुनौती का सबसे कठिन हिस्सा है। इसलिए या तो इसे वैसे ही छोड़ दें, या इसे बदलने के लिए कहें कि इसे मनमाने ढंग से सेट आकारों से निपटना चाहिए (जो तकनीकी रूप से भी कोई बदलाव नहीं है, क्योंकि आपने इनपुट आकार को सीमित नहीं किया है, मुझे लगता है कि बेहतर इनपुट आकार वैसे भी माना जाना चाहिए) ।
— मार्टिन एंडर
@ रेयान ध्यान दें कि मैं उत्पादन खंड में "आरेख के उचित क्षेत्रों में प्रदर्शित करके" बताता हूं। कुछ उत्तर (आपका शामिल) अंतरतम खंड को सही ढंग से प्रदर्शित नहीं करते हैं यदि कहा जाता है कि अनुभाग में 5 से अधिक तत्व हैं, तो मुझे लगता है कि यह अमान्य है
— विलियम बारबोसा
प्रासंगिक xkcd: xkcd.com/1810
— sergiol

जवाबों:

8

गणितज्ञ 343 264

UnGolfed

m=Input[]; data=Input[];


(* The circles to represent set boundaries *)
{R1,R2,R3}=Circle[#,5]&/@{{-2,8.5},{2,8.5},{0,5}};

(*converts  {1,0,1} to base 10, ie, the number 5.
bool[x_]:=FromDigits[Boole[x],2]

(* determines the region in which each number from 0 to `m` resides *)
encode[num_]:=bool[Table[MemberQ[data[[k]],num],{k,3}]]

(*Centroid of each region; the first is a location for numbers in none of the three sets *)
points={{7,4},{0,2},{4,10},{3,6},{-4,10},{-3,6},{0,11},{0,7}}

(* Plots the venn diagram with numbers in regions *)
Graphics[{
Text@@@({#[[1]],points[[#[[2]]+1]]}&/@({#[[All,1]],#[[1,2]]}&/@GatherBy[{#,encode[#]}&/@Range[0,m],Last])),
Opacity[.1],R1,R2,R3
}]

मान लिया 10गया कि इनपुट था mऔर के {{1,2,3,4,5,9},{1,2,3,6,8},{7,2,9}}लिए इनपुट था d,

नया वेन आरेख

गोल्फ 264

मैं आश्चर्यचकित था कि सभी संगणना Graphicsसमारोह के भीतर ही की जा सकती है। इनपुट के अपवाद के साथ, यह एक-लाइनर है।

m=Input[];d=Input[]
Graphics@{Text@@@({#[[1]],{{7,4},{0,2},{4,10},{3,6},{-4,10},{-3,6},{0,11},{0,7}}[[#[[2]]+1]]}&/@({#[[All,1]],#[[1,2]]}&/@GatherBy[{#,FromDigits[Boole[Table[d[[k]]~MemberQ~#,{k,3}]],2]}&/@Range[0,m],Last])),Circle[#,5]&/@{{-2,8.5},{2,8.5},{0,5}}}
— DavidC
स्रोत
मंडलियों की उपस्थिति के लिए +1। मुझे आश्चर्य है कि वे ग्रे में इतने अच्छे दिखते हैं। संख्याओं का बिखराव हालांकि अजीब है। आप RandomSampleस्थान चुनने के लिए उपयोग कर रहे हैं ?
— लेवल रिवर सेंट
ग्रे काम करता है क्योंकि अपारदर्शिता 10% है। लोकेशन लेने के लिए रैंडम सैंपल का इस्तेमाल किया गया। एक बार एक स्थान चुने जाने के बाद, इसे अतिरिक्त पिक्स के लिए उम्मीदवारों के सेट से हटा दिया जाता है। मैंने अन्य तरीकों के साथ खेला (जैसे कि एक उप-क्षेत्र के केंद्रक को नियोजित करना, लेकिन परिणाम पसंद नहीं आया)। BTW, मैं फिटिंग लेबल के लिए अपने दृष्टिकोण की तरह।
— डेविड ऑग
पात्रों को बचाने के लिए, मैंने स्विच किया Circles, इसलिए ग्रे डिस्क चले गए। अधिकांश बचत इस तथ्य से आती है कि किसी क्षेत्र के सभी सदस्यों को उस क्षेत्र के केंद्र में प्लॉट किया जाता है।
— डेविड
45

रूबी, 654 590 566 542 505 बाइट्स

यह मजेदार था। मैंने ASCII का इस्तेमाल किया। मैं अभी तक हर संभव संयोजन का परीक्षण करने में सक्षम नहीं था, इसलिए यदि आप एक गड़बड़ परीक्षण का मामला पाते हैं, तो कृपया मुझे बताएं।

require'set'
u=(0..gets.to_i).to_set
a,b,c=eval(gets).map &:to_set
i=' '
m,M,n,N,o,O,p,P,q,Q,r,R,s,S=[a-b-c,b-a-c,c-a-b,a&b-c,b&c-a,a&c-b,a&b&c].map{|u|[t=u.to_a*i,t.size]}.flatten
H,V,X=?─,?│,?┼
puts'┌'+H*(A=[1+M+[P,S].max,1+R].max)+?┐+(u-a-b-c).to_a*i,V+i*M+?┌+(b=H*(T=-M+U=A-1)+X+H*(B=[N,Q].max))+?┐,V+m+V+p+i*(T-P)+V+n+i*(B-N)+V,'│┌'+H*(K=M-1)+X+b+X+H*(C=[O-B-1,0].max)+?┐,(v=V*2+i*K)+V+s+i*(T-S)+V+q+i*(B-Q)+V+i*C+V,v+?└+b+?┘+i*C+V,V*2+r+i*(U-R)+V+o+i*(-O+D=B+C+1)+V,'└┼'+H*U+?┘+i*D+V,' └'+H*(A+D)+?┘

यह निम्नलिखित प्रारूप में एसटीडीआईएन पर इनपुट की अपेक्षा करता है

10
[[1,2,3,4,5,9],[1,2,3,6,8],[7,2,9]]

और फिर इस सुंदरता से आपको पुरस्कृत करेंगे

┌───────┐0 10
│   ┌───┼───┐
│4 5│1 3│6 8│
│┌──┼───┼───┼┐
││  │2  │   ││
││  └───┼───┘│
││9     │7   │
└┼──────┘    │
 └───────────┘

मुझे नहीं लगता कि मुझे एक अनऑर्गनाइज्ड संस्करण जोड़ने के लिए परेशान किया जा सकता है। कृपया कुछ अधिक पठनीय संस्करण के लिए संपादन इतिहास में मूल संस्करण पर एक नज़र है ।

यह निश्चित रूप से सेट की सीमाओं को कम तंग करके या यहां तक ​​कि उन्हें बनाए रखा जा सकता है जैसे कुछ ग्राफिकल वाले करते हैं, लेकिन मुझे लगता है कि यह अच्छा लग रहा है और गोल्फ होने के बावजूद "ठीक से" किया जाता है।

— मार्टिन एंडर
स्रोत
यदि आप आज की टोपी तक नहीं पहुँच पाए होते तो आप आज इस जवाब के साथ 10K क्लब तक पहुँच जाते, क्या अफ़सोस है
— विलियम बारबोसा
@WilliamBarbosa हो सकता है कि यह मुझे कल आवश्यक अपवोट दे। ;)
— मार्टिन एंडर
यह एक अच्छी लग रही वेन आरेख है। मैं अनुमान लगा रहा हूं कि आरेख की उपस्थिति आपके सभी उत्थान का मुख्य कारण है। बड़े सेट के लिए क्या होता है? मैं अनुमान लगा रहा हूं कि यह एक ही ऊंचाई पर है और बस व्यापक और व्यापक हो जाती है?
— लेवल रिवर सेंट
@steveverrill हाँ बिल्कुल। प्रत्येक 8 सबसेट को सही स्थिति में एक अंतरिक्ष सीमांकित सूची के रूप में मुद्रित किया जाता है। सीमाएं हमेशा एक ही आकार की होती हैं, और प्रत्येक खंड की चौड़ाई अंदर की हर चीज को फिट करने के लिए न्यूनतम संभव होना निर्धारित किया जाता है। निश्चित रूप से, यह अच्छा लग सकता है यदि मैं प्रत्येक उपसमूह को मोटे तौर पर रखने के लिए लाइन ब्रेक की गणना करता हूं, लेकिन फिर यह कोड-गोल्फ है आखिरकार;)। यह भी लाइनों के बीच अतिरिक्त रिक्ति के बिना और भी बेहतर लगता है
— मार्टिन एंडर
1
छोटे कोण पात्रों को देखा और एक डबल-ले लिया, यह सोचकर कि यह एपीएल या कुछ और था। :)
— hoosierEE
15

BBC BASIC, 243 ASCII वर्ण (टोकन फ़ाइल का आकार 211 बाइट्स)

Http://www.bbcbasic.co.uk/bbcwin/bbcwin.html पर एमुलेटर डाउनलोड करें

golfed

  INPUT"N",n
  DIMs(n+1)
  FORi=0TO2PRINT"S";i
  REPEATINPUTx:s(x)=s(x)+2^i:UNTILx>n
  NEXTMODE4r=360CIRCLE460,r,r
  CIRCLE640,664,r
  CIRCLE820,r,r
  FORi=0TO7FORx=0TOn:IFs(x)=i PRINT;x
  NEXTREADa
  VDU28,a+1792;a+5;
  NEXT
  DATA19,4873,2572,4893,2586,5907,3091,34

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

Ungolfed

संख्याओं के प्रत्येक सेट को उपयोगकर्ता द्वारा N + 1 दर्ज करने से समाप्त कर दिया जाता है (थोड़ा असामान्य विकल्प, यह किसी सरणी की सीमा के बाहर लिखने की कोशिश करने से होने वाली त्रुटियों से बचने के लिए है।) फिर यह पाठ मोड से ग्राफिक्स मोड में बदल जाता है। और वेन आरेख प्लॉट करता है।

इनपुट डेटा को सरणी में संग्रहीत किया जाता है, प्रत्येक सेल के लिए एक सेल प्रदर्शित किया जाता है। डेटा एक 3-बिट मूल्य के रूप में संग्रहीत किया जाता है: 1 के लिए Set0 + 2 के लिए SET1 4 SET2, 7. बीबीसी बुनियादी करने के लिए रेंज 0 में एक नंबर देने के लिए इतनी शक्ति ऑपरेटर के बजाय प्रयोग किया जाता है कोई बदलाव ऑपरेटर है: 2^iके बजाय 1<<iमें उदाहरण के लिए सी।

मंडलियों की साजिश रचने के बाद, एक बाहरी लूप आठ क्षेत्रों में से प्रत्येक के माध्यम से जाता है, आवश्यक निर्देशांक (एक डेटा तालिका के अनुसार) पर जा रहा है। एक आंतरिक लूप उस क्षेत्र में सभी नंबरों को प्रिंट करता है (जो संबंधित 3-बिट मान वाले हैं। सरणी।)

  INPUT"N",n                                 :REM create an array called s() with range 0..n+1
  DIMs(n+1)
  FORi=0TO2
    PRINT"S";i                               :REM prompt the user for data for set 0, set 1 and set 2.
    REPEATINPUTx:s(x)=s(x)+2^i:UNTILx>n      :REM input numbers and store as a bit table. Repeat until user enters n+1.
  NEXT
  MODE4                                      :REM change to graphics mode.
  r=360
  CIRCLE460,r,r                              :REM plot a circle at x,y,r.
  CIRCLE640,664,r                            :REM for the bottom two circles y=r.
  CIRCLE820,r,r
  FORi=0TO7                                  :REM for each region of the venn diagram
    READa                                    :REM read a 2 byte value for the  coordinates of the top left corner of a text viewport from the DATA statement: x+256y
    VDU28,a+1792;a+5;                        :REM create a 5x7 viewport (limits each region to 7 numbers.) 1792=7*256
    FORx=0TOn:IFs(x)=i PRINT;x               :REM print all numbers in the array belonging to that region
    NEXT
  NEXT
  VDU26                                      :REM Restore the viewport to the whole screen, to ensure the command prompt does not mess up the display at the end of the program.
  DATA34,19,4873,2572,4893,2586,5907,3091

ठेठ इनपुट और आउटपुट का असेंबल (असम्बद्ध संस्करण)

गोल्फ संस्करण में, सेट के बाहर संख्याओं की स्थिति का संकेत कमांड प्रॉम्प्ट के साथ दिया जाता है >।

यहाँ छवि विवरण दर्ज करें

— स्तर नदी सेंट
स्रोत
क्या यह मनमाने ढंग से बड़े इनपुट के लिए काम करता है?
— मार्टिन एंडर
@ मार्टिनबटनर सिद्धांत रूप में हाँ एल्गोरिथ्म यह कर सकता है, लेकिन प्रदर्शन इसे नीचे देता है (जैसा कि अन्य समाधानों के साथ समस्या होने की संभावना है।) मैं कार्यक्रम टिप्पणियों में संकेत देता हूं कि प्रत्येक क्षेत्र को स्क्रॉल करने से पहले 7 नंबर तक सीमित है ( संख्या एक ऊर्ध्वाधर स्तंभ में होती है जैसा कि मैंने सोचा था कि रैपिंग भयानक दिखेगी।) मैं जिस एमुलेटर का उपयोग कर रहा हूं वह बहुत अधिक स्क्रीन रिज़ॉल्यूशन को संभाल सकता है, लेकिन मैं "प्रामाणिक" बीबीसी माइक्रो स्क्रीन मोड में से एक के लिए चला गया हूं जो काफी सीमित है। यदि कोई इसे जावा में पोर्ट करता है, तो केवल व्यावहारिक सीमा आरेख को पढ़ने की मानवीय क्षमता होगी।
— लेवल रिवर सेंट
आह, मैं बस सोच रहा था कि क्या सर्कल इनपुट आकार के अनुकूल होंगे ... बेशक मेरा समाधान भी बड़े इनपुट के लिए अपठनीय होगा यदि आपका टर्मिनल लाइनों को लपेटता है, लेकिन जब तक यह स्क्रॉलबार के साथ प्रदर्शित होता है तब तक यह किसी भी इनपुट को संभाल सकता है आकार।
— मार्टिन एंडर 22
2
यहां तक ​​कि अगर यह जावा में रखी गई थी, तो आपको अधिक पाठ के लिए मंडलियों को बड़ा बनाने के लिए कोड जोड़ना होगा
— Sparr
14

जावास्क्रिप्ट 1235

http://jsfiddle.net/44a4L/7/

Google chrome v36 में परीक्षण किया गया।

इनपुट ऊपरी, सेट 1, सेट 2 और सेट 3 चर में लिया जाता है।

अद्यतन: अब स्वचालित रूप से इनपुट के आकार के आधार पर तराजू।

function t(e,t){z.getElementById(e).innerHTML+=" "+t}z=document;s=200+upper*20;z.body.innerHTML+="<style>#m{width:"+s+"px;height:"+s+"px;}div{position:absolute;text-align:center;border-radius:50%;}#s1{left:calc(15% + 15px);top:30px;bottom:30%;right:calc(15% + 15px);background-color:rgba(255,0,0,0.4);padding:10%;}#s2{left:30px;bottom:30px;top:30%;right:30%;background-color:rgba(0,255,0,0.4);padding-right:40%;padding-top:30%;}#s3{right:30px;bottom:30px;top:30%;left:30%;background-color:rgba(0,0,255,0.4);padding-left:40%;padding-top:30%;}#s123{left:40%;top:40%;right:40%;bottom:40%;}#s12{left:20%;top:35%;right:65%;bottom:50%;}#s13{right:20%;top:35%;left:65%;bottom:50%;}#s23{left:40%;right:40%;bottom:15%;top:70%;}</style><div id=m><div id=s1 class=s></div><div id=s2 class=s></div><div id=s3 class=s></div><div id=s123 class=v></div><div id=s12 class=v></div><div id=s13 class=v></div><div id=s23 class=v></div></div>";for(i=0;i<=upper;i++){i1=i2=i3=false;if(set1.indexOf(i)!=-1)i1=true;if(set2.indexOf(i)!=-1)i2=true;if(set3.indexOf(i)!=-1)i3=true;if(i1&&i2&&i3)t("s123",i);else if(i1&&i2)t("s12",i);else if(i1&&i3)t("s13",i);else if(i2&&i3)t("s23",i);else if(i1)t("s1",i);else if(i2)t("s2",i);else if(i3)t("s3",i);else t("m",i)}

नमूना उत्पादन:

वेन

— rdans
स्रोत
बहुत अच्छा! मैं इसे थोड़ा तंग करने में सक्षम था, jsfiddle.net/44a4L/2 देखें - "t" फ़ंक्शन, CSS और body.innerHTML को देखें। हालांकि वही तर्क। मुझे यकीन है कि यह अभी भी निचोड़ा जा सकता है।
— नेनोटलेप
यह अब तक सबसे सुंदर है, यह एक दया है जो इसे अच्छी तरह से पैमाने पर नहीं करता है। अंतरतम क्षेत्र के अंदर तीन तत्व इसे तोड़ देते हैं। क्या आप इसे किसी तरह से बनाने की योजना बना रहे हैं?
— विलियम बारबोसा
@WilliamBarbosa स्केलिंग को अब लागू किया गया है
— rdans
2
भव्य! चौका देने वाला! बहुत शानदार! (एक से अधिक अतिशयोक्ति का उपयोग करने के लिए क्योंकि एसई संक्षिप्तता से नफरत करता है।)
— स्कॉट लीडले
4

अजगर - 603

import re
n,a,b,c=eval(input())
h=set(range(n+1))-a-b-c
g=a&b&c
d,e,f=a&b-g,b&c-g,a&c-g
l,m=set(a),set(b)
a-=b|c
b-=l|c
c-=l|m
for t in'abcdefgh':exec("%s=' '.join(map(str,%s))"%(2*(t,)))
l=len
x,y,z=max(l(a),l(f)+2,3),l(max(d,g)),max(l(b),l(e)+2,l(c)-l(f+g)-2,3)
j=[0]*4
for t in'abcdefg':exec("%s=%s.ljust([x,z,x+y+z-2,y,z-2,x-2,y][ord('%s')-97])+'|'"%(3*(t,)))
s='\d| '
w=re.sub
for r in (1,3):q=r//2;j[r]=['','| '][q]+'|'+[a+d+b,f+g+e][q]+['',' |'][q];j[r-1]=w('\|','+',w(s,'-',j[r]))
j[0]+=h
o=j[2]
j[2]='| +'+j[2][3:-3]+'+ |'
p='  |'+c
q='  '+w('\|','+',w(s,'-',p))[2:]
for l in j+[o,p,q]:print(l)

इनपुट को तीन सेटों द्वारा अनुसरण किया जाता है, जिन्हें अल्पविराम (जैसे 8, {1,2,4}, {2,3,4,5}, {4,6,8}) द्वारा अलग किया जाता है । यह निम्नलिखित की तरह ACSII कला में एक सेट का उत्पादन करता है:

+---+-+---+0 7
|1  | |3 5|
| +-+-+-+ |
| |2|4| | |
+-+-+-+-+-+
  |6 8  |
  +-----+
— faubi
स्रोत
Haha, 5 मिनट के भीतर दो लगभग समान समाधान। (चैलेंज पोस्ट होने के 3 घंटे बाद ...)
— मार्टिन एंडर
1
कृपया नोट संख्या 6 देखें। आपके किनारों और क्रॉसिंग सीमाओं को एक अलग चरित्र होना चाहिए, जैसे "+"।
— विलियम बारबोसा
4

HTML + जावास्क्रिप्ट (E6) 752 761

इनपुट प्रारूप: अधिकतम सेट 1 सेट 2 सेट 3 (प्रत्येक सेट एक अल्पविराम से अलग की गई सूची है)

उदाहरण: 10 1,2,3,4,5,9 1,2,3,6,8 7,2,9

स्क्रीनशॉट

उदाहरण 2: 30 2,4,6,8,10,12,14,16,18,30 3,6,9,12,15,18,21,30,10,15,20,25,30

क्रोम स्क्रीनशॉट

HTML रेंडरिंग के लिए सभी अनुभाग ऑटो आकार के लिए धन्यवाद।

<html><body><script>
i=prompt().split(' ');
r=",,,,,,,, class=',></i>".split(c=',')
for (j=-1;j++<i[0];r[h]+=j+' ')for(h=k=0;++k<4;)if((c+i[k]+c).search(c+j+c)+1)h+=k+(k>2);
document.write(
"<style>div{1row}p{position:relative;text-align:center;padding:7;1cell}i{position:absolute;top:0;3:0;4:0;left:0}.a{2top-left5b{2top-45c{23-left5d{23-45x{6880,9.y{680,89.z{60,889</style>"
.replace(/\d/g,x=>'09display:table-9border-9bottom9right9-radius:60px}.9background:rgba(930px9255,9.3)}'.split(9)[x])
+"<div><p8x a'/><p8x'>1</p><p><i8y a'9<i8x b'93</p><p8y'>2</p><p8y b'/></div><div><p8x c'/><p8z a'><i8x'95</p><p8z'><i8x d'9<i8y c'97</p><p8z b'><i8y'96</p><p8y d'/></div><div><p/><p8z c'/><p8z'>4</p><p8z d'/></div>0"
.replace(/\d/g,x=>r[x]))
</script></body></html>

जावास्क्रिप्ट E5 संस्करण क्रोम और MSIE 10 में काम करता है (शायद 9)

<html><body><script>
i=prompt().split(' ');
r=",,,,,,,, class=',></i>".split(c=',')
for (j=-1;j++<i[0];r[h]+=j+' ')for(h=k=0;++k<4;)if((c+i[k]+c).search(c+j+c)+1)h+=k+(k>2);
document.write(
"<style>div{1row}p{position:relative;text-align:center;padding:7;1cell}i{position:absolute;top:0;3:0;4:0;left:0}.a{2top-left5b{2top-45c{23-left5d{23-45x{6880,9.y{680,89.z{60,889</style>"
.replace(/\d/g,function(x){return '09display:table-9border-9bottom9right9-radius:60px}.9background:rgba(930px9255,9.3)}'.split(9)[x]})
+"<div><p8x a'/><p8x'>1</p><p><i8y a'9<i8x b'93</p><p8y'>2</p><p8y b'/></div><div><p8x c'/><p8z a'><i8x'95</p><p8z'><i8x d'9<i8y c'97</p><p8z b'><i8y'96</p><p8y d'/></div><div><p/><p8z c'/><p8z'>4</p><p8z d'/></div>0"
.replace(/\d/g,function(x){return r[x]}))
</script></body></html>

नहीं (तो) गोल्फ

<html>
<style>
div {   display:table-row; }
p {
    position: relative;
    text-align: center;
    padding: 30px;
    display: table-cell;
}
i {
    position: absolute;
    top:0;bottom:0;right:0;left:0;
}
.a { border-top-left-radius: 60px; }
.b { border-top-right-radius: 60px; }
.c { border-bottom-left-radius: 60px; }
.d { border-bottom-right-radius: 60px; }
.x { background: rgba(255,255,0,.3) }
.y { background: rgba(255,0,255,.3) }
.z { background: rgba(0,255,255,.3) }
</style>
<body>
<div>
<p class='x a'/><p class='x'><b id='b1'></b></p><p><i class='y a'></i><i class='x b'></i><b id='b3'></b></p><p class='y'><b id='b2'></b></p><p class='y b'/>
</div>    
<div>
<p class='x c'/><p class='z a'><i class='x'></i><b id='b5'></b></p><p class='z'><i class='x d'></i><i class='y c'></i><b id='b7'></b></p><p class='z b'><i class='y'></i><b id='b6'></b></p><p class='y d'/>
</div>        
<div>
<p/><p class='z c'/><p class='z'><b id='b4'></b></p><p class='z d'/>
</div>    
<b id='b0'></b>    
<script>
i=prompt().split(' ')
r=',,,,,,,'.split(c=',')
for (j=-1; j++<i[0];)
{
    for(h = k = 0; ++k < 4;)
    {
    if( (c+i[k]+c).search(c+j+c) >= 0)
      h += k + (k>2); // bit mask 1 or 2 or 4
  }
  r[h] += j + ' ';
}        
for (j = 0; j < 8; j++)
    document.getElementById('b'+j).innerHTML=r[j]
</script>
</html>
— edc65
स्रोत
3

पायथन 3 - 353

# 353 bytes, input format like: 6 1,2,3 2,3,4 1,3,4
import sys
from turtle import*
_,n,*q=sys.argv
n=set(range(int(n)))
a,b,c=map(set,map(eval,q))
for x,y in(0,0),(-115,-185),(115,-185):goto(x,y),pd(),circle(200),up()
for x,y,s in(200,331,n-a-b-c),(-101,278,a-b-c),(-254,-49,b-a-c),(95,-49,c-a-b),(-172,164,a&b-c),(58,164,a&c-b),(-49,-39,b&c-a),(-49,52,a&b&c):goto(x,y),write(s or'',font=None)
ht()
done()

क्या किसी और ने एक बच्चे के रूप में लोगो के साथ खेला था?

नमूना: python3 turtletest.py 15 1,2,3,4,5,9,10,12 1,3,4,6,7,9 1,2,7,8,9

यहाँ छवि विवरण दर्ज करें

— जेसन एस
स्रोत
क्या मनमाने ढंग से बड़े इनपुट के लिए फ़ॉन्ट / मंडल पैमाने होंगे?
— स्पेर
नहीं, अभी भी उस बारे में सोच रहे हैं।
— जेसन एस
@ जैसन अभी भी सोच रहे हैं?
— जोनाथन फ्रेच
3

पर्ल 388 बी 346 बी 488 बी

यह दूसरी प्रविष्टि के समान आउटपुट है:

@a=split($",<>);
$n=pop @a;
@a=map[split(',')],@a;
for$i(0..2){$b{$_}+=1<<$i foreach@{$a[$i]}}
push@{$c[$b{$_}]},$_ for(0..$n);
$l|=length($d[$_]=join($",@{$c[$_]}))for(0..$n);
print$h=(("+-"."-"x$l)x3)."+
";
sub j{sprintf"% ".(sprintf"%ds",$l+($_[0]<4)+($_[0]==7)),$d[$_[0]]}
sub r{join('|',map{j($_)}@_)}
$h=~s/\+-/|+/;
$h=~s/-\+$/+|/;
print "|".r(1,3,2)."|
".$h;
$h=~s/[|+]{2}/++/g;
print "||".r(5,7,6)."||
".$h;
$h=~s/\+\+/ +/;
$h=~s/\+\+/+ /;
$h=~s/-\+-/---/g;
$l=$l*3+3;print " |".j(4)."|
",$h,$d[0]

टेस्ट रन और आउटपुट:

# echo "1,2,3,7,13 2,3,8,11,13,6,9 3,4,5,11,12,13,14 15" | perl venn.pl ;echo
+----------------+----------------+----------------+
|             1 7|               2|           6 8 9|
|+---------------+----------------+---------------+|
||               |            3 13|             11||
++---------------+----------------+---------------++
 |                                       4 5 12 14|
 +------------------------------------------------+
— Sparr
स्रोत
हम्म, मुझे यकीन नहीं है कि अगर आपने इनपुट नहीं देखा है तो लेआउट वास्तव में अस्पष्ट है।
— मार्टिन एंडर
आप सही कह रहे हैं, यह पर्याप्त नहीं है
— विलियम बारबोसा
@WilliamBarbosa ठीक है, मैंने इसे faubiguy की प्रविष्टि की तरह बनाया
— Sparr
2

टी-एसक्यूएल 2095

मान लिया जाता है कि @ एन एक एन युक्त है। मान लिया गया है कि ए, @ बी, और @ सी तीन नंबर वाले सेट हैं। यह बहुत ज्यादा गोल्फ की कोशिश नहीं की।

DECLARE @D INT=@N,@E INT=0,@F CHAR='/',@G CHAR='\',@H CHAR='-',@I CHAR='|',@J CHAR='+'DECLARE @ TABLE(Z INT,Y INT,X INT,W INT,V INT,U INT,T INT,S INT)INSERT INTO @(Z)SELECT A.P FROM @A A JOIN @B B ON A.P=B.P JOIN @C C ON A.P=C.P INSERT INTO @(Y)SELECT A.P FROM @A A JOIN @B B ON A.P=B.P LEFT JOIN @C C ON A.P=C.P WHERE C.P IS NULL INSERT INTO @(X)SELECT C.P FROM @C C JOIN @A A ON C.P=A.P LEFT JOIN @B B ON C.P=B.P WHERE B.P IS NULL INSERT INTO @(W)SELECT B.P FROM @B B JOIN @C C ON B.P=C.P LEFT JOIN @A A ON B.P=A.P WHERE A.P IS NULL INSERT INTO @(V)SELECT A.P FROM @A A LEFT JOIN @B B ON A.P=B.P LEFT JOIN @C C ON A.P=C.P WHERE C.P IS NULL AND B.P IS NULL INSERT INTO @(U)SELECT C.P FROM @C C LEFT JOIN @A A ON C.P=A.P LEFT JOIN @B B ON C.P=B.P WHERE B.P IS NULL AND A.P IS NULL INSERT INTO @(T)SELECT B.P FROM @B B LEFT JOIN @C C ON B.P=C.P LEFT JOIN @A A ON B.P=A.P WHERE A.P IS NULL AND C.P IS NULL WHILE @N>=0BEGIN INSERT INTO @(S)SELECT @N WHERE @N NOT IN(SELECT*FROM @A UNION SELECT*FROM @B UNION SELECT*FROM @C)SET @N-=1 END DECLARE @Z TABLE(A CHAR(5),B CHAR(5),C CHAR(5),D CHAR(5),E CHAR(5),F CHAR(5),G CHAR(5),H CHAR(5))INSERT INTO @Z SELECT @F,@H,@F,@H,@G,@H,@G,''WHILE @E<=@D BEGIN INSERT INTO @Z SELECT @I,ISNULL((SELECT CONVERT(CHAR,@E,5) WHERE @E IN(SELECT V FROM @)),''),@I,ISNULL((SELECT CONVERT(CHAR,@E,5) WHERE @E IN(SELECT X FROM @)),''),@I,ISNULL((SELECT CONVERT(CHAR,@E,5) WHERE @E IN(SELECT U FROM @)),''),@I,ISNULL((SELECT CONVERT(CHAR,@E,5) WHERE @E IN(SELECT S FROM @)),'')SET @E+=1 END INSERT INTO @Z SELECT @F,@H,@J,@H,@G,'',@I,''SET @E=0WHILE @E<=@D BEGIN INSERT INTO @Z SELECT @I,ISNULL((SELECT CONVERT(CHAR,@E,5) WHERE @E IN(SELECT Y FROM @)),''),@I,ISNULL((SELECT CONVERT(CHAR,@E,5) WHERE @E IN(SELECT Z FROM @)),''),@I,'',@I,''SET @E+=1 END INSERT INTO @Z SELECT @G,@H,@J,@H,@F,'',@I,''SET @E=0WHILE @E<=@D BEGIN INSERT INTO @Z SELECT @I,ISNULL((SELECT CONVERT(CHAR,@E,5) WHERE @E IN(SELECT T FROM @)),''),@I,ISNULL((SELECT CONVERT(CHAR,@E,5) WHERE @E IN(SELECT W FROM @)),''),@I,'',@I,''SET @E+=1 END INSERT INTO @Z SELECT @G,@H,@G,@H,@F,@H,@F,''SELECT*FROM @Z

कम गोल्फ वाला संस्करण:

--finding the sets
DECLARE @D INT=@N,@E INT=0,@F CHAR='/',@G CHAR='\',@H CHAR='-',@I CHAR='|',@J CHAR='+'
DECLARE @ TABLE(Z INT,Y INT,X INT,W INT,V INT,U INT,T INT,S INT)
INSERT INTO @(Z)
SELECT A.P FROM @A A JOIN @B B ON A.P=B.P JOIN @C C ON A.P=C.P 
INSERT INTO @(Y)
SELECT A.P FROM @A A JOIN @B B ON A.P=B.P LEFT JOIN @C C ON A.P=C.P WHERE C.P IS NULL 
INSERT INTO @(X)
SELECT C.P FROM @C C JOIN @A A ON C.P=A.P LEFT JOIN @B B ON C.P=B.P WHERE B.P IS NULL 
INSERT INTO @(W)
SELECT B.P FROM @B B JOIN @C C ON B.P=C.P LEFT JOIN @A A ON B.P=A.P WHERE A.P IS NULL 
INSERT INTO @(V)
SELECT A.P FROM @A A LEFT JOIN @B B ON A.P=B.P LEFT JOIN @C C ON A.P=C.P WHERE C.P IS NULL AND B.P IS NULL 
INSERT INTO @(U)
SELECT C.P FROM @C C LEFT JOIN @A A ON C.P=A.P LEFT JOIN @B B ON C.P=B.P WHERE B.P IS NULL AND A.P IS NULL 
INSERT INTO @(T)
SELECT B.P FROM @B B LEFT JOIN @C C ON B.P=C.P LEFT JOIN @A A ON B.P=A.P WHERE A.P IS NULL AND C.P IS NULL 
WHILE @N>=0
BEGIN 
    INSERT INTO @(S)
    SELECT @N WHERE @N NOT IN(SELECT*FROM @A UNION SELECT*FROM @B UNION SELECT*FROM @C)
    SET @N-=1 
END

--displaying the venn diagram
DECLARE @Z TABLE(A CHAR(5),B CHAR(5),C CHAR(5),D CHAR(5),E CHAR(5),F CHAR(5),G CHAR(5),H CHAR(5))
INSERT INTO @Z 
SELECT @F,@H,@F,@H,@G,@H,@G,''
WHILE @E<=@D 
BEGIN 
    INSERT INTO @Z 
    SELECT @I,ISNULL((SELECT CONVERT(CHAR,@E,5) WHERE @E IN(SELECT V FROM @)),''),@I,ISNULL((SELECT CONVERT(CHAR,@E,5) WHERE @E IN(SELECT X FROM @)),''),@I,ISNULL((SELECT CONVERT(CHAR,@E,5) WHERE @E IN(SELECT U FROM @)),''),@I,ISNULL((SELECT CONVERT(CHAR,@E,5) WHERE @E IN(SELECT S FROM @)),'')
    SET @E+=1 
END 
INSERT INTO @Z 
SELECT @F,@H,@J,@H,@G,'',@I,''
SET @E=0
WHILE @E<=@D 
BEGIN 
    INSERT INTO @Z 
    SELECT @I,ISNULL((SELECT CONVERT(CHAR,@E,5) WHERE @E IN(SELECT Y FROM @)),''),@I,ISNULL((SELECT CONVERT(CHAR,@E,5) WHERE @E IN(SELECT Z FROM @)),''),@I,'',@I,''
    SET @E+=1 
END 
INSERT INTO @Z 
SELECT @G,@H,@J,@H,@F,'',@I,''
SET @E=0
WHILE @E<=@D 
BEGIN 
    INSERT INTO @Z 
    SELECT @I,ISNULL((SELECT CONVERT(CHAR,@E,5) WHERE @E IN(SELECT T FROM @)),''),@I,ISNULL((SELECT CONVERT(CHAR,@E,5) WHERE @E IN(SELECT W FROM @)),''),@I,'',@I,''
    SET @E+=1 
END 
INSERT INTO @Z 
SELECT @G,@H,@G,@H,@F,@H,@F,''
SELECT*FROM @Z
— bmarks
स्रोत
हमारी साइट का प्रयोग करके, आप स्वीकार करते हैं कि आपने हमारी Cookie Policy और निजता नीति को पढ़ और समझा लिया है।
Licensed under cc by-sa 3.0 with attribution required.