आपके पास प्रत्येक कोने में एक एकल अंक संख्या वाला एक बॉक्स है:

1|2
---
3|4

यदि हम अंकों को बाएँ से दाएँ पंक्तियों के साथ जोड़ते हैं, तो हमें 12 और 34 मिलते हैं। यदि हम अंकों को कॉलम के साथ ऊपर से नीचे तक पहुँचाते हैं, तो हमें 13 और 24 मिलते हैं। यदि हम इन सभी संख्याओं को जोड़ते हैं, तो हमें 12 + 34 या 13 + मिलते हैं। 24 = 83।

चुनौती

ऐसे सभी बक्से को मुद्रित करने के लिए एक कार्यक्रम लिखें जहां ऊपर की गणना की गई राशि 100 के बराबर है।

यह मानते हुए कि प्रत्येक कोने में 1 और 9 के बीच एक एकल अंक संख्या होती है, 9 संयोजन होते हैं: 1157, 1247, 1337, 1427, 1517, 2138, 2228, 2318, और 3119। (ध्यान दें कि 25 संयोजन हैं जिनमें हम 0 शामिल हैं, लेकिन हम इस चुनौती के लिए नहीं हैं।)

ध्यान दें कि 1234 का उदाहरण काम नहीं करता है क्योंकि 12 + 34 + 13 + 24 100 के बराबर नहीं है।

इनपुट

कोई नहीं

उत्पादन

निम्नलिखित प्रारूप में उत्तर बॉक्स:

A|B
---
C|D

आउटपुट को STDOUT या निकटतम विकल्प के लिए मुद्रित किया जाना चाहिए।

नियम

एबी + सीडी + एसी + बीडी = १००
प्रत्येक कोने में सकारात्मक पूर्णांक 1-9 ही होंगे।
0 को बाहर रखा गया है।
संख्याओं का एक से अधिक बार उपयोग किया जा सकता है।
आपको ऊपर के रूप में बक्से खींचने की जरूरत है। ( A|B\n---\nC|D\n)
आपको सभी मान्य उत्तरों को आउटपुट करने की आवश्यकता है।
एक अतिरिक्त अनुगामी न्यूलाइन ठीक है।
कोड-गोल्फ , बाइट्स में सबसे छोटा कोड जीतता है।
मानक कमियां और टी एंड सी लागू होते हैं।

यह मेरा पहला सबमिशन है इसलिए कृपया मुझे बताएं कि क्या मुझे कुछ भी स्पष्ट करने की आवश्यकता है।

code-golf

— देनहम कोट
स्रोत

क्या आप दिखा सकते हैं कि आउटपुट क्या माना जाता है? इसके अलावा, एक अनुगामी न्यूलाइन चरित्र के बारे में क्या?

— स्पिकैट्रिक्स

अच्छी चुनौती है। मुझे लगता है कि आपको स्पष्ट रूप से यह बताने की आवश्यकता है कि कौन सी संख्याओं को जोड़ने की आवश्यकता है। रेखा "दो, संक्षिप्त, दो अंकीय संख्याएँ PLUS दो, दो अंकीय संख्याएँ 100 के बराबर होती हैं।" पर्याप्त स्पष्ट नहीं है। मुझे केवल 1234 के उदाहरण का उपयोग करके पता चला है। इसके अलावा, मुझे केवल 9 संयोजन मिल रहे हैं। क्या आप 16 संयोजनों का उल्लेख कर सकते हैं?

— ऑप्टिमाइज़र

1

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

— एलेक्स ए।

1

@ डेंहमकूट वास्तव में, मेरा अर्ध-हार्डकोड समाधान करने के लिए काफी दिलचस्प था, क्योंकि यह केवल अर्ध-हार्डकोड है। यह नियम के लिए एक अपवाद रहा है, क्योंकि ऐसे प्रश्न जहाँ ब्लोटेंट हार्डकोडिंग सबसे अच्छा / सबसे स्पष्ट विकल्प होता है, अक्सर दिलचस्प उत्तर नहीं देते हैं (उदाहरण के लिए हाल ही के ब्रोमीन रिंग्स प्रश्न देखें।) प्रश्न के लिए धन्यवाद।

— लेवल रिवर सेंट

1

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

— लेवल रिवर सेंट

8

पायथ, 42 38 34 बाइट्स

V ^ ST4IqC \ ds * VNsM ^, T1 2Xj \ | N3 "
---

कोड में अनुगामी newline महत्वपूर्ण है। मुख्य कारण यह है कि मैं प्रतिस्पर्धी हूँ क्योंकि मैं के वेक्टर डॉट उत्पाद का उपयोग है [1, 1, 5, 7]और [20, 11, 11, 2]और 100 की तुलना।

