ทำไมต้องเป็น Simulator?

เด็ก ๆ ในทุกวันนี้ไม่มีเวลาหรือความทะเยอทะยานที่จะไปและสแต็คกล่องที่เห็นหรือเล่นด้วยการปรับสมดุลวัตถุทางกายภาพ ทำให้เหลือพื้นที่มากมายในตลาดซอฟต์แวร์สำหรับ Lever Simulator ซึ่งตามโมเดลของฉันจะขายอย่างบ้าคลั่ง!

ต้องการความช่วยเหลือในการเขียนโปรแกรม

ฉันได้ยื่นสิทธิบัตรสำหรับเกมดังกล่าว (รอดำเนินการ) แต่ต้องการโปรแกรมเมอร์ผู้เชี่ยวชาญเพื่อเขียนเกมตรรกะสำหรับฉัน จากความเข้าใจของฉันมันเป็นวิธีปฏิบัติมาตรฐานในการชดเชยโปรแกรมเมอร์ตามขนาดของไบต์ของโปรแกรมสุดท้าย เช่นนี้ฉันจะทำการตัดสินสัญญาที่มีกำไรนี้ให้กับผู้ประมูลที่ต่ำที่สุด

สเปค

คันโยกเป็นชุดของกล่องหรือช่องว่างที่สมดุลกับศูนย์กลาง แต่ละกล่องมีน้ำหนักหนึ่งถึงเก้าและช่องว่างไม่มีน้ำหนัก อย่างที่คุณทราบน้ำหนักของกล่องบนคันโยกนั้นเป็นสัดส่วนโดยตรงกับความกว้างของกล่องนั้นจากศูนย์กลาง กล่องน้ำหนัก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

(หากใครมีกรณีทดสอบ "หลอกลวง" บางอย่างคุณสามารถแก้ไขได้)

บรรณานุกรม

ไม่จำเป็นต้องเป็นแรงบันดาลใจ แต่เกี่ยวข้องกับการถ่วงน้ำหนักชุดบนกระดานหก

Python 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 แต่นั่นไม่สำคัญเพราะมันอยู่บนเดือย

พอร์ต Pyth 18 ไบต์โดย Maltysen:

._s.e*-kxz\^%Cb16z

สำหรับรหัส Python ถ้าจำเป็นต้องใช้โปรแกรมแบบเต็มนี่คือ 79 ไบต์ ความคิดคือการเริ่มต้นดัชนี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)

Javascript 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
• -3 ไบต์:เปลี่ยนe.split``เป็น[...e](ขอบคุณ @ Vɪʜᴀɴ)
• -33 ไบต์:อัลกอริทึมที่เปลี่ยนแปลงเพื่อใช้น้ำหนักเชิงลบมากกว่าการแยกที่ pivot
• -9 ไบต์:ลบการตรวจสอบ pivot (เห็นได้ชัดว่า~~'^'ประเมินเป็น0... )
• -2 ไบต์:ทำให้ฟังก์ชั่นที่ไม่ระบุชื่อ (ขอบคุณ @ cᴏɴᴏʀ-obʀɪᴇɴ)

Japt , 22 ไบต์

Japtเป็นรุ่นสั้นJa vaScri พอยต์ ล่าม

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

ผลตอบแทน-1สำหรับL, 0สำหรับB, และสำหรับ1R

มันทำงานอย่างไร

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

APL, 39 30 ไบต์

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

หลังจากอ่านกฎใหม่ฉันได้เปลี่ยนสิ่งนี้เป็นเอาท์พุท-1 0 1แทนที่จะL B Rบันทึกเก้าไบต์

ลองมันนี่

Pyth, 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.

Haskell, 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 และไม่เพิ่มทุน ฉันใช้เคล็ดลับ mod @ @ xnor ของการแปลงตัวเลข / ช่องว่างเป็นค่าจำนวนเต็ม หากผลรวมเป็นลบ (บวก) คันโยกจะหนักไปทางซ้าย (หนักขวา) และสมดุลถ้าผลรวมเป็น 0

TeaScript , 23 ไบต์ 25

ฉันพยายามเขียนคำตอบของ Pyth แต่มันน่ากลัวมาก: \

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

มัน²ดูนอกสถานที่ แต่มันช่วยประหยัด 1 ไบต์ดังนั้นฉันจะเก็บมันไว้

ลองออนไลน์!

ทดสอบทุกกรณี

สำหรับรูปแบบผลลัพธ์ที่ฉันได้เลือก:

