Vous devez faire un jeu trop bas --- trop haut (TLTH) dans le code le plus court (en octets)

Regles du jeu:

1. L'ordinateur choisira un nombre aléatoire hors de la plage entière (-32768..32767).
2. Vous allez maintenant penser à un nombre et le saisir.
3. L'ordinateur vous dira si votre numéro est inférieur ( TOO LOW) ou supérieur ( TOO HIGH) au numéro choisi.
4. Lorsque vous devinez le nombre, l'ordinateur devrait s'afficher Congrats! You found the number!.

Règles du code:

1. Ne pas utiliser les caractères T, O, L, W, H, Iet G(ni minuscule ni majuscules) dans des chaînes ou caractères.
   Par exemple:

   tolower(T);  // Acceptable  
   cout<<"T";   // Unacceptable
   char ch='T'; // Unacceptable
   

2. Supprimez 300 octets si votre code peut afficher les règles du jeu avant de démarrer le jeu.

3. Supprimez 50 octets si votre code peut compter le nombre de tours et afficher le nombre de tours effectués à la fin du jeu comme ceci:

   "Congrats! You found the number in n turns!"
   

   où n est le nombre de tours effectués, au lieu de

   "Congrats! You found the number!"  
   

4. Supprimez 25 octets de votre score si votre code peut indiquer à l'utilisateur que le nombre que vous entrez est hors de la plage entière.
   Par exemple:

   Enter the number: 40000  
   Sorry! This number is out of range
   Please Enter the number again:  
   

5. Supprimer 25 octets Si votre code prend le nombre aléatoire, pas à partir d'une fonction aléatoire intégrée.

6. Supprimer 10 octets Si votre code affiche "félicitations" en couleur (choisissez n'importe quelle couleur sauf le blanc par défaut).

Règles de soumission:

1. Ajoutez un titre avec le nom de votre langue et le score avec tous les calculs de primes et leurs explications.

2. Postez votre code golfé et non golfé.

Gagnant

1. La réponse avec le moins d'octets l' emporte.
2. S'il y a égalité, la réponse avec le plus de votes l'emporte.
3. Le gagnant sera choisi après 5 jours.

EDIT : Veuillez afficher la sortie de votre code.
EDIT-2 : Vous pouvez ignorer la règle-1 pour les règles-2,3 et 4 dans les règles de code

Bonne chance :]

JavaScript (-210 points ( 190octets - 300 (pour les règles) - 50 (pour le nombre de suppositions) - 25 (pour ne pas utiliser de source de nombres aléatoires intégrée) - 25 (pour vous dire si l'entrée est hors de la plage d'un signe) 16-bit entier) ):

Golfé:

alert('Guess number',n=(m=2<<15)/2-new Date%m);for(z=0;a=+prompt(++z);)alert(a>m|a<1-m?m+'-'+-~-m:a==n?'Great! You found the number in '+z+' turns':atob('VE9P\x47E'+(a>n?'hJR0g=':'xPVw==')))

Code complet (bien formaté):

var max = 2 << 15;
var random = max/2 - new Date%max;
var counter = 0;

while (1) {
    var guess = +prompt();

    ++counter;

    if (guess > max | guess < -~-max) {
        alert(-~-max + '-' + max); // Shows that the range is between -32767 and 32768
    } else if (guess > random) {
        alert('TOO HIGH');
    } else if (guess < random) {
        alert('TOO LOW');
    } else if (guess == random) {
        alert('Congrats! You found the number in ' + counter + ' turns');
        break;
    }
}

Production:

ALERT:  Guess number
PROMPT: 5
ALERT:  TOO LOW
PROMPT: 20000
ALERT:  TOO LOW
PROMPT: 30000
ALERT:  TOO HIGH
PROMPT: 25000
ALERT:  TOO HIGH
PROMPT: 22500
ALERT:  TOO HIGH
PROMPT: 21000
ALERT:  TOO HIGH
PROMPT: 20500
ALERT:  TOO HIGH
PROMPT: 20200
ALERT:  TOO LOW
PROMPT: 20400
ALERT:  TOO LOW
PROMPT: 20450
ALERT:  TOO LOW
PROMPT: 20475
ALERT:  TOO HIGH
PROMPT: 20460
ALERT:  TOO LOW
PROMPT: 20468
ALERT:  TOO HIGH
PROMPT: 20464
ALERT:  TOO LOW
PROMPT: 20466
ALERT:  TOO LOW
PROMPT: 34000
ALERT:  -32767-32768
PROMPT: 20467
ALERT:  Great! You found the number in 17 turns!
PROMPT: (nothing)

Perl 5.10+: 159 144 octets - 350 = −206 points

