Where does the pivot belong?

Question

You will be given a positive integer as input.

The integer is the board of a seesaw.

Th integer will not have leading zeroes. You may take this input however you like.

Your task is to output the location of the pivot point of this seesaw, such that the board would balance.

A board balances if the moments on each side are equal in magnitude. A moment is calculated by multiplying the force by the distance from the pivot point. In this case, the force is equal to the digit.

For the integer 100 with a pivot point below the first 0, the moment on the left is 1x1=1. The moment on the right is 0x1=0. If the pivot point was below the second 0, the moment on the left would be 2x1=2 (because the 1 is now 2 away from the pivot).

For example, for the integer 31532 the pivot goes underneath the number 5. This is because the moments on the left are 3x2 + 1x1 = 7 and on the right the moments are 3x1 + 2x2 = 7.

The output for this integer is 3 because the pivot goes underneath the 3rd digit.

If the integer cannot be balanced, your code does not have to do anything - it can hang, error, output nothing - whatever you want.

Note that a pivot cannot go between two numbers. The pivot location must be an integer.

Test cases:

31532 -> 3
101 -> 2
231592 -> 4
8900311672 -> 5

Standard loopholes apply, this is code golf so shortest answer wins.

Answer 1

Haskell, 64 62 59 57 45 35 31 bytes

d l=sum(zipWith(*)[1..]l)/sum l

Try it online!

Answer 2

R, 66 bytes

sum(1:length(n<-strtoi(strsplit(paste(scan()),"")[[1]]))*n)/sum(n)

Try it online!

Answer 3

Jelly, 7 bytes

Dµæ.J:S

Try it online! or verify all inputs at once.

Answer 4

J, 29 bytes

[:>:@(+/%~]+/@:*i.@$)10#.inv]

Try it online!

Answer 5

Brain-Flak, 64 bytes

({({}[((((()()()){}){}){}){}]<>{})<>}<>)({()<({}[({})])>}<>)

Try it online!

60+4 bytes for the -ar flags.

Explanation

 {                                  }     for each digit in input (starting at the end)
   {}                                     get digit as ASCII code
     [((((()()()){}){}){}){}]             subtract 48 to get digit as number
  (                          <>{})<>      add to cumulative sum on second stack
(                                    <>)  push total of all cumulative sums (the sum of moments)

 {              }       while sum of moments != 0
     ({}[({})])         subtract sum of weights
  ()<          >        count the number of iterations needed
(                <>)    push onto first stack and implicitly output

Answer 6

Python 3, 66 bytes

f=lambda n,a=0,b=0,c=1:n and f(n//10,a+n%10*c,b+n%10,c+1)or c-a//b

Try it online!

Answer 7

Brachylog, 14 bytes

ẹ⟨{iᶠ×ᵐ+}÷+⟩+₁

Try it online!

Answer 8

GolfScript (24 bytes)

0:i.@{15&.@+@@i):i*+\}//

Online demo

Answer 9

C (gcc), 72 bytes

a,b,c;f(long n){a=b=c=0;for(;n;a+=n%10*++c,n/=10)b+=n%10;return-~c-a/b;}

Try it online!

Answer 10

MATL, 12 bytes

48-ttn:*sws/

Try it online!

Answer 11

Mathematica, 42 bytes

Range@Length@#.#/Total@#&@IntegerDigits@#&

Try it online! (Mathics)

Answer 12

Python 3, 69 bytes

x=[*map(int,input())]
print(sum(v*k for k,v in enumerate(x))//sum(x))

Try it online!

-7 bytes and fixed thanks to ovs

Answer 13

Pyth, 14 bytes

h/s.e*bkJjQTsJ

Test suite.

Answer 14

Actually, 10 bytes

♂≡;Σ@;r*\u

Try it online!

Answer 15

Cheddar, 63 bytes

n->(a->a.map((x,y)->x*y).sum/a.sum+1)(("%d"%n).bytes=>((-)&48))

Try it online!

Answer 16

Retina, 43 bytes

$
;$`
(?=(.*);)
$1
\d
$*
^(1+)(\1)*;\1$
$#2

Try it online!

Answer 17

Java (OpenJDK 8), 80 bytes

int f(long n){int a=0,b=0,c=0;for(;n>0;a+=n%10*++c,n/=10)b+=n%10;return-~c-a/b;}

Try it online!

Answer 18

05AB1E, 10 bytes

TвÐgL*OsO÷

Try it online!

Answer 19

GolfScript, 33 bytes

{48-}%.[.,,]zip{{*}*}%{+}*\{+}*/)

Try it online!

Answer 20

Python 2, 132 134 126 112 bytes

• Thanks @ovs for 14 bytes.

n,m=map(int,input()),0
z=lambda a,b:sum(n[j]*abs(m-j)for j in range(a,b))
while z(0,m)<z(m,len(n)):m+=1
print-~m

Try it online!

Answer 21

Retina, 30 bytes

$'¶
1>`¶

.
$*
(1+)¶(\1)+
$#2

Try it online! Link includes test cases. Explanation: The first stage sneakily creates newline-delimited duplicates of all the suffixes of the original string. This means that the each digit appears after the first newline the number of times according to how far away it is from the left, effectively multiplying to give its moment. The second stage deletes all the newlines after the first, completing the calculation of the moments. The third stage converts the digits to unary, summing them, and the fourth stage divides the sums (exact division is assumed to apply here).

Answer 22

J, 29 bytes

(0 i.~]+/ .*[:-/~#\)@(,.&.":)

J executes verbs right-to-left, so let's start at the end and work our way towards the beginning.

Explanation

         ,.&.":      NB. Explode integer into digits
         #\          NB. 0 .. N-1, where N=number of digits
         -/~         NB. Distance table, one row per digit
         ] +/ .* …   NB. Forces at each pivot (F=digit * distance)
         0 i.~ …     NB. Digit index where F=0

Note that J is an index-origin 0 language, so it would be more natural and idiomatic for the answer to 8900311672 to be 4 rather than 5, for 231592 to be 3 rather than 4, etc, and so that's the way this function is written.

But if the index-origin 1 is required for output, then add 1+ before 0 i.~ and add 2 bytes to the score, bringing it up from 29 to 31.

Answer 23

Python 3, 127 bytes

I am a newbie golfer. All suggestions and tips are greatly apreciated :).

lambda x:min([(abs(eval("+".join(list(x[:i+1])))-eval("+".join(list(x[i:])))),i+1)for i in range(len(x))],key=lambda x:x[0])[1]

Try it Online!

Answer 24

C# (.NET Core), 84 bytes

a=>{int p=0,q=0,i=1;for(;i<=a.Length;p+=a[i-1],q+=i*a[i++-1]);return q/(q%p>0?0:p);}

Try it online!

Takes in an array of single digits as the 'integer' input. Uses the image moments approach for finding the centre of mass. Throws a divide by zero if the seesaw is unbalanced.

DeGolfed

a=>{
    int p=0, // used to store the image moment of order 0
        q=0, // used to store the image moment of order 1
        i=1; // array index, offset to 1 as 1 based indexing is required

    for (; i <= a.Length; // go through the array
        p += a[i-1],      // getting the order 0 image moment value
        q += i*a[i++-1]); //     and the order 1 image moment value

    // q / p is the centre of mass, but as an exact integer pivot is required,
    // if q is not evenly divisible by p,
    // then throw a divide by zero error.
    // otherwise return q / p
    return q / ( q % p > 0? 0 : p);
}