লিভার সিমুলেটর 2015

Question

কেন একটি সিমুলেটর?

বাচ্চাদের এই দিনগুলিতে প্রকৃতপক্ষে সামঞ্জস্য রেখে শারীরিক বস্তুগুলিতে ভারসাম্য বজায় রাখতে বা স-বক্সে বাক্সগুলি স্ট্যাক করার বা খেলার জন্য সময় দেওয়ার বা উচ্চাকাঙ্ক্ষা নেই। এটি একটি লিভার সিমুলেটারের জন্য সফ্টওয়্যার বাজারে প্রচুর জায়গা ছেড়ে দেয় যা আমার মডেল অনুসারে পাগলের মতো বিক্রি করবে!

প্রোগ্রামিং সহায়তা চেয়েছিল

আমি এই জাতীয় গেমের পেটেন্ট ফাইল করেছি (মুলতুবি), তবে আমার জন্য গেম-লজিক লেখার জন্য একজন বিশেষজ্ঞ প্রোগ্রামার প্রয়োজন। আমার বোধগম্যতা থেকে, চূড়ান্ত প্রোগ্রামের বাইটের আকারের উপর ভিত্তি করে প্রোগ্রামারদের ক্ষতিপূরণ দেওয়ার জন্য এটি স্ট্যান্ডার্ড অনুশীলন । যেমন আমি এই লোভনীয় চুক্তিটি সর্বনিম্ন দরদাতাকে প্রদান করব।

সবিস্তার বিবরণী

লিভারটি বাক্স বা খালি জায়গাগুলির একটি সিরিজ যা একটি পূর্ণাঙ্গ দ্বারা ভারসাম্যপূর্ণ। প্রতিটি বাক্সে একটি নির্দিষ্ট ওজন আছে এক মাধ্যমে নয়টি এবং স্পেস কোন ওজন আছে। আপনি কি জানেন যে লিভারে একটি বাক্সের ওজন সেই বাক্যটি ফুলক্রাম থেকে কতটা দূরে তার সরাসরি আনুপাতিক। 4ফুলক্রাম থেকে তৃতীয় স্থানে থাকা ওজনের একটি বাক্স 12লিভারের সেই দিকটিতে কার্যকর ইউনিটগুলির অবদান রাখবে ।

আমার একটি প্রোগ্রাম দরকার যা একটি ইনপুট লিভার দেওয়া হলে, লিভারটি বাম, ডানদিকে পুরোপুরি সুষম হবে কিনা তা আউটপুট দেয়।

I / O নির্দেশিকা

• আপনি আমার জন্য একটি প্রোগ্রাম লিখবেন।
• ইনপুটটিতে পাঠ্যের একটি লাইন থাকবে।
• ইনপুটটি stdinএকটি কমান্ড-লাইন স্ট্রিং থেকে বা হিসাবে আসবে ।
• বক্সগুলি ' 1' মাধ্যমে ' 9' অক্ষর দ্বারা প্রতিনিধিত্ব করবে । এই অক্ষরগুলি তাদের নিজ নিজ ওজনের প্রতিনিধিত্ব করে। একটি ফাঁকা স্থান একটি স্থান দ্বারা প্রতিনিধিত্ব করা হবে ' '। ফুলক্রাম একটি ক্যারেট দ্বারা প্রতিনিধিত্ব করা হবে ' ^'।

একটি নমুনা ইনপুট লিভার দেখতে পারে: 8 2^ 941

এই লিভার পুরোপুরি ভারসাম্যযুক্ত: (4*8) + 0 + 0 + (1*2) == 0 + (2*9) + (3*4) + (4*1) == 34

• এখানে কোনও শীর্ষস্থানীয় বা পিছনে স্থান নেই। কোনও পিছনে নতুন লাইন থাকবে না।
• ত্রুটিযুক্ত ইনপুট হ্যান্ডেল করার দরকার নেই, ইনপুটটিতে সর্বদা ঠিক এক পরিপূর্ণ এবং শুধুমাত্র সংখ্যা এবং স্পেস থাকবে।
• আউটপুটটি লিভারটি বাম-ভারী, ডান-ভারী বা ভারসাম্যযুক্ত কিনা তা নির্দেশ করবে।
• আপনার প্রোগ্রামের অবশ্যই 3 টি সম্ভাব্য আউটপুট থাকতে হবে যা একটি সুগঠিত ইনপুট থেকে আসতে পারে। এগুলি কী আপনি তা চয়ন করতে পারেন।
• আউটপুটটি হয় মুদ্রিত হতে হবে stdoutবা প্রোগ্রামটির রিটার্ন কোড হতে হবে।

পরীক্ষার মামলা

এখানে আমি ব্যবহার L, R, Bমানে বাম-ভারী, ডান-ভারী, সুষম:

1. ইনপুট: 11 ^9আউটপুট:B

2. ইনপুট: 321^ 12আউটপুট:L

3. ইনপুট: 9^ 1আউটপুট:R

