Solution optimale pour aller dans le coin opposé d'un rectangle


13

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


La sortie doit-elle donc contenir le nombre de #dans "la solution optimale" (quelle est la solution qui ne se déplace jamais vers la gauche ou vers le bas)?
Martin Ender

12
Re "Désolé, c'est ma première question de code-golf, donc je ne suis pas très bon pour les faire." Permettez-moi de recommander le bac à sable où vous pouvez publier des idées de défis et recevoir des commentaires avant de les publier sur main. Et bienvenue chez PPCG! :)
Martin Ender

@ MartinBüttner Oui, le nombre de coups est essentiellement le nombre de #car il est illogique d'aller à gauche ou à descendre.
ericw31415

Est-il correct de séparer chaque caractère par des espaces?
Blue

1
Doit-on sortir le nombre de coups ET l'art ascii? À quoi devrait ressembler exactement la sortie?
James

Réponses:


0

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 .


Quelle est la différence entre un octet et un caractère?
Leaky Nun

2
@KennyLau J'oublie toujours de mentionner que dans mes messages ... 05AB1E utilise l'encodage CP-1252, chaque caractère utilisé dans le code ici est de 1 octet.
Adnan du

3

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.


Peut-être qu'un intégré devrait être ajouté à la rétine pour être converti en unaire.
Cyoce

3

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

Pourquoi est-il non compétitif?
Leaky Nun

3
J'ai changé de langue après la publication du défi
Bleu

@muddyfish Erreur de serveur interne lorsque vous cliquez, essayez-le ici
Insane

@Insane a corrigé le bogue (avec un peu de chance) Le test interne du temps échouait chaque fois que le jour changeait.
Bleu

2

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

@ MartinBüttner Peut-être pourriez-vous m'aider à jouer au golf?
Leaky Nun

@KennyLau Je ne connais aucun Pyth ...
Martin Ender

@ MartinBüttner C'est assez gênant pour Pyth d'être vaincu, à droite
Leaky Nun

Vous pouvez combiner les deux premières affectations avec AtMQ . Cela affecte les deux valeurs à Get H.
Jakube

1

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

Je n'ai pas vu de solution CJam depuis un moment.
Cyoce


1

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.


1

JavaScript (ES6), 60 octets

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

Usage

f(4)(5)

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

1

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

0

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 "#"

0

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

0

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;}

Java n'est pas exactement une blague cependant ...
ericw31415

s + = au lieu de s = s + vous fera économiser quelques octets
Blue

0

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)

0

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