Este es un seguimiento de CodeGolf: ignore el ruido n. ° 1, el único problema es que Barry nos ha empeorado las cosas. Vamos a ver que pasó

Actualizar

Agregué código para crear entradas aleatorias y salidas esperadas porque no soy tan bueno para explicar lo que quiero, y supongo que a veces las palabras son más engañosas que el código (¿no es así siempre?)

Descripción

Otro método en la API de Dumb Corp nos da el precio actual que un proveedor nos está dando por un artículo, el precio óptimo con el que estaríamos haciendo ventas máximas y la tendencia de ese precio en comparación con los precios anteriores como una cadena UPo DOWN. Necesitamos decidir si debemos eliminar el artículo de la tienda o esperar.

Entrada

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

Para una demostración de muestra de gran entrada con salida esperada, coloque el siguiente código (js) en la consola de su navegador y debería generar una entrada aleatoria válida para la prueba.

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

Como siempre tendremos una variable Gcomo nuestra entrada, sin embargo, si su idioma le facilita la lectura de la entrada, también está bien. El formato es constante y sigue el formato.int,int,string

Salida deseada

Eres el cerebro de esta operación, Barry debería estar haciendo este cálculo en el servidor, pero no podemos contar con él como debes saber. Debe generar WAITsi la tendencia es hacia el precio óptimo, o STOPsi la tendencia es hacia la pérdida.

En otras palabras, con la 80,90,UPentrada como, sabemos que hay un producto con un precio actual de 80 y un precio óptimo de 90 con una tendencia a subir, por lo que deberíamos WAIT. Por otro lado, 840,1200,DOWNsignifica que el precio del producto está bajando y nuestro precio óptimo es más alto, por lo que deberíamos detener las pérdidas produciendo STOP.

Si los dos precios son idénticos, la producción WAITindependientemente de la tendencia.

Cada producto en una nueva línea, una sola palabra por línea:

WAIT
WAIT
WAIT
WAIT
STOP
STOP
STOP

Por favor, cuando sea posible, proporcione una forma de verificar que su código esté funcionando, ya que no todos podemos saberlo simplemente mirando la sintaxis. Como siempre, use la menor cantidad de caracteres posible y recuerde que no está compitiendo necesariamente con otros idiomas, compite con idiomas con una sintaxis similar.

CJam, 31 29 27 caracteres

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

Esta es solo una versión codificada del siguiente código (para hacer uso de la puntuación por caracteres):

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

Ejecute todos los casos de prueba aquí.

Puede haber una forma de acortar esto mediante la codificación STOPy WAIT, pero estoy bastante contento con el resto.

Explicación

El código está rodeado por un bucle que se lee en línea a la vez, lo procesa, luego empuja una nueva línea y lee la siguiente línea ... El bucle termina una vez que rdevuelve una cadena vacía (es decir, después de que se hayan procesado todas las líneas). Esa es esta parte:

r{ ... Nr}h

En cuanto al procesamiento de cada línea, estoy haciendo uso del hecho de que las letras mayúsculas son variables en CJam, por lo que puedo evaluar algunas de las entradas.

',/:~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.

Entonces, el problema es que UPinvertimos los tamaños relativos de los precios, para que podamos cubrir todos los casos con una desigualdad única al final.

Perl, 35

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

Ponme a prueba .

Perl, 77 73 bytes

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

Así es como funciona:

• while(<>) analiza cada línea.
• @p=split","lo divide por cada coma. Está utilizando el operador Perl predeterminado $_(que es donde se almacena la línea).
• print (ternary) determina qué imprimir.
• $p[0]<$p[1]and$p[2]=~/D/ pregunta si el precio actual es menor que el precio que queremos y está bajando (marcando una D.)
• (condition)?(if):(else) es el operador ternario.
• Si nuestra condición coincidía anteriormente, saldrá STOP. De lo contrario, saldrá WAIT.

Supongo que no hay una nueva línea final en la entrada; una nueva línea final produce un extra WAIT.

¡Gracias a Alex A. por ayudarme a ahorrar 4 bytes!

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

Ponme a prueba .

R, 95 108

R y cadenas, no realmente amigos :)

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

La entrada es el vector de caracteres y Gluego cambia cada cadena en una ifdeclaración que se evalúa.

Editar en mal estado mi interpretación de las reglas. Fix costó unos pocos personajes.

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

Ruby - 89 caracteres

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

Con ayuda de a 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])

Explicación:

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

No es tan pequeño como me gustaría, especialmente la conversión de booleano a cadenas es muy larga. Intenté reducir algunos bytes al cambiar a Octave, pero aparentemente% c aún no es compatible con textcan en Octave.

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

Personalmente, creo que es bueno que esta solución sea la única hasta ahora que no use división :)

EDITAR: originalmente resolvió la situación de igualdad de manera demasiado compleja.

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)

Solo en navegadores compatibles con ECMAScript 6

Explicación

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

Utiliza el hecho de que si preguntamos si 0 es verdadero, devolverá falso, por lo que podemos decir 1 para UP, -1 para DOWN. Luego lo multiplicamos por la diferencia del precio actual y el precio óptimo para que ambos funcionen por más de 0 partes.

Si se cumple la condición, regrese STOP, de lo contrario (incluyendo valores iguales) regreseWAIT

Necesita más golf

Javascript ( ES6 ), 82 80 79 bytes

Editar: -2 usando el método de multiplicación @ JuanCortés

Editar: -1 usando un truco para reducir el método de multiplicación

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

Comentado:

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

Fragmento de demostración:

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>

Revisión histórica:

// 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

Porque C tiene que estar allí en alguna parte

Ahora se ve muy similar a la versión @nutki, aunque determinar si la salida "STOP" o "WAIT" es diferente.

Sin golfos

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

Golfizado

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

El viejo

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

Continuaré intentando cortarlo

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

Trabajo en progreso...