Este é um acompanhamento do CodeGolf - Ignore o barulho # 1, o único problema é que Barry tornou as coisas ainda piores para nós. Vamos ver o que aconteceu

Atualizar

Eu adicionei código para criar entrada aleatória e saída esperada porque não sou tão bom em explicar o que quero, e acho que às vezes as palavras são mais enganosas que o código (isso nem sempre é?)

Descrição

Outro método na API da Dumb Corp nos fornece o preço atual que um fornecedor está nos oferecendo por um item, o preço ideal com o qual estaríamos realizando vendas máximas e a tendência desse preço em comparação aos preços anteriores como uma string UPou DOWN. Precisamos decidir se devemos remover o item da loja ou esperar.

Entrada

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

Para uma demonstração de exemplo de entrada enorme com saída esperada, coloque o seguinte código (js) no console do navegador e ele deve gerar uma entrada aleatória válida para teste.

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 sempre, teremos uma variável Gcomo nossa entrada; no entanto, se o seu idioma facilitar a leitura da entrada, tudo bem. O formato é constante e segue o formatoint,int,string

Saída desejada

Você é o cérebro desta operação, Barry deveria estar fazendo esse cálculo no servidor, mas não podemos contar com ele como você deve saber. Você precisa produzir WAITse a tendência é para o preço ideal ou STOPse a tendência é para perder.

Em outras palavras, com a 80,90,UPentrada como, sabemos que existe um produto com preço atual de 80 e preço ideal de 90 com tendência a subir, por isso devemos WAIT. Por outro lado, 840,1200,DOWNsignifica que o preço do produto está caindo e nosso preço ideal é mais alto; portanto, devemos parar as perdas produzindo STOP.

Se os dois preços forem idênticos, a produção será WAITindependente da tendência.

Cada produto em uma nova linha, uma palavra por linha:

WAIT
WAIT
WAIT
WAIT
STOP
STOP
STOP

Sempre que possível, forneça uma maneira de verificar se seu código está funcionando, pois nem todos podemos saber apenas olhando a sintaxe. Como sempre, use o mínimo de caracteres possível e lembre-se de que você não está competindo necessariamente com outros idiomas, mas sim com idiomas com sintaxe semelhante.

CJam, 31 29 27 caracteres

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

Esta é apenas uma versão codificada do código a seguir (para fazer uso da pontuação por caracteres):

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

Execute todos os casos de teste aqui.

Pode haver uma maneira de reduzir isso codificando STOPe WAIT, mas estou muito feliz com o resto.

Explicação

O código é cercado por um loop que lê on-line de cada vez, processa-o, envia uma nova linha e lê a próxima linha ... O loop termina quando rretorna uma string vazia (ou seja, depois que todas as linhas foram processadas). É esse pedaço:

r{ ... Nr}h

Quanto ao processamento de cada linha, estou fazendo uso do fato de que letras maiúsculas são variáveis ​​no CJam, para avaliar algumas das 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.

Portanto, o problema é que UP, invertemos os tamanhos relativos dos preços, para que possamos cobrir todos os casos com uma única desigualdade no final.

Perl, 35

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

Me teste .

Perl, 77 73 bytes

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

Veja como funciona:

• while(<>) analisa todas as linhas.
• @p=split","divide por cada vírgula. Está usando o operador Perl padrão $_(que é onde a linha está armazenada).
• print (ternary) determina o que imprimir.
• $p[0]<$p[1]and$p[2]=~/D/ pergunta se o preço atual é menor que o preço desejado e está diminuindo (verificando um D.)
• (condition)?(if):(else) é o operador ternário.
• Se nossa condição corresponder anteriormente, ela será gerada STOP. Caso contrário, será exibido WAIT.

Estou assumindo que não há nova linha final na entrada - uma nova linha final produz um extra WAIT.

Obrigado a Alex A. por me ajudar a economizar 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");}

Me teste .

R, 95 108

R e cordas, não realmente amigos :)

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

Input é o vetor de caracteres e Gdepois muda cada string em uma ifinstrução que é avaliada.

Editar Desarrumei minha interpretação das regras. A correção custou alguns caracteres.

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

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

Com ajuda de para 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])

Explicação:

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

Não é tão pequeno quanto eu gostaria - especialmente a conversão de booleano para strings é muito longa. Tentei cortar alguns bytes alternando para o Octave, mas aparentemente o% c ainda não é suportado para textos no 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)

Pessoalmente, acho bom que esta solução seja a única até agora que não use split :)

EDIT: originalmente resolveu a situação igual a muito complexa.

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)

Somente em navegadores compatíveis com ECMAScript 6

Explicação

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

Ele faz uso do fato de que, se perguntarmos se 0 é verdadeiro, ele retornará falso, para que possamos dizer 1 para UP, -1 para DOWN. Em seguida, multiplicamos isso pela diferença de preço atual e preço ideal para fazê-los funcionar por mais de 0 parte

Se a condição for atendida, retorne STOP, caso contrário (incluindo valores iguais) retorneWAIT

Precisa de mais golfe

Javascript ( ES6 ), 82 80 79 bytes

Edit: -2 usando o método de multiplicação @ JuanCortés

Edit: -1 usando um truque para reduzir o método de multiplicação

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

Demonstração de trechos:

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>

Histórico de Revisão:

// 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 tem que estar lá em algum lugar

Agora parece muito semelhante à versão @nutki, embora seja difícil diferenciar a saída "STOP" ou "WAIT".

Ungolfed-

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

Golfed-

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

O antigo

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

Vou continuar tentando reduzi-lo

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

Trabalho em progresso...