Votre travail consiste à écrire un programme qui trouve le nombre optimal de mouvements nécessaires pour passer du coin inférieur gauche d'un rectangle au coin supérieur droit directement opposé.

Votre programme acceptera la saisie comme paire ordonnée (width, height). Ce seront les dimensions du rectangle avec lequel vous travaillerez. Votre programme créera un art ASCII de la solution (à utiliser .pour le carré vide et #pour une partie de la solution, Xpour le carré de départ) et comptera le nombre de mouvements nécessaires pour atteindre le point final. Les déplacements en diagonale ne sont pas autorisés. S'il existe plusieurs solutions, choisissez-en une pour la sortie.

Le programme le plus court en octets gagne.

Exemple

Contribution: (4, 5)

Production:

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

Nombre de coups: 7

05AB1E , 27 24 octets

Code:

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

Explication:

+                         # 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.

Essayez-le en ligne! . Utilise l' encodage CP-1252 .

Rétine , 54 53 octets

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

Prend les entrées séparées par un saut de ligne et sort la grille de solution suivie du nombre de mouvements.

Essayez-le en ligne!

Explication

\d+
$*.

Transformez les deux entiers en autant de .s, c'est-à-dire convertissez-les en unaires.

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

Cela construit une grille de .s, en faisant correspondre chacun .à la hauteur unaire et en capturant la représentation unaire de la largeur. Le Sactive le mode split qui renvoie les chaînes capturées, et le |\Det _s'assurent que tout le reste est supprimé de la chaîne.

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

Cela transforme le dernier caractère de chaque ligne ainsi que la dernière ligne entière en #s.

:m-1=`^#
X

Cela utilise une tonne d'options pour convertir uniquement la première #de la dernière ligne en X(nous devons nous assurer que seule la dernière ligne est affectée en raison des entrées de largeur 1). mactive le mode multi-lignes qui fait ^correspondre le début des lignes. -1=indique à Retina d'effectuer la substitution uniquement lors du dernier match. Enfin, :désactive le mode silencieux par défaut de sorte que la grille est imprimée sur STDOUT en tant que résultat intermédiaire.

#

Enfin, nous comptons simplement le nombre #dans la chaîne, ce qui correspond au nombre de mouvements.

Pyke, 26 octets

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

Essayez-le ici

Ou 34 octets non compétitifs, ajoutez un nœud d'application avec un ast)

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

Essayez-le ici!

Ou 30 octets si les espaces sont autorisés comme remplissage

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

Pyth, 32 29 24 octets

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

Essayez-le en ligne!

Exemple d'entrée:

(4, 5)

Exemple de sortie:

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

Comment ça fonctionne:

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

Tentative précédente:

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

Essayez-le en ligne!

Exemple d'entrée:

(4, 5)

Exemple de sortie:

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

Comment ça fonctionne:

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 octets

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

Prend l'entrée dans le formulaire width heightet affiche le nombre de déplacements sur la première ligne, suivi de la grille de solution.

Testez-le ici.

Cela fonctionne également pour le même nombre d'octets:

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

Rubis, 48 ​​octets

Il s'agit d'une fonction anonyme qui, selon cette méta-publication, est acceptable, sauf si la question indique «programme complet». Je ne serais pas normalement pédant à ce sujet mais le problème est très simple et faire un programme serait une augmentation significative du score de%.

L'entrée est deux arguments. La valeur de retour est un tableau contenant la chaîne d'art ASCII et le nombre de #dans le chemin.

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

En programme de test

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

puts f[4,5]

Production

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

C'est juste une chaîne de h-1 rangées de points w-1, suivie d'un #et d' une nouvelle ligne. J'ai mis le #à la fin afin d'utiliser un seul #\nlittéral pour les deux #et la nouvelle ligne (le code contient une nouvelle ligne réelle plutôt qu'une séquence d'échappement.) La dernière ligne est ensuite Xsuivie de w-1 #.

Il était plus court de décrémenter les valeurs de w et h pendant la génération de l'art ASCII, de sorte que le calcul final est simple w+h.

JavaScript (ES6), 60 octets

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

Usage

f(4)(5)

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

MATL , 28 26 25 octets

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

EDIT (10 juin 2016): le lien ci-dessous inclut une modification ( 5Lest remplacé par IL) pour s'adapter aux changements de langue

Essayez-le en ligne!

Explication

+       % 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 octets

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

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

Exemple d'utilisation:

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

Comment ça fonctionne:

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 octets

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 octets

Essayez-le en ligne!

Golfé:

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

Non golfé:

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)

Pour l'utiliser, ajoutez f=avant la ligne ci-dessus et appelez-le comme ceci:

f(4, 5)

Résultat:

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