— orlp
स्रोत

"|"-> \|, \n-> (शाब्दिक लाइनफ़ीड) और आपको अंतिम उद्धरण की आवश्यकता नहीं है।

— डेनिस

@ डेनिस सो रहा था। <

— orlp

2

यदि आपको कोई आपत्ति नहीं है, तो क्या आप उन लोगों (जैसे मेरे) के लिए स्पष्टीकरण जोड़ सकते हैं, जो आपके अविश्वसनीय रूप से संक्षिप्त उत्तर को नहीं समझ सकते हैं?

— डेन्हम कोट

6

रूबी, 71

जैसा कि हार्डकोडिंग को अस्वीकृत नहीं किया गया है (और किसी भी स्थिति में एक रेखा खींचना मुश्किल है) यहां एक आंशिक हार्डकोड किया गया उत्तर है।

1.upto(3){|i|1.upto(7-i*2){|j|print i,?|,j,'
---
',8-j-2*i,?|,i+6,'
'}}

व्याख्या

समाधान का सूत्र इस प्रकार है:

A*20+(B+C)*11+D*2=100

मॉड्यूलर अंकगणितीय तर्कों द्वारा, हम देखते हैं कि A और D एक स्थिर राशि से भिन्न होना चाहिए, जैसे कि (A*20+D*2)%11स्थिर है। वास्तव में डी = ए + 6। iए के तीन संभावित मान के माध्यम से लूप दोहराता

B का मान 1 से कुछ भी हो सकता है 7-i*2और B और C का कुल योग होना चाहिए 14-A-D। इस प्रकार हम निम्नलिखित भाव प्राप्त करते हैं, जो मुद्रित होते हैं। रूबी में संलग्न तार में शाब्दिक नए समाचारों की अनुमति देता है''

   i     |    j
------------------
8-j-2*i  |   i+6

— स्तर नदी सेंट
स्रोत

4

जावा, २०२ २०० १ ९ 8

पहली बार कोशिश कर रहा है: डी

संपादित करें: एक छोटी सी गणना के साथ 2 बाइट्स बचाए जो एक अन्य टिप्पणी में पाए गए।

class C{public static void main(String[]c){for(int i=0;++i<5;)for(int j=0;++j<7;)for(int k=0;++k<10;)for(int l=0;++l<10;)if(20*i+11*(j+k)+2*l==100)System.out.printf("%s|%s%n---%n%s|%s%n",i,j,k,l);}}

— Koekje
स्रोत

4

बैच - 187 बाइट्स

पाशविक बल।

@!! 2>nul||cmd/q/v/c%0&&exit/b
set y=for /l &set z= in (1,1,9)do 
%y%%%a%z%%y%%%b%z%%y%%%c%z%%y%%%d%z%set/aa=%%a%%b+%%c%%d+%%a%%c+%%b%%d&if !a!==100 echo %%a^|%%b&echo ---&echo %%c^|%%d

अन-गोल्फ यह थोड़ा कम घृणित है:

@echo off
setLocal enableDelayedExpansion
for /l %%a in (1,1,9) do (
    for /l %%b in (1,1,9) do (
        for /l %%c in (1,1,9) do (
            for /l %%d in (1,1,9) do (
                set/aa=%%a%%b+%%c%%d+%%a%%c+%%b%%d
                if !a!==100 (
                    echo %%a^|%%b
                    echo ---
                    echo %%c^|%%d
                )
            )
        )
    )
)

— unclemeat
स्रोत

3

सीजेएम, 40 बाइट्स

A4m*{[KBBY].*:+56=},{:)2/'|f*"
---
"*N}/

संयोजनों को खोजने के लिए दृष्टिकोण @ ऑप्टिमाइज़र से अलग है, लेकिन उन्हें प्रिंट करने के लिए कोड समान है।

CJam दुभाषिया में इसे ऑनलाइन आज़माएं ।

यह काम किस प्रकार करता है

A4m*     e# Push all vectors of length 4 with coordinates in [0 ... 9].
         e# We'd normally use [0 ... 8] here, but "9 4m*" is 1 byte longer and
         e# "A4m*" doesn't produce any false positives.

{        e# Filter the vectors:
[KBBY].* e#   Multiply the elements of the vector by 20, 11, 11 and 2.
:+       e#   Add all four products.
56=      e#   Check if the sum is 56. 56 is used instead of 100 since all elements
         e#   of the vector will be incremented and 56 + 20 + 11 + 11 + 2 == 100.
},       e# Keep only vectors for which = pushed a truthy value.

{        e# For each vector:
:)       e#   Increment each coordinate.
2/       e#   Split into pair.
'|f*     e#   Join each pair, delimiting by '|'.
"
---
"*       e#   Join the two pairs, delimiting by "\n---\n".
N        e#   Push "\n".
}/       e#

— डेनिस
स्रोत

चूँकि मैं कुछ जावा से बहुत कम जानता हूं, मुझे इस बात का स्पष्टीकरण पसंद है कि यह कैसे काम करता है, अगर आप तैयार हैं ..?

— डेन्हम कोट

यह एक अच्छी चाल है।

— ऑप्टिमाइज़र

वाह। मुझे बहुत कुछ सीखना है। स्पष्टीकरण के लिए धन्यवाद :)

