Hebel Simulator 2015

46

Warum ein Simulator?

Kinder haben heutzutage weder die Zeit noch den Ehrgeiz, Kisten auf der Wippe zu stapeln oder mit balancierenden Gegenständen herumzuspielen. Dies lässt auf dem Softwaremarkt viel Platz für einen Hebel-Simulator, der sich nach meinen Modellen wie verrückt verkaufen wird!

Programmierhilfe gesucht

Ich habe ein Patent für ein solches Spiel angemeldet (anhängig), benötige aber einen erfahrenen Programmierer, um die Spielelogik für mich zu schreiben. Nach meinem Verständnis ist es üblich, Programmierer basierend auf der Größe des endgültigen Programms in Bytes zu kompensieren . Als solches werde ich diesen lukrativen Auftrag an den niedrigsten Bieter vergeben.

Spezifikation

Ein Hebel ist eine Reihe von Kisten oder leeren Räumen, die durch einen Drehpunkt ausgeglichen werden. Jede Box hat ein bestimmtes Gewicht von eins bis neun und Leerzeichen haben kein Gewicht. Wie Sie wissen, ist das Gewicht einer Box auf dem Hebel direkt proportional zum Abstand dieser Box vom Drehpunkt. Eine Gewichtskiste 4, die sich auf dem dritten Raum vom Drehpunkt befindet, trägt 12wirksame Krafteinheiten zu dieser Seite des Hebels bei.

Ich brauche ein Programm, das bei gegebenem Eingabehebel ausgibt, ob der Hebel nach links, rechts oder perfekt ausbalanciert ist.

I / O-Richtlinien

  • Du wirst für mich ein Programm schreiben.
  • Die Eingabe enthält eine Textzeile.
  • Die Eingabe kommt von stdinoder als eine Befehlszeilenzeichenfolge.
  • Boxen werden durch die Zeichen ' 1' bis ' 9' dargestellt. Diese Zeichen repräsentieren ihre jeweiligen Gewichte. Ein leerer Raum wird durch ein Leerzeichen ' ' dargestellt. Der Drehpunkt wird durch ein Caret ' ^' dargestellt.

Ein Beispieleingabehebel könnte folgendermaßen aussehen: 8 2^ 941

Dieser Hebel ist perfekt ausbalanciert: (4*8) + 0 + 0 + (1*2) == 0 + (2*9) + (3*4) + (4*1) == 34

  • Es gibt keine führenden oder nachfolgenden Leerzeichen. Es wird keine nachgestellte Newline geben.
  • Es ist nicht erforderlich, fehlerhafte Eingaben zu verarbeiten. Die Eingabe hat immer genau einen Drehpunkt und nur Zahlen und Leerzeichen.
  • Der Ausgang zeigt an, ob der Hebel links schwer, rechts schwer oder ausgeglichen ist.
  • Ihr Programm muss genau 3 mögliche Ausgaben haben, die sich aus einer wohlgeformten Eingabe ergeben könnten. Sie können wählen, was diese sind.
  • Die Ausgabe muss entweder auf stdoutden Rückgabecode des Programms oder auf den Rückgabecode des Programms lauten.

Testfälle

Hier verwende ich L, R, Bbedeuten links schweren rechten schwer, ausgewogen:

  1. Eingabe: 11 ^9Ausgabe:B

  2. Eingabe: 321^ 12Ausgabe:L

  3. Eingabe: 9^ 1Ausgabe:R

(Wenn jemand "kniffligere" Testfälle hat, können Sie diese gerne bearbeiten.)

Literaturverzeichnis

Nicht unbedingt inspiriert, aber mit Balance verbunden, eine Reihe von Gewichten auf einer Wippe

turbulencetoo
quelle
8
The output must either be print to stdout or be the return code of the program.Nun, jetzt fordern Sie mich auf, eine Linux-Distribution zu erstellen, die die Wippe-Notation für Exit-Codes verwendet.
Katze
1
Ich würde auf der Wippe spielen, außer die meisten Spielplätze haben sie entfernt, da sie "unsicher" sind. Ich hoffe, sie entfernen niemals Schaukeln aus diesem Grund. "Kinder könnten von ihnen springen, oh nein!"
mbomb007
2
Kann die Eingabe leere Seiten haben? Wie in ^16, 16^oder ^? (Angenommen, es kann)
Runium
ahhh ein Loch in der Spezifikation, ja, ich würde annehmen, dass die Seiten leer sein können
turbulencetoo
7
Ich habe mich nur einige Sekunden lang gefragt, wie 11 mal 3 oder 4 mit 9 mal 1 ausgeglichen werden können.
James Thorpe

Antworten:

7

Python 2, 69 Bytes

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

Der Modul ord(c)%16extrahiert den Wert eines Ziffernzeichens, während der Abstand 0 ergibt. Für jedes Zeichen wird sein Drehmomentbeitrag als sein Gewicht multipliziert mit dem vorzeichenbehafteten Abstand zum Drehpunkt berechnet. i-s.find('^')Diese werden summiert und mit 0 verglichen -1,0,1. Der Charakter ^wird mit einem Gewicht von 14 berechnet, aber das spielt keine Rolle, da er sich auf dem Drehpunkt befindet.

Ein 18-Byte-Pyth-Port von Maltysen:

._s.e*-kxz\^%Cb16z

Wenn für den Python-Code ein vollständiges Programm erforderlich ist, finden Sie hier 79 Bytes. Die Idee ist, den Index iverschoben zu starten s.find('^')und herunterzählen zu lassen.

s=raw_input()
t=0;i=s.find('^')
for c in s:t-=ord(c)%16*i;i-=1
print cmp(t,0)
xnor
quelle
Hier ist ein Pyth-Programm, das Ihre Methode verwendet und das Sie posten können, wenn Sie pyth.herokuapp.com/ 18 Bytes möchten . Hatte nicht das richtige Gefühl, es selbst zu posten.
Maltysen
@Maltysen Danke, ich habe es aufgenommen.
25.
16

Javascript ES6, 62 Bytes

s=>Math.sign([...s].reduce((p,c,i)=>p+~~c*(i-s.indexOf`^`),0))
  • -1 wenn links ist schwerer
  • 0 wenn ausgeglichen
  • 1 wenn rechts schwerer ist

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)

Testläufe (Zuweisen anonymer Funktionen an f):

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

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

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

  • -11 Bytes: Ausgabe von R B Lnach geändert-1 0 1
  • -3 Bytes: geändert e.split``in [...e](danke @ Vɪʜᴀɴ)
  • -33 Bytes: Der Algorithmus wurde geändert, um negative Gewichte zu verwenden, anstatt am Pivot zu teilen
  • -9 Bytes: Pivot Check entfernt (wird anscheinend ~~'^'zu 0... ausgewertet )
  • -2 Bytes: Funktion anonymisiert (danke @ cᴏɴᴏʀ-obʀɪᴇɴ)
Dendrobium
quelle
3
Es ist allgemeiner Konsens, dass Sie das führende weglassen f=und sagen können, dass es eine anonyme Funktion erzeugt. (-2 Bytes FYI)
Conor O'Brien
5

Japt , 22 Bytes

Japt ist eine verkürzte Version von Ja vaScri pt . Dolmetscher

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

Gibt -1für L, 0für Bund 1für zurück R.

Wie es funktioniert

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
ETHproductions
quelle
5

APL, 39 30 Bytes

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

Nach dem erneuten Lesen der Regeln habe ich dies geändert und -1 0 1stattdessen L B Rneun Bytes gespart.

Probieren Sie es hier aus .

Lirtosiast
quelle
4

Pyth, 20 Bytes

._s*V-Rxz\^Uzm.xsd0z

Testsuite

-1für links vorgespannt, 0für ausgeglichen, 1für rechts vorgespannt.

Wie es funktioniert:

._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.
isaacg
quelle
4

Haskell, 116 96 82 76 Bytes

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

Die Ausgabe ist 0für ausgeglichene, -1für linkslastige und 1für rechtslastige.

Anwendungsbeispiel: f "321^ 12"->-1

So funktioniert es: Finde das Teil vor dem ^. Multiplizieren Sie die Eingabezeichenfolge und die Liste der Gewichte, die bei beginnt - length-of-first-part. Der ^hat eine Gewichtung von 0 und addiert sich nicht zur Summe. Ich verwende @ xnors Mod 16-Trick , um Ziffern / Leerzeichen in ganzzahlige Werte umzuwandeln. Wenn die Summe negativ (positiv) ist, ist der Hebel linksschwer (rechtsschwer) und ausgeglichen, wenn die Summe 0 ist.

nimi
quelle
4

TeaScript , 23 Bytes 25

Ich habe versucht, eine Pyth-Antwort zu schreiben, aber das ist schrecklich gelaufen: \

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

Das ²sieht so unangebracht aus, spart aber 1 Byte, also werde ich es behalten.

Probieren Sie es online!

Testen Sie alle Fälle

Für das von mir gewählte Ausgabeschema:

  • -1wenn links schwerer ist als rechts ( L)
  • 0wenn links so schwer ist wie rechts ( B)
  • 1ist links ist weniger schwer als rechts ( R)

Ungolfed && Erklärung

Dabei werden Karten und Reduzierungen verwendet, um die Arbeit zu erledigen.

$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
Downgoat
quelle
4

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]

Das war eine knifflige Sache. pb war nicht dafür gedacht, in so etwas gut zu sein. Es gibt nicht einmal eine Multiplikation . Aber hey, es funktioniert.

Ed. Anmerkung: Habe ich gerade gesagt, dass pb keine Multiplikation hat? Was? pb hat definitiv definitiv Multiplikation. Ich habe diese Sprache entworfen und implementiert . Ich sollte wissen, dass sie eine integrierte Multiplikation hat und ich keine alberne Addition mit Schleifen durchführen muss. Wenn ich das behebe (und jetzt etwas kreativ umstelle, da ich diesen Teil des Problems aus einem anderen Blickwinkel betrachten könnte), spare ich 20 Bytes. Peinlich.

Der schwierigste Teil war, nachdem die Summe (Gewicht * Abstand) für jede Seite ermittelt worden war, tatsächlich zu bestimmen, welcher Brief gedruckt werden sollte. pb hat keine >oder <Operatoren, nur ==und !=. Es ist nicht einfach zu erkennen, welcher Wert größer ist. Ich kann nicht einmal subtrahieren und mit 0 vergleichen ... es sei denn, ich mache etwas wirklich Dummes.

  • Finden Sie die Summe der beiden Summen.
  • Gehen Sie so weit nach rechts, auf einer Linie, die für nichts verwendet wird.
  • Bis X = 0 erreicht ist, gehe nach links und setze 'L'.
  • Platziere ein 'B' bei X = 0.
  • Gehe nach links um die Summe der beiden Summen.
  • Bis X = 0 erreicht ist, gehe nach rechts und setze 'R'.

Dann gehen Sie einfach zu X = (linke Seite - rechte Seite) und es gibt Ihre Antwort! Löschen Sie alles in dieser Zeile, um zu bereinigen, und drucken Sie dann den Wert, der bei (0, 0) gefunden wurde.

... Aber es gibt einen etwas kürzeren Weg. Verwenden Sie statt 'L', 'B' und 'R' diese Werte - 'B' und fügen Sie beim Drucken wieder 'B' hinzu. Auf diese Weise müssen Sie niemals 'B' bei X = 0 platzieren, sondern belassen es einfach als die 0, die es bereits war. Das einzige Problem ist, dass das Programm im Watch-Modus sehr doof wird, wenn Sie dies tun. 'L'-'B'==76-66==10=='\n'. Alles scheint in Ordnung zu sein, bis plötzlich eine große Anzahl von Zeilenumbrüchen gedruckt wird und es unmöglich ist, den Überblick zu behalten: D Im regulären Ausführungsmodus von pbi funktioniert jedoch alles in Ordnung, da die Zeilenumbrüche gelöscht werden, bevor etwas auf die Seite gedruckt wird Konsole.

^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)
untergrundbahn
quelle
3
Als würde man den Abstieg eines Mannes in den Wahnsinn beobachten.
Kzqai
3

Perl 5, 72 Bytes

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

MATLAB 91, 57, 55 Oktave, 50 Bytes

Ich hatte nicht damit gerechnet, weiter Golf zu spielen, aber durch den Wechsel zu Octave konnten 5 zusätzliche Bytes eingespart werden! Wow, das hat einige Zeit gedauert ...

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

Es gibt -Inf, NaN, Inffür L, B, Rjeweils.

Testsuite!

Erläuterung:

Dies ist definitiv ein schwer lesbarer Code, aber ich werde versuchen, ihn so gut wie möglich zu erklären. Ich werde zwischen Codeblock-Erklärung und Text wechseln.

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

Schauen wir uns an, was in den Klammern vor sich geht:

[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

Dieser ist ein bisschen knifflig:

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

Die Zahlen auf jeder Seite der Leiter müssen mit dem Abstand zum Caret multipliziert werden. Wenn wir auf der linken Seite negative Zahlen und auf der rechten Seite positive Zahlen verwenden, können wir den Vektor einfach summieren, um zu sehen, welche Seite am schwersten ist.

Angenommen , die Eingabezeichenfolge ist: '321^ 12'. Wir wollen die folgende: 3*(-3)+2*(-2)+1*(-1)+1*3+2*4. Der Vektor, den wir in den Klammern erstellt haben, beginnt bei 1-i, in diesem Fall -3, da sich das Caret in der 4. Position befindet. Es geht bis nnz(x)-iin Schritten von eins. Wir können nnz(x)statt verwenden numel(s), weil xes sich um eine Zeichenfolge handelt, die keine Nullen enthält.

Deshalb:

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

Nun können wir elementweise multiplizieren s.*[...]und die Summe daraus ziehen. Da wir aber zwei Vektoren haben, können wir auch die Summe mit der Matrixmultiplikation stransponieren [...]und berechnen:

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

Dies ergibt entweder eine negative Zahl, was bedeutet, dass die linke Seite schwerer ist, eine Null, was bedeutet, dass sie ausgeglichen ist, oder eine positive Zahl, was bedeutet, dass die rechte Seite schwerer ist. Anstatt den naiven Ansatz von zu verwenden sign(...), multiplizieren wir ihn mit inf, was uns entweder für links -Infoder Inffür rechts ergibt. Wir bekommen NaNdafür 0*inf, da es undefiniert ist.

Dies gibt uns drei unterschiedliche Werte für die drei möglichen Ergebnisse.

Stewie Griffin
quelle
2

𝔼𝕊𝕄𝕚𝕟 22 Zeichen / 38 Bytes

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

Try it here (Firefox only).

Mama Fun Roll
quelle
2
-1 Dies optimiert die Anzahl der Zeichen, nicht die Anzahl der Bytes
Mego
Dafür wurde 𝔼𝕊𝕄𝕚𝕟 gebaut, @Mego.
Mama Fun Roll
3
Unabhängig davon, wofür es erstellt wurde, erfolgt die Bewertung in Byte.
Mego
Ich verstehe das.
Mama Fun Roll
2

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

Ziemlich massiv.

Demo .

nicael
quelle
Mit ES6 können Sie einige Bytes einsparen. Das Ganze function t(s){könnte t=>{und split('^')könnte werdensplit`^`
Downgoat
@ Vɪʜᴀɴ du meintest wohl s => {?
Nicael
oh ja, sorry, das habe ich gemeint
Downgoat
@Ypnypn -6 Zeichen :)
Nicael
2

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

Erläuterung

Summiert den gewichteten Wert jeder Zahl auf jeder Seite. Dann verwendet es den Ruby-Raumschiff-Operator, um eine Gleichheit / Ungleichheit von 1,0, -1 der beiden Seiten bereitzustellen, was der Index eines Arrays mit der richtigen Ausgabe ist.

Alexis Andersen
quelle
2

PowerShell, 83-73 Byte

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

Vielen Dank an TessellatingHeckler für den Golf.

Verwendet im Wesentlichen den gleichen Algorithmus wie den folgenden älteren Code, aber hier werden die Zeichen in der Eingabezeichenfolge einzeln durchlaufen, anstatt den Index zu durchlaufen, wodurch eine Handvoll Bytes gespart werden. Wirft immer noch die gleiche spektakuläre Fehlermeldung, wenn der Algorithmus erreicht ^- wirkt sich nicht auf STDOUT aus.


Bisherige

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

Verwendet den gleichen hervorragenden Algorithmus wie Dendrobiums ausgezeichnete Antwort und verwendet daher die gleiche Ausgabe wie -1 / 0 / 1bei der Eingabe left-heavy / balanced / right-heavy.

Pfui. Lange wegen eines Casting Marotte Merkmal , dass Powershell hat. Am relevantesten ist hier die charMultiplikation mit intFunktionen. Einen Array-Index eines stringErgebnisses in ein charObjekt aufnehmen. PowerShell konvertiert den charWert vor der Multiplikation in den entsprechenden ASCII-Wert (und nicht in den Literalwert). So etwas $a='012'[0];[int]$a*2führt zu 96.

Das heißt, wir müssen es wieder als Zeichenfolge umwandeln. Wenn wir es jedoch einfach stringmal intmachen , werden wir es so oft stringwiederholen. Zum Beispiel $a='0';$a*2würde ergeben 00.

Dies bedeutet, dass wir den charRücken als stringvor dem erneuten Wirken werfen müssen, da intdann eine Multiplikation stattfinden kann, bevor wir ihn in unseren Akkumulator hinzufügen $x.

Kombinieren Sie dies mit der langen Iterationszeit durch einen String und dem .NET-Aufruf zur Ausgabe des Zeichens, und Sie erhalten einen ziemlich langen Code.

NB - Dies wird einen spektakulären Fehler auslösen, wenn es ^in die Zeichenkette gelangt und besagt, dass es nicht in eine konvertiert werden kann int. Beeinflusst STDOUT nicht.

AdmBorkBork
quelle
Ich habe param($b)$i=-$b.indexOf('^');[char[]]$b|%{$x+=$i++*+"$_"};[math]::Sign($x)bei 74 Bytes. Dies dauerte lange und es wurden mehrere Anlaufversuche unternommen. math :: sign sieht so lang aus, aber ich sehe keinen Weg, um dieses Bit zu verbessern.
TessellatingHeckler
@TessellatingHeckler Sicher, das Durchlaufen der Zeichen selbst und nicht der Indizes ... macht Sinn! Ich habe ein zusätzliches Byte mit dem impliziten Casting von PowerShell abgegolft. Dies $i++*+"$_"entspricht $i++*"$_"if $iis a int.
AdmBorkBork
1

CJam, 29 Bytes

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

Probieren Sie es online aus

Das Ergebnis ist -1für linkslastig, 0für ausgeglichen, 1für rechtslastig.

Das schien ein bisschen lang zu sein, aber ich habe eine Reihe von Alternativen ausprobiert, und alle endeten zwischen 29 und 33 Bytes. Ein Problem ist, dass ich keine Möglichkeit gefunden habe, die Zeichenfolge in Werte zu konvertieren, die automatisch zu 0 für die Leerzeichen führen würden. Also habe ich explizit die Leerzeichen durch '0 Zeichen ersetzt, was natürlich die Länge des Codes erhöht.

Alternativen ausprobiert:

  • Teilen der Zeichenfolge bei '^, Umkehren der ersten und anschließendes Berechnen des gewichteten Werts für beide.
  • Verwenden des eeOperators zum Hinzufügen des Index zur Werteliste.
  • Anstatt die Caret-Position von jedem Index zu subtrahieren, berechnen Sie das Skalarprodukt ohne Subtraktion und subtrahieren Sie dann die Caret-Position mal die String-Länge vom Ergebnis.

Erläuterung:

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.
Reto Koradi
quelle
1

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

Normaler Code:

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

Erläuterung:

  1. Erzeugt eine Liste von Zahlen + den Drehpunkt von stdin.
  2. Addiert für jede Zahl den Abstand vom Drehpunkt zu der Variablen zur Gesamtsumme (Zahlen links sind negativ und Zahlen rechts sind positiv).
  3. Gibt je nach Ergebnis den richtigen Buchstaben aus (B, wenn er gleich ist, L, wenn er größer als Null ist, und R, wenn er kleiner als Null ist).

Vielen Dank an @ThomasKwa für das Reduzieren von 82 Bytes (mehr als 40%)!

Coder256
quelle
Einfache 15 oder so Bytes: Verwenden Sie print('LBR'[(B>D)-(B<D)])für das Ende und B=D=0am Anfang.
Lirtosiast
Nein, noch besser: Verfolgen Sie nicht links und rechts getrennt; Multiplizieren Sie stattdessen die verbleibenden Zahlen mit einem negativen Abstand ^. Das erspart dir das abs()auch.
Lirtosiast
1

C, 140 139 138 134 100 Bytes

Rückkehr:

  • 1 = LINKS
  • 2 = AUSGEWOGEN
  • 0 = RECHTS
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;}

Lauf:

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

Wie wir ASCII haben:

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

Wir bekommen:

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

Dann summiere nach Faktor Abstand zu ^.

Runium
quelle
1

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)

tWenn es sich um eine laufende Summe handelt, sind die Werte negativ, wenn die Zeichenposition größer als die Karatposition ist. Am Ende wird angezeigt, ob total negativ, null oder positiv ist, und es wird das entsprechende Zeichen von R, B oder L ausgegeben.

Ich könnte ein paar Bytes weg rasieren, indem ich einfach -1, 0 oder 1 wie einige der anderen Antworten ausgebe.

Brian
quelle
1

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));}
Roman Gräf
quelle