(কারও কাছে যদি কিছু "ট্রিকার" পরীক্ষার মামলা থাকে তবে এগুলিতে সম্পাদনা করতে নির্দ্বিধায়)

গ্রন্থ-পঁজী

অগত্যা-অনুপ্রাণিত দ্বারা নয়, তবে ভারসাম্যের ওজনের একটি সেট ভারসাম্যের সাথে সম্পর্কিত

Comments

The output must either be print to stdout or be the return code of the program.ভাল, এখন আপনি আমাকে লিনাক্সের এমন একটি বিতরণ করতে বলছেন যা প্রস্থান কোডগুলির জন্য সও-নোটেশন ব্যবহার করে।

— বিড়াল

বেশিরভাগ খেলার মাঠগুলি "অনিরাপদ" হওয়ায় এগুলি অপসারণ করা বাদ দিয়ে আমি দেখে-দেখে / টিটার-টোটারে খেলতে যাব। আমি আশা করি যে কারণে তারা কখনও দোল মুছে ফেলবে না। "বাচ্চারা এগুলি ছুঁড়ে মারতে পারে, ওহ না!"

— mbomb007

ইনপুট ফাঁকা দিক থাকতে পারে? হিসাবে হিসাবে ^16, 16^বা ^? (ধরে নিতে পারেন)

— রুনিয়াম

আহে specুকের ছিদ্র, হ্যাঁ আমি ধরে নিই যে পক্ষগুলি খালি থাকতে পারে

— টারবুলেন্সটো

আমি মাত্র অনেক দীর্ঘ সেকেন্ড সময় নিয়ে ভাবছিলাম যে 11 বা অফসেটটি 3 বা 4 দ্বারা 9 টি অফসেট 1 দিয়ে কীভাবে ভারসাম্য বজায় রাখা যায়

— জেমস থর্প

Answer 1

পাইথন 2, 69 বাইট

lambda s:cmp(sum(ord(c)%16*(i-s.find('^'))for i,c in enumerate(s)),0)

ord(c)%16স্থানটি 0 পাওয়ার সময় মডুলাস একটি অঙ্কের অক্ষরের মান বের করে। প্রতিটি চরিত্রের জন্য, এর টর্কের অবদানটিকে পিটটির সাথে স্বাক্ষরিত দূরত্বের ওজনের গুণ হিসাবে গণনা করা হয় i-s.find('^')এবং এগুলি সংক্ষিপ্ত করে এবং 0 এর সাথে তুলনা করা হয়, যার একটি তৈরি করে -1,0,1। চরিত্রটি ^ওজন 14 হিসাবে গণনা করা হয়েছে, তবে এটি মুভির উপর কারণ কিছু যায় আসে না।

একটি 18-বাইট Pyth বন্দর Maltysen দ্বারা:

._s.e*-kxz\^%Cb16z

পাইথন কোডের জন্য যদি কোনও পূর্ণ প্রোগ্রাম প্রয়োজন হয় তবে এখানে here৯ বাইট রয়েছে। ধারণাটি হ'ল সূচকটি iস্থানান্তরিত করা শুরু করবে s.find('^')এবং এটি গণনা করবে।

s=raw_input()
t=0;i=s.find('^')
for c in s:t-=ord(c)%16*i;i-=1
print cmp(t,0)

Comments

আপনার পদ্ধতিটি ব্যবহার করে এখানে একটি পাইথ প্রোগ্রাম রয়েছে যা আপনি যদি পাইথ.হেরোকুয়াপ . com/… 18 বাইট চান তবে পোস্ট করতে পারেন । এটি নিজে পোস্ট করা সম্পর্কে ঠিক মনে হয়নি।

— মালটিসেন

@ মাল্টেসেন ধন্যবাদ, আমি এটি অন্তর্ভুক্ত করেছি।

— xnor

Answer 2

জাভাস্ক্রিপ্ট ES6, 62 বাইট

s=>Math.sign([...s].reduce((p,c,i)=>p+~~c*(i-s.indexOf`^`),0))

• -1 যদি বাম ভারী হয়
• 0 সুষম হলে
• 1 যদি ডান ভারী হয়

Ungolfed:

s=>
  Math.sign(                     // output sign of weight of lever
    [...s].reduce((p,c,i)=>      // split and reduce input
      p+~~c*(i-s.indexOf`^`),0)) // add weights of all elements
                                 //   (elements left of pivot are negatively weighted)

টেস্ট রান (বেনাম ফাংশন নির্ধারণ f):

>> f("11   ^9")
<< 0

>> f("321^  12")
<< -1

>> f("9^         1")
<< 1

---

• -11 বাইট: থেকে আউটপুট পরিবর্তিত R B Lহয়েছে-1 0 1
• -৩ বাইট: এ পরিবর্তন e.split``হয়েছে [...e](ধন্যবাদ @ ভিও)
• -৩৩ বাইট: পিভটে বিভাজনের পরিবর্তে নেতিবাচক ওজন ব্যবহার করতে অ্যালগরিদম পরিবর্তিত হয়েছে
• -9 বাইট: মুছে ফেলা পিভট চেক (দৃশ্যত, ~~'^'মূল্যায়ন 0...)
• -২ বাইট: ফাংশনটি বেনামে তৈরি করা হয়েছে (ধন্যবাদ @ সিও-ওবি)

