Un jeu de devinettes plat

13

Il y a un jeu auquel j'aime jouer. Cela se produit sur une grille de taille finie (mais elle est enveloppée, comme une sphère). Sur cette grille, un point aléatoire (entier uniquement) est sélectionné. Ensuite, moi, l'utilisateur, je suis invité à entrer des coordonnées. Si ma contribution correspond exactement au point aléatoire, on me dit que j'ai gagné. Sinon, on me dit la distance point par point entre mon entrée et le point aléatoire. Par exemple, si je devinais (2,2)et que le point aléatoire était à (4,3), alors la distance serait sqrt[(3-2)^2 + (4-2)^2] = sqrt[5].

Le jeu continue jusqu'à ce que le joueur arrive au bon endroit du point.

Objectif Créer une version fonctionnelle du jeu décrit ci-dessus. Pour ce faire, vous devez créer un programme complet. Voici ce que votre programme devrait faire:

  1. Demandez deux entrées: la hauteur et la largeur de la planche. L'origine se trouve en haut à gauche du plateau. Ces entrées ne dépasseront pas 1024.
  2. Sélectionnez un point au hasard sur cette planche; ce sera le point à deviner.
  3. Acceptez une entrée simulant un virage. L'entrée sera soit une paire d'entiers séparés par des espaces, soit deux entrées entières distinctes. En réponse à cette contribution, le programme fera l'une des deux choses suivantes:
    1. Si l'entrée correspond au point aléatoire sélectionné, émettez un message signalant la victoire de l'utilisateur. Je dirais "Tu as gagné!".
    2. Sinon, affichez la distance entre le point d'entrée de l'utilisateur et le point aléatoire.
    Dans les deux cas, vous devez incrémenter le compteur de tours.
  4. Une fois que l'utilisateur a remporté la victoire, affichez le nombre de tours qu'il a pris. Le programme se ferme ensuite.

Bonus

