Perché un simulatore?

I bambini in questi giorni non hanno il tempo né l'ambizione di andare effettivamente a impilare le scatole sulla sega o giocare con oggetti fisici in equilibrio. Questo lascia molto spazio nel mercato del software per un simulatore di leva che, secondo i miei modelli, venderà come un matto!

Cercasi aiuto per la programmazione

Ho depositato il brevetto per un gioco del genere (in attesa), ma ho bisogno di un programmatore esperto per scrivere la logica del gioco per me. Da quanto ho capito, è pratica standard compensare i programmatori in base alla dimensione in byte del programma finale. In quanto tale, assegnerò questo lucroso contratto al miglior offerente.

specificazione

Una leva è una serie di scatole o spazi vuoti bilanciati da un fulcro. Ogni scatola ha un peso particolare da uno a nove e gli spazi non hanno peso. Come sapete, il peso di una scatola sulla leva è direttamente proporzionale alla distanza di quella scatola dal fulcro. Una scatola di peso 4che si trova sul terzo spazio dal fulcro contribuirà con 12efficaci unità di forza a quel lato della leva.

Ho bisogno di un programma che, data una leva di input, emetta se la leva si inclina verso sinistra, a destra o è perfettamente bilanciata.

Linee guida I / O

• Scriverai per me un programma.
• L'input conterrà una riga di testo.
• L'input verrà da stdino come una stringa della riga di comando.
• Le caselle saranno rappresentate dai caratteri 1"da" a 9". Questi personaggi rappresentano i loro rispettivi pesi. Uno spazio vuoto sarà rappresentato da uno spazio ' '. Il fulcro sarà rappresentato da un cursore ' ^'.

Una leva di input di esempio potrebbe apparire come: 8 2^ 941

Questa leva è perfettamente bilanciata: (4*8) + 0 + 0 + (1*2) == 0 + (2*9) + (3*4) + (4*1) == 34

• Non ci saranno spazi iniziali né finali. Non ci saranno newline finali.
• Non è necessario gestire input non validi, l'input avrà sempre esattamente un fulcro e solo numeri e spazi.
• L'uscita indicherà se la leva è pesante, destra o pesante a sinistra.
• Il tuo programma deve avere esattamente 3 possibili uscite che potrebbero derivare da un input ben formato. Puoi scegliere quali sono.
• L'output deve essere stampato stdouto essere il codice di ritorno del programma.

Casi test

Qui uso L, R, Ba significare sinistra-pesante, destra-pesante, equilibrato:

1. Ingresso: 11 ^9Uscita:B

2. Ingresso: 321^ 12Uscita:L

3. Ingresso: 9^ 1Uscita:R

(Se qualcuno ha dei casi di test "più complicati", sentiti libero di modificarli).

Bibliografia

Non necessariamente ispirato, ma correlato a Balance una serie di pesi su un'altalena

Python 2, 69 byte

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

Il modulo ord(c)%16estrae il valore di un carattere cifra mentre ottiene 0 per lo spazio. Per ogni personaggio, il suo contributo di coppia viene calcolato come il suo peso moltiplicato per la distanza indicata dal perno i-s.find('^')e questi vengono sommati e confrontati con 0, producendo uno di -1,0,1. Si ^calcola che il personaggio abbia un peso di 14, ma non importa perché è sul perno.

Una porta Pyth a 18 byte di Maltysen:

._s.e*-kxz\^%Cb16z

Per il codice Python, se è richiesto un programma completo, ecco 79 byte. L'idea è quella di avviare l'indice ispostato s.find('^')e farlo contare alla rovescia.

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 byte

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

• -1 se lasciato è più pesante
• 0 se equilibrato
• 1 se giusto è più pesante

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)

Esecuzioni di test (assegnazione della funzione anonima a f):

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

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

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

• -11 byte: modificato l'output da R B La-1 0 1
• -3 byte: modificato e.split``in [...e](grazie @ Vɪʜᴀɴ)
• -33 byte: algoritmo modificato per utilizzare pesi negativi anziché dividere al perno
• -9 byte: rimosso il controllo pivot (apparentemente, ~~'^'valuta 0...)
• -2 byte: funzione anonima (grazie @ cᴏɴᴏʀ-obʀɪᴇɴ)

Japt , 22 byte

Japt è una versione abbreviata di Ja vaScri pt . Interprete

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

Restituisce -1per L, 0per Be 1per R.

Come funziona

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 byte

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

Dopo aver riletto le regole, l'ho modificato in output -1 0 1anziché in L B R, salvando nove byte.

Provalo qui .

Pyth, 20 byte

._s*V-Rxz\^Uzm.xsd0z

Suite di test

-1per sbilanciato a sinistra, 0equilibrato, 1sbilanciato a destra.

Come funziona:

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

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

L'output è 0bilanciato, -1sinistro-pesante e 1destro-pesante.

Esempio di utilizzo: f "321^ 12"->-1