say"Guess 16 bit signed number";$==32767-rand 65536;say(TOO.$",$_<0?LOW:HIGH)while++$i,$_=<>-$=;say"Congrats! You found the number in $i turns!"

Edit 2: Avec la récente modification des règles qui me permet d'utiliser n'importe quel littéral de chaîne pour le message "félicitations", je peux enregistrer 15 octets à partir de ma solution originale de 159 octets. Il n'y a rien de particulièrement nouveau ou intéressant dans le nouveau code ci-dessus par rapport à l'ancien code (je viens de me débarrasser de la pfonction et d'appeler saydirectement à la place), donc le reste de cet article décrira le code original, illustré ci-dessous:

sub p{say join$",@_}p Guess,16,bit,signed,number;$==32767-rand 65536;p(TOO,$_<0?LOW:HIGH)while++$i,$_=<>-$=;p Congrats."!",You,found,the,number,in,$i,turns."!"

Ouais, j'abuse l'enfer de la règle 1. Qui a besoin de chaînes, quand vous pouvez avoir des mots nus ? ;-)

Exécutez avec perl -M5.010pour activer la fonction Perl 5.10+ say(ou remplacez le corps de la pfonction par print join$",@_,$/un coût supplémentaire de 5 octets).

Scores bonus:

• −300 points: "afficher les règles du jeu avant de commencer le jeu"
• −50 points: "afficher le nombre de tours effectués en fin de partie"

Le code ne contient aucun littéral de chaîne au sens strict, donc je dirais que la règle 1 n'est, techniquement, pas violée. L'astuce est que, en Perl, sans use strict, tout identifiant qui ne correspond pas à un mot-clé ou un sous-programme de langue connu sera simplement évalué à son propre nom. La fonction pprend alors simplement une liste de mots et les imprime, séparés par des espaces.

Exemple de lecture:

Guess 16 bit signed number
0
TOO HIGH
-10000
TOO LOW
-5000
TOO HIGH
-7500 
TOO LOW
-6250
TOO HIGH
-6875
TOO LOW
-6553
TOO HIGH
-6700
TOO HIGH
-6790
TOO LOW
-6745
TOO HIGH
-6767
TOO LOW
-6756
TOO HIGH
-6761
Congrats! You found the number in 13 turns!

Edit: Oh, c'est vrai, les règles disent que je dois aussi publier une version non golfée du code, alors voilà. Techniquement, c'est "dé-golfé", car je compose habituellement mes programmes de golf de code sous une forme plus ou moins complète depuis le début, et il peut parfois être difficile de supprimer toutes les optimisations "golfiques" sans changer fondamentalement la façon dont certaines parties du programme de travail. Pourtant, j'ai au moins essayé d'ajouter des espaces, des commentaires et des noms de fonction / variable plus significatifs:

sub output {
    # print all arguments separated by spaces, plus a newline:
    # (in the golfed code, I use the special variable $" instead of " " for a space)
    say join " ", @_;
}

# print the rules:
output Guess, 16, bit, signed, number;

# choose a random number between -32768 and 32767 inclusive:
# (in the golfed version, using the special variable $= allows
# the int() to be left out, since $= can only take integer values)
$number = int( 32767 - rand 65536 );

# loop until the input equals the chosen number, printing "TOO LOW / HIGH":
# (the loop ends when $diff == 0, since 0 is false in Perl)
output (TOO, $diff < 0 ? LOW : HIGH) while ++$count, $diff = (<> - $number);

# print congratulations, including the loop count:
output Congrats."!", You, found, the, number, in, $count, turns."!";

Ps. Comme alternative, si le simple fait d'utiliser des mots nus au lieu de chaînes vous semble trop trompeur, voici une solution de 182 octets qui n'utilise pas les lettres TOLWHIG même dans les mots nus (mais les utilise dans un opérateur de translittération). Il obtient toujours les mêmes bonus, pour un score total de 182 à 350 = −168 points :

sub t{pop=~y/kpqvxyz/tolwhig/r}say"Guess 16 bit signed number";$==32767-rand 65536;say uc t"kpp ".($_<0?qpv:xyzx)while++$n,$_=<>-$=;say t"Cpnzraks! Ypu fpund kxe number yn $n kurns!"

La sortie est exactement la même que ci-dessus. Selon les règles (originales), j'utilise les lettres tet ipour imprimer les règles, car c'est autorisé; cependant, l'élimination de ces utilisations ne coûterait que deux octets supplémentaires. Inversement, rendre toutes les sorties en majuscules (qui, sur la base des commentaires ci-dessus, semble être autorisé) me permettrait d'économiser trois octets.

Python 2: -80 points (270-300-50)

print"WhileURong(USayNumbr;ISayBigrOrSmalr)"
import random
r=random.randint(-32768,32767)
g=i=1
while g:g=cmp(input(),r);print("C\x6fn\x67ra\x74s! Y\x6fu f\x6fund \x74\x68e number \x69n %d \x74urns!"%i,"\x54\x4f\x4f \x48\x49\x47\x48","\x54\x4f\x4f \x4c\x4f\x57")[g];i+=1

Le score est de 270 caractères, moins 300 pour afficher les instructions, moins 50 pour afficher le nombre de suppositions dans les "félicitations!" chaîne, pour un total de 80 points négatifs.

Version non golfée de la boucle, avec des chaînes non échappées:

while g:
    g=cmp(input(),r)
    print ("Congrats! You found the number in %d turns!"%i,
           "TOO HIGH",
           "TOO LOW")[g]
    i+=1

La cmpfonction intégrée renvoie 0 si les valeurs sont égales, -1 si la première est plus petite et 1 si la première est plus grande. J'utilise la valeur pour indexer un tuple de chaînes, puis à nouveau comme condition de sortie de la boucle. L'indexation d'une séquence avec un indice négatif (comme -1) compte à partir de la fin de la séquence, plutôt qu'à partir du début.

J'ai été cruellement tenté de sauter les importations et de simplement utiliser 4comme numéro aléatoire, conformément à XKCD 221 (cela pourrait-il bénéficier du bonus de -25 caractères?).

Exemple d'exécution (complet avec une erreur, où je ne peux pas faire de calculs négatifs):

WhileURong(USayNumbr;ISayBigrOrSmalr)
0
TOO HIGH
-16000
TOO LOW
-8000
TOO HIGH
-12000
TOO HIGH
-14000
TOO LOW
-13000
TOO HIGH
-13500
TOO HIGH
-13750
TOO LOW
-13625
TOO HIGH
-13712
TOO LOW
-13660
TOO HIGH
-13640
TOO HIGH
-13685
TOO HIGH
-13700
TOO LOW
-13695
TOO LOW
-13690
TOO LOW
-13687
Congrats! You found the number in 17 turns!

JavaScript 293, -300 (règles) - 50 (affichage des tours) - 25 (avertissement de portée) - 25 (pas de fonction aléatoire) = -107 (nouveau score)

r=new Date%65536+~(z=32767);n=x="";for((A=alert)("\107uess my number, \111 \147\151ve feedback");(x=prompt())!=r;A(0>(x-~z^x-z)?"\164\157\157 "+(x>r?"\150\151\147\150":"\154\157\167"):"Ran\147e: "+~z+" - "+z))n++;A("C\157n\147ra\164s! Y\157u f\157und \164\150e number \151n "+ ++n+"\164urns!")

Je dirais que selon les conventions RVB, le noir est une couleur, mais ce serait un peu tricher ...

Oh, et puis-je ajouter, pas de violation de la règle # 1 non plus!

Sortie dans une série d'alertes et d'invites

ALERT: Guess my number, I give feedback
PROMPT: 0
ALERT: too low
PROMPT: 16000
ALERT: too low
PROMPT: 24000
ALERT: too low
PROMPT: 28000
ALERT: too high
PROMPT: 26000
ALERT: too high
PROMPT: 25000
ALERT: too low
PROMPT: 25500
ALERT: too high
PROMPT: 25250
ALERT: too low
PROMPT: 25375
ALERT: too high
PROMPT: 25310
ALERT: too low
PROMPT: 25342
ALERT: too low
PROMPT: 25358
ALERT: too low
PROMPT: 25366
ALERT: too high
PROMPT: 25362
ALERT: too high
PROMPT: 25360
ALERT: too high
PROMPT: 25359
ALERT: Congrats! You found the number in 16 turns!

Code non golfé:

r = (new Date)%65536+~(z=32767); //Generates random number in range based off date's milliseconds... I'd use epoch, but I need to conserve
n=x=""; // Sets count and input to blank, these change as time goes on
// The line below sets up a call for `alert`, provides the initial rules, and subsequent loops compares the prompt with the number, as well as sets up "too", "high",  "low" and "out of range" message strings, and provides the feedback
for((A=alert)("\107uess my number, \111 \147\151ve feedback");(x=prompt())!=r;A(0>(x-~z^x-z)?"\164\157\157 "+(x>r?"\150\151\147\150":"\154\157\167"):"Ran\147e: "+~z+" - "+z))
{
    n++; // adds one to count providing the number isn't guessed yet
}
alert("C\157n\147ra\164s! Y\157u f\157und \164\150e number \151n "+ ++n+" \164urns!") // Congratulates the player, and displays the correct number of turns taken

Javascript, 324 octets, score -76

[Mis à jour en raison de changements de règles]

• 324 octets
• -300 pour afficher les règles
• -50 pour afficher les tours lorsque l'utilisateur gagne
• -25 pour indiquer à l'utilisateur lorsqu'il saisit un nombre en dehors de la plage
• -25 pour ne pas utiliser l'aléatoire intégré (mis à jour)

Note totale: -76

Golfé:

function q(y){return y.replace(/./g,function(x){h=x.charCodeAt(0);return String.fromCharCode(h>32&h<58?h+32:h)})}d=o=32768;alert("WhileURong(USayNumbr;ISayBigrOrSmalr)");for(a=1,n=new Date%(2*o)-o;d-n;a++)d=+prompt(a),alert(d>=o|d<-o?"BAD":d<n?q("4// ,/7"):d>n?q("4// ()'("):"Congrats! You found the number in "+a+" turns!")

Permet de débloquer ce gâchis.

Tout d'abord, correctement identifié (mais ce n'est toujours pas très bon avec du code obscurci):

function q(y) {
  return y.replace(/./g, function(x) {
    h = x.charCodeAt(0);
    return String.fromCharCode(h > 32 & h < 58 ? h + 32 : h)
  })
}

d = o = 32768;
alert("WhileURong(USayNumbr;ISayBigrOrSmalr)");

for (a = 1, n = new Date % (2 * o) - o; d - n; a++)
  d = +prompt(), alert(d >= o | d < -o ? "BAD" : d < n ? q("4// ,/7") : d > n ? q("4// ()'(") : "Congrats! You found the number in " + a + " turns!")

Deuxièmement, renommer les identificateurs:

function unencrypt(encrypted) {
  return encrypted.replace(/./g, function(character) {
    charCode = character.charCodeAt(0);
    return String.fromCharCode(charCode > 32 & charCode < 58 ? charCode + 32 : charCode)
  })
}

guess = limit = 32768;
alert("WhileURong(USayNumbr;ISayBigrOrSmalr)");

for (tries = 1, randomNumber = new Date % (2 * o) - o; guess - randomNumber; tries++)
  guess = +prompt(),
  alert(guess >= limit | guess < -limit ? "BAD" : guess < randomNumber ? unencrypt("4// ,/7") : guess > randomNumber ? q("4// ()'(") : "Congrats! You found the number in " + tries + " turns!")

Ainsi, la fonction de décryptage obtient tous les caractères entre ASCII 33 ( !) et ASCII 58 ( :) et ajoute 32, les convertissant en caractères de la plage A-Z.

Permet de dé-golfer davantage le code en décryptant toutes les chaînes:

guess = limit = 32768;
alert("WhileURong(USayNumbr;ISayBigrOrSmalr)");

for (tries = 1, randomNumber = new Date % (2 * o) - o; guess - randomNumber; tries++)
  guess = +prompt(),
  alert(guess >= limit | guess < -limit ? "BAD" : guess < randomNumber ? "TOO LOW" : guess > randomNumber ? "TOO HIGH" : "Congrats! You found the number in " + tries + " turns!")

Et enfin, permet de déplacer certaines instructions à d'autres endroits, de remplacer la longue chaîne ternaire par des ifs et des elses, de joindre des chaînes de concaténation et de simplifier les calculs, pour augmenter la lisibilité:

guess = 32768;
alert("WhileURong(USayNumbr;ISayBigrOrSmalr)");

randomNumber = new Date % 65536 - 32768;

for (tries = 1; guess - randomNumber; tries++) {
  guess = +prompt(); // The preceding + is a golfing trick to convert string to number.
  if (guess > 32767 | guess < -32768) {
    alert("BAD");
  } else if (guess < randomNumber) {
    alert("TOO LOW");
  } else if (guess > randomNumber) {
    alert("TOO HIGH");
  } else {
    alert("Congrats! You found the number in " + tries + " turns!");
  }
}

Échantillon:

ALERT:  WhileURong(USayNumbr;ISayBigrOrSmalr)
PROMPT: 5
ALERT:  TOO LOW
PROMPT: 20000
ALERT:  TOO LOW
PROMPT: 30000
ALERT:  TOO HIGH
PROMPT: 25000
ALERT:  TOO HIGH
PROMPT: 22500
ALERT:  TOO HIGH
PROMPT: 21000
ALERT:  TOO HIGH
PROMPT: 20500
ALERT:  TOO HIGH
PROMPT: 20200
ALERT:  TOO LOW
PROMPT: 20400
ALERT:  TOO LOW
PROMPT: 20450
ALERT:  TOO LOW
PROMPT: 20475
ALERT:  TOO HIGH
PROMPT: 20460
ALERT:  TOO LOW
PROMPT: 20468
ALERT:  TOO HIGH
PROMPT: 20464
ALERT:  TOO LOW
PROMPT: 20466
ALERT:  TOO LOW
PROMPT: 20467
ALERT:  Congrats! You found the number in 16 turns!"

C - 272 caractères - 300 - 50 - 25 = -103

• -300 pour afficher les règles;
• -50 pour indiquer au joueur le nombre de tours;
• -25 pour ne pas utiliser une bibliothèque RNG standard.

Code golf:

main(i){short a,c=i=0,b=time(0);for(a=b;b--;a=(a*233)+4594);b=a;puts("WhileURong(USayNumbr;ISayBigrOrSmalr)");while(1){i++;scanf("%hi",&a);if(a==b){printf("Congrats! You found the number in %i turns!",i);break;}for(c=0;c^9;c++)putchar(c[a<b?"kff7cfn7!":"kff7_`^_!"]-23);}}

Non golfé:

int main(int i) {
    short a,
          b = time(0),
          c = i = 0;

    for( a = b ; b-- ; a = (a * 233) + 4594);
    b = a;

    puts("WhileURong(USayNumbr;ISayBigrOrSmalr)");

    while(1) {
        i++;
        scanf("%hi", &a);
        if(a == b) {
            printf("Congrats! You found the number in %i turns!", i);
            break;
        }
        for( c = 0 ; c ^ 9 ; c++ )
            putchar(c[ a < b ? "kff7cfn7!" : "kff7_`^_!" ] - 23);
    }
}

Production:

C: 237 - 300 - 50 - 25 - 25 - 10: -173 points

-300 pour les règles, -50 pour afficher le nombre de suppositions, -25 pour ne pas utiliser de générateur de nombres aléatoires intégré, -25 pour le message hors plage et -10 pour colorer le message de félicitations.

int s[3]={542068564},g,n;main(r){for(r=(short)&r,puts("WhileURong(USayNumbr;ISayBigrOrSmalr)");n++,scanf("%d",&g),s[1]=g<r?5721932:1212631368,g^r;puts(g^(short)g?"OOR":s));printf("\033[31mCongrats! You found the number in %d turns!",n);}

Non golfé:

int s[3]={542068564},g,n;

main(r){
        for(
                r=(short)&r,
                puts("WhileURong(USayNumbr;ISayBigrOrSmalr)");

                n++,
                scanf("%d",&g),
                s[1]=g<r?5721932:1212631368,
                g^r;

                puts(g^(short)g?"OOR":s)
        );

        printf("\033[31mCongrats! You found the number in %d turns!",n);
}

Exemple d'exécution:

WhileURong(USayNumbr;ISayBigrOrSmalr)
-32769
OOR
32768
OOR
0
TOO HIGH
-16384
TOO HIGH
-24576
TOO HIGH
-28672
TOO LOW
-26624
TOO LOW
-25600
TOO HIGH
-26112
TOO LOW
-25856
TOO LOW
-25728
TOO LOW
-25664
TOO HIGH
-25696
TOO HIGH
-25712
TOO LOW
-25704
Congrats! You found the number in 15 turns!

La dernière ligne apparaît en rouge.

bash, -137

But

273 (octets) - 300 (règles) - 50 (nombre d'essais) - 25 (avertissement OOF) - 25 (PRNG personnalisé) - 10 (couleur)

Version golfée

IFS=# a=(`<$0`)
c=65536
y=$[10#`date +%N`%c]
e(){ echo -e ${a[$1]/z/$z};}
e 7
while read x
do((z++,x+=c/2,i=3+(x>y),x==y))&&break
((x<0||x>c-1))&&i=6
e $i
done
e 5
#TOO LOW#TOO HIGH#\e[32mCongrats! You found the number in z turns!#OOR#Guess my number. I'll say HIGH or LOW.

Notez que la dernière ligne est un commentaire, elle ne contient donc pas de chaîne ou de littéraux de caractères.

Version non golfée

MYNUMBER=$[10#$(date +%N) % 65536 - 32768]
echo "Guess my number. I'll say HIGH or LOW."

while true; do
    read YOURGUESS
    GUESSES=$((GUESSES + 1))

    if ((YOURGUESS == MYNUMBER)); then
        break
    elif ((YOURGUESS < -32768 || YOURGUESS > 32767)); then
        echo OOR
    elif ((YOURGUESS < MYNUMBER)); then
        echo "TOO LOW"
    else
        echo "TOO HIGH"
    fi
done

echo -e "\e[32mYou found the number in $GUESSES turns!"

Exemple de sortie

$ ./tlth
Guess my number. I'll say HIGH or LOW.
-32769
OOR
32768
OOR
0
TOO LOW
16384
TOO HIGH
8192
TOO HIGH
4096
TOO HIGH
2048
TOO HIGH
1024
TOO HIGH
512
TOO HIGH
256
TOO HIGH
128
TOO HIGH
64
TOO HIGH
32
TOO LOW
48
TOO HIGH
40
TOO LOW
44
TOO HIGH
42
Congrats! You found the number in 17 turns!

La dernière ligne est imprimée en vert.

C #: -30 points

• 345 octets
• -300 pour afficher les règles
• -50 pour afficher les tours lorsque l'utilisateur gagne
• -25 pour indiquer à l'utilisateur lorsqu'il saisit un nombre en dehors de la plage

Golfé :

int l=-32768,h=32767,n=new Random().Next(l,h),t=0,g=h+1;Console.Write("WhileURong(USayNumbr;ISayBigrOrSmalr)\n");while(n!=g){g=Convert.ToInt32(Console.ReadLine());Console.WriteLine(g==n?"C\x6fn\x67ra\x74s! Y\x6fu f\x6fund \x74\x68\x65 number in {0} \x74urns!":g<l||g>h?"BAD":g<n?"\x54\x4f\x4f \x4c\x4f\x57":"\x54\x4f\x4f \x48\x49\x47\x48",++t);}

Pour l' exécuter, mettre dans un fichier (code.cs) et exécuter avec scriptcs sur la ligne de commande: scriptcs code.cs.

Non golfé : élargi les noms de variables en quelque chose de plus facile à comprendre et changé les lettres hexadécimales en vraies lettres.

int low = -32768, 
    high = 32767, 
    number = new Random().Next(low, high), 
    turns = 0, 
    guess = h+1;
Console.Write("WhileURong(USayNumbr;ISayBigrOrSmalr)\n");  // instructions
while (number != guess)
{
    guess = Convert.ToInt32(Console.ReadLine());
    Console.WriteLine(
      guess == number                                     // if you got it right 
        ? "Congrats! You found the number in {0} turns!"  // give the victory speech
        : guess < low || guess > high                     // if out of range
          ? "BAD"                                         // let them know
          : guess < number                                // if guess is low
            ? "TOO LOW"                                   // tell them low
            : "TOO HIGH"                                  // otherwise tell them high
      , ++turns                                           // preincrement turns, add to output
    );
}

Exemple de sortie disponible ici .

C ++ 505 + (-300-50-25-25) = 105

-300: Instructions
-50: Affichage du nombre de tours
-25: Ne pas utiliser la fonction aléatoire
-25: avertir l'utilisateur d'une entrée hors de portée

GOLFED

#include<iostream>
#include<stdlib.h>
using namespace std;int main(){short int a,i=0,*r=new short int;int b=0;a=*r;char t[]={84,79,79,' ','\0'},l[]={76,79,87,'\n','\0'},h[]={72,73,71,72,'\n','\0'};cout<<"WhileURong(USayNumbr;ISayBigrOrSmalr)\n";while(a!=b){cin>>b;if(b<-32768||b>32767){cout<<"Sorry! the number is out of range please enter the number again\n";continue;}i++;if(b<a){cout<<'\n'<<t<<l;}if(b>a){cout<<'\n'<<t<<h;}if(a==b){cout<<"Congrats!You found the number in "<<i<<" turns!";}}return 0;}  

NON GOLFE

#include<iostream>
#include<stdlib.h>
using namespace std;
int main()
{
    short int a,i=0,*r=new short int;
    int b=0;
    a=*r;
    char t[]={84,79,79,' ','\0'},l[]={76,79,87,'\n','\0'},h[]={72,73,71,72,'\n','\0'};
    cout<<"WhileURong(USayNumbr;ISayBigrOrSmalr)\n";
    while(a!=b)
    {
        cin>>b;
        if(b<-32768||b>32767)
        {
            cout<<"Sorry! the number is out of range please enter the number again\n";
            continue;
        }
        i++;
        if(b<a)
        {
            cout<<'\n'<<t<<l;
        }
        if(b>a)
        {
        cout<<'\n'<<t<<h;
        }
    if( a==b)
    {   

            cout<<"Congrats!You found the number in "<<i<<" turns!";
        }
    }
    return 0;
}  

PRODUCTION

C, 183-300-25 = -142

183 octets -300 pour les règles -25 pour ne pas utiliser une bibliothèque aléatoire

main(){short g,n=time(0)*(time(0)&1?1:-1);puts("WhileURong(USayNumbr;ISayBigrOrSmalr)");while(g^n)scanf("%d",&g),puts(g>n?"TOO HIGH":g<n?"TOO LOW":"Congrats! You found the number!");}

version non golfée:

main(){
    short g,n=time(0)*(time(0)&1?:-1);
    puts("WhileURong(USayNumbr;ISayBigrOrSmalr)");
    while(g^n)
        scanf("%d",&g),
        puts(g>n?"TOO HIGH":g<n?"TOO LOW":"Congrats! You found the number!");
}

échantillon:

WhileURong(USayNumbr;ISayBigrOrSmalr)
40
TOO HIGH
20
TOO HIGH
1
TOO HIGH
0
TOO HIGH
-20
TOO HIGH
-200
TOO HIGH
-2000
TOO HIGH
-20000
TOO LOW
-10000
TOO LOW
-5000
TOO LOW
-3000
TOO HIGH
-4000
TOO LOW
-3500
TOO HIGH
-3700
TOO HIGH
-3900
TOO HIGH
-3950
TOO HIGH
-3970
TOO LOW
-3960
Congrats! You found the number!

J - 190 caractères -300-50 = -160 pts

'Congrats, you found the number in ',' turns!',~":1>:@]^:(]`(1[2:1!:2~a.{~71+13 8 8 _39,(5 8 16;1 2 0 1){::~0&>)@.*@-[:".1!:1@1:)^:_~32767-?2^16['WhileURong(USayNumbr;ISayBigrOrSmalr)'1!:2]2

Explication (rappelez-vous que J se lit de droite à gauche):

• 'WhileURong(USayNumbr;ISayBigrOrSmalr)'1!:2]2 - Imprimez les règles.
• 32767-?2^16[- Lancez la valeur de retour, puis générez un nombre aléatoire compris entre 0 et 2 ^ 16-1 inclus. Ensuite, ajustez-le sur la plage -32768..32767 en le soustrayant de 32767.
• 1>:@]^:(...)^:_~- Le x u^:v^:_ ymotif est un peu comme une boucle while. xreste constant et yest muté à chaque exécution de u. Cela continue jusqu'à ce que x v yrenvoie 0 ou x u yn'entraîne aucune modification y. Le ~permute les deux arguments, de sorte que ce xsera le nombre aléatoire et ycommencera à 1. Notre uest >:@], qui incrémente ce 1 et le renvoie, donc il agit comme un compteur et la x u ycondition de terminaison ne peut jamais se produire.
• [:".1!:1@1:- Prenez le compteur et ignorez sa valeur en utilisant le chiffre 1 à la place ( 1:). Lisez une ligne d'entrée ( 1!:1) à partir du clavier (descripteur de fichier 1) et exécutez-la ( ".). Cela permet à J, dont le signe négatif est normalement _, de prendre des nombres sous la forme -n(s'évalue comme la négation appliquée au nombre n).
• ]`(...)@.*@-- Prenez la différence entre le nombre aléatoire d'avant et la supposition ( -). Maintenant, nous sélectionnons l'action suivante selon que cette différence est nulle ( @.*). Si c'est le cas, retournez ( ]`) ce 0 comme résultat pour x v y, afin que l'exécution se termine, et la boucle while entière renvoie le compteur. Autre...
• 71+13 8 8 _39,(5 8 16;1 2 0 1){::~0&>- Renvoie le tableau 5 8 16si le nombre est négatif et 1 2 0 1s'il est positif. Ensuite 13 8 8 _39, ajoutez et ajoutez 71 à tout, nous avons donc soit 84 79 79 32 76 79 87ou 84 79 79 32 72 73 71 72.
• 1[2:1!:2~a.{~- Transformez ces nombres en caractères ASCII en indexant l'alphabet a.avec eux. Imprimez-les ensuite avec 1!:2(à l'aide de la poignée de fichier 2) et retournez 1 comme résultat de x v y.
• 'Congrats, you found the number in ',' turns!',~":- Lorsque la boucle se termine, elle renvoie le compteur. Convertissez-le en chaîne avec ":et placez-le entre les chaînes 'Congrats, you found the number in 'et ' turns!'.

Exemple de sortie:

   'Congrats, you found the number in ',' turns!',~":1>:@]^:(]`(1[2:1!:2~a.{~71+13 8 8 _39,(5 8 16;1 2 0 1){::~0&>)@.*@-[:".1!:1@1:)^:_~32767-?2^16['WhileURong(USayNumbr;ISayBigrOrSmalr)'1!:2]2
WhileURong(USayNumbr;ISayBigrOrSmalr)
0
TOO HIGH
-20000
TOO LOW
-10000
TOO LOW
-5000
TOO HIGH
-7500
TOO HIGH
-8750
TOO HIGH
-9000
TOO HIGH
-9500
TOO LOW
-9250
TOO HIGH
-9375
TOO HIGH
-9450
TOO LOW
-9400
TOO HIGH
-9425
TOO HIGH
-9437
TOO LOW
-9431
TOO LOW
-9428
TOO HIGH
-9430
TOO LOW
-9429
Congrats, you found the number in 18 turns!

JavaScript -40

335-300 (règles) - 50 (nombre de tours) - 25 (hors de portée)

Je ne vais pas gagner, mais une façon amusante d'obtenir les lettres, je pense.

Golfé

!function T(O,L,W,H,I,G){a=T.toString();c=L.floor(65536*L.random())+H;O(W+G+" between "+H+" & "+I);k=(f=a[9]+(d=a[11])+d+" ")+(e=a[17])+a[19]+a[21]+e;l=f+a[13]+d+a[15];for(m=1;(n=prompt(W+G))!=c;m++)n<H||n>I?O("Out of range"):n>c?O(l):O(k);O("Congrats! You found the"+G+" in "+m+" turns!")}(alert,Math,"Guess a",-32768,32767," number")

Non golfé

!function T(O,L,W,H,I,G){
    fn = T.toString();
    random = L.floor(L.random() * 65536) + H;

    O(W + G + " between " + H + " & " + I);

    tooLow = (too = fn[9] + (o = fn[11]) + o + " ") + (h = fn[17]) + fn[19] + fn[21] + h;
    tooHigh = too + fn[13] + o + fn[15];

    for (n=1; (guess = prompt(W + G)) != random; n++) {
        if (guess < H || guess > I) {
            O("Out of range");  
        } else if (guess > random) {
            O(tooHigh);
        } else {
            O(tooLow);  
        }
    }

    O("Congrats! You found the" + G + " in " + n + " turns!");
}(alert, Math, "Guess a", -32768, 32767, " number")

Exemple de sortie

(ALERT) Guess a number between -32768 & 32767
(PROMPT) Guess a number
9999999
(ALERT) Out of range
(PROMPT) Guess a number
0
(ALERT) TOO LOW
(PROMPT) Guess a number
8008
(ALERT) Congrats! You found the number in 3 turns!

APL (Dyalog) (157-300-50 = -193)

(Oui, ceux-ci comptent comme octets, le jeu de caractères APL tient dans un octet.)

J'ai revendiqué "afficher les règles du jeu" et "compter le nombre de tours".

G
n←32768-?65536
t←0
⎕←'Guess 16-bit signed number'
t+←1
→8/⍨n=g←⎕
⎕←⎕AV[(⌽⎕AV)⍳'×↑↑ ','○↑-' '∇⌊∘∇'⊃⍨1+n<g]
→4
⎕←'Congrats! You found the number in't'tries!'

Exemple d'exécution:

      G
Guess 16-bit signed number
⎕:
      0
TOO HIGH
⎕:
      -10000
TOO LOW
⎕:
      -5000
TOO LOW
⎕:
      -2500
TOO LOW
⎕:
      -1250
TOO HIGH
⎕:
      -1750
TOO LOW
⎕:
      -1500
TOO LOW
⎕:
      -1375
TOO LOW
⎕:
      -1300
TOO LOW
⎕:
      -1275
TOO LOW
⎕:
      -1265
TOO HIGH
⎕:
      -1270
TOO HIGH
⎕:
      -1273
 Congrats! You found the number in  13  tries!

Non golfé:

GuessNumber;num;tries;guess;decode;too;low;high
decode←{⎕AV[(⌽⎕AV)⍳⍵]} ⍝ invert the character code, char 1 becomes char 255 etc.
num←32768-?65536 ⍝ select a random number
tries←0

⍝ strings for low/high
too←decode '×↑↑ '
low←decode '○↑-'
high←decode '∇⌊∘∇'

⎕←'Guess 16-bit signed number'

try:
  tries +← 1
  guess ← ⎕
  →(guess=num)/found
  ⍝ still here: number was wrong
  ⎕←too, (1+num<guess)⊃low high  ⍝ output appropriate word
  →try ⍝ try again
found:
  ⎕←'Congrats! You found the number in' tries 'tries!'

Pogo: -95 (255 - 300 - 50)

method main:void
    print("Guess the number. You will be told if you are high or low.")
    declare(integer,n,0)
    declare(integer,i,0)
    declare(integer,j,0)
    random() i
    while j != i
        set(n+1) n
        print("Number?")
        getinput() j
        if j > i
            print("High")
        end
        else
            print("Low")
        end
    end
    print("Yay" n "turns")
end main

Si le nombre est 10:

Nombre?

5

Faible

8

Faible

12

Haute

dix

Oui 4 tours

Le nombre de caractères est basé sur le code avec tous les espaces supprimés.

Notez que Pogo n'est pas une fausse langue. Je l'ai créé et j'ai écrit un compilateur et un IDE ici: https://github.com/nrubin29/Pogo