Dies ist eine Fortsetzung von CodeGolf - Ignorieren Sie den Lärm Nr. 1, das einzige Problem ist, dass Barry die Dinge für uns noch schlimmer gemacht hat. Lass uns nachsehen, was passiert ist

Aktualisieren

Ich habe Code hinzugefügt, um zufällige Eingaben und erwartete Ausgaben zu erstellen, weil ich nicht so gut erklären kann, was ich will, und ich denke, dass Wörter manchmal irreführender sind als Code (ist das nicht immer so?)

Beschreibung

Eine andere Methode in der API von Dumb Corp gibt uns den aktuellen Preis an, den uns ein Anbieter für einen Artikel gibt, den optimalen Preis, mit dem wir maximale Verkäufe erzielen würden, und die Tendenz dieses Preises im Vergleich zu früheren Preisen als Zeichenfolge UPoder DOWN. Wir müssen uns entscheiden, ob wir den Artikel aus dem Shop entfernen oder warten sollen.

Eingang

80,90,UP
150,100,DOWN
65,65,UP
1618,1618,DOWN
840,1200,DOWN
54,12,UP
30,1,UP

Geben Sie für eine große Demo eines Eingabebeispiels mit erwarteter Ausgabe den folgenden Code (js) in die Browserkonsole ein und es sollte eine gültige zufällige Eingabe zum Testen ausgeben.

var output = "";
var result = "";

for(i=10;i--;){
  var currentPrice = Math.floor(Math.random() * 10000) + 1;
  var optimalPrice = Math.floor(Math.random() * 10000) + 1;
  var tendency = Math.round(Math.random())?"UP":"DOWN";
  var tresult = "WAIT\n";

  if((currentPrice > optimalPrice && tendency == "UP") ||
     (currentPrice < optimalPrice && tendency == "DOWN")){
       tresult = "STOP\n";
     }

  output +=currentPrice+","+optimalPrice+","+tendency+"\n";
  result +=tresult;
}
console.log(output);
console.log(result);

Wie immer haben wir eine Variable Gals Eingabe. Wenn Ihre Sprache es Ihnen jedoch leichter macht, die Eingabe einfach zu lesen, ist das auch in Ordnung. Das Format ist konstant und folgt dem Formatint,int,string

Gewünschte Ausgabe

Sie sind der Kopf dieser Operation. Barry sollte diese Berechnung auf dem Server durchführen, aber wir können uns nicht auf ihn verlassen, wie Sie wissen sollten. Sie müssen ausgeben, WAITwenn die Tendenz zum optimalen Preis geht oder STOPwenn die Tendenz zu Verlusten geht.

Mit anderen Worten, mit dem 80,90,UPas-Input wissen wir, dass es ein Produkt mit einem aktuellen Preis von 80 und einem optimalen Preis von 90 gibt, mit der Tendenz zu steigen, also sollten wir es tun WAIT. Auf der anderen Seite 840,1200,DOWNbedeutet dies , dass der Produktpreis sinkt und unser optimaler Preis höher ist. Daher sollten wir Verluste durch Ausgabe stoppen STOP.

Wenn die beiden Preise identisch sind, wird WAITunabhängig von der Tendenz ausgegeben .

Jedes Produkt in einer neuen Zeile, ein Wort pro Zeile:

WAIT
WAIT
WAIT
WAIT
STOP
STOP
STOP

Bitte geben Sie nach Möglichkeit eine Möglichkeit, um zu überprüfen, ob Ihr Code funktioniert, da wir nicht alle nur anhand der Syntax wissen können. Verwenden Sie wie immer so wenig Zeichen wie möglich und denken Sie daran, dass Sie nicht unbedingt mit anderen Sprachen konkurrieren, sondern mit Sprachen mit ähnlicher Syntax

CJam, 31 29 27 Zeichen

"㫅㍸ꕆ敟鸢Ꝓ約䢫솓儓隆뻨"2G#b128b:c~

Dies ist nur eine codierte Version des folgenden Codes (um die Bewertung nach Zeichen zu nutzen):

