Por que um simulador?

Hoje em dia, as crianças não têm tempo nem ambição de realmente empilhar caixas na gangorra ou brincar com objetos físicos equilibrados. Isso deixa muito espaço no mercado de software para um Lever Simulator que, de acordo com meus modelos, venderá como louco!

Procura-se ajuda de programação

Eu registrei a patente para esse jogo (pendente), mas preciso de um programador especializado para escrever a lógica do jogo para mim. Pelo meu entendimento, é prática padrão compensar os programadores com base no tamanho em bytes do programa final. Como tal, estarei concedendo este contrato lucrativo ao menor lance.

Especificação

Uma alavanca é uma série de caixas ou espaços vazios equilibrados por um ponto de apoio. Cada caixa tem um peso específico de um a nove e os espaços não têm peso. Como você sabe, o peso de uma caixa na alavanca é diretamente proporcional à distância da caixa do ponto de apoio. Uma caixa de peso 4que fica no terceiro espaço a partir do ponto de apoio contribuirá com 12unidades de força efetivas para esse lado da alavanca.

Preciso de um programa que, dada uma alavanca de entrada, produza se a alavanca se inclina para a esquerda, a direita ou se está perfeitamente equilibrada.

Diretrizes de E / S

• Você vai escrever para mim um programa.
• A entrada conterá uma linha de texto.
• A entrada virá de stdinou como uma sequência de linha de comando.
• As caixas serão representadas pelos caracteres ' 1' a ' 9'. Esses caracteres representam seus respectivos pesos. Um espaço vazio será representado por um espaço ' '. O ponto de apoio será representado por um sinal de intercalação ' ^'.

Uma alavanca de entrada de amostra pode se parecer com: 8 2^ 941

Esta alavanca está perfeitamente equilibrada: (4*8) + 0 + 0 + (1*2) == 0 + (2*9) + (3*4) + (4*1) == 34

• Não haverá espaços à esquerda nem à direita. Não haverá nova linha final.
• Não há necessidade de lidar com entrada malformada, a entrada sempre terá exatamente um ponto de apoio e apenas números e espaços.
• A saída indicará se a alavanca está pesada para a esquerda, pesada para a direita ou equilibrada.
• Seu programa deve ter exatamente 3 saídas possíveis que podem resultar de uma entrada bem formada. Você pode escolher o que é isso.
• A saída deve ser impressa stdoutou ser o código de retorno do programa.

Casos de teste

Aqui eu uso L, R, Bpara significar deixou-pesado, pesado direita, equilibrada:

1. Entrada: 11 ^9Saída:B

2. Entrada: 321^ 12Saída:L

3. Entrada: 9^ 1Saída:R

(Se alguém tiver alguns casos de teste "mais complicados", fique à vontade para editá-los).

Bibliografia

Não necessariamente inspirado, mas relacionado a Equilibrar um conjunto de pesos em uma gangorra

Python 2, 69 bytes

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

O módulo ord(c)%16extrai o valor de um caractere de dígito enquanto obtém 0 para espaço. Para cada caractere, sua contribuição de torque é calculada como seu peso multiplicado pela distância sinalizada ao pivô i-s.find('^'), e estes são somados e comparados a 0, produzindo um de -1,0,1. O personagem ^é calculado para ter peso 14, mas isso não importa, porque está no pivô.

Uma porta Pyth de 18 bytes de Maltysen:

._s.e*-kxz\^%Cb16z

Para o código Python, se um programa completo for necessário, aqui estão 79 bytes. A idéia é iniciar o índice ialterado s.find('^')e fazer a contagem regressiva.

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 bytes

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

• -1 se a esquerda for mais pesada
• 0 se equilibrado
• 1 se certo é mais pesado

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)

Execuções de teste (atribuindo função anônima a f):

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

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

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

• -11 bytes: saída alterada de R B Lpara-1 0 1
• -3 bytes: alterado e.split``para [...e](obrigado @ Vɪʜᴀɴ)
• -33 bytes: algoritmo alterado para usar pesos negativos em vez de dividir no pivô
• -9 bytes: verificação de pivô removida (aparentemente ~~'^'avalia como 0...)
• -2 bytes: função anônima (obrigado @ cᴏɴᴏʀ-obʀɪᴇɴ)

Japonês , 22 bytes

Japt é uma versão abreviada do Ja vaScri pt . Intérprete

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

Retorna -1para L, 0para Be 1para R.

Como funciona

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 bytes

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

Depois de reler as regras, mudei para saída, em -1 0 1vez de L B Rsalvar nove bytes.

Experimente aqui .

Pitão, 20 bytes

._s*V-Rxz\^Uzm.xsd0z

Suíte de teste

-1para tendencioso à esquerda, 0equilibrado, 1para tendencioso à direita.

