To kontynuacja CodeGolf - zignoruj ​​hałas nr 1, jedynym problemem jest to, że Barry jeszcze pogorszył sytuację. Zobaczmy co się stało

Aktualizacja

Dodałem kod do tworzenia losowych danych wejściowych i oczekiwanych danych wyjściowych, ponieważ nie jestem dobry w wyjaśnianiu tego, czego chcę, i wydaje mi się, że czasami słowa są bardziej mylące niż kod (czy nie zawsze?)

Opis

Inna metoda w interfejsie API Dumb Corp daje nam bieżącą cenę, jaką dostawca podaje nam za przedmiot, optymalną cenę, przy której osiągalibyśmy maksymalną sprzedaż, oraz tendencję tej ceny w porównaniu do poprzednich cen jako ciąg UPlub DOWN. Musimy zdecydować, czy powinniśmy usunąć przedmiot ze sklepu, czy poczekać.

Wejście

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

W przypadku ogromnej przykładowej demonstracji wejściowej z oczekiwanymi danymi wyjściowymi umieść następujący kod (js) w konsoli przeglądarki i powinna wypisać prawidłowe losowe dane wejściowe do testowania.

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

Jak zawsze będziemy mieli zmienną Gjako dane wejściowe, jednak jeśli twój język ułatwia ci czytanie danych wejściowych, to również dobrze. Format jest stały i zgodny z formatemint,int,string

Pożądane wyjście

Jesteś mózgiem tej operacji, Barry powinien wykonywać te obliczenia na serwerze, ale nie możemy na niego liczyć, jak powinieneś wiedzieć. Musisz generować, WAITjeśli tendencja jest w kierunku optymalnej ceny lub STOPjeśli tendencja jest w kierunku strat.

Innymi słowy, przy 80,90,UPdanych wejściowych jako wiemy, że istnieje produkt o aktualnej cenie 80 i optymalnej cenie 90 z tendencją do wzrostu, więc powinniśmy WAIT. Z drugiej strony 840,1200,DOWNoznacza to, że cena produktu spada, a nasza optymalna cena jest wyższa, więc powinniśmy zatrzymać straty poprzez produkcję STOP.

Jeśli dwie ceny są identyczne, produkcja jest WAITniezależna od tendencji.

Każdy produkt w nowej linii, pojedyncze słowo w linii:

WAIT
WAIT
WAIT
WAIT
STOP
STOP
STOP

Jeśli to możliwe, proszę podać sposób sprawdzenia, czy kod działa, ponieważ nie wszyscy możemy się dowiedzieć, patrząc tylko na składnię. Jak zawsze używaj jak najmniejszej liczby znaków i pamiętaj, że niekoniecznie konkurujesz z innymi językami, konkurujesz z językami o podobnej składni

CJam, 31 29 27 znaków

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

To tylko zakodowana wersja następującego kodu (w celu wykorzystania punktacji według znaków):

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

Tutaj uruchom wszystkie przypadki testowe.

Może być sposób na skrócenie tego przez kodowanie STOPi WAIT, ale jestem całkiem zadowolony z reszty.

Wyjaśnienie

Kod jest otoczony pętlą, która odczytuje jednocześnie linię, przetwarza ją, a następnie wypycha nową linię i odczytuje następny wiersz ... Pętla kończy się, gdy rzwraca pusty ciąg (tj. Po przetworzeniu wszystkich wierszy). To jest to:

r{ ... Nr}h

Jeśli chodzi o przetwarzanie każdej linii, wykorzystuję fakt, że wielkie litery są zmiennymi w CJam, więc mogę ewaluować niektóre dane wejściowe.

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

Więc haczyk polega na tym, UPże odwracamy względne rozmiary cen, abyśmy mogli pokryć wszystkie przypadki z jedną nierównością na końcu.

Perl, 35

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

Przetestuj mnie .

Perl, 77 73 bajtów

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

Oto jak to działa:

• while(<>) analizuje każdą linię.
• @p=split","dzieli go przez każdy przecinek. Używa domyślnego operatora Perla $_(który jest miejscem, w którym linia jest przechowywana).
• print (ternary) określa, co wydrukować.
• $p[0]<$p[1]and$p[2]=~/D/ pyta, czy bieżąca cena jest niższa niż cena, jakiej chcemy, i spada (sprawdzając D.)
• (condition)?(if):(else) jest operatorem trójskładnikowym.
• Jeśli nasz warunek wcześniej pasował, zostanie wygenerowany STOP. W przeciwnym razie wyświetli się WAIT.

Zakładam, że nie ma końcowej nowej linii na wejściu - końcowa nowa linia produkuje dodatkową WAIT.

Dzięki Alex A. za pomoc w oszczędzeniu 4 bajtów!

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

Przetestuj mnie .

R 95 108

R i stringi, niezbyt przyjaciele :)

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

Dane wejściowe są wektorem znaków, Ga następnie zmieniają każdy ciąg znaków w ifocenianą instrukcję.

Edytuj Zepsuty moją interpretację zasad. Napraw kosztował kilka znaków.

> 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 znaków

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

Z pomocą do bluetorange!

Python 3, 89 84 82 bajtów

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

Wyjaśnienie:

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 bajtów

Nie tak mały, jak bym chciał - zwłaszcza konwersja z wartości logicznej na łańcuchy jest bardzo długa. Próbowałem zgolić kilka bajtów, przełączając się na Octave, ale najwyraźniej% c nie jest jeszcze obsługiwany dla tekstów w 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)

Osobiście uważam, że to miłe, że to rozwiązanie jest jak dotąd jedynym, które nie korzysta z podziału :)

EDYCJA: pierwotnie rozwiązany problem równości był zbyt skomplikowany.

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)

Tylko w przeglądarkach zgodnych z ECMAScript 6

Wyjaśnienie

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

Wykorzystuje fakt, że jeśli zapytamy, czy 0 jest prawdą, zwróci fałsz, więc możemy powiedzieć 1 dla UP, -1 dla DOWN. Następnie mnożymy to przez różnicę aktualnej ceny i optymalne ceny, aby oba z nich pracuje na większą niż 0 części

Jeśli warunek jest spełniony, zwróć STOP, w przeciwnym razie (w tym równe wartości) zwróćWAIT

Potrzebuje dalszej gry w golfa

JavaScript ( ES6 ), 82 80 79 bajtów

Edycja: -2 przy użyciu metody mnożenia @ JuanCortés

Edycja: -1 za pomocą lewy w celu zmniejszenia metody mnożenia

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

Skomentowano:

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

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

Historia zmian:

// 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 bajtów

Ponieważ C musi gdzieś tam być

Teraz wygląda bardzo podobnie do wersji @nutki, chociaż zastanawianie się, czy wypisać „STOP” czy „WAIT” jest różne.

Niegolfowany

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

W golfa

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

Ten stary

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

Będę nadal próbował to wyciąć

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

Praca w toku...