Comments

এটি সাধারণ sensকমত্য যে আপনি অগ্রণীটিকে বাদ দিতে f=এবং বলতে পারেন যে এটি একটি বেনাম ফাংশন উত্পন্ন করে। (-2 বাইট এফওয়াইআই)

— কনর ও'ব্রায়েন

Answer 3

জাপট , 22 বাইট

Japt একটি সংক্ষিপ্ত সংস্করণ জা vaScri পর্তুগীজ ভাষায় । অনুবাদক

U¬r@X+~~Y*(Z-Ub'^),0 g

এর -1জন্য L, 0জন্য Bএবং এর 1জন্য প্রদান করে R।

কিভাবে এটা কাজ করে

Uq r@X+~~Y*(Z-Ub'^),0 g
                         // Implicit: U = input string
Uq r@              ,0    // Reduce the input by this function, starting at 0:
     X+~~Y*              //  Return the previous value, plus the current value times
           (Z-Ub'^)      //   the current index minus the index of "^" in U.
                      g  // Take the sign of the resulting number.
                         // Implicit: output last expression

Answer 4

এপিএল, 39 30 বাইট

{×+/(10|⍵⍳⍨∊⍕¨⍳9)×(⍳⍴⍵)-⍵⍳'^'}

নিয়মগুলি পুনরায় পড়ার পরে আমি এটিকে নয়টি বাইট সংরক্ষণের -1 0 1পরিবর্তে আউটপুটে পরিবর্তন করেছি L B R।

এখানে চেষ্টা করুন ।

Answer 5

পাইথ, 20 বাইট

._s*V-Rxz\^Uzm.xsd0z

পরীক্ষা স্যুট

-1বাম পক্ষপাতদুষ্ট, 0ভারসাম্যের 1জন্য, ডান পক্ষপাতদুষ্টের জন্য।

কিভাবে এটা কাজ করে:

._s*V-Rxz\^Uzm.xsd0z
                        z = input()
                        Weights:
             m     z    Map over z
              .x        try:
                sd           cast charater to int
                  0     except: 0
                        Lever arm:
           Uz           range(len(input()))
     -Rxz\^             Subtract index of caret from each value.
   *V                   Vectorized multiplication.
  s                     Sum.
._                      Take sign and print.

Answer 6

হাস্কেল, 116 96 82 76 বাইট

 f x=signum$sum$zipWith(*)[-length(fst$span(<'^')x)..]$(`mod`16).fromEnum<$>x

আউটপুটটি 0ভারসাম্যপূর্ণ, -1বাম-ভারী এবং 1ডান-ভারী জন্য।

ব্যবহারের উদাহরণ: f "321^ 12"->-1

এটি কীভাবে কাজ করে: এর আগে অংশটি সন্ধান করুন ^। ইনপুট স্ট্রিং এবং শুরু হওয়া ওজনের তালিকার গুণকে - length-of-first-part। এর ^ওজন 0 রয়েছে এবং যোগফলটি যোগ করে না। অঙ্কগুলি / স্পেসগুলি পূর্ণসংখ্যার মানগুলিতে রূপান্তর করতে আমি @ xnor এর 16 টি কৌশল ব্যবহার করছি । যোগফলটি negativeণাত্মক (ধনাত্মক) হলে, লিভারটি বাম-ভারী (ডান-ভারী) হয় এবং যোগফল 0 হলে ভারসাম্যপূর্ণ হয়।

Answer 7

টিস্ক্রিপ্ট , 23 বাইট 25

আমি একটি পাইথ উত্তর লেখার চেষ্টা করেছি তবে তা মারাত্মকভাবে চলেছে: \

$²xd»l+~~i*(a-xi`^`),0©

এটি ²জায়গা থেকে খুব অবিচ্ছিন্ন দেখায় তবে এটি 1 বাইট সাশ্রয় করে, তাই আমি এটি রাখব।

এটি অনলাইন চেষ্টা করুন!

সমস্ত ক্ষেত্রে পরীক্ষা

আউটপুট স্কিমের জন্য আমি নির্বাচন করেছি:

• -1বামটি যদি ডান ( L) এর চেয়ে বেশি ভারী হয়
• 0যদি বামটি ডান ( B) এর মত ভারী হয়
• 1বামটি ডান ( R) এর চেয়ে কম ভারী

অবহেলিত ও & ব্যাখ্যা

এটি মানচিত্র ব্যবহার করে এবং কাজটি কমাতে হ্রাস করে।

$C(xd(#l+~~i*(a-xi`^`),0))

              // Implicit: x = input
$C(           // Compare...
  xd(#        // Reduce...
    l+          // Pending weight...
    ~~i         // Current weight -> int times...
    (a-         // Total length minus...
    xi`^`       // Fulcrum location
  ,0)
)             // Implicit: Output result

Answer 8

পিবি , 349 329 বাইট

^w[B!94]{>}w[B!0]{vb[T]^t[T+1]>}vb[46]<w[B!0]{<}b[1]vvb[46]^^t[X]w[X!0]{<b[T-X]}^w[B!0]{w[B=32]{b[48]}>}w[X!0]{<t[B-48]vb[B*T]^}w[B!0]{vt[B]vb[1]>^w[B!46]{>}vvb[B+T]^w[B=0]{<}b[0]^b[0]^>}vb[0]vvt[B]<w[B!0]{<}t[B+T]^>[T]w[X!0]{b[10]<}<[T]w[X!0]{b[16]>}vw[B=0]{>}t[B]b[0]w[B=0]{>}t[T-B]b[0]^<[X-T]t[B]<[X]>w[B!0]{b[0]>}<[X]^b[T+66]

এটি একটি কৌতুকপূর্ণ ছিল। পিবি এই ধরণের জিনিস ভাল হতে ডিজাইন করা হয়নি। এমনকি এর গুণনও হয় না । কিন্তু ওহে, এটা কাজ করে।

এড। দ্রষ্টব্য: আমি কি বলেছিলাম pb এর কোন গুণ নেই? কি? পিবি অবশ্যই স্পষ্টভাবে গুণ আছে। আমি এই ভাষাটি ডিজাইন করেছি এবং প্রয়োগ করেছি, আমার জানা উচিত এটির মধ্যে বহুগুণ তৈরি হয়েছে এবং আমাকে কিছু নির্বোধ লুপযুক্ত সংযোজন করতে হবে না। এটি স্থির করা (পাশাপাশি এখন কিছু সৃজনশীল পুনর্বিন্যাসের ফলে আমি [প্রায় আক্ষরিক] একটি ভিন্ন কোণ থেকে সমস্যার সেই অংশটির কাছে যেতে পারি) আমার 20 বাইট সংরক্ষণ করে। বিব্রতকর।

সবচেয়ে শক্তিশালী অংশটি ছিল, প্রতিটি পক্ষের জন্য (ওজন * দূরত্ব) এর যোগফল পাওয়ার পরে আসলে কোন অক্ষরটি প্রিন্ট করা হবে তা নির্ধারণ করে। পিবি >বা <অপারেটর নেই, শুধু ==এবং !=। কোন মানটি আরও বড় তা বলার সহজ উপায় নেই। আমি 0 এর সাথে বিয়োগ ও তুলনাও করতে পারি না ... যদি না আমি সত্যিই নির্বোধ কিছু করি।

• দুটি যোগফলের যোগফলটি সন্ধান করুন।
• এমন কোনও লাইনে যা কোনও কিছুর জন্য ব্যবহৃত হচ্ছে না, ডানদিকে যান।
• এক্স = 0 এ পৌঁছা পর্যন্ত, বাম দিকে যান এবং 'এল' রাখুন।
• এক্স = 0 এ একটি 'বি' রাখুন।
• দুটি যোগফলের যোগফল বামে যান।
• এক্স = 0 এ পৌঁছা পর্যন্ত ডানদিকে যান এবং 'আর' রাখুন।

তারপরে, আপনি কেবল এক্স = (বাম দিকে - ডান দিকে) যান, এবং আপনার উত্তর আছে! পরিষ্কার করার জন্য সেই লাইনের সমস্ত কিছু মুছুন এবং তারপরে (0, 0) পাওয়া গিয়েছিল মুদ্রণ করুন।

... তবে কিছুটা ছোট পথ আছে। 'এল', 'বি' এবং 'আর' ব্যবহার না করে সেই মানগুলি - 'বি' ব্যবহার করুন এবং প্রিন্ট করার সময় 'বি' যুক্ত করুন। এইভাবে, আপনাকে কখনই এক্স = 0 এ 'বি' স্থাপন করতে হবে না, আপনি এটি ইতিমধ্যে 0 হিসাবে রেখে গেছেন। একমাত্র সমস্যাটি হ'ল একবার আপনি এটি করেন, প্রোগ্রামটি ওয়াচ মোডে খুব বোকা হয়ে যায়। 'L'-'B'==76-66==10=='\n'। সমস্ত কিছু ঠিকঠাক হয়ে গেছে বলে মনে হচ্ছে, যতক্ষণ না হঠাৎ করেই বিশাল সংখ্যক নিউলাইনগুলি মুদ্রিত হয় এবং কী চলছে সে সম্পর্কে নজর রাখা অসম্ভব: ডিবি পিবিআইয়ের নিয়মিত এক্সিকিউশন মোডে, সবকিছু ঠিকঠাক কাজ করে কারণ কোনও কিছু মুদ্রিত হওয়ার আগেই নিউলাইনগুলি মুছে ফেলা হয় কনসোল।

^w[B!94]{>}                 # Find the fulcrum

w[B!0]{                     # Starting at the fulcrum and going right:
    vb[T]^                    # Store the T below each character of input
    t[T+1]                    # Increment T
    >
}

vb[46]                      # Put a '.' at the end of the values below the input

<w[B!0]{<}                  # Go to the space below the fulcrum
b[1]                        # Put a 1 (So the fulcrum will be represented as '.' later)
vvb[46]^^                   # Put a 46 two spaces below it

t[X]                        # Store the current X value in T
w[X!0]{<                    # Until reaching the beginning of the input:
    b[T-X]                    # Put T - (the current X value) below each byte
}

^w[B!0]{                    # For each byte of input:
    w[B=32]{b[48]}            # Set spaces to '0'
    >
}

w[X!0]{<                    # For each byte of input:
    t[B-48]                   # Set T to the value of the number (fulcrum becomes '.')
    vb[B*T]^                  # Multiply the value below by T
}

# This has nothing to do with the input, except that it's the right length:
w[B!0]{                     # For every byte of input:
    v                         # Go to the value below it
    t[B]                      # Store it in T
    vb[1]>^                   # Put a flag below it
    w[B!46]{>}                # Go to the next '.' value
    vvb[B+T]                  # Add T to whatever is two spaces below the '.'
                              # This will cause the sum for the right side of
                              # the fulcrum to be 46 too high. This is why 46
                              # was left below the fulcrum earlier: both sums
                              # will be off by the same amount.
    ^w[B=0]{<}                # Go back to the flag
    b[0]^b[0]                 # Erase the flag and the value above it
    ^>
}

vb[0]                       # Erase the stray '.'
vvt[B]<w[B!0]{<}t[B+T]      # Get the sum of the two sums
^>[T]                       # Go right that far
w[X!0]{b[10]<}              # Head back to X=0, leaving 'L'-'B' the whole way
<[T]                        # Go left the same amount as before
w[X!0]{b[16]>}              # Head back to X=0, leaving 'R'-'B' the whole way
vw[B=0]{>}                  # Find the sum from left of the fulcrum
t[B]b[0]                    # Save it to T and erase it from the canvas
w[B=0]{>}                   # Find the other sum
t[T-B]b[0]                  # Subtract it from T and erase it from the canvas
^<[X-T]                     # On the line that was just prepared, go to X=T
t[B]                        # Save the value of that space to T
<[X]>w[B!0]{b[0]>}          # Erase the entire visible part of that line
<[X]^b[T+66]                # Print (the value read from that line)+'B' at (0, 0)

Comments

পাগল হয়ে যাওয়া কোনও মানুষের বংশোদ্ভূত দেখার মতো।

— Kzqai

Answer 9

পার্ল 5, 72 বাইট

@_=split//,<>;($i)=grep$_[$_]eq'^',0..@_;$j+=$_*($k++-$i)for@_;say$j<=>0

Answer 10

ম্যাটল্যাব 91, 57, 55 অক্টোব, 50 বাইট

আমি এটি আর গল্ফের আশা করিনি, তবে অক্টাভে স্যুইচিংয়ের ফলে 5 টি অতিরিক্ত বাইট সংরক্ষণ করা সম্ভব হয়েছে! বাহ, এই সময় নিল ...

@(x)(s=mod(+x,16))*[1-(i=find(s>9)):nnz(x)-i]'*inf 

এটা তোলে আউটপুট -Inf, NaN, Infজন্য L, B, Rযথাক্রমে।

পরীক্ষা স্যুট!

ব্যাখ্যা:

এটি অবশ্যই একটি হার্ড-টু-পঠিত কোড, তবে আমি যথাসাধ্য ব্যাখ্যা করার চেষ্টা করব। আমি কোড ব্লক ব্যাখ্যা এবং পাঠ্যের মধ্যে স্যুইচ করব।

@(x)                 % Anonymous function that takes a string x as input
           +x        % Convert the string into a numeric array, 
                     % where each character is represented by its ASCII-value
       mod(+x,16)    % Takes this string modulus 16, to make spaces (ASCII 32) equal 0 
    (s=mod(+x,16))   % Assigns this numeric array to s, thanks to Octave's awesome 
                     % inline variable assignment possibility
    (s=mod(+x,16))*  % Multiply s by the vector inside the brackets    

বন্ধনীগুলির ভিতরে কী চলছে তা দেখুন:

[1-(i=find(s>9)):nnz(x)-i]
      find(s>9)             % The only value in the vector s that's larger than 9, 
                            % after the modulus is ^, (it's now 14)             
   (i=find(s>9))            % Assign the position of `^` to the index variable i

এটি একটি সামান্য কৌশল:

[1-(i=find(s>9)):nnz(x)-i]

মইয়ের প্রতিটি পাশের নম্বরগুলি অবশ্যই ক্যারেট থেকে দূরত্ব দিয়ে গুণ করতে হবে। আমরা যদি বাম দিকে নেতিবাচক সংখ্যা এবং ডান দিকের ধনাত্মক সংখ্যা ব্যবহার করি তবে আমরা কোন দিকটি সবচেয়ে ভারী তা দেখতে কেবল ভেক্টরটির যোগফল দিতে পারি।

ধরুন ইনপুট স্ট্রিং: '321^ 12'। আমরা নিম্নলিখিত চাই : 3*(-3)+2*(-2)+1*(-1)+1*3+2*4. বন্ধনীগুলির ভিতরে আমরা তৈরি ভেক্টরটি শুরু হয় 1-i, যা এই ক্ষেত্রে -3, কারণ ক্যারেটটি চতুর্থ অবস্থানে রয়েছে। এটি nnz(x)-iএকের ইনক্রিমেন্টে যায় । এর nnz(x)পরিবর্তে আমরা ব্যবহার করতে পারি numel(s), কারণ xএটি একটি স্ট্রিং যার শূন্য নেই।

অতএব:

[1-(i=find(s>9)):nnz(x)-i]
ans =
  -3  -2  -1   0   1   2   3   4

এখন, আমরা উপাদান-ভিত্তিক গুণ করতে পারি s.*[...], এবং এর যোগফল নিতে পারি। কিন্তু, যেহেতু আমরা দুই ভেক্টর আছে, আমরা এটি করতে পারেন mutliply sদ্বারা পক্ষান্তরিত [...]এবং ম্যাট্রিক্স গুণ ব্যবহার সমষ্টি নিরূপণ:

(s=mod(+x,16))*[1-(i=find(s>9)):nnz(x)-i]'

এটি আমাদের হয় একটি নেতিবাচক সংখ্যা দেয় যার অর্থ বাম দিকটি ভারী, শূন্য, যার অর্থ এটি ভারসাম্যযুক্ত, বা একটি ধনাত্মক সংখ্যা, যার অর্থ ডান দিকটি ভারী। এর নিষ্পাপ দৃষ্টিভঙ্গিটি ব্যবহার না করে sign(...), আমরা এটিকে দ্বারা গুণ করি inf, যা আমাদের যথাক্রমে -Infবা Infবাম এবং ডানদিকে দেবে। আমরা পেতে NaNজন্য 0*inf, যেহেতু এটি undefined হচ্ছে।

এটি আমাদের তিনটি সম্ভাব্য ফলাফলের জন্য তিনটি স্বতন্ত্র মান দেয়।

Answer 11

22, 22 চর / 38 বাইট

МŴ⟬ïĊ⇀$+˜_*(ã-ïÿ⍘^),0⸩

Try it here (Firefox only).

Comments

-1 এটি বাইট গণনা নয়, চর গণনার জন্য অনুকূল করছে

— মেগো

@ মেগো এর জন্যই built নির্মিত হয়েছিল।

— মামা ফান রোল

এটি যার জন্য নির্মিত হয়েছিল তা নির্বিশেষে স্কোরিং বাইটে রয়েছে।

— মেগো

আমি বুঝতে পারি যে.

— মামা ফান রোল

Answer 12

জাভাস্ক্রিপ্ট, 146 বাইট

s=>{a=[0,0];d=s.split`^`;for(j=0;j<2;j++)for(i=0;i<d[j].length;i++)a[j]+=d[j][i]*(j==0?d[j].length-i:i+1);alert(a[0]==a[1]?'B':a[0]>a[1]?'L':'R')}

বেশ বিশাল।

ডেমো ।

Comments

আপনি ES6 ব্যবহার করে বেশ কয়েকটি বাইট সংরক্ষণ করতে পারেন। পুরো function t(s){হতে পারে t=>{এবং split('^')হতে পারেsplit`^`

— Downgoat

@ Vɪʜᴀɴ আপনি সম্ভবত s => mean বলতে চাইছেন?

— নিকেল

ওহ হ্যাঁ, দুঃখিত, এটাই আমি বোঝাতে

— চাইছিলাম

@Ypnypn -6 অক্ষর :)

— নিকেল

Answer 13

রুবি, 111 108 বাইট

->s{l,r=s.split'^';v=->x{x.chars.map.with_index{|c,i|c.to_i*(i+1)}.reduce:+};%w(B L R)[v[l.reverse]<=>v[r]]}

ব্যাখ্যা

প্রতিটি পাশের প্রতিটি সংখ্যার ওজনের মান যোগ করে। তারপরে এটি রুবি স্পেসশিপ অপারেটরটিকে উভয় পক্ষের সমতা / অসমতাটির 1,0, -1 সরবরাহ করতে ব্যবহার করে, যা সঠিক আউটপুট সহ একটি অ্যারের সূচক।

Answer 14

পাওয়ারশেল, 83 73 বাইট

param($b)$i=-$b.indexOf('^');[char[]]$b|%{$x+=$i++*"$_"};[math]::Sign($x)

গল্ফ জন্য TessellatingHeckler ধন্যবাদ ।

নীচের পুরানো কোড হিসাবে মূলত একই অ্যালগরিদম ব্যবহার করে তবে এখানে আমরা ইনডেক্স স্ট্রিংয়ের অক্ষরগুলির মাধ্যমে সূচকগুলির মাধ্যমে পুনরাবৃত্তির পরিবর্তে একবারে পুনরাবৃত্তি করি যা মুষ্টিমেয় বাইটগুলি সংরক্ষণ করে। অ্যালগোরিদম পৌঁছালে এখনও একই দর্শনীয় ত্রুটি বার্তাটি ছুঁড়ে দেয় ^- STDOUT কে প্রভাবিত করে না।

---

আগে

param($a)1..$a.length|%{$x+=+"$($a[$_-1])"*($_-$a.indexof('^')-1)};[math]::Sign($x)

ডেনড্রোবিয়ামের দুর্দান্ত উত্তরের মতো একই দুর্দান্ত অ্যালগরিদম ব্যবহার করে এবং এভাবে -1 / 0 / 1যদি ইনপুট থাকে তবে একই আউটপুট ব্যবহার করে left-heavy / balanced / right-heavy।

বিতৃষ্ণা। পাওয়ারশেলের রয়েছে একটি কাস্টিং কিরক বৈশিষ্ট্যের কারণে দীর্ঘ । এখানে বেশিরভাগ প্রাসঙ্গিক হ'ল ফাংশনগুলি charদ্বারা কীভাবে গুণিত হয় int। stringকোনও charবস্তুর ফলাফলের অ্যারে-সূচক নেওয়া । পাওয়ারশেল charগুণিতকরণের আগে এর সম্পর্কিত ASCII মানকে (আক্ষরিক মানের চেয়ে) রূপান্তর করে । সুতরাং, $a='012'[0];[int]$a*2ফলাফল মত কিছু 96।

এর অর্থ আমাদের এটি আবার স্ট্রিং হিসাবে পুনরায় কাস্ট করা প্রয়োজন। যাইহোক, কেবল stringবার করা intআমাদের stringবারবার বারবার দেয় । উদাহরণস্বরূপ, $a='0';$a*2ফলাফল হবে 00।

এর অর্থ এটি পুনরায় কাস্টিংয়ের আগে charহিসাবে আমাদের পিছনে পিছনে ফেলে দিতে হবে , তারপরে আমাদের সংযোজকটিতে যোগ করার আগেই গুণটি ঘটতে পারে ।stringint$x

একটি স্ট্রিং দিয়ে পুনরাবৃত্তি করার দীর্ঘ পথের সাথে এই দম্পতি এবং সাইন আউটপুট নেওয়ার জন্য .NET কল করুন এবং আমরা একটি দীর্ঘ দীর্ঘ কোড পেয়েছি।

_{এনবি - ^স্ট্রিংয়ে পৌঁছালে এটি দর্শনীয় ত্রুটি ছুঁড়ে ফেলবে , উল্লেখ করে যে এটি এটিকে রূপান্তর করতে পারে না int। STDOUT প্রভাবিত করে না।}

Comments

আমার param($b)$i=-$b.indexOf('^');[char[]]$b|%{$x+=$i++*+"$_"};[math]::Sign($x)কাছে 74 বাইট আছে এটি দীর্ঘ সময় নিয়েছে এবং বেশ কয়েকটি পদ্ধতির চেষ্টা করেছে। গণিত :: চিহ্নটি এত দীর্ঘ দেখাচ্ছে, তবে আমি সেই বিটটি উন্নত করার কোনও উপায় দেখতে পাচ্ছি না।

— টেসেল্ল্যাটিংহেকলারের

@ টেসেল্লাটিংহেকলার অবশ্যই, সূচকগুলির চেয়ে চরিত্রগুলি দিয়ে নিজেরাই পুনরাবৃত্তি করুন ... তা বোঝা যায়! আমি পাওয়ারশেলের অন্তর্নিহিত ingালাইটি ব্যবহার করে একটি অতিরিক্ত বাইট গল্ফ করলাম যদি কোন int হয় $i++*+"$_"to $i++*"$_"$i

— অ্যাডমবর্কবার্ক

Answer 15

সিজেম, 29 বাইট

l_'^#\"^ "'0er'0f-_,,@fm.*:+g

এটি অনলাইনে চেষ্টা করুন

ফলাফলটি -1বাম-ভারী, 0ভারসাম্যের 1জন্য, ডান-ভারী জন্য।

এটি কিছুটা দীর্ঘ মনে হয়েছিল, তবে আমি বিকল্পগুলির একটি গুচ্ছ চেষ্টা করেছিলাম এবং সেগুলি 29 এবং 33 বাইটের মধ্যে শেষ হয়েছিল। একটি সমস্যা হ'ল আমি স্ট্রিংগুলিকে মানগুলিতে রূপান্তর করার কোনও উপায় খুঁজে পাইনি যা স্পেসগুলির জন্য স্বয়ংক্রিয়ভাবে 0-এ আসে result সুতরাং আমি স্পষ্টভাবে স্পেসটি '0 টি অক্ষর দ্বারা প্রতিস্থাপন করে শেষ করেছি যা স্পষ্টতই কোডটির দৈর্ঘ্যে যোগ করে।

বিকল্প চেষ্টা করা হয়েছে:

• স্ট্রিংটি '^ এ বিভক্ত করা, প্রথম একটিকে বিপরীত করে এবং তারপরে উভয়ের জন্য ওজনযুক্ত মান গণনা করা।
• eeঅপারেটরটি ব্যবহার করে মানগুলির তালিকাকে সূচক যুক্ত করতে।
• প্রতিটি সূচক থেকে ক্যারেটের অবস্থান বিয়োগের পরিবর্তে বিয়োগফলকে বিয়োগ ছাড়াই গণনা করুন এবং তারপরে ফলাফল থেকে স্ট্রিংয়ের দৈর্ঘ্যের বিয়োগফলকে বিয়োগ করুন।

ব্যাখ্যা:

l         Get input.
_'^#      Copy and find caret position.
\         Swap input back to top.
"^ "'0er  Replace caret and spaces with '0.
'0f-      Subtract '0 from all characters, to get integer values.
_,,       Build index array with same length.
@         Rotate caret position to top.
fm        Subtract it from all indices.
.*        Calculate element wise product of two vectors.
:+        Add up the element products to get dot product.
g         Signum.

Answer 16

পাইথন 3, 196 114 বাইট

r=0
I=list(input())
p=I.index("^")
i=0
for E in I:
 if E.isdigit():r+=int(E)*(p-i)
 i+=1
print('BLR'[(r>0)-(r<0)])

নিয়মিত কোড:

total = 0

inp=list(input())
ful_index=inp.index("^")

i=0
for num in inp:
    if num.isdigit(): total += int(num) * (ful_index - i)
    i+=1

print('BLR'[(total>0)-(total<0)])

ব্যাখ্যা:

1. থেকে পূর্ণসংখ্যার একটি তালিকা তৈরি করে stdin।
2. প্রতিটি সংখ্যার জন্য, পূর্ণতম সংখ্যার থেকে সংখ্যাটি চলকটিতে মোটের সাথে দূরত্ব যুক্ত করে (বাম দিকে সংখ্যাগুলি নেতিবাচক হবে এবং ডানে সংখ্যাগুলি ধনাত্মক হবে)।
3. ফলাফলের উপর নির্ভর করে সঠিক অক্ষর মুদ্রণ করে (বি সমান হলে, শূন্যের চেয়ে বেশি এল, এবং শূন্যের চেয়ে কম হলে আর)।

@ থমাসকওয়া কে 82 বাইট (40% এর বেশি) ছাঁটাই করার জন্য বিশাল ধন্যবাদ!

Comments

একটি সহজ 15 বা তাই বাইট: print('LBR'[(B>D)-(B<D)])শেষের জন্য এবং B=D=0শুরুতে ব্যবহার করুন।

— lirtosiast

না, আরও ভাল: বাম এবং ডানদিকে আলাদাভাবে নজর রাখবেন না; পরিবর্তে এর বাম সংখ্যার জন্য নেতিবাচক দূরত্ব দিয়ে গুণ করুন ^। এটি আপনাকেও বাঁচায় abs()।

— lirtosiast

Answer 17

সি, 140 139 138 134 100 বাইট

ফেরত দিন:

• 1 = বাম
• 2 = ভারসাম্যহীন
• 0 = ডানদিকে

k;main(int x,char**a){char*n=a[1],*g=n;for(;*n^94;++n);for(;*g;++g)k+=(*g&15)*(n-g);return!k?2:k>0;}

চালান:

./see-saw "11   ^9"
echo $?
2

আমাদের যেমন ASCII রয়েছে:

SPACE = 0x20
    0 = 0x30 ... 9 = 0x39

আমরা পেতে:

0x20 & 0x0f = 0
0x30 & 0x0f = 0
0x31 & 0x0f = 1
0x32 & 0x0f = 2
... etc.

তারপরে গুণকের দূরত্ব অনুসারে যোগফল ^।

Answer 18

স্পেসবিএএস - 140 বাইট

1 INPUT b$: LET t=0,p=POS("^",b$),l$="RBL"
2 FOR i=1 TO LEN b$
3 IF b$(i) IN ["1" TO "9"] THEN INC t,(p-i)*VAL b$(i)
4 NEXT i
5 TEXT l$(2+SGN t)

tচলমান মোট, মানগুলি নেতিবাচক হয় যখন ক্যারেট অবস্থানের চেয়ে অক্ষরের অবস্থান বেশি হয়। শেষে এটি দেখতে পায় যে মোটটি নেতিবাচক, শূন্য বা ধনাত্মক কিনা এবং আর, বি বা এল এর সংশ্লিষ্ট চরিত্রটি মুদ্রণ করে

আমি অন্যান্য উত্তরগুলির মতো কেবল -1, 0 বা 1 আউটপুট করে কয়েক বাইট বন্ধ করতে পারি।

Answer 19

জাভা, 83 বাইট

l->{int s=0,l=0;for(char c:l)if(l<1)s-=c-48;else s+=c-48;return s<0?-1:(s>0?1:0));}