• -1ถ้าซ้ายหนักกว่าขวา ( L)
• 0ถ้า Left หนักพอ ๆ กับ Right ( B)
• 1ซ้ายหนักน้อยกว่าขวา ( R)

Ungolfed && คำอธิบาย

สิ่งนี้ใช้แผนที่และลดเพื่อให้งานเสร็จ

$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

pb , 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 ไม่ได้ถูกออกแบบมาให้เก่งในเรื่องแบบนี้ มันไม่ได้มีการคูณ แต่เดี๋ยวก่อนมันใช้ได้

เอ็ด หมายเหตุ:ฉันแค่บอกว่า pb ไม่มีการคูณหรือไม่? อะไร? pb แน่นอนว่ามีการคูณ ฉันออกแบบและใช้ภาษานี้ฉันควรรู้ว่ามันมีการคูณในตัวและฉันไม่ต้องทำอะไรเพิ่มเติมนอกจากนี้ แก้ไขสิ่งนั้น (รวมถึงการจัดเรียงโฆษณาใหม่ในตอนนี้ซึ่งฉันสามารถเข้าใกล้ส่วนนั้นของปัญหาจาก [มุมที่แตกต่างกันเกือบจะ]) ช่วยฉัน 20 ไบต์ น่าอาย.

ส่วนที่ยากที่สุดคือหลังจากได้รับผลรวมของ (น้ำหนัก * ระยะทาง) สำหรับแต่ละด้านจริง ๆ แล้วกำหนดจดหมายที่จะพิมพ์ PB ไม่ได้>หรือ<ผู้ประกอบการเพียงและ== !=ไม่มีวิธีง่ายๆที่จะบอกว่าค่าใดมีขนาดใหญ่กว่า ฉันไม่สามารถลบและเปรียบเทียบกับ 0 ... เว้นแต่ฉันจะทำอะไรที่โง่จริงๆ

• หาผลรวมของผลรวมทั้งสอง
• ไปไกลไปทางขวาบนบรรทัดที่ไม่ได้ใช้เพื่ออะไร
• จนกว่าจะถึง X = 0 ให้ไปทางซ้ายแล้ววาง 'L's
• วาง 'B' ที่ X = 0
• ไปทางซ้ายด้วยผลรวมของผลรวมทั้งสอง
• จนกว่าจะถึง X = 0 ไปทางขวาและวาง 'R's

จากนั้นคุณเพียงไปที่ X = (ด้านซ้าย - ด้านขวา) และมีคำตอบของคุณ! ลบทุกอย่างในบรรทัดนั้นเพื่อล้างข้อมูลแล้วพิมพ์ค่าที่พบที่ (0, 0)

... แต่มีวิธีที่สั้นกว่าเล็กน้อย แทนที่จะใช้ 'L', 'B' และ 'R' ให้ใช้ค่าเหล่านั้น - 'B' และเพิ่ม 'B' อีกครั้งเมื่อพิมพ์ ด้วยวิธีนี้คุณไม่จำเป็นต้องวาง 'B' ที่ X = 0 คุณเพียงแค่ปล่อยให้มันเป็น 0 แล้ว ปัญหาเดียวคือเมื่อคุณทำเช่นนี้โปรแกรมจะโง่มากในโหมดดู 'L'-'B'==76-66==10=='\n'. ดูเหมือนว่าทุกอย่างจะทำงานได้ดีจนกระทั่งจู่ๆมีการพิมพ์บรรทัดใหม่จำนวนมากและเป็นไปไม่ได้ที่จะติดตามว่าเกิดอะไรขึ้น: D ในโหมดการดำเนินการตามปกติของ pbi แม้ว่าทุกอย่างจะทำงานได้ดีเพราะบรรทัดใหม่จะถูกลบออกก่อน ปลอบใจ

^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)

Perl 5, 72 ไบต์

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

MATLAB 91, 57, 55 Octave, 50 bytes

ฉันไม่ได้คาดหวังว่าจะได้เล่นกอล์ฟต่อไป แต่การเปลี่ยนไปใช้ Octave ทำให้สามารถบันทึกเพิ่มได้อีก 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เนื่องจากเครื่องหมายรูปหมวกอยู่ในตำแหน่งที่ 4 มัน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เนื่องจากมันไม่ได้กำหนด

สิ่งนี้ทำให้เรามีค่าที่แตกต่างกันสามค่าสำหรับผลลัพธ์ที่เป็นไปได้ทั้งสามรายการ