Come funziona: trova la parte prima di ^. Moltiplicare la stringa di input e l'elenco dei pesi che inizia da - length-of-first-part. Il ^ha un peso di 0 e non aggiunge alla somma. Sto usando il trucco mod 16 di @ xnor per convertire cifre / spazi in valori interi. Se la somma è negativa (positiva), la leva è sinistra-pesante (destra-pesante) ed equilibrata se la somma è 0.

TeaScript , 23 byte 25

Ho provato a scrivere una risposta Pyth ma è andata orribilmente: \

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

Che ²sembra così fuori luogo, ma consente di risparmiare 1 byte, così sarò mantenendolo.

Provalo online!

Prova tutti i casi

Per lo schema di output ho scelto:

• -1se Sinistra è più pesante di Destra ( L)
• 0se Sinistra è pesante come Destra ( B)
• 1è Sinistra è meno pesante di Destra ( R)

Ungolfed && Explanation

Questo utilizza mappe e riduce per fare il lavoro.

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

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

Questo è stato difficile. pb non è stato progettato per essere bravo in questo genere di cose. Non ha nemmeno moltiplicazione . Ma hey, funziona.

Ed. nota: ho appena detto che pb non ha moltiplicazione? Che cosa? pb ha sicuramente sicuramente moltiplicazioni. Ho progettato e implementato questo linguaggio, dovrei sapere che ha la moltiplicazione integrata e non devo fare qualche stupida aggiunta in loop. Risolvere il problema (oltre a fare un po 'di riarrangiamento creativo ora che potrei affrontare quella parte del problema da [quasi letteralmente] un'angolazione diversa) mi fa risparmiare 20 byte. Imbarazzante.

La parte più difficile è stata, dopo aver ottenuto le somme di (peso * distanza) per ciascun lato, determinando effettivamente quale lettera stampare. pb non ha >o <operatori, solo ==e !=. Non esiste un modo semplice per dire quale valore è maggiore. Non riesco nemmeno a sottrarre e confrontare con 0 ... a meno che non faccia qualcosa di veramente sciocco.

• Trova la somma delle due somme.
• Vai così lontano a destra, su una linea che non viene utilizzata per nulla.
• Fino a raggiungere X = 0, vai a sinistra e posiziona "L".
• Posiziona una "B" su X = 0.
• Vai a sinistra per la somma delle due somme.
• Fino a raggiungere X = 0, vai a destra e posiziona "R".

Quindi, vai semplicemente a X = (lato sinistro - lato destro) e c'è la tua risposta! Elimina tutto su quella riga per ripulire, quindi stampa il valore trovato in (0, 0).

... Ma c'è un modo leggermente più breve. Invece di usare 'L', 'B' e 'R', usa quei valori - 'B' e aggiungi 'B' di nuovo durante la stampa. In questo modo, non devi mai posizionare 'B' su X = 0, lo lasci semplicemente come lo era già lo 0. L'unico problema è che una volta fatto questo, il programma diventa molto sciocco in modalità orologio. 'L'-'B'==76-66==10=='\n'. Tutto sembra funzionare bene, fino a quando all'improvviso viene stampato un numero enorme di newline ed è impossibile tenere traccia di ciò che sta succedendo: D Nella normale modalità di esecuzione di pbi, tuttavia, tutto funziona bene perché le newline vengono eliminate prima che qualsiasi cosa venga stampata sul 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 byte

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

MATLAB 91, 57, 55 Ottava, 50 byte

Non mi aspettavo di continuare a giocare a golf, ma il passaggio a Octave ha permesso di salvare 5 byte aggiuntivi! Wow, questo ci è voluto del tempo ...

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

Produce -Inf, NaN, Infper L, B, Rrispettivamente.

Suite di test!

Spiegazione:

Questo è sicuramente un codice difficile da leggere, ma cercherò di spiegare come posso. Passerò dalla spiegazione del blocco di codice al testo.

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

Diamo un'occhiata a cosa sta succedendo tra parentesi:

[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

Questo è un po 'complicato:

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

I numeri su ciascun lato della scala devono essere moltiplicati per la distanza dal punto di inserimento. Se utilizziamo numeri negativi sul lato sinistro e numeri positivi sul lato destro, possiamo semplicemente sommare il vettore per vedere quale lato è più pesante.

Supponiamo che la stringa di input è: '321^ 12'. Vogliamo che la seguente: 3*(-3)+2*(-2)+1*(-1)+1*3+2*4. Il vettore che abbiamo creato all'interno delle parentesi inizia da 1-i, che in questo caso è -3, poiché il cursore è in 4a posizione. Va a nnz(x)-iincrementi di uno. Possiamo usare nnz(x)invece di numel(s), perché xè una stringa che non contiene zeri.

Perciò:

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

Ora, potremmo fare moltiplicazioni in termini di elementi s.*[...]e prendere la somma di questo. Ma, poiché abbiamo due vettori, possiamo anche mutliply sper il trasposto [...]e calcolare la somma usando la moltiplicazione della matrice:

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

Questo ci dà un numero negativo, il che significa che il lato sinistro è più pesante, uno zero, che significa che è bilanciato, o un numero postivo, il che significa che il lato destro è più pesante. Invece di usare l'approccio ingenuo di sign(...), lo moltiplichiamo per inf, che ci darà rispettivamente -Info Infper sinistra e destra. Otteniamo NaNper 0*inf, dal momento che è indefinito.

Questo ci dà tre valori distinti per i tre possibili risultati.

𝔼𝕊𝕄𝕚𝕟, 22 caratteri / 38 byte

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

Try it here (Firefox only).

JavaScript, 146 byte

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

Abbastanza massiccio

Demo .

Rubino, 111 108 byte

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

Spiegazione

Riassume il valore ponderato di ciascun numero su ciascun lato. Quindi utilizza l'operatore ruby ​​spaceship per fornire un 1,0, -1 di uguaglianza / disuguaglianza dei due lati, che è l'indice di un array con l'output corretto.

PowerShell, 83 73 byte

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

Grazie a TessellatingHeckler per il golf.

Utilizza essenzialmente lo stesso algoritmo del codice precedente riportato di seguito, ma qui eseguiamo l'iterazione dei caratteri nella stringa di input uno alla volta anziché iterare l'indice, risparmiando una manciata di byte. Emette comunque lo stesso spettacolare messaggio di errore quando l'algoritmo raggiunge ^- non influisce su STDOUT.

Precedente

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

Utilizza lo stesso straordinario algoritmo della risposta eccellente di Dendrobium e quindi utilizza lo stesso output di -1 / 0 / 1se l'input è left-heavy / balanced / right-heavy.

Ugh. A lungo a causa di una colata capriccio caratteristica che PowerShell ha. Il più pertinente qui è come charmoltiplicato per le intfunzioni. Prendendo un array-index di un stringrisultato in un charoggetto. PowerShell converte il charvalore ASCII corrispondente (anziché il valore letterale) prima della moltiplicazione. Quindi, qualcosa come $a='012'[0];[int]$a*2risultati 96.

Ciò significa che dobbiamo ricollegarlo come stringa. Tuttavia, semplicemente facendo i stringtempi intce ne viene stringripetuto molte volte. Ad esempio, $a='0';$a*2si tradurrebbe in 00.

Ciò significa che dobbiamo lanciare il chardorso come stringprima di ripubblicare come int, quindi può verificarsi la moltiplicazione, prima di aggiungerlo nel nostro accumulatore $x.

Abbinalo al lungo modo di iterare attraverso una stringa e alla chiamata .NET per generare il segno e otteniamo un pezzo di codice piuttosto lungo.

_{NB - Questo genererà un errore spettacolare quando raggiunge ^la stringa, affermando che non può convertirlo in un int. Non influisce su STDOUT.}

CJam, 29 byte

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

Provalo online

Il risultato è -1per sinistro-pesante, 0per bilanciato, 1per destro-pesante.

Sembrava un po 'lungo, ma ho provato un sacco di alternative, e sono finite tutte tra 29 e 33 byte. Un problema è che non sono riuscito a trovare un modo per convertire la stringa in valori che comporterebbero automaticamente 0 per gli spazi. Così ho finito per sostituire esplicitamente gli spazi con '0 caratteri, il che ovviamente aumenta la lunghezza del codice.

Alternative tentate:

• Dividere la stringa in '^, invertendo la prima e quindi calcolando il valore ponderato per entrambi.
• Utilizzo eedell'operatore per aggiungere l'indice all'elenco di valori.
• Invece di sottrarre la posizione del punto di inserimento da ciascun indice, calcolare il prodotto punto senza la sottrazione, quindi sottrarre la posizione della posizione del punto di inserimento per la lunghezza della stringa dal risultato.

Spiegazione:

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 byte

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

Codice normale:

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

Spiegazione:

1. Genera un elenco di numeri + il fulcro di stdin.
2. Per ogni numero, aggiunge la distanza dal fulcro per il numero del numero alla variabile al totale (i numeri a sinistra saranno negativi e i numeri a destra saranno positivi).
3. Stampa la lettera corretta in base al risultato (B se uguale, L se maggiore di zero e R se minore di zero).

Enorme grazie a @ThomasKwa per aver tagliato 82 byte (oltre il 40%) di sconto!

C, 140 139 138 134 100 100 byte

Ritorno:

• 1 = SINISTRA
• 2 = BILANCIATO
• 0 = DESTRA

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

Correre:

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

Come abbiamo ASCII:

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

Noi abbiamo:

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

Quindi sommare per fattore distanza a ^.

SpecBAS - 140 byte

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è un totale parziale, i valori sono negativi quando la posizione del personaggio è superiore alla posizione in carati. Alla fine vede se il totale è negativo, zero o positivo e stampa il carattere corrispondente di R, B o L.

Potrei radere qualche byte semplicemente emettendo -1, 0 o 1 come alcune delle altre risposte.

Java, 83 byte

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