Les bonus sont appliqués dans l'ordre dans lequel ils apparaissent dans cette liste

  • -150 octets si votre programme prend un entier d'entrée Dqui décrit la dimension dans laquelle le jeu se déroule. Par exemple, si D = 3, alors vous créez un point aléatoire d' 3entiers, prenez 3des entrées entières et affichez la distance entre ces points.
  • -50% (ou + 50% si score < 0) si vous fournissez une représentation graphique de la carte (ASCII ou Image) qui montre où l'utilisateur a déjà deviné sur la grille de dimensions données et le compteur de tours. (Si vous optez pour le premier bonus, ce bonus ne s'applique qu'aux modes 2Det 1D. Si vous ajoutez une sortie graphique 3D, vous obtenez un supplément de -50%.)
  • -60 octets si vous pouvez fournir un mode de jeu (sélectionné par une entrée au début; c'est-à-dire, lorsqu'il est donné 0, effectuer le mode de jeu normal; lorsqu'il est donné 1, effectuer ce mode de jeu) dans lequel le point se déplace de 1 unité dans une direction orthogonale aléatoire par tour

Plus sur l'emballage

L'habillage ne se produit que lorsque, dans le troisième bonus, le point mobile se déplace à travers l'une des limites; dans ce cas, le point mobile est déformé au point respectif, comme suit:

...              ...
..R (move right) R..
...              ...

Ce comportement d'habillage n'affecte pas la supposition de l'utilisateur, mis à part le fait que le point a changé de direction.

Classement

L'extrait de pile au bas de cet article génère le catalogue à partir des réponses a) en tant que liste des solutions les plus courtes par langue et b) en tant que classement général.

Pour vous assurer que votre réponse apparaît, veuillez commencer votre réponse avec un titre, en utilisant le modèle de démarque suivant:

# Language Name, N bytes

où Nest la taille de votre soumission. Si vous améliorez votre score, vous pouvez conserver les anciens scores dans le titre en les rayant. Par exemple:

# Ruby, <s>104</s> <s>101</s> 96 bytes

Si vous souhaitez inclure plusieurs nombres dans votre en-tête (par exemple, parce que votre score est la somme de deux fichiers ou si vous souhaitez répertorier les pénalités de drapeau d'interprète séparément), assurez-vous que le score réel est le dernier numéro de l'en-tête:

# Perl, 43 + 2 (-p flag) = 45 bytes

Vous pouvez également faire du nom de la langue un lien qui apparaîtra ensuite dans l'extrait de code:

# [><>](http://esolangs.org/wiki/Fish), 121 bytes

Afficher l'extrait de code

code-golf  game 
— Conor O'Brien
source
7
Petite piqûre: vous voulez probablement dire qu'elle s'enroule comme un tore et non une sphère. Il est impossible d'enrouler une grille 2D sur une sphère sans créer de discontinuités.
— Alistair Buxton
2
De plus, si la carte s'enroule, il peut y avoir un chemin plus court entre la supposition et la cible en traversant un bord.
— Alistair Buxton
1
@NBZ Oui, vous le pouvez.
— Conor O'Brien
1
@NBZ 1 unité dans une seule direction.
— Conor O'Brien
2
1. Je ne sais toujours pas quelle est la topologie. Pour aider à clarifier les choses, si la carte est 10x10, le point aléatoire est (9,4), et je suppose (2,2), la distance sqrt(13)ou sqrt(53)? (Remarque pour l'avenir: si vous faites quelque chose de bizarre, n'incluez pas le hasard car il est presque impossible de fournir des cas de test). 2. Dans le troisième bonus, la distance doit-elle être calculée et émise avant ou après le déplacement du point?
— Peter Taylor

Réponses:

8

CJAM, -113 -139 -152 -157 -159 octets

l~]:B:mr{_ea:i~mr0a*W2mr#+*.+B:,.=_[l~].-:mh_p}g],(

Le programme est long de 51 octets et se qualifie pour les bonus de -150 octets et -60 octets .

Le mode de jeu et le nombre de dimensions sont lus comme un argument de ligne de commande, la taille dans chaque dimension de STDIN. Le message de victoire étant arbitraire , le programme imprimera 0.0(distance jusqu'au but) pour indiquer que la partie est terminée.

Essais

$ cjam game.cjam 0 3; echo
2 2 2
1 1 1
1.4142135623730951
1 1 0
1.7320508075688774
1 0 1
1.0
0 0 1
0.0
4
$ cjam game.cjam 1 3; echo
2 2 2
0 0 0
1.0
0 0 0
0.0
2

Comment ça fonctionne

l~]       e# Read a line from STDIN, evaluate it and collect the result.
:B        e# Save the resulting array in B. The result is [B1 ... Bd],
          e# where Bk is the board size in dimension k.
:mr       e# Pseudo-randomly select a non-negative integer below Bk,
          e# for each k between 1 and d.
{         e# Do:
  _       e#   Copy the item on the stack. The original becomes a dummy value
          e#   that will be used to count the number of turns.
  ea      e#   Push the array of command-line arguments.
  :i~     e#   Cast each to integer and dump them on the stack.
          e#   This pushes m (game mode) and d (number of dimensions).
  mr      e#   Pseudo-randomly select a non-negative integer below d.
  0a*     e#   Push an array of that many zeroes.
  W2mr#   e#   Elevate -1 to 0 or 1 (selected pseudo-randomly).
  +       e#   Append the result (1 or -1) to the array of zeroes.
  *       e#   Repeat the array m times.
  .+      e#   Perform vectorized addition to move the point.
  B:,.=   e#   Take the k-th coordinate modulo Bk.
  _[l~]   e#   Push a copy and an evaluated line from STDIN.
  .-:mh   e#   Compute their Euclidean distance.
  _p      e#   Print a copy.
}g        e# While the distance is non-zero, repeat the loop.
],(       e# Get the size of the stack and subtract 1.
          e# This pushes the number of turns.
— Dennis
source
2
Et Dennis a surpassé tout le monde. Encore.
— Seadrus
1
Vous avez accidentellement mis à jour le score à 152 au lieu de -152, ce qui vous place en dernier dans le classement
— Moose
7

Pyth, 91 (-150 -60) = -119

VvwaYOvw;JY#IqQ1=dOlY XYd@S[0 @Jd +@Yd?O2_1 1)1)=T[)VYaT^-Nvw2)=ZhZ=b@sT2Iqb0Bb;p"Won in "Z

Ancienne solution: (54-150 = -96)

JYVQaYOvw;#=J[)VYaJ^-Nvw2)=ZhZ=b@sJ2Iqb0Bb;p"Won in "Z

Toutes les entrées ont lieu sur une nouvelle ligne.

  • Le premier entier représente le mode de jeu ( soit 1ou0 )
  • Le premier deuxième entier Dreprésente les dimensions du jeu.
  • Les Dentrées suivantes représentent la taille du champ
  • Chaque D entrées à partir de ce moment sont des suppositions

Exemple de lecture (les indices n'apparaissent pas dans le programme réel):

  #Hint: Gamemode (1 or 0)
1
  #Hint: Dimensions
3
  #Hint: X-size
4
  #Hint: Y-size
4
  #Hint: Z-size
4
  #Hint: Guesses
  #Hint:[3, 2, 1]
3
2
2
1.0
  #Hint:[3, 2, 1]
3
2
1
1.0
  #Hint:[2, 2, 1]
2
2
1
1.0
  #Hint:[3, 2, 1]
3
2
1
Won in 4
— élan
source
Le deuxième coup ne devrait-il pas gagner?
— JNF
@JNF le point peut se déplacer dans le mode de jeu 1 (bonus de -60 octets)
— Jakube
Holy moly, c'est un long code pyth. Pas vraiment joué au golf. Par exemple, je vois deux espaces qui peuvent être supprimés. Aussi: Vous pouvez utiliser J=YmOvwvwau lieu de VvwaYOvw;JY, ce qui est 2 octets plus court. Je n'ai pas regardé l'autre code, mais je suppose que vous pouvez également y raccourcir quelques éléments.
— Jakube
@ Jakube, je supposais que l'indice nous indique où est le point actuellement
— JNF
3

Python 2, 210 - 150 = 60

from random import*
q,r,o=map,raw_input,int
a=q(randrange,q(o,r().split(' ')))
m=q(o,r().split(' '))
t=1
while m!=a:print sum([(c-d)**2for c,d in zip(m,a)])**.5;m=q(o,r().split(' '));t+=1
print'You won in %d'%t

Premier défi jusqu'à présent. Essayez-le en ligne

— Mego
source
3

Pip, 43 42 octets - 150 = -108

Prend les dimensions de la carte comme arguments de ligne de commande (avec D implicite du nombre d'arguments). Prend des suppositions sous forme de nombres séparés par des espaces sur stdin.

YRR_MgWd:++i&RT$+(y-(q^s))**2Pd"Won in ".i

Ce code profite largement des fonctionnalités de programmation de tableaux de Pip. Le tableau d'arguments cmdline est stocké dans g. Nous générons le point à deviner en cartographiant l'opérateur plageAleatoire RRsur get Yank la liste résultant dans la yvariable. Vient ensuite la boucle principale tandis que la condition est la suivante:

d:++i&RT$+(y-(q^s))**2

  ++i&                  Increment i, the guess counter; the result is always > 0, so the
                          short-circuiting & operator evaluates the next expression:
              q         Read a line from stdin
               ^s       Split on spaces
           y-(   )      Subtract from our chosen point itemwise
          (       )**2  Square, itemwise
        $+              Fold on +, summing the list of squares
      RT                Square root
d:                      Assign this distance to d

Si la distance n'était pas nulle, l'intérieur de la boucle l'imprime. Si c'était zéro, nous avons atteint le point cible; la boucle s'arrête et le programme génère le message de gain et le nombre de tours.

Exemple d'exécution:

C:\Users\dlosc> pip.py -f guessing.pip 10 5 6 4
5 2 3 2
3.1622776601683795
6 2 3 2
4.123105625617661
3 2 3 2
1.4142135623730951
3 1 3 2
2.23606797749979
3 2 2 2
1.7320508075688772
2 2 3 2
1
2 2 3 1
1.4142135623730951
2 3 3 2
Won in 8
— DLosc
source
2

R, 134-150 = -16 octets

function(...){G=sapply(list(...),sample,1)
C=0
repeat{g=scan()
C=C+1
if(any(G!=g))cat(sqrt(sum((G-g)^2)))else{cat("Won in",C);break}}}
— flodel
source
2

Haskell, 240-150 = 90

import System.Random
r x=randomRIO(0,x-1)
m=map read.words
g=getLine
main=do g;(fmap m g::IO[Int])>>=mapM r>>=b 1
b c v=do i<-fmap(sqrt.fromIntegral.sum.map(^2).zipWith(-)v.m)g;if i==0 then putStrLn$"Won in "++show c else do print i;b(c+1)v
— Damien
source
1

Dyalog APL , 77 71-210 = -139

S F M
P←?S
{P←S|P+(?D)⌽D↑Mׯ1 1[?2]
C+←1
P≢G←⎕:0⊣⎕←.5*⍨+/2*⍨P-G
C}⍣≢C←0

D'accord:

Notez que cela s'exécute dans l'index d'origine 0 ( ⎕IO←0) qui est par défaut dans de nombreux APL.
Prend le mode booléen comme argument de droite ( M) et les tailles de dimension comme argument de gauche ( S).
Le nombre de dimensions est D, qui doit être défini (par exemple D←3) avant l'appel, conformément à l'OP). enregistrer une nouvelle estimation de l'entrée du compteur d'incrément du point d'objectif , et s'il est différent du point d'objectif, alors ... distances dans chaque dimension
P←?Sle but obtient un point aléatoire dans la plage 1 bien que chacune des limites de dimension
{... }⍣≢C←0répète la fonction jusqu'à ce que le résultat soit différent de C, ce qui obtient initialement 0
?2un nombre aléatoire 0 ou 1
¯1 1[... ]index de la liste de deux nombres
M×multiplié par mode; fait 0si le mode est 0
D↑pad avec 0s pour correspondre au nombre de dimensions ajuster le module de taille mondiale de l' objectif actuel
(?D)⌽ tourner la liste au hasard (0 à nombre de dimensions-1)
P+
S|
P←
C+←1
P≢G←⎕:
P-G
2*⍨ carré les
+/additionnent en
.5*⍨racine carrée
⎕←qui
0⊣retournent 0 (c'est-à-dire identiques à la valeur initiale, donc répétez)
C... sinon, retourne le nombre de suppositions (qui, étant différent de 0, arrête la boucle et retourne la dernière valeur)

— Adam
source
@ Dennis En fait, je l'ai cassé quand j'en ai fait une fonction, alors maintenant c'est à nouveau un programme. J'ai économisé autant d'octets que la "programmation" m'a coûté en passant à l'index d'origine 0, ce que OP permet.
— Adám
1
D'ACCORD. Par curiosité: de quel dialecte s'agit-il? Je n'ai aucune idée de ce que la première ligne est supposée faire ...
— Dennis
@Dennis Dyalog. Il s'agit d'une fonction traditionnelle, la première ligne est la ligne [0], c'est-à-dire l'en-tête de la fonction, mais elle semble inhabituelle car elle a l'argument gauche nom-fn l'argument droit, mais aucun résultat.
— Adám
En utilisant notre site, vous reconnaissez avoir lu et compris notre politique liée aux cookies et notre politique de confidentialité.
Licensed under cc by-sa 3.0 with attribution required.