r{',/:~3<)(f*~<"STOP""WAIT"?Nr}h

Führen Sie hier alle Testfälle aus.

Es könnte eine Möglichkeit geben, dies durch Codierung STOPund zu verkürzen WAIT, aber mit dem Rest bin ich ziemlich zufrieden.

Erläuterung

Der Code ist von einer Schleife umgeben, die jeweils eine Zeile liest, verarbeitet, dann eine neue Zeile drückt und die nächste Zeile liest ... Die Schleife wird beendet, sobald reine leere Zeichenfolge zurückgegeben wird (dh nachdem alle Zeilen verarbeitet wurden). Das ist das bisschen:

r{ ... Nr}h

Bei der Verarbeitung jeder Zeile nutze ich die Tatsache, dass Großbuchstaben Variablen in CJam sind, damit ich einen Teil der Eingabe auswerten kann.

',/:~3<)(f*~<"STOP""WAIT"?
',/                        e# Split the input on commas.
   :~                      e# Eval each of the three resulting strings. The first two
                           e# will yield the prices, the third will dump a bunch of
                           e# values corresponding to the variables DNOPUW in the array.
     3<                    e# Truncate to three elements, so we only get the prices and
                           e# the values corresponding to U (0) and D (13).
       )(                  e# Slices off that variable value and decrement it, to get
                           e# something negative for UP and positive for DOWN.
         f*                e# Multiply both numbers by that value. So if we had UP then
                           e# both numbers will be negative now, otherwise they'll just
                           e# be scaled without affecting their relative size.
           ~<              e# Unwrap the array and check which element is larger.
             "STOP""WAIT"? e# Select the desired output string based on this boolean.

Der Haken ist also, dass UPwir die relativen Größen der Preise umkehren, so dass wir am Ende alle Fälle mit einer einzigen Ungleichung abdecken können.

Perl, 35

#!perl -pl
/,/;$_=$`-$'&&$`>$'^/D/?STOP:WAIT

Teste mich .

Perl, 77 73 Bytes

while(<>){@p=split",";print($p[0]<$p[1]and$p[2]=~/D/?"STOP":"WAIT")."\n"}

So funktioniert das:

• while(<>) analysiert jede Zeile.
• @p=split","teilt es durch jedes Komma. Es wird der Standard-Perl-Operator verwendet $_(in dem die Zeile gespeichert ist).
• print (ternary) legt fest, was gedruckt werden soll.
• $p[0]<$p[1]and$p[2]=~/D/ fragt, ob der aktuelle Preis niedriger ist als der von uns gewünschte Preis, und er sinkt (durch Überprüfen auf ein D.)
• (condition)?(if):(else) ist der ternäre Operator.
• Wenn unser Zustand früher übereinstimmt, wird er ausgegeben STOP. Andernfalls wird es ausgegeben WAIT.

Ich gehe davon aus, dass die Eingabe keine nachgestellte Newline enthält - eine nachfolgende Newline erzeugt eine zusätzliche WAIT.

Vielen Dank an Alex A., der mir geholfen hat, 4 Bytes zu sparen!

C 85

c;main(i,j){for(;scanf("%d,%d,%c%*s",&i,&j,&c)>0;)puts(i-j&&i>j^c<70?"STOP":"WAIT");}

Teste mich .

R 95, 108

R und Streicher, nicht wirklich Freunde :)

eval(parse(t=sub("U","<",sub("D",">",gsub("(.*),(.*),(.).*","cat(if(\\1\\3=\\2)'WAIT\n'else'STOP\n')",G)))))

Die Eingabe ist der Zeichenvektor Gund ändert dann jede Zeichenfolge in eine ifAnweisung, die ausgewertet wird.

Bearbeiten Hat meine Interpretation der Regeln durcheinander gebracht. Fix kostet ein paar Zeichen.

> G=c(
+     '80,90,UP',
+     '150,100,DOWN',
+     '65,65,UP',
+     '1618,1618,DOWN',
+     '840,1200,DOWN',
+     '54,12,UP',
+     '30,1,UP'
+ )
> eval(parse(t=sub("U","<",sub("D",">",gsub("(.*),(.*),(.).*","cat(if(\\1\\3=\\2)'WAIT\n'else'STOP\n')",G)))))
WAIT
WAIT
WAIT
WAIT
STOP
STOP
STOP
>

Rubin - 89 Zeichen

G.split.map{|a|b,c,d=a.split(?,);puts (b.to_i>=c.to_i)^(e=d[2])&&(b!=c||e)?'STOP':'WAIT'}

RubyFiddle

Mit Hilfe von zu Bluetorange!

Python 3, 89 84 82 Bytes

for l in G:a,b,c=l.split(',');print('WSATIOTP'[a==b or(int(a)<int(b))^(c<'U')::2])

Erläuterung:

for l in G:                                   #For every line in G:
           a,b,c=l.split(',');                #Split the line into three strings.
                              print()         #Print the contained expression.

'WSATIOTP'                                    #'WAIT' and 'STOP' interleaved.
          [                              ::2] #Select every other character.
                or                            #If either expression is true, pick 'WAIT'
           a==b
                  (             )^(     )     #Select 'WAIT' if exactly one is true.
                   int(a)<int(b)              #If first number < second number.
                                   c<'U'      #If c is 'DOWN'

Matlab, 100 90 Bytes

Nicht so klein wie ich möchte - besonders die Konvertierung von Booleschen zu Strings ist sehr lang. Ich habe versucht, ein paar Bytes durch Umschalten auf Octave zu sparen, aber anscheinend wird% c für Textscan in Octave noch nicht unterstützt.

B=textscan(G,'%f,%f,%c%s\n');xor(B{1}>=B{2},B{3}==85);C(a)={'STOP'};C(~a)={'WAIT'};char(C)

