Un gioco d'ipotesi piatto

13

C'è un gioco a cui mi piace giocare. Succede su una griglia di dimensioni finite (ma è avvolta, come una sfera). Su quella griglia, viene selezionato un punto casuale (solo intero). Quindi, io, all'utente, viene richiesto un input di coordinate. Se il mio input corrisponde esattamente al punto casuale, mi viene detto che ho vinto. Altrimenti, mi viene detta la distanza punto-punto tra il mio input e il punto casuale. Ad esempio, se avessi indovinato (2,2)e il punto casuale fosse a (4,3), allora la distanza sarebbe sqrt[(3-2)^2 + (4-2)^2] = sqrt[5].

Il gioco continua fino a quando il giocatore arriva nella posizione corretta del punto.

Obiettivo Creare una versione funzionale del gioco sopra descritto. È necessario creare un programma completo per farlo. Ecco cosa dovrebbe fare il tuo programma:

  1. Richiedi due input: l'altezza e la larghezza della scheda. L'origine è nella parte in alto a sinistra del tabellone. Questi ingressi non supereranno 1024.
  2. Seleziona un punto casuale su quel tabellone; questo sarà il punto da indovinare.
  3. Accetta input simulando un turno. L'input sarà una coppia di numeri interi separati da spazio o due input interi separati. In risposta a questo input, il programma farà una delle due cose:
    1. Se l'ingresso corrisponde al punto casuale selezionato, emette un messaggio che segnala la vittoria dell'utente. Suggerirei "Hai vinto!".
    2. In caso contrario, emettere la distanza tra il punto di input dell'utente e il punto casuale.
    In entrambi i casi, è necessario incrementare il contatore di virate.
  4. Una volta che l'utente ha ottenuto la vittoria, visualizza il numero di turni effettuati dall'utente. Il programma quindi termina.

bonus

I bonus vengono applicati nell'ordine in cui compaiono in questo elenco

  • -150 byte se il tuo programma accetta un numero intero di input Dche descrive la dimensione in cui si svolge il gioco. Ad esempio, se D = 3, quindi, si crea un punto casuale di 3numeri interi, si prendono 3input di numeri interi e si genera la distanza tra questi punti.
  • -50% (o + 50% se score < 0) se si fornisce una rappresentazione grafica della scheda (ASCII o Picture) che mostra dove l'utente ha precedentemente indovinato sulla griglia di determinate dimensioni e il contatore di virate. (Se scegli il primo bonus, questo bonus si applica solo alle modalità 2De 1D. Se aggiungi un output grafico 3D, otterrai un ulteriore -50%.)
  • -60 byte se è possibile fornire un gamemode (selezionato da un input all'inizio; ovvero, quando assegnato 0, eseguire il gamemode normale; quando assegnato 1, eseguire questo gamemode) in cui il punto si sposta di 1 unità in una direzione ortogonale casuale per turno

Maggiori informazioni sul confezionamento

L'avvolgimento si verifica solo quando, nel terzo bonus, il punto mobile si sposta attraverso uno qualsiasi dei confini; in questo caso, il punto mobile viene deformato al rispettivo punto, in questo modo:

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

Questo comportamento di avvolgimento non influisce sull'ipotesi dell'utente, a parte il fatto che il punto ha cambiato direzione.

Classifica

Lo snippet di stack nella parte inferiore di questo post genera il catalogo dalle risposte a) come elenco della soluzione più breve per lingua eb) come classifica generale.

Per assicurarti che la tua risposta venga visualizzata, ti preghiamo di iniziare la risposta con un titolo, usando il seguente modello Markdown:

# Language Name, N bytes

dov'è Nla dimensione del tuo invio. Se si migliora il punteggio, è possibile mantenere i vecchi punteggi nel titolo, colpendoli. Per esempio:

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

Se si desidera includere più numeri nell'intestazione (ad es. Perché il punteggio è la somma di due file o si desidera elencare separatamente le penalità del flag dell'interprete), assicurarsi che il punteggio effettivo sia l' ultimo numero nell'intestazione:

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

Puoi anche rendere il nome della lingua un collegamento che verrà quindi visualizzato nello snippet:

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

Mostra snippet di codice

code-golf  game 
— Conor O'Brien
fonte
7
Piccolo nitpick: probabilmente intendi che si avvolge come un toro e non una sfera. È impossibile avvolgere una griglia 2D su una sfera senza creare discontinuità.
— Alistair Buxton,
2
Inoltre, se la tavola si avvolge, potrebbe esserci un percorso più breve tra ipotesi e bersaglio attraversando un bordo.
— Alistair Buxton,
1
@NBZ Sì, puoi.
— Conor O'Brien,
1
@NBZ 1 unità in una sola direzione.
— Conor O'Brien,
2
1. Non sono ancora sicuro di quale sia la topologia. Per chiarire le cose, se la tavola è 10x10, il punto casuale è (9,4), e immagino (2,2), è la distanza sqrt(13)o sqrt(53)? (Nota per il futuro: se stai facendo qualcosa di strano, non includere la casualità perché rende quasi impossibile fornire casi di test). 2. Nel terzo bonus, la distanza deve essere calcolata ed emessa prima o dopo lo spostamento del punto?
— Peter Taylor,

