एक नजर में वजन का एक सेट संतुलन

Question

संतुलनकारी कार्य

अवलोकन

वजन के एक सेट का प्रतिनिधित्व करने वाले 3 एकल-अंक पॉजिटिव पूर्णांकों के इनपुट को देखते हुए, उस पर रखे गए वेट के साथ एक वॉच का ASCII प्रतिनिधित्व आउटपुट करता है ताकि यह लीवर प्रभाव को ध्यान में रखते हुए एक केंद्रीय धुरी के चारों ओर संतुलन में हो।

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

इनपुट

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

इनपुट हमेशा गणितीय रूप से मान्य आउटपुट के लिए अनुमति देते हैं, अन्यथा इनपुट मान्य नहीं होता है।

उत्पादन

आउटपुट को उस पर रखे गए वेट के साथ वॉशॉ का 2-लाइन एएससीआईआई प्रतिनिधित्व होना चाहिए। पहली पंक्ति में अंक होते हैं, जो उन्हें सीसॉ पर संतुलित करने के लिए फैलाया जाता है।

संख्या को स्केल के बहुत केंद्र में नहीं रखा जा सकता है, जहां दूरी और इसलिए टोक़ शून्य होगा। केंद्र से वैध दूरी 1-10 वर्णों से लेकर धुरी के बाएँ या दाएँ तक होती है।

संख्याओं के अनुसार रिक्त स्थान में 18 अंडरस्कोर वर्ण (एक केंद्र अंडरस्कोर और प्रत्येक पक्ष पर 10, संख्याओं द्वारा कब्जा किए गए 3 पदों को घटाता है) हैं। आखिरी पंक्ति में स्केल के केंद्र के साथ एक एकल कैरेट वर्ण है, जो धुरी का प्रतिनिधित्व करता है।

उदाहरण

इनपुट:

4,7,2

आउटपुट:

________7___42_______
          ^

7 * 2 = 4 * 2 + 2 * 3

संख्याएँ दोनों ओर आउटपुट हो सकती हैं, उदाहरण के लिए यह भी मान्य होगा:

_______24___7________
          ^

2 * 3 + 4 * 2 = 7 * 2

संख्या को पैमाने पर कहीं भी रखा जा सकता है जब तक वे संतुलन रखते हैं, जैसे:

इनपुट:

3,1,5

आउटपुट:

_____5________1__3___
          ^

5 * 5 = 1 * 4 + 3 * 7

या

____5________1_____3_
          ^

५ * ६ = १ * ३ + ३ * ९

या

____5___________1_3__
          ^

5 * 6 = 1 * 6 + 3 * 8

आदि

आपके प्रोग्राम को केवल एक ही आउटपुट आउटपुट के लिए है। यदि इनपुट मान्य नहीं है, तो इसे एक त्रुटि आउटपुट नहीं करना है।

टिप्पणियाँ

• यह कोड-गोल्फ है इसलिए बाइट्स जीत में सबसे छोटा कार्यक्रम है
• प्रोग्राम एक स्टैंड-अलोन या एक फ़ंक्शन हो सकता है जो संख्याओं को इनपुट के रूप में स्वीकार करता है और एक स्ट्रिंग लौटाता है।
• अंतिम पंक्ति पर नईलाइन और श्वेत-स्थान अनुगामी वैकल्पिक है
• यदि आप नहीं जानते कि एक झूला क्या है, तो इसे टेटर-टॉट्टर या टेथरबोर्ड के रूप में भी जाना जाता है।

Comments

यहाँ एक पेस्ट वैध इनपुट्स और समाधान दिखा रहा है (कुछ दोहराव के साथ)

— samgak

एक उत्कृष्ट पहली चुनौती! एक दिलचस्प समस्या और गहन कल्पना।

— xnor

अल्गोरिदमिक रूप से, एक पूर्ण-संख्या वाला वेक्टर दिया गया है, यह आपको सभी भिन्न प्रविष्टियों के साथ एक पूर्ण-संख्या वाले ऑर्थोगोनल वेक्टर को खोजने के लिए कहता है।

— गर्वित हैकेलर

Answer 1

CJam, 40 39 38 बाइट्स