Persönlich finde ich es schön, dass diese Lösung die einzige ist, die bisher keinen Split verwendet :)

EDIT: Ursprünglich gelöst die Gleichstellungssituation viel zu komplex.

Javascript ECMAScript 6, 112b

var O="";for(let E of G.split("\n"))[A,B,C]=E.split(","),O+=("U"<C||-1)*(A-B)>0?"STOP\n":"WAIT\n";console.log(O)

Nur in ECMAScript 6-kompatiblen Browsern

Erläuterung

("U"<C||-1)*(A-B)>0?"STOP\n":"WAIT\n"

Es nutzt die Tatsache, dass wenn wir fragen, ob 0 wahr ist, es falsch zurückgibt, so dass wir 1 für UP, -1 für sagen können DOWN. Dann multiplizieren wir dies mit der Differenz zwischen dem aktuellen Preis und dem optimalen Preis, damit beide für den Teil größer als 0 funktionieren

Wenn die Bedingung erfüllt ist, geben Sie zurück STOP, andernfalls (einschließlich gleicher Werte)WAIT

Benötigt weiteres Golfen

Javascript ( ES6 ), 82 80 79 Bytes

Bearbeiten: -2 mit der @ JuanCortés-Multiplikationsmethode

Bearbeiten: -1 mit einem Trick, um die Multiplikationsmethode zu reduzieren

alert(G.replace(/(.+),(.+),(.)+/g,(x,c,o,t)=>(c-o)*~{P:-2}[t]>0?'STOP':'WAIT'))

Kommentiert:

alert(                           // alert final output after replacement
    G.replace(/(.+),(.+),(.)+/g, // capture group for sections of each line
                                 // (.)+ captures only the last character
                                 // . doesn't match newlines, so this runs for each line
        (x,c,o,t)=>              // use a function to calculate each replacement string
            (c - o)              // calculate difference, negative for o>c
            *                    // multiply by
            ~{ P: -2 }[t]        // { P: -2 }[t] returns -2 for UP ('P') -2, else undefined
                                 // ~-2 => 1, ~undefined => -1
            > 0                  // if result > 0 (muplication of negatives or positives)
            ? 'STOP' : 'WAIT'    // return corresponding replacement string
    )
)

Snippet-Demo:

function run(){
    G = input.value;
    /* start solution */
    alert(G.replace(/(.+),(.+),(.)+/g,(x,c,o,t)=>(c-o)*~{P:-2}[t]>0?'STOP':'WAIT'))
    /* end solution */
}

<textarea id="input" cols="25" rows="7">80,90,UP
150,100,DOWN
65,65,UP
1618,1618,DOWN
840,1200,DOWN
54,12,UP
30,1,UP</textarea><br />
<button id="run" onclick="run();">Run</button>

Versionsgeschichte:

// 80
alert(G.replace(/(.+),(.+),(.)+/g,(x,c,o,t)=>(c-o)*(t>'N'||-1)>0?'STOP':'WAIT'))

// 82
alert(G.replace(/(.+),(.+),(.)+/g,(x,c,o,t)=>+c>o&t>'N'|+c<o&t<'P'?'STOP':'WAIT'))

C-91 Bytes

Weil C irgendwo da sein muss

Sieht jetzt der @ nutki-Version sehr ähnlich, obwohl es unterschiedlich ist, herauszufinden, ob "STOP" oder "WAIT" ausgegeben werden soll.

Ungolfed-

main(i,j)
{
    char c[5];
    while(scanf("%i,%i,%s",&i,&j,c)+1)
        puts((j-i)*(*c-70)<0?"STOP":"WAIT");
}

Golf-

 main(i,j){char c[5];while(scanf("%i,%i,%s",&i,&j,c)+1)puts((j-i)*(*c-70)<0?"STOP":"WAIT");}

Das Alte

Ungolfed-

int main()
{
    int i,j;
    char *c="";
    while(scanf("%i,%i,%s",&i,&j,c)+1)
    {
        if(i<j)
        {
            if(*c-68)
                printf("WAIT\n");
            else
                printf("STOP\n");
        }
        if(i>j)
        {
            if(*c-68)
                printf("STOP\n");
            else
                printf("WAIT\n");
        }
        if(i==j)
            printf("WAIT\n");
    }
    return 0;
}

Golfed

#define W printf("WAIT\n");
#define S printf("STOP\n");
int main(){int i,j;char *c="";while(scanf("%i,%i,%s",&i,&j,c)+1){if(i<j){if(*c-68)W else S}if(i>j){if(*c-68)S else W}if(i==j)W}return 0;}

Ich werde weiterhin versuchen, es zu reduzieren

Python 3 - 108 106 102 97B

for l in G:a,b,c=l.split(',');s=int(a)-int(b);d=c<'E';print(['WAIT','STOP'][(s<0)*d+(s>0)*(1-d)])

In Arbeit...