Questo è il seguito di CodeGolf - Ignora il rumore n. 1, l'unico problema è che Barry ha peggiorato le cose per noi. Vediamo cosa è successo

Aggiornare

Ho aggiunto del codice per creare input casuali e output attesi perché non sono così bravo a spiegare quello che voglio, e immagino che a volte le parole siano più fuorvianti del codice (non è sempre così?)

Descrizione

Un altro metodo nell'API di Dumb Corp ci fornisce il prezzo corrente che un fornitore ci fornisce per un articolo, il prezzo ottimale con il quale faremmo il massimo delle vendite e la tendenza di quel prezzo rispetto ai prezzi precedenti come stringa UPo DOWN. Dobbiamo decidere se rimuovere l'articolo dal negozio o attendere.

Ingresso

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

Per un'enorme demo di esempio di input con output previsto, inserisci il seguente codice (js) nella console del tuo browser e dovrebbe generare un input casuale valido per il test.

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

Come sempre avremo una variabile Gcome input, tuttavia se la tua lingua ti rende più semplice leggere l'input, va bene lo stesso. Il formato è costante e segui il formatoint,int,string

Uscita desiderata

Sei il cervello di questa operazione, Barry dovrebbe fare questo calcolo sul server, ma non possiamo contare su di lui come dovresti sapere. È necessario produrre WAITse la tendenza è verso il prezzo ottimale o STOPse la tendenza è verso le perdite.

In altre parole, con l' 80,90,UPingresso as, sappiamo che esiste un prodotto con un prezzo attuale di 80 e un prezzo ottimale di 90 con una tendenza a salire, quindi dovremmo WAIT. D'altra parte, 840,1200,DOWNsignifica che il prezzo del prodotto sta scendendo e il nostro prezzo ottimale è più alto, quindi dovremmo fermare le perdite emettendo STOP.

Se i due prezzi sono identici, produrre WAITindipendentemente dalla tendenza.

Ogni prodotto in una nuova riga, parola singola per riga:

WAIT
WAIT
WAIT
WAIT
STOP
STOP
STOP

Per favore, quando possibile, fornisci un modo per verificare che il tuo codice funzioni poiché non possiamo saperlo semplicemente guardando la sintassi. Come sempre, usa il minor numero di caratteri possibile e ricorda che non stai necessariamente competendo con altre lingue, stai competendo con lingue con sintassi simile

CJam, 31 29 27 caratteri

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

Questa è solo una versione codificata del seguente codice (per utilizzare il punteggio per carattere):

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

Esegui tutti i casi di test qui.

Potrebbe esserci un modo per accorciarlo codificando STOPe WAIT, ma sono abbastanza contento del resto.

Spiegazione

Il codice è circondato da un ciclo che legge alla riga alla volta, lo elabora, quindi spinge una nuova riga e legge la riga successiva ... Il ciclo termina una volta rrestituisce una stringa vuota (cioè dopo che tutte le righe sono state elaborate). Questo è questo bit:

r{ ... Nr}h

Per quanto riguarda l'elaborazione di ogni riga, sto sfruttando il fatto che le lettere maiuscole sono variabili in CJam, quindi posso valutare alcuni degli input.

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

Quindi il problema è che UPinvertiamo le dimensioni relative dei prezzi, in modo da poter coprire tutti i casi con un'unica disuguaglianza alla fine.

Perl, 35

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

Metti alla prova me .

Perl, 77 73 byte

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

Ecco come funziona:

• while(<>) analizza ogni riga.
• @p=split","lo divide per ogni virgola. Sta usando l'operatore Perl predefinito, $_(che è dove è memorizzata la linea.)
• print (ternary) determina cosa stampare.
• $p[0]<$p[1]and$p[2]=~/D/ chiede se il prezzo corrente è inferiore al prezzo che vogliamo e sta diminuendo (controllando una D.)
• (condition)?(if):(else) è l'operatore ternario.
• Se la nostra condizione in precedenza corrispondeva, verrà emessa STOP. Altrimenti, verrà emesso WAIT.

Suppongo che non ci sia una nuova riga finale sull'input - una nuova riga finale produce un extra WAIT.

Grazie ad Alex A. per avermi aiutato a salvare 4 byte!

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

Metti alla prova me .

R, 95 108

R e archi, non proprio amici :)

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

L'input è il vettore di caratteri, Gquindi cambia ogni stringa in ifun'istruzione che viene valutata.

Modifica Ho incasinato la mia interpretazione delle regole. Il costo fisso di alcuni personaggi.

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

Rubino - 89 caratteri

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 l'aiuto di bluetorange!

Python 3, 89 84 82 byte

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

Spiegazione:

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 byte

Non piccolo come vorrei - specialmente la conversione da booleana a stringhe è molto lunga. Ho provato a radere alcuni byte passando a Octave, ma a quanto pare% c non è ancora supportato per il textcan in 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 penso che sia bello che questa soluzione sia l'unica finora che non usa split :)

EDIT: originariamente risolto la situazione uguale troppo complesso.

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 su browser compatibili con ECMAScript 6

Spiegazione

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

Fa uso del fatto che se chiediamo se 0 è vero, restituirà falso, quindi possiamo dire 1 per UP, -1 per DOWN. Poi si moltiplica che dalla differenza di prezzo corrente e il prezzo ottimale di rendere entrambi lavoro per la maggiore di 0 parte

Se la condizione è soddisfatta, ritorna STOP, altrimenti (compresi gli stessi valori) ritornaWAIT

Ha bisogno di ulteriore golf

Javascript ( ES6 ), 82 80 79 byte

Modifica: -2 usando il metodo di moltiplicazione @ JuanCortés

Modifica: -1 usando un trucco per ridurre il metodo di moltiplicazione

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

ha commentato:

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

Demo dello snippet:

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>

Cronologia delle revisioni:

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

Perché C deve essere lì da qualche parte

Ora sembra molto simile alla versione di @nutki anche se capire se l'output di "STOP" o "WAIT" è diverso.

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

Quello vecchio

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

Continuerò a provare a ridurlo

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

Lavori in corso...