𝔼𝕊𝕄𝕚𝕟, 22 ตัวอักษร / 38 ไบต์

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

Try it here (Firefox only).

จาวาสคริปต์, 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')}

ค่อนข้างใหญ่

การสาธิต

Ruby, 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]]}

คำอธิบาย

ผลรวมค่าถ่วงน้ำหนักของแต่ละหมายเลขในแต่ละด้าน จากนั้นจะใช้ตัวดำเนินการ ruby ​​spaceship เพื่อจัดเตรียมความเสมอภาค / ความไม่เท่าเทียมกันของทั้งสองฝ่ายซึ่งมีค่า 1,0, -1

PowerShell, 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 / 1left-heavy / balanced / right-heavy

ฮึ. นานเพราะคุณสมบัติการเล่นโวหารที่หล่อมี PowerShell ส่วนใหญ่ที่เกี่ยวข้องที่นี่คือวิธีการcharคูณด้วยintฟังก์ชั่น การจัดทำดัชนีอาร์เรย์ของstringผลลัพธ์ในcharวัตถุ PowerShell แปลงเป็นcharค่า ASCII ที่สอดคล้องกัน (แทนค่าตามตัวอักษร) ก่อนการคูณ ดังนั้นสิ่งที่ต้องการผลในการ$a='012'[0];[int]$a*296

นั่นหมายความว่าเราต้องนำมันกลับมาเป็นสตริงอีกครั้ง อย่างไรก็ตามการทำstringเวลาเพียงแค่intให้เราstringทำซ้ำหลายครั้ง ยกตัวอย่างเช่นจะส่งผลให้$a='0';$a*200

ซึ่งหมายความว่าเราต้องโยนcharกลับมาเป็นstringก่อนอีกครั้ง -casting เป็นแล้วคูณสามารถเกิดขึ้นก่อนที่เราจะเพิ่มมันเข้าไปสะสมของเราint$x

จับคู่กับวิธีที่มีความยาวในการวนซ้ำผ่านสตริงและการเรียก. NET เพื่อเอาท์พุทสัญญาณและเราได้รับโค้ดที่ค่อนข้างยาว

_{NB - นี้จะโยนความผิดพลาดที่งดงามเมื่อมันมาถึงในสตริงที่ระบุว่าจะไม่สามารถแปลงเป็น^ intไม่ส่งผลกระทบ STDOUT}

CJam, 29 ไบต์

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

ลองออนไลน์

ผลลัพธ์คือ-1แบบหนักซ้าย0สำหรับสมดุล1สำหรับหนักขวา

ดูเหมือนว่าจะมีความยาวเล็กน้อย แต่ฉันลองใช้ตัวเลือกมากมายและพวกมันก็จบลงระหว่าง 29 ถึง 33 ไบต์ ปัญหาหนึ่งคือฉันไม่สามารถหาวิธีแปลงสตริงเป็นค่าที่จะส่งผลเป็น 0 สำหรับช่องว่างโดยอัตโนมัติ ดังนั้นฉันจึงลงเอยด้วยการแทนที่ช่องว่างด้วย '0 ตัวอักษรซึ่งเพิ่มความยาวของรหัสอย่างชัดเจน

ลองใช้ทางเลือกอื่น:

• สตริงการแยกที่ '^, ย้อนกลับสตริงที่ 1 จากนั้นคำนวณค่าถ่วงน้ำหนักสำหรับทั้งสอง
• การใช้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.

Python 3, 196 114 bytes

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. พิมพ์ตัวอักษรที่ถูกต้องขึ้นอยู่กับผลลัพธ์ (B ถ้าเท่ากับ, L ถ้ามากกว่าศูนย์และ R ถ้าน้อยกว่าศูนย์)

ต้องขอบคุณ @ThomasKwa อย่างมากสำหรับการลดขนาด 82 ไบต์ (มากกว่า 40%)!

C, 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.

^แล้วสรุปตามระยะทางปัจจัยที่จะต้อง

SpecBAS - 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เป็นผลรวมสะสมค่าเป็นลบเมื่อตำแหน่งอักขระมากกว่าตำแหน่งกะรัต ในตอนท้ายจะเห็นว่าผลรวมเป็นลบศูนย์หรือบวกและพิมพ์อักขระที่เกี่ยวข้องของ R, B หรือ L

ฉันสามารถโกนออกได้สองสามไบต์โดยเพียงแค่แสดง -1, 0 หรือ 1 เช่นเดียวกับคำตอบอื่น ๆ

Java, 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));}