Évitez la descente la plus raide!

19

Contexte

Il y a quelques mois, l'aventure de votre vie était sur le point de commencer. Maintenant, en ce moment précis (ouais, maintenant), après des mois de souffrance et de dur labeur, vous et un groupe d'amis vous tenez au sommet du monde. Oui, vous avez raison, vous êtes au sommet de Sagarmāthā .

Cependant, les choses ne se passent pas aussi bien que vous le souhaiteriez. Un brouillard dense vous a entouré et une tempête incroyablement mauvaise arrive aussi vite que possible. Vous n'avez fixé aucune corde en montant et vos empreintes de pas ont été couvertes de neige. Si vous voulez survivre (au moins pour aujourd'hui), vous devez sortir de là aussi vite que possible, mais vous DEVEZ d'abord trouver un moyen de savoir quelle face de la montagne est celle que vous devez descendre.

Heureusement, vous avez apporté avec vous votre téléphone satellite que vous avez modifié avant le voyage afin de pouvoir y programmer et exécuter des programmes.

Défi

Vous avez pu télécharger sur votre téléphone la carte de la montagne d'une manière ASCII à l'ancienne et illisible sur le sommet du monde. Votre tâche consiste à décider quelle face de la montagne présente la descente la plus facile afin d'augmenter vos chances de survie. Pour ce faire, vous avez la brillante idée de coder un programme sur votre téléphone qui vous dira quelle est la voie la plus simple. (Avertissement: Ces activités ont été réalisées par des professionnels. Aucun programmeur n'a été blessé au cours de cette narration. S'il vous plaît, n'essayez pas cela à la maison.)

Les cartes sont uniquement constituées des caractères /et \(plus les espaces et les nouvelles lignes). Dans toute carte, le sommet de la montagne est toujours représenté par

 /\ 
 \/

et de chacun des côtés ( 1,2,3ou 4) du sommet, vous trouverez toujours un chemin "possible" vers le bas de la montagne.

1 /\ 2
3 \/ 4

Les itinéraires sont toujours présentés de la manière suivante:

                      \
  Steep-> /          /
           /        / <-Flat
            /      \
      Flat-> \    \
              /  \ <-Steep
               /\
               \/

où chaque nouveau personnage est soit un endroit à gauche / droite de son prédécesseur. La signification de chaque caractère est:

  • Si la barre oblique / jeu est parallèle à son côté sommet -> compte comme une partie «raide».
  • Si la barre oblique / barre oblique inversée est perpendiculaire à son côté sommet -> compte comme une partie «plate».

* Pour plus d'informations, voir le graphique ci-dessus.

Remarque : Les côtés peuvent avoir des longueurs différentes et les caractères qui constituent le sommet comptent également comme faisant partie de leur côté. En cas d'égalité, vous pouvez choisir n'importe lequel d'entre eux.

Les failles standard ne sont pas autorisées.

Contribution

Une chaîne représentant la carte de la montagne ou un fichier texte contenant les mêmes informations.

Soit

C:\....\file.txt

ou

                  \
      /          /
       /        /
        /      \
         \    \
          /  \
           /\
           \/
          \  /
         \    \
        \      \
       \        \
      /          /

sous forme de chaîne sont des entrées valides.

Production

En sortie, vous devez produire un fichier en texte brut ou par stdout une représentation de profil ASCII du côté avec la plus faible pente moyenne en utilisant _pour les pièces plates et /pour les pièces raides avec la pente moyenne du côté (number of "/")/(total chars).

Exemple de sortie pour la carte ci-dessus:

       /
   ___/
  /
  AS:0.5

Le format n'est pas important tant que vous avez le profil et la pente moyenne.

Notation

Quelle? Voulez-vous une meilleure récompense que de sauver votre vie et celle de vos amis et d'être le premier programmeur à avoir programmé au sommet du monde? D'accord ... c'est le golf de code, donc le programme le plus court en octets gagne.

Cas de test

Contribution:

                  \
      /          /
       /        /
        /      \
         \    \
          /  \
           /\
           \/
          \  /
         \    \
        \      \
       \        \
      /          /