q~21Ue]e!{21,Af-Aest.*:+!}=0'_erNAS*'^

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

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

q~                                     e# Read and evaluate the input.
  21Ue]                                e# Append zeroes to achieve a length of 21.
       e!                              e# Push all unique permutations.
         {               }=            e# Find the first permutation such that:
          21,                          e#  Push [0 ... 20].
             Af-                       e#  Subtract 10 from each.
                Aest                   e#  Replace the element at index 10 with the
                                       e#  current time (ms since epoch) to push
                                       e#  [-10 ... -1 <big number> 1 ... 10].
                    .*                 e#  Multiply each number of the permutation
                                       e#  by the corresponding distance.
                      :+               e#  Add the products.
                                       e#  The timestamp makes sure that this sum
                                       e#  is non-zero for a non-zero element in
                                       e#  the middle of the permutation.    
                        !              e#  Push the logical NOT of the sum.
                           0'_er       e# Replace zeroes with underscores.
                                NAS*'^ e# Push a linefeed, ten spaces and a caret.

Answer 2

CJam, 46 44 बाइट्स

'_21*q~K,Am3m*{___&=*Afm1$.*:+!}=.{\t}NAS*'^

इसका परीक्षण यहां करें।

व्याख्या

सबसे पहले, एक अवलोकन: हमें कभी-कभी सीसॉ के सिरों पर दो अंक लगाने की आवश्यकता नहीं है। जब भी यह एक वैध समाधान होता है, तो कम से कम एक अन्य वैध समाधान होता है (चुनौती पर टिप्पणी में पिछलेबिन के अनुसार)।

'_21*   e# Push a string of 21 underscores.
q~      e# Read and eval input.
K,      e# Push the array [0 1 .. 19 20]
Am      e# Remove the 10. This is now an array of all valid positions on the seesaw.
3m*     e# Get all 3-tuples of valid positions.
{       e# Select the first tuple for which the following block yields a truthy result.
  ___   e# Make three copies of the tuple.
  &=    e# Intersect the last two copies and check for equality with the first one.
        e# This yields 1 if all positions are distinct, and 0 otherwise.
  *     e# Repeat the original tuple that many times. That is, if the positions are
        e# distinct, leave the tuple unchanged. Otherwise, replace it with an empty array.
  Afm   e# Subtract 10 from each position to get its weight.
  1$    e# Copy the input digits.
  .*    e# Take the pairwise product of weights and digits. If the weights are empty
        e# (because they were not unique), this will just yield a list of the digits.
  :+    e# Sum the weighted digits. If the weights were not unique, this will just sum
        e# the digits and will always be positive.
  !     e# Logical NOT - give 1 if the sum was 0, or 0 otherwise.
}=
.{\t}   e# For each pair of digit and position, replace that position in the underscore
        e# string with the corresponding digit.
N       e# Push a newline.
AS*     e# Push ten spaces.
'^      e# Push a caret.

Answer 3

जावा, 519 414 321 बाइट्स

static int f(int a,int b,int c){int i,j,k;for(i=-10;i<=10;i++)for(j=i+1;j<=10;j++)for(k=j+1;k<=10;k++){if(a*i+b*j+c*k==0&&i!=0&&j!=0&&k!=0){for(int q=0;q<21;q++){if(q==10+i)p(a);else if(q==10+j)p(b);else if(q==10+k)p(c);else p('_');}p("\n          ^\n");return 0;}}return 0;}static void p(Object a){System.out.print(a);}}

गोल्फ में मेरा पहला प्रयास।

आप इसके साथ कॉल कर सकते हैं f(a,b,c)। इसे यहाँ आज़माएँ

EDIT: चेक की izlin विधि का इस्तेमाल किया(a*i+b*j+c*k)==0

संपादित करें: धन्यवाद, जे Atkin गोल्फ सुझाव के लिए।

Comments

आप के हस्ताक्षर बदलकर कुछ बाइट्स बचा सकते हैं pकरने के लिए Object aऔर अन्य 2 के स्थान पर इसे का उपयोग System.out.print(ln)है।

— J Atkin

और जब aसे केवल एक बार उपयोग किया जाता है, आप इसे इनलाइन कर सकते हैं।

— J Atkin

Answer 4

