Il tuo compito è quello di scrivere un programma che trova il numero ottimale di mosse necessarie per ottenere dall'angolo inferiore sinistro di un rettangolo all'angolo superiore destro direttamente opposto.

Il tuo programma accetterà l'input come coppia ordinata (width, height). Queste saranno le dimensioni del rettangolo con cui lavorerai. Il tuo programma creerà un'arte ASCII della soluzione (utilizzare .per il quadrato vuoto e #per parte della soluzione,X per il quadrato iniziale) e conteggerà il numero di mosse necessarie per raggiungere l'endpoint. Non sono consentite mosse diagonali. Se ci sono più soluzioni, scegline una per l'output.

Vince il programma più breve in byte.

Esempio

Ingresso: (4, 5)

Produzione:

..##
..#.
.##.
.#..
X#..

Conteggio mosse: 7

05AB1E , 27 24 byte

Codice:

+Í,¹<'.×'#¶J²<×'X'#¹<×J,

Spiegazione:

+                         # Add the length and the height.
 Í                        # Decrease by two.
  ,                       # Print this value with a newline.
   ¹<'.×                  # Take the first input, decrease by 1 and multiply with ".".
        '#¶               # Push a "#"-character and a newline character.
           J              # Join the string.
            ²<            # Take the second input and decrease by 1.
              ×           # Multiply the joined string with this value.
               'X         # Push the "X"-character.
                 '#¹<×J   # Multiply the "#"-character with (first input - 1).
                       ,  # Pop and print with a newline.

Provalo online! . Utilizza la codifica CP-1252 .

Retina , 54 53 byte

\d+
$*.
S_`(?<=(.+)¶.*).|\D
T`.`#`.¶|.*$
:m-1=`^#
X
#

Accetta input separati da un avanzamento riga e genera la griglia della soluzione seguita dal conteggio degli spostamenti.

Provalo online!

Spiegazione

\d+
$*.

Trasforma entrambi i numeri interi in tante .s, ovvero convertili in unari.

S_`(?<=(.+)¶.*).|\D

Questo crea una griglia di .s, abbinando ciascuna .all'altezza unaria e catturando la rappresentazione unaria della larghezza. L' Sattiva modo split che restituisce le stringhe catturate, e la |\De _insieme assicurare che tutto il resto viene rimosso dalla stringa.

T`.`#`.¶|.*$

Questo trasforma l'ultimo carattere di ogni riga e l'intera ultima riga in #s.

:m-1=`^#
X

Questo utilizza una tonnellata di opzioni per convertire solo la prima #nell'ultima riga X(dobbiamo assicurarci che solo l'ultima riga sia interessata a causa degli input di larghezza-1). mattiva la modalità multilinea che fa ^coincidere l'inizio delle righe. -1=dice a Retina di eseguire la sostituzione solo sull'ultima partita. Infine, :disattiva la modalità silenziosa predefinita in modo tale che la griglia venga stampata su STDOUT come risultato intermedio.

#

Infine, contiamo semplicemente il numero #nella stringa, che corrisponde al numero di mosse.

Pyke, 26 byte

DtQ+RtF; Q\.*t\#+)\X\#Qt*+

Provalo qui

O 34 byte non competitivi, aggiungi il nodo apply con un ast)

jUa]Dm!X|RZjht]q+".#X"R@)Fs
);jmts

Provalo qui!

O 30 byte se spazi consentiti come riempimento

jUa]Dm!X|RZjht]q+".#X"R@)Pjmts

Pyth, 32 29 24 byte

AtMQVH+*\.G\#;+\X*\#G+GH

Provalo online!

Input di esempio:

(4, 5)

Uscita campione:

...#
...#
...#
...#
X###
7

Come funziona:

AtMQVH+*\.G\#;+\X*\#G+GH
                           assign('Q',eval_input())
AtMQ                       assign('[G,H]',Pmap(lambda d:tail(d),Q))
    VH       ;             for N in range(H):
      +*\.G\#                  implicit_print(plus(times(".",G),"#"))
              +\X*\#G      implicit_print(plus("X",times("#",G)))
                     +GH   implicit_print(plus(G,H))

Tentativo precedente:

JthQK@Q1+*++*\.J\#btK+\X*\#Jt+JK

Provalo online!

Input di esempio:

(4, 5)

Uscita campione:

...#
...#
...#
...#
X###
7

Come funziona:

JthQK@Q1+*++*\.J\#btK+\X*\#Jt+JK
                                 assign('Q',eval_input())        --Q is now an official pair of numbers (4, 5)
JthQ                             assign("J",decrement(first(Q))) --gets the first element, and then take 1 from it, and assign it to J
    K@Q1                         assign("K",lookup(Q,1))         --K is now the second element (count from 0) of the pair.
        +            +\X*\#J     concat(-----------------------------------------------------------,concat("X",times("#",J)))
         *         tK                   repeat(--------------------------------------,decrement(K))
          +       b                            concat(-------------------------,"\n")
           +    \#                                    concat(-------------,"#")
            *\.J                                             repeat(".",J)
                            t+JK decrement(add(J,K)) <--- auto-print

CJam, 35 33 byte

q~\(_2$(+p'.*a*'#f+)W%_"X#"era+N*

Accetta l'input nel modulo width heighte genera il conteggio delle mosse sulla prima riga, seguito dalla griglia della soluzione.

Provalo qui.

Questo funziona anche per lo stesso conteggio byte:

q~\('.*a*'#f+)W%_"X#"era+N*_'#e=p

Rubino, 48 byte

Questa è una funzione anonima, che secondo questo meta post è accettabile a meno che la domanda non indichi "programma completo". Normalmente non sarei pedante per questo, ma il problema è molto semplice e fare un programma sarebbe un aumento significativo in% del punteggio.

L'input è di due argomenti. Il valore restituito è un array contenente la stringa di arte ASCII e il numero di #nel percorso.

->w,h{[(?.*(w-=1)+'#
')*(h-=1)+?X+?#*w,w+h]}

Nel programma di test

f=->w,h{[(?.*(w-=1)+'#
')*(h-=1)+?X+?#*w,w+h]}

puts f[4,5]

Produzione

...#
...#
...#
...#
X###
7

È solo una stringa di righe h-1 di punti w-1, seguite da a #e newline. Ho messo il #fine alla fine per usare un singolo #\nletterale per entrambi #e per la nuova riga (il codice contiene una nuova riga effettiva anziché una sequenza di escape). La riga finale è quindi Xseguita da w-1# .

È stato più breve decrementare i valori di w e h durante la generazione di arte ASCII, quindi il calcolo finale è semplicemente w+h.

JavaScript (ES6), 60 byte

w=>h=>--w+--h+`
${"."[r="repeat"](w)}#`[r](h)+`
X`+"#"[r](w)

uso

f(4)(5)

7
...#
...#
...#
...#
X###

MATL , 28 26 25 byte

+qq35IMwX"46 5Lt4$(88HG(c

EDIT (10 giugno 2016): il link seguente include una modifica ( 5Lè sostituita da IL) per adattarsi alle modifiche della lingua

Provalo online!

Spiegazione

+       % take two inputs. Add them
qq      % subtract 2
35      % push ASCII for '#'
IMw     % push the two inputs again. Swap them
X"      % 2D char array of '#'  repeated as indicated by inputs
46      % push ASCII for '.'
5Lt4$(  % fill all but last and row columns with that
88HG(   % fill 88 (ASCII for 'X') at linear index given by second input
c       % convert to char

Scala, 118 byte

(w:Int,h:Int)=>{print(Array.fill(h-1,w-1)('.')map(new String(_))mkString("","#\n","#\nX"));Seq.fill(w-1)(print("#"))}


(w:Int,h:Int)=>{...}           //define a function with 2 Ints as parameters
print(                        //print ...   
  Array.fill(h-1,w-1)('.')    //an array of arrays with dimensions (h-1,w-1)
                              //and fill it with a dot
  map(new String(_))          //map each inner array of chars to a string
  mkString("","#\n","#\nX")   //create a string from the array, with
                              //an empty string before the array,
                              //"#\n" as a seperator between the elements
                              //and "#\nX" at the end   
);
Seq.fill(w-1)(print("#"))     //w-1 times print "#"

Haskell, 64 byte

c!n=c<$[2..n]
w#h=unlines$('.'!w++"#")!h++['X':'#'!w,show$w+h-2]

Esempio di utilizzo:

*Main> putStr $ 4 # 5
...#
...#
...#
...#
X###
7

Come funziona:

c!n = c <$ [2..n]                       -- helper function: make (n-1) copies of c

                                        -- main function
                     !h                 -- (h-1) times
       ('.'!w ++ "#")                   --    (w-1) dots and a hash sign
                       ++[      ,     ] -- followed by
                          'X' : '#'!w   --    an 'X' and (w-1) hash signs
                            show$w+h-2  --    and the number of steps
unlines                                 -- join everything with newlines in-between

Java, 137 132 byte

w->h->{String s="";int i=0,j;for(;i<h;i++){for(j=1;j<w;j++)s+=".";s+="#\n";}s+="X";for(j=1;j<w;j++)s+=".";s+="\n"+(w+h-2);return s;}

Lua, 81 byte

Provalo online!

golfed:

w,h=(...)print((("."):rep(w-1).."#\n"):rep(h-1).."X"..("#"):rep(w-1))print(w+h-2)

Ungolfed:

w,h=4,5
print((("."):rep(w-1).."#\n"):rep(h-1).."X"..("#"):rep(w-1))
print(w+h-2)

Python, 48.

lambda w,h:('.'*(w-1)+'#\n')*(h-1)+'X'+'#'*(w-1)

Per usarlo, aggiungi f=prima della riga sopra e chiamalo così:

f(4, 5)

Risultato:

...#
...#
...#
...#
X###