— डेनहम कोट

3

हास्केल, 107 131 बाइट्स

s=show
r=[1..9]
v=putStr$unlines[s a++"|"++s b++"\n---\n"++s c++"|"++s d++"\n"|a<-r,b<-r,c<-r,d<-r,(2*a+b+c)*10+b+2*d+c==100]

मेरे पहले हास्केल कार्यक्रम का दूसरा संस्करण!

इस बार आवश्यकता के अनुसार प्रदर्शन के साथ, बेशर्मी से निम्मी से ~~चुराया~~ गया (अच्छी तरह से मैंने कुछ शोध किया था लेकिन ऐसा लगता है कि हास्केल में पात्रों को प्रदर्शित करने के लिए कुशल तरीके नहीं हैं ताकि पुटस्ट्रल $ अनलीन से बचना मुश्किल हो)।

और ... अंत में सूत्र के गुणन के अलावा, यह अभी भी पठनीय है =)

— dungeoncrawler
स्रोत

3

हास्केल, 125 121 बाइट्स

s=show
f=putStr$unlines[s a++'|':s b++"\n---\n"++s c++'|':s d|[a,b,c,d]<-mapM id$"abcd">>[[1..9]],20*a+11*(b+c)+2*d==100]

उपयोग:

*Main> f
1|1
---
5|7
1|2
---
4|7
1|3
---
3|7
1|4
---
2|7
1|5
---
1|7
2|1
---
3|8
2|2
---
2|8
2|3
---
1|8
3|1
---
1|9

>>में "abcd">>[[1..9]]बनाता है 4 (1 पैरामीटर की लंबाई) दूसरा तत्व की प्रतियां, यानी साथ एक सूची [[1..9],[1..9],[1..9],[1..9]]। mapM idउसके सभी संयोजनों, यानी की एक सूची बनाता है [0,0,0,0]करने के लिए [9,9,9,9]। उन लोगों को रखें जो इसे जोड़ते हैं 100और इसके बॉक्स के साथ एक स्ट्रिंग बनाते हैं। सभी बॉक्स प्रिंट करें।

धन्यवाद 1 @ बाइट के लिए मौरिस और मुझे 3 और खोजने के लिए मेरी पोस्ट की समीक्षा करें।

— nimi
स्रोत

mapM idएक बाइट बनाम बचाता है sequence।

— लिन

2

पायथन 2, 145 129 बाइट्स

मैं वर्तमान में गणना के कुछ अलग तरीकों के साथ कर रहा हूं, जो कि उल्लिखित की तुलना में कम होना चाहिए, लेकिन मैं अभी जो मेरे पास है उसे पोस्ट करूंगा।

i=int
for k in range(1000,9999):
 a,b,c,d=`k`
 if i(a+b)+i(c+d)+i(a+c)+i(b+d)==100and not'0'in`k`:print a+'|'+b+'\n---\n'+c+'|'+d

— Kade
स्रोत

2

CJam, 43 42 बाइट्स

A,1>4m*{2/_z+Afb:+100=},{2/'|f*"
---
"*N}/

पालन करने के लिए स्पष्टीकरण .. आज तक ई.ओ.डी.

इसे यहाँ ऑनलाइन आज़माएँ

— अनुकूलक
स्रोत

मेरा गोल्फ का जावा संस्करण (जो बक्से से परेशान नहीं है, यह केवल दृश्यों को सूचीबद्ध करता है) 197 वर्ण था। यह लंबाई के एक चौथाई में यह सब करता है! कूल :)

— डेन्हम कोट

@DenhamCoote यह हर CJam, Pyth और GolfScript का जवाब है।

— चरण

अभी भी उस स्पष्टीकरण के लिए आगे देख रहे हैं ;-)

— Denham Coote

1

अजगर 3, 159

जल्दी और गन्दी।

N='123456789'
D='%s|%s\n'
O=D+'---\n'+D
I=int
[print(O%(a,b,c,d)if I(a+b)+I(c+d)+I(a+c)+I(b+d)==100 else'',end='')for a in N for b in N for c in N for d in N]

— डैनियल वेकफील्ड
स्रोत

1

आर, 165 बाइट्स