Como funciona:

._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 bytes

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

A saída é 0para balanceado, -1pesado para a esquerda e pesado 1para a direita.

Exemplo de uso: f "321^ 12"->-1

Como funciona: encontre a peça antes da ^. Multiplique a sequência de entrada e a lista de pesos que começa em - length-of-first-part. O valor ^é 0 e não é adicionado à soma. Estou usando o truque de mod 16 do @ xnor para converter dígitos / espaços em valores inteiros. Se a soma for negativa (positiva), a alavanca é pesada para a esquerda (pesada para a direita) e equilibrada se a soma for 0.

TeaScript , 23 bytes 25

Tentei escrever uma resposta Pyth, mas isso foi horrivelmente: \

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

Que ²parece tão fora do lugar, mas ele salva 1 byte, então eu vou ser mantê-lo.

Experimente online!

Teste todos os casos

Para o esquema de saída que escolhi:

• -1se Esquerda for mais pesada que Direita ( L)
• 0se Esquerda for tão pesada quanto Direita ( B)
• 1Esquerda é menos pesada que Direita ( R)

Ungolfed && Explicação

Isso usa mapas e reduz para fazer o trabalho.

$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 bytes

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

Este foi um assunto complicado. O pb não foi projetado para ser bom nesse tipo de coisa. Nem sequer tem multiplicação . Mas ei, isso funciona.

Ed. nota: Acabei de dizer que pb não tem multiplicação? O que? definitivamente definitivamente tem multiplicação. Eu projetei e implementei essa linguagem, eu deveria saber que ela tem multiplicação embutida e não preciso fazer nenhuma adição boba em loop. Corrigir isso (assim como fazer uma reorganização criativa agora que eu poderia abordar essa parte do problema de [quase literalmente] um ângulo diferente) me economiza 20 bytes. Embaraçoso.

A parte mais difícil foi, depois de obter as somas de (peso * distância) de cada lado, determinar realmente qual letra imprimir. pb não tem >ou <operadores, apenas ==e !=. Não há uma maneira fácil de saber qual valor é maior. Eu não posso nem subtrair e comparar com 0 ... a menos que eu faça algo realmente bobo.

• Encontre a soma das duas somas.
• Vá tão longe para a direita, em uma linha que não está sendo usada para nada.
• Até atingir X = 0, vá para a esquerda e coloque 'L'.
• Coloque um 'B' em X = 0.
• Vá para a esquerda pela soma das duas somas.
• Até atingir X = 0, vá para a direita e coloque 'R'.

Então, você simplesmente vai para X = (lado esquerdo - lado direito), e aí está a sua resposta! Exclua tudo nessa linha para limpar e, em seguida, imprima o valor encontrado em (0, 0).

... Mas há uma maneira um pouco mais curta. Em vez de usar 'L', 'B' e 'R', use esses valores - 'B' e adicione 'B' novamente ao imprimir. Dessa forma, você nunca precisa colocar 'B' em X = 0, basta deixá-lo como o 0 já era. O único problema é que, depois de fazer isso, o programa se torna muito pateta no modo de exibição. 'L'-'B'==76-66==10=='\n'. Tudo parece estar funcionando bem, até que de repente um grande número de novas linhas é impresso e é impossível acompanhar o que está acontecendo: D No modo de execução regular do pbi, tudo funciona bem porque as novas linhas são excluídas antes que qualquer coisa seja impressa no console.

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

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

MATLAB 91, 57, 55 oitava, 50 bytes

Eu não esperava mais jogar golfe, mas a mudança para o Octave tornou possível salvar 5 bytes adicionais! Uau, este levou tempo ...

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

Ele gera -Inf, NaN, Infpara L, B, Rrespectivamente.

Suíte de teste!

Explicação:

Definitivamente, esse é um código difícil de ler, mas tentarei explicar o melhor que puder. Vou alternar entre a explicação do bloco de código e o texto.

