Ceci est une suite de CodeGolf - Ignorez le bruit # 1, le seul problème étant que Barry a encore aggravé les choses pour nous. Voyons ce qui se passe

Mise à jour

J'ai ajouté du code pour créer une entrée aléatoire et une sortie attendue parce que je ne suis pas très bon pour expliquer ce que je veux, et je suppose que parfois les mots sont plus trompeurs que le code (n'est-ce pas toujours?)

La description

Une autre méthode de l' API de Dumb Corp nous donne le prix actuel qu'un fournisseur nous donne pour un article, le prix optimal avec lequel nous ferions des ventes maximales et la tendance de ce prix par rapport aux prix précédents sous forme de chaîne UPou DOWN. Nous devons décider si nous devons retirer l'article de la boutique ou attendre.

Contribution

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

Pour un énorme exemple de démonstration d'entrée avec la sortie attendue, mettez le code suivant (js) dans la console de votre navigateur et il devrait sortir une entrée aléatoire valide pour le 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);

Comme toujours, nous aurons une variable Gcomme entrée, mais si votre langue vous facilite la lecture de l'entrée, c'est bien aussi. Le format est constant et suit le formatint,int,string

Sortie désirée

Vous êtes le cerveau de cette opération, Barry devrait faire ce calcul sur le serveur, mais nous ne pouvons pas compter sur lui comme vous devez le savoir. Vous devez produire WAITsi la tendance est au prix optimal ou STOPsi la tendance est à la perte.

En d'autres termes, avec l' 80,90,UPentrée as, nous savons qu'il existe un produit avec un prix actuel de 80 et un prix optimal de 90 avec une tendance à la hausse, nous devrions donc WAIT. D'un autre côté, cela 840,1200,DOWNsignifie que le prix du produit baisse et que notre prix optimal est plus élevé, nous devons donc arrêter les pertes en produisant STOP.

Si les deux prix sont identiques, production WAITquelle que soit la tendance.

Chaque produit dans une nouvelle ligne, un seul mot par ligne:

WAIT
WAIT
WAIT
WAIT
STOP
STOP
STOP

S'il vous plaît, si possible, fournissez un moyen de vérifier que votre code fonctionne car nous ne pouvons pas tous le savoir simplement en regardant la syntaxe. Comme toujours, utilisez le moins de caractères possible et rappelez-vous que vous n'êtes pas nécessairement en concurrence avec d'autres langues, votre concurrence avec des langues avec une syntaxe similaire

CJam, 31 29 27 caractères

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

Ceci est juste une version codée du code suivant (afin d'utiliser la notation par caractères):

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

Exécutez tous les cas de test ici.

Il pourrait y avoir un moyen de raccourcir cela en encodant STOPet WAIT, mais je suis assez content du reste.

Explication

Le code est entouré d'une boucle qui lit en ligne à la fois, le traite, puis pousse une nouvelle ligne et lit la ligne suivante ... La boucle se termine une fois rrenvoie une chaîne vide (c'est-à-dire après que toutes les lignes ont été traitées). Voilà ce morceau:

r{ ... Nr}h

Quant au traitement de chaque ligne, j'utilise le fait que les lettres majuscules sont des variables dans CJam, donc je peux évaluer une partie de l'entrée.

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

Donc, le hic, c'est que pour UPnous inversons les tailles relatives des prix, afin que nous puissions couvrir tous les cas avec une seule inégalité à la fin.

Perl, 35

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

Testez- moi .

Perl, 77 73 octets

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

Voici comment ça fonctionne:

• while(<>) analyse chaque ligne.
• @p=split","le divise par chaque virgule. Il utilise l'opérateur Perl par défaut $_(qui est l'endroit où la ligne est stockée).
• print (ternary) détermine ce qu'il faut imprimer.
• $p[0]<$p[1]and$p[2]=~/D/ demande si le prix actuel est inférieur au prix que nous voulons, et il baisse (en vérifiant un D.)
• (condition)?(if):(else) est l'opérateur ternaire.
• Si notre condition correspondait plus tôt, elle sortira STOP. Sinon, il sortira WAIT.

Je suppose qu'il n'y a pas de nouvelle ligne de fin sur l'entrée - une nouvelle ligne de fin produit un extra WAIT.

Merci à Alex A. de m'avoir aidé à économiser 4 octets!

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

Testez- moi .

R, 95 108

R et cordes, pas vraiment amis :)

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

L'entrée est le vecteur de caractères, Gpuis change chaque chaîne en une ifinstruction qui est évaluée.

Edit Foiré mon interprétation des règles. Le correctif coûte quelques caractères.

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

Rubis - 89 caractères

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

Avec l'aide de à bluetorange!

Python 3, 89 84 82 octets

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

Explication:

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 octets

Pas aussi petit que je le souhaiterais - en particulier la conversion du booléen en chaînes est très longue. J'ai essayé de raser quelques octets en passant à Octave, mais apparemment% c n'est pas encore pris en charge pour textoscan dans 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)

Personnellement, je pense que c'est bien que cette solution soit la seule à ce jour qui n'utilise pas le split :)

EDIT: à l'origine résolu la situation d'égalité beaucoup trop complexe.

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)

Uniquement sur les navigateurs compatibles ECMAScript 6

Explication

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

Il utilise le fait que si nous demandons si 0 est vrai, il retournera faux, donc nous pouvons dire 1 pour UP, -1 pour DOWN. Ensuite , on multiplie que par la différence de prix actuel et le prix optimal pour faire les deux d'entre eux travaillent pour la plus grande que 0 partie

Si la condition est remplie, retournez STOP, sinon (y compris des valeurs égales) retournezWAIT

A besoin de plus de golf

Javascript ( ES6 ), 82 80 79 octets

Edit: -2 en utilisant la méthode de multiplication @ JuanCortés

Edit: -1 en utilisant une astuce pour réduire la méthode de multiplication

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

Commenté:

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

Démo d'extrait:

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>

Historique des révisions:

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

Parce que C doit être là quelque part

Cela ressemble maintenant beaucoup à la version @nutki, bien qu'il soit différent de déterminer si sortir "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");
}

Golfé-

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

Le vieux

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

Je continuerai d'essayer de le réduire

Python 3 - 108 106 102 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)])

Travail en cours ...