e=expand.grid(d<-1:9,d,d,d)
a=apply
o=a(e[a(e,1,function(x)20*x[1]+11*(x[2]+x[3])+2*x[4]==100),],1,function(x)cat(x[1],"|",x[2],"\n---\n",x[3],"|",x[4],"\n",sep=""))

यह काफी कम होता था जब मैंने किसी तरह से आउटपुट को हार्ड-कोड करने के लिए चुना था। कुछ अन्य समाधानों की तरह, यह पहचान का लाभ उठाता है 20 x ₁ + 11 ( x ₂ + x ₃ ) + 2 x ₄ = 100।

असंगठित + स्पष्टीकरण:

# Create a matrix where each row is a combination of the digits 1-9
e <- expand.grid(1:9, 1:9, 1:9, 1:9)

# Filter the rows of the matrix using the aforementioned identity
e <- e[apply(e, 1, function(x) 20*x[1] + 11*(x[2]+x[3]) + 2*x[4] == 100), ]

# Print each row formatted into boxes
o <- apply(e, 1, function(x) cat(x[1], "|", x[2], "\n---\n", x[3], "|", x[4], sep = ""))

आप सोच रहे होंगे कि अंतिम कथन एक नियत कार्य क्यों है। जैसा कि यह पता चला है, catफ़ंक्शन, जो सहमति देता है और प्रिंट करता है, का मान लौटाता है NULL। जब आप catकिसी फ़ंक्शन के भीतर से कॉल करते हैं apply, जैसे आउटपुट का अनुसरण किया जाएगा NULL, जो अवांछनीय है। इसके चारों ओर दो तरीके हैं: इसे एक चर में निर्दिष्ट करें या इसे इसमें लपेटें invisible। यहाँ मैंने पूर्व के लिए चुना है क्योंकि यह काफी छोटा है।

आप इसे ऑनलाइन आज़मा सकते हैं ।

— एलेक्स ए।
स्रोत

1

जावा, 450

मेरा पहला (अनगुल्ड) प्रयास इस तरह दिखाई दिया:

कक्षा बी {
  सार्वजनिक स्थैतिक शून्य मुख्य (स्ट्रिंग [] ए) {
    for (int i = 1; मैं <10; i ++)
      for (int j = 1; j <10; j ++)
        for (int k = 1; k <10; k ++)
          के लिए (int l = 1; l <10; l ++)
            अगर (Integer.parseInt (मैं + "" + जे) + Integer.parseInt (k + "" + l) + Integer.parseInt (मैं + "" + k) + Integer.parseInt (जे + "" + l) == 100) {
              Println (i + "|" + जे);
              Println ( "---");
              Println (k + "|" + l + "\ n");
            }
  }
}

— देनहम कोट
स्रोत

3

संकेत: 20*a + 11*(b + c) + 2*d == 100।

— orlp

हाँ, यह समाधान विशुद्ध रूप से स्ट्रिंग संघनन था - एक बहुत ही विनम्र पहला प्रयास।

— डेनहेम कोट

1

मैं केवल 436 बाइट्स गिनता हूं , 450 नहीं। इसके अलावा, व्हाट्सएप आवश्यक नहीं है, जो आपको काफी मात्रा में बचाएगा।

— एलेक्स ए।

इसके अलावा, अनावश्यक व्हाट्सएप को हटाते हुए, यह 340 बाइट्स के करीब होना चाहिए :)

— केड

1

पॉवरशेल, 98

अनुकूलित स्टीववेरील का सूत्र

:\>cat printbox.ps1

1..9|%{for($j=1;$j-lt10;$j++){if(($k=(8-$j-2*$_))-gt0){"{0}|{1}`n---`n{2}|{3}"-f$_,$j,$k,
($_+6)}}}

:\>powershell -f printbox.ps1
1|1
---
5|7
1|2
---
4|7
1|3
---
3|7
1|4
---
2|7
1|5
---
1|7
2|1
---
3|8
2|2
---
2|8
2|3
---
1|8
3|1
---
1|9

— blabb
स्रोत

उन संयोजनों को आकर्षित करें जो 100 तक जोड़ते हैं

चुनौती

इनपुट

उत्पादन

नियम

पायथ, 42 38 34 बाइट्स

रूबी, 71

जावा, २०२ २०० १ ९ 8

बैच - 187 बाइट्स

सीजेएम, 40 बाइट्स

यह काम किस प्रकार करता है

हास्केल, 107 131 बाइट्स

हास्केल, 125 121 बाइट्स

पायथन 2, 145 129 बाइट्स

CJam, 43 42 बाइट्स

अजगर 3, 159

आर, 165 बाइट्स

जावा, 450

पॉवरशेल, 98