@(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    

Vejamos o que está acontecendo dentro dos colchetes:

[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

Este é um pouco complicado:

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

Os números de cada lado da escada devem ser multiplicados pela distância do sinal de intercalação. Se usarmos números negativos no lado esquerdo e números positivos no lado direito, podemos simplesmente somar o vetor para ver qual lado é mais pesado.

Suponha que a seqüência de entrada é: '321^ 12'. Queremos o seguinte: 3*(-3)+2*(-2)+1*(-1)+1*3+2*4. O vetor que criamos dentro dos colchetes começa em 1-i, que neste caso é -3, já que o cursor está na 4ª posição. Aumenta nnz(x)-iem incrementos de um. Podemos usar em nnz(x)vez de numel(s), porque xé uma string que não contém zeros.

Portanto:

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

Agora, poderíamos fazer a multiplicação por elementos s.*[...]e pegar a soma disso. Mas, como temos dois vetores, também podemos mutliplicar spela transposição [...]e calcular a soma usando a multiplicação de matrizes:

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

Isso nos dá um número negativo, ou seja, o lado esquerdo é mais pesado, um zero, significa que é equilibrado ou um número positivo, o que significa que o lado direito é mais pesado. Em vez de usar a abordagem ingênua de sign(...), nós a multiplicamos por inf, o que nos dará uma -Infou outra Infpara esquerda e direita, respectivamente. Recebemos NaNpara 0*inf, uma vez que está indefinido.

Isso nos dá três valores distintos para os três resultados possíveis.

, 22 caracteres / 38 bytes

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

Try it here (Firefox only).

JavaScript, 146 bytes

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')}

Bastante enorme.

Demo .

Ruby, 111 108 bytes

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

Explicação

Resume o valor ponderado de cada número de cada lado. Em seguida, ele usa o operador de nave espacial ruby ​​para fornecer 1,0, -1 de igualdade / desigualdade dos dois lados, que é o índice de uma matriz com a saída correta.

PowerShell, 83 73 bytes

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

Agradecimentos a TessellatingHeckler pelo golfe.

Usa essencialmente o mesmo algoritmo que o código antigo abaixo, mas aqui iteramos os caracteres na string de entrada, um de cada vez, em vez de iterar pelo índice, o que economiza um punhado de bytes. Ainda lança a mesma mensagem de erro espetacular quando o algoritmo chega ^- não afeta STDOUT.

Anterior

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

Usa o mesmo algoritmo impressionante da excelente resposta do Dendrobium e, portanto, usa a mesma saída -1 / 0 / 1se a entrada for left-heavy / balanced / right-heavy.

Ugh. Muito tempo por causa de um recurso peculiar de elenco que o PowerShell possui. O mais pertinente aqui é o quão charmultiplicado por intfunções. Obter um índice de matriz de um stringresultado em um charobjeto. O PowerShell converte o charvalor correspondente em ASCII (em vez do valor literal) antes da multiplicação. Então, algo como $a='012'[0];[int]$a*2resulta em 96.

Isso significa que precisamos refazê-lo novamente como uma string. No entanto, simplesmente fazer os stringtempos intnos dá uma stringrepetição disso muitas vezes. Por exemplo, $a='0';$a*2resultaria em 00.

Isto significa que precisamos para lançar a charvolta como stringantes re -Fundição como int, então multiplicação pode acontecer, antes de adicioná-lo ao nosso acumulador $x.

Junte isso à maneira longa de iterar por meio de uma string, e o .NET chama a saída do sinal, e obtemos um longo pedaço de código.

_{NB - Isso gera um erro espetacular quando atinge ^a string, declarando que não pode convertê-lo em um int. Não afeta STDOUT.}

CJam, 29 bytes

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

Experimente online

O resultado é -1para pesado à esquerda, 0para equilibrado, 1para pesado à direita.

Isso pareceu um pouco demorado, mas tentei várias alternativas e todas elas terminaram entre 29 e 33 bytes. Um problema é que não consegui encontrar uma maneira de converter a string em valores que resultariam automaticamente em 0 para os espaços. Então, acabei substituindo explicitamente os espaços por '0 caracteres, o que obviamente aumenta o comprimento do código.

Alternativas tentadas:

• Dividindo a string em '^, invertendo a 1ª e calculando o valor ponderado para ambas.
• Usando o eeoperador para adicionar o índice à lista de valores.
• Em vez de subtrair a posição do cursor de cada índice, calcule o produto escalar sem a subtração e subtraia a posição do cursor vezes o comprimento da string do resultado.

Explicação:

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

Código regular:

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

Explicação:

1. Gera uma lista de números + o ponto de apoio de stdin.
2. Para cada número, adiciona a distância do ponto de apoio vezes o número da variável ao total (os números à esquerda serão negativos e os números à direita serão positivos).
3. Imprime a letra correta, dependendo do resultado (B se for igual, L se for maior que zero e R se for menor que zero).

Muito obrigado a @ThomasKwa por cortar 82 bytes (mais de 40%)!

C, 140 139 138 134 100 bytes

Retorna:

• 1 = ESQUERDA
• 2 = EQUILÍBRIO
• 0 = DIREITA

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;}

Corre:

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

Como temos ASCII:

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

Nós temos:

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

Em seguida, some por fator de distância até ^.

SpecBAS - 140 bytes

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é um total corrente, os valores são negativos quando a posição do caractere é maior que a posição do quilate. No final, ele vê se o total é negativo, zero ou positivo e imprime o caractere correspondente de R, B ou L.

Eu poderia economizar alguns bytes apenas produzindo -1, 0 ou 1 como algumas das outras respostas.

Java, 83 bytes

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