Risposte:

8

CJam, -113 -139 -152 -157 -159 byte

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

Il programma è lungo 51 byte e si qualifica per i bonus di -150 byte e -60 byte .

La modalità di gioco e il numero di dimensioni vengono letti come argomento della riga di comando, la dimensione in ogni dimensione da STDIN. Poiché il messaggio di vittoria è arbitrario , il programma stamperà 0.0(distanza dall'obiettivo) per indicare che il gioco è finito.

Esecuzioni di test

$ 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

Come funziona

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
fonte
2
E Dennis ha superato tutti. Ancora.
— Seadrus,
1
Hai accidentalmente aggiornato il punteggio a 152 invece di -152, mettendoti per ultimo in classifica
— 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

Vecchia soluzione: (54-150 = -96)

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

Tutti gli input avvengono su una nuova riga.

  • Il primo numero intero rappresenta la modalità di gioco ( o 1oppure0 )
  • Primo Secondo intero Drappresenta le dimensioni del gioco.
  • Gli Dinput successivi rappresentano la dimensione del campo
  • Tutti gli Dinput da questo punto in poi sono ipotesi

Riproduzione di esempio (i suggerimenti non vengono visualizzati nel programma reale):

  #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
— alce americano
fonte
La seconda mossa non dovrebbe vincere?
— JNF,
@JNF il punto può muoversi nel gamemode 1 (bonus di -60 byte)
— Jakube
Holy moly, questo è un codice Pyth lungo. Ma non ho davvero giocato a golf. Ad esempio, vedo due spazi che possono essere rimossi. Inoltre: è possibile utilizzare J=YmOvwvwinvece di VvwaYOvw;JY, che è di 2 byte in meno. Non ho controllato l'altro codice, ma immagino che tu possa anche accorciare alcune cose lì.
— Jakube,
@ Jakube, stavo supponendo che il suggerimento ci dice dove si trova attualmente il punto
— 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

Prima sfida solo finora. Provalo online

— Mego
fonte
3

Pip, 43 42 byte - 150 = -108

Prende le dimensioni della scheda come argomenti della riga di comando (con D implicito dal numero di arg). Indovina come numeri separati da spazi su stdin.

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

Questo codice sfrutta appieno le funzionalità di programmazione di array di Pip. L'array di cmdline args è archiviato ing . Generiamo il punto da indovinare mappando l'operatore randrange RRsu g, e trasciniamo l'elenco risultante nella yvariabile. Quindi arriva il ciclo while principale, dove la condizione è la seguente:

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

Se la distanza era diversa da zero, l'interno del ciclo lo stampa. Se era zero, abbiamo raggiunto il punto target; il loop si interrompe e il programma emette il messaggio di vincita e il numero di turni.

Esempio di esecuzione:

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

R, 134-150 = -16 byte

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

Ok:

Si noti che questo viene eseguito nell'indice origine 0 ( ⎕IO←0) che è predefinito in molti APL.
Utilizza la modalità booleana come argomento destro ( M) e le dimensioni della dimensione come argomento sinistro ( S).
Il numero di dimensioni è D, che deve essere impostato (ad es. D←3) Prima di chiamare, come da OP).
P←?Sl'obiettivo ottiene un punto casuale nell'intervallo 1 anche se ciascuno dei limiti di dimensione
{... }⍣≢C←0ripete la funzione fino a quando il risultato è diverso da C, che inizialmente ottiene 0
?2un numero casuale 0 o 1
¯1 1[... ]indice dall'elenco di due numeri
M×moltiplicato per la modalità; rende 0se la modalità è 0
D↑pad con 0s per abbinare il numero di dimensioni regolare il modulo di dimensione mondiale dell'obiettivo attuale
(?D)⌽ ruota l'elenco a caso (da 0 a numero di dimensioni-1)
P+
S|
P← salva la nuova ipotesi di input del
C+←1contatore dell'incremento del punto obiettivo
P≢G←⎕:e se è diverso dal punto obiettivo quindi ... le
P-Gdistanze in ogni dimensione al
2*⍨quadrato
+/sommano la stampa a
.5*⍨radice quadrata
⎕←che
0⊣restituisce 0 (cioè identico al valore iniziale, quindi ripeti)
C... altrimenti, restituisce il numero di ipotesi (che, essendo diverso da 0, interrompe il ciclo e restituisce l'ultimo valore)

— Adamo
fonte
@Dennis In realtà, l'ho rotto quando l'ho reso una funzione, quindi ora è di nuovo un programma. Ho salvato tanti byte quanti mi sono costati "programmazione" passando all'indice origine 0, cosa che OP consente.
— Adám,
1
OK. Per curiosità: che dialetto è questo? Non ho idea di cosa dovrebbe fare la prima riga ...
— Dennis,
@Dennis Dyalog. Questa è una funzione tradizionale, la prima riga è la riga [0], ovvero l'intestazione della funzione, ma sembra insolita perché ha arg-left fn-name right-arg, ma nessun risultato.
— Adám,
Utilizzando il nostro sito, riconosci di aver letto e compreso le nostre Informativa sui cookie e Informativa sulla privacy.
Licensed under cc by-sa 3.0 with attribution required.