Production:

       /
   ___/
  /
  AS=0.5

Contribution:

                  /
      \          /
       /        /
        \      /
         \    /
          /  /
           /\
           \/
          \  /
         \    \
        \      \
       \        \
      /          /
     / 
    /

Production:

______/
AS=0.143 (1/7)

Contribution:

           /        \
            \      \
             /    /
              /  \
               /\
               \/
              \  /
             \    /
            \      /
           /        \

Production:

        /        
       /
      /       
    _/
    AS=0.8
code-golf Ioannes
la source
Sur la base des exemples, il semble que le profil montre le chemin de bas en haut si vous le lisez de gauche à droite? Cela semble quelque peu inhabituel, car nous allons de haut en bas, mais pas de problème si c'est clairement défini de cette façon.
Reto Koradi
6
@RetoKoradi vous avez raison. Je ne sais pas pourquoi je l'ai fait de cette façon ... Vous savez, à cette hauteur, il est difficile de garder vos pensées en ordre ...
Ioannes
La sortie doit-elle également inclure le numéro de la pente la moins raide (1, 2, 3 ou 4)? Dans l'état actuel des choses, vous savez que l'un d'eux est définitivement le gagnant mais pas lequel.
Vic
1
* Aucun programmeur n'a été blessé pendant cette narration. * Ça me tient à cœur. +1
edc65
3
J'aime que vous ayez utilisé Sagarmāthā :)
Beta Decay

Réponses:

4

JavaScript (ES6), 303

Testez l'exécution de l'extrait de code dans un navigateur compatible EcmaScript - sûrement Firefox, probablement Chrome. Utilisation de chaînes de modèle, fonctions de flèche.

// Golfed, no indentenation, all newlines are significant

f=s=>(s=`
${s}
`.split`
`,s.map((r,i)=>~(q=r.search(/\/\\/))&&(y=i,x=q),x=y=0),z=[],[0,2,0,2].map((d,i)=>{t=x+i%2,u=y+i/2|0,b=s[u][t];for(p=[''],n=l=0;(c=s[u][t])>' ';++l,t+=d-1,u+=(i&2)-1)c==b?p.push(p[n++].replace(/./g,' ',w='/')):w='_',p=p.map((r,i)=>(i<n?' ':w)+r);z=z[0]<(p[0]=n/l)?z:p}),z.join`
`)

// Less golfed

U=s=>(
  s=(`\n${s}\n`).split`\n`,
  x = y = 0,
  s.map((r,i)=>~(q=r.search(/\/\\/))&&(y=i,x=q)),
  z=[],
  [0,2,0,2].map((d,i) => {
    t = x+i%2,
    u = y+i/2|0,
    b = s[u][t];
    for(p=[''], n=l=0; (c=s[u][t])>' '; ++l, t += d-1, u +=(i&2)-1)
      c == b
        ? p.push(p[n++].replace(/./g,' ',w='/'))
        : w='_',
      p = p.map((r,i) => (i<n?' ':w)+r);
    z = z[0]<(p[0]=n/l)?z:p
  }),
  z.join`\n`
)

// TEST
// redirect console into the snippet body
console.log=x=>O.innerHTML+=x+'\n'

maps=[ // as javascript string literals, each baskslasch has to be repeated
`                  \\
      /          /
       /        /
        /      \\
         \\    \\
          /  \\
           /\\
           \\/
          \\  /
         \\    \\
        \\      \\
       \\        \\
      /          /`,
`                  /
      \\          /
       /        /
        \\      /
         \\    /
          /  /
           /\\
           \\/
          \\  /
         \\    \\
        \\      \\
       \\        \\
      /          /
     / 
    / `,
`           /        \\
            \\      \\
             /    /
              /  \\
               /\\
               \\/
              \\  /
             \\    /
            \\      /
           /        \\`]

maps.forEach(m=>console.log(m + '\n'+ f(m) +'\n'))
<pre id=O></pre>
Développer l'extrait

edc65
la source