Pyth, 67 58 53 49 बाइट्स

यह पाइथ के लिए विशाल पक्ष पर थोड़ा महसूस करता है, लेकिन मैं भाषा के साथ लगभग परिचित नहीं हूं कि यह बहुत छोटा हो सके। 50 बाइट्स के साथ, मैं आखिरकार इससे खुश हूं!

V.c-KrT-011Z3FY.pQIqs*VNYZjkm?}dN@YxNd\_K+*dT\^.q

उदाहरण के लिए, पूर्णांक की एक सरणी के रूप में इनपुट अपेक्षित है [1,2,3]। इसे यहाँ आज़माएँ ।

explaination:

V.c-KrT-011Z3FY.pQIqs*VNYZjkm?}dN@YxNd\_K+*dT\^.q
                                                       Implicit: Q = eval(input())
     rT-011                                            Create range from 10 to -10
    K                                                  Store in K
   -       Z                                           Drop 0 from the above
V.c         3                                          For N in (combinations of the above of size 3)
             FY.pQ                                     For Y in (permutations of input)
                     *VNY                              Multiply each element in N by the corresponding element in Y
                    s                                  Take the sum
                  Iq     Z                             If it's equal to zero:
                            m           K              For d in K (K = [10, ..., -10])
                             ?}dN                      Is d in N?
                                 @YxNd                 If so, get corresponding value from Y
                                      \_               Otherwise, get '_'
                          jk                           Join the resulting array into a string (implicit print)
                                         +*dT\^        Join 10 spaces and '^', implicit print
                                               .q      Break all loops and exit

और अंत में, कुछ उदाहरण इनपुट और आउटपुट:

[1,1,1] ->
1__________1_______1_
          ^

[2,9,5] ->
2____5_________9_____
          ^

[9,8,5] ->
5____8______________9
          ^

Answer 5

सी - 237 228 बाइट्स

i,j,k;f(a,b,c){char o[]="_____________________\n          ^";for(i=-10;i<9;i+=i+1?1:2){for(j=i+1;j<11;j+=j+1?1:2){for(k=j+1;k<11;k+=k+1?1:2){if((a*i+b*j+c*k)==0){o[i+10]=a+48;o[j+10]=b+48;o[k+10]=c+48;printf("%s",o);return;}}}}}

आप इसके साथ कॉल कर सकते हैं f(a,b,c)।

इसे यहाँ आज़माएँ ।

उदाहरण आउटपुट:

f(4,7,2):
4_____________7_2____
          ^         

f(3,1,5)
3____1___________5___
          ^       

Answer 6

पायथन 2.7 235 226 219 बाइट्स

def s(n,p=__import__("itertools").permutations):
 l=["_"]*21
 for p,q in[[(a,x+10),(b,y+10),(c,10-z)]for a,b,c in p(n,3)for x,y,z in p(range(1,11),3)if x!=y and a*x+b*y==c*z][0]:l[q]=`p`
 return`l`[2::5]+"\n"+" "*10+"^"

कुछ बुनियादी उदाहरणों के साथ इसका परीक्षण(1,1,1),(1,2,1),(3,1,5),(4,7,2) करना- परिणाम-:

(1, 1, 1)
_______1___11________
          ^
(1, 2, 1)
_____1_____12________
          ^
(3, 1, 5)
________5__3_____1___
          ^
(4, 7, 2)
_2_________47________
          ^

सभी संभावित इनपुट के लिए आउटपुट यहां चिपकाए गए हैं

Comments

"".join(l) -> 'l'[2::5]एक बाइट छोटा होता है (कोट्स को बैकटिक्स से बदलें)।

— Kade

इसके अलावा, यदि आप एक समारोह से किसी कार्यक्रम के लिए अपना दृष्टिकोण बदलने के लिए तैयार हैं, तो आप इसे 222 बाइट्स तक सीमित कर सकते हैं।

— Kade

@samgak उफ़। मेरे बुरे, विचार से मैंने प्रश्न को ठीक से पढ़ा। 2 और बाइट्स :(

— कम्मेहा

@ Vioz- बहुत बढ़िया टिप। के बारे में नहीं पता था repr। :)

— कम्मेहा

Answer 7

PHP, 278 बाइट्स

एक जानवर बल समाधान जो नेस्टेड छोरों का एक गुच्छा और कुछ परीक्षणों का उपयोग करता है।

$p=explode(',',$argv[$i=1]);for(;$i<=10;$i++)for($j=1;$j<=10;$j++)
for($k=1;$k<=10;$k++)if($j-$k)for($l=0;$l<3;$l++){$q=array_shift($p);
if($i*$q==$j*$p[0]+$k*$p[1]){$o=str_repeat('_',21);$o[10-$i]=$q;$o[10+$j]=$p[0];
$o[10+$k]=$p[1];echo($o."\n          ^\n");}array_push($p,$q);}

हमेशा की तरह, इसे एक फ़ाइल में डालें (इसे नाम दें seesaw.php), लाइनों में शामिल हों (पठनीयता के लिए यहां विभाजित करें), <?phpफ़ाइल की शुरुआत में PHP मार्कर ( ) डालें (तकनीकी रूप से, यह कार्यक्रम का हिस्सा नहीं है) और आप ' जाने के लिए अच्छा है

निष्पादन का एक उदाहरण:

$ php seesaw.php 9,2,1
_________9_2_____1___
          ^
_________9__2__1_____
          ^
_________9_1__2______
          ^
________9_____2_____1
          ^
________9______2__1__
          ^
________9_____1__2___
          ^
________9___1_____2__
          ^
_______9_________1__2
          ^
____2______9_1_______
          ^
___2_______9___1_____
          ^
__2________9_____1___
          ^
_2_________9_______1_
          ^

यह सभी समाधानों (बिना प्रतिबिंबों) को उत्पन्न और प्रदर्शित करता है, लेकिन यह डुप्लिकेट (जब इनपुट मान में डुप्लिकेट होते हैं) को पट्टी नहीं करता है।

Answer 8

जूलिया, 154 बाइट्स

f(a,b,c)=(x=replace(join(first(filter(p->p⋅[-10:-1,1:10]==0,permutations([a,b,c,zeros(Int,17)])))),"0","_");print(x[1:10]*"_"*x[11:20]*"\n"*" "^10*"^"))

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

function f(a,b,c)
    # Create a 20-element array of the input with 17 zeros
    z = [a,b,c,zeros(Int,17)]

    # Get the set of all permutations of z such that the dot product
    # of the permutation with the distances is 0
    d = filter(p -> p ⋅ [-10:-1,1:10] == 0, permutations(z))

    # Join the first element of d into a string and replace all of
    # the zeros with underscores
    x = replace(join(first(d)), "0", "_")

    # Print the output
    print(x[1:10] * "_" * x[11:20] * "\n" * " "^10 * "^")
end

Answer 9

सी, 252 (214) बाइट्स

कमांड लाइन पर तर्क के रूप में a, b, c के साथ कॉल करें।

e=48;main(_,v,x,y,z,a,b,c)char**v;{char s[]="_____________________\n          ^";x=*v[1]-e;y=*v[2]-e;z=*v[3]-e;for(a=-1;a+11;--a)for(b=-10;b-11;++b)_=a*x+b*y,!b|b==a|_%z?0:(c=-_/z,c&c<11&c>-11?s[a+10]=x+e,s[b+10]=y+e,s[c+10]=z+e,puts(s),exit(0):0);} 

यदि मुख्य को ommitted किया जा सकता है, तो बाइट काउंट एक फ़ंक्शन के लिए 214 तक गिर जाता है।

a,b,c;f(x,y,z){char s[]="_____________________\n          ^";for(a=-1;a+11;--a)for(b=-10;b-11;++b)!b|b==a|(a*x+b*y)%z?0:(c=-(a*x+b*y)/z,c&&c<11&&c>-11?s[a+10]=x+48,s[b+10]=y+48,s[c+10]=z+48,puts(s),b=10,a=-b:0);}

दोनों पहले वजन को बाईं ओर रखने की एक ही रणनीति का उपयोग करते हैं, फिर संभावित दूसरे वजन की स्थिति को स्कैन करते हैं और तीसरे वजन की गणना करते हैं। यह एक आंतरिक लूप को हटाने की अनुमति देता है।