Die Einrichtung:

Ein soziales Netzwerk gibt die Anzahl der Stimmen eines Posts auf zwei Arten an: die Anzahl der Netto-Upvotes (Gesamt-Upvotes - Gesamt-Downvotes) und die Prozentzahl der Stimmen, die Upvotes waren , auf die nächste Ganzzahl gerundet (0,5 Aufrundungen ). Die Anzahl der Netto-Upvotes ist eine ganze Zahl (nicht unbedingt positiv), und die zweite ist garantiert eine ganze Zahl zwischen 0 und einschließlich +100. Sowohl die Anzahl der positiven als auch die Anzahl der negativen Stimmen sind entweder null oder positive 32-Bit-Ganzzahlen (Sie können vorzeichenbehaftete oder vorzeichenlose angeben). Angenommen, bei einer Gesamtzahl von null Stimmen wird der Prozentsatz der abgegebenen Stimmen als null gemeldet.

Die Herausforderung:

Was ist das kürzeste Programm, das Sie schreiben können, um die niedrigste Anzahl von Gesamt-Upvotes zu ermitteln, die der Beitrag erhalten hat, wenn alle oben genannten Bedingungen erfüllt sind?

Eingabebeschränkungen sind garantiert. Wenn die Eingabe die oben genannten Einschränkungen nicht erfüllt, liegt das Programmverhalten bei Ihnen. Bonus-Kudos, wenn es nicht in eine Endlosschleife geht oder auf andere Weise abstürzt. Überlegen Sie, ob Sie eine negative Zahl zurückgeben möchten, wenn Sie weitere Anleitungen benötigen.

Allgemeine Regeln:

• Das ist Code-Golf , also gewinnt die kürzeste gültige Lösung (gemessen in Bytes).
• Lassen Sie sich von Code-Golf-Sprachen nicht davon abhalten, Antworten mit Nicht-Codegolf-Sprachen zu veröffentlichen. Versuchen Sie, für jede Programmiersprache eine möglichst kurze Antwort zu finden. Bonuskudos für eine clientseitige Web-Sprache wie Javascript.
• Wenn Sie interessante Lösungen in mehreren Sprachen haben, veröffentlichen Sie diese separat .
• Für Ihre Antwort gelten Standardregeln. Daher dürfen Sie STDIN / STDOUT, Funktionen / Methoden mit den richtigen Parametern und dem richtigen Rückgabetyp oder vollständige Programme verwenden. Ihr Anruf.
• Standardlücken sind verboten.
• Fügen Sie nach Möglichkeit einen Link mit einem Test für Ihren Code hinzu.
• Fügen Sie außerdem eine Erläuterung der Funktionsweise des Codes hinzu.
• Denken Sie daran, dass wenn Sie eine Ganzzahldivisionsoperation ausführen, die anstelle von Runden abschneidet (z. B. 20/3 = 6) , dies möglicherweise nicht vollständig korrekt ist.
• Zusätzliche Testfälle, die die Randfälle in den obigen Einschränkungen untersuchen, sind willkommen.
• Während der erwartete Rückgabetyp numerisch ist, kann anstelle von 0 der Boolesche Wert "false" verwendet werden .

Beispiel Testfälle:

Die erste Spalte enthält lediglich eine Referenznummer, um die Diskussion zu erleichtern.

ref net  %up    answer
1   0    0   => 0    
2   -5   0   => 0    
3   -4   17  => 1    
4   -3   29  => 2    
5   -2   38  => 3    
6   -1   44  => 4    
7   0    50  => 1    
8   5    100 => 5    
9   4    83  => 5    
10  3    71  => 5    
11  2    63  => 5    
12  1    56  => 5    
13  1234 100 => 1234
14  800  90  => 894  (tip: don't refer to this as the "last test case;" others may be added.)

JavaScript (ES6), 47 Byte

Nimmt Eingaben in der Currying-Syntax vor (n)(p), wobei n die Anzahl der Netto-Upvotes und p der Prozentsatz der Upvotes ist. Mai zurückkehren falsefür0 .

n=>p=>(g=u=>u/(u-n/2)*50+.5^p?g(u+1):u)(n>0&&n)

Probieren Sie es online!

Kommentiert

n => p => (          // given n and p
  g = u =>           // g = recursive function taking u = number of upvotes
    u / (u - n / 2)  //   compute u / (total_votes / 2)
    * 50 + .5        //   turn it into a percentage, add 1/2
    ^ p ?            //   XOR it with p, which gives 0 if the integer parts are matching
                     //   if the result is not equal to 0:
      g(u + 1)       //     try again with u + 1
    :                //   else:
      u              //     stop recursion and return u
)(n > 0 && n)        // initial call to g() with u = max(0, n)

Edge-Fälle

Sei F _n (u) = u / (u - n / 2) * 50 + 0,5

• Wenn U = 0 und n = 0 , dann F _n (u) = NaN und F _n (u) XOR p = p . Wir geben also u = 0 zurück, wenn n = p = 0 (erste Iteration des ersten Testfalls) oder fahren mit der Rekursion fort, wenn p! = 0 (erste Iteration des 7. Testfalls).

• Wenn u> 0 und u = n / 2 , dann ist F _n (u) = + Unendlich und - wieder - F _n (u) XOR p = p . Sofern nicht p = 0 , fahren wir mit der nächsten Iteration fort. (Dies geschieht im 9. und 11. Testfall.)

Stax , 17 Bytes

ëI╩½• ╠☺Vì∞«S↑♠αS

Führen Sie es aus und debuggen Sie es

Das ist rohe Gewalt. Es beginnt mit 0 für Kandidaten-Upvotes und wird inkrementiert, bis es die Formel erfüllt.

Ausgepackt, ungolfed und kommentiert sieht es so aus.

0       push zero
{       start filter block...
        candidate upvotes is on the stack
  cHx-  calculate candidate downvotes for denominator (upvotes * 2 - net)
  c1?   if denominator is zero, replace it with 1
  :_    floating point division
  AJ*   multiply by 100
  j     round to integer
  ;=    is equal to second input?
        increment until a match is found
}gs

Führen Sie dieses aus

Sauber , 114 107 104 Bytes

import StdEnv
? =toReal o toInt
$a d#e= ?d
= ?a+until(\c#b= ~c*e/(e-100.0)
= ?(?100*b/(?b+c))==e)inc 0.0

Probieren Sie es online!

Definiert die Funktion $ :: Int Int -> Real, bei der die Argumente Ganzzahlen mit Vorzeichen sind und der Rückgabewert ein Gleitkomma mit doppelter Genauigkeit ist, das exakt durch eine 32-Bit-Ganzzahl mit Vorzeichen dargestellt werden kann.

Es prüft jeden Wert cin der Gleichung b=-cd/(d+1), um eine bbefriedigende zu finden , a+c=bund nimmt b/(b+c)=d, da das kleinste cErgebnis das kleinste bist, das erste Element der Menge aller Lösungen.

05AB1E , 13 Bytes [geringfügig unterbrochen]

*²·т-/ò²т;Qi1

Probieren Sie es online!

Erläuterung:

Um dies zu lösen, nahm ich die Eingaben a, b und das erwartete Ergebnis x an. Angesichts der Informationen im Setup ergab sich folgende Gleichung:

 2x         100x
———— - a = ——————
 a           b

Neuordnung für x ergibt

        ab
x = ——————————
     2b - 100

Der einzige Testfall, für den dies nicht funktioniert, ist 0, 50 - ich habe es einfach hartcodiert, um dies zu überprüfen.

*²·т-/ò²т;Qi1     Implicit Inputs: a, b              STACK (bottom to top)
*                 Multiply the inputs together       [ab]
 ²·               Take the second input * 2          [ab, 2b]
   т-             Subtract 100                       [ab, 2b - 100]
     /ò           Divide and round                   [round(ab/(2b-100))]
       ²т;Qi1     If 2nd input = 50, push 1 to stack
                  { Implicitly output top item of stack [either 1, or round(...)] }

Gehe zu 1.10, 154 Bytes

func h(n,u float64)float64{if u==50{return 1};r:=Round(n*u/(2*u-100));s:=Round(n*(u+.5)/(2*u-99));v:=s/(2*s-n);if v>1||Round(v*100)!=u{return r};return s}

Probieren Sie es auf Go Playground! (TIO führt Go 1.9 aus, das keine math.Round hat.)

Ungolfed-Version

func haters(n, u float64) float64 {
    if u == 50 {
        return 1
    }
    r := Round(n * u / (2*u - 100))
    //Test the case where we were given a percentage that was rounded down (e.g. 90.4% given as 90%)
    //We test this by adding 0.5% to u. The denominator is just a simplified form of 2*(u+0.5) - 100
    s := Round(n * (u + .5) / (2*u - 99))
    //Check if s is a valid result
    v := s / (2*s - n)
    if v > 1 || Round(v*100) != u {
        return r
    }
    //s is strictly less than r, so we don't need to check the minimum.
    return s
}

Um eine Erklärung hinzuzufügen, kann die obige Formel für r durch gleichzeitiges Lösen n=v-dund u = 100 * v/(v + d)für v abgeleitet werden, wobei v und d die Anzahl der positiven bzw. negativen Stimmen sind. Die abgeleitete Formel ist für v = 50 undefiniert, daher müssen wir diesen Fall behandeln (was wir mit der ersten if-Anweisung tun).