Étant donné deux paramètres de tracé de voie et de longueur de route , imprimez une représentation ASCII des marquages ​​de voie pour Roads and Traffic Service pour peindre les routes.

Exemple d'entrée / sortie

Entrée:, BTHMLRPHU 21

Je me fiche que vous preniez deux paramètres ou que vous concaténiez le nombre à la fin de la chaîne, c'est sans ambiguïté.

L'entrée peut provenir de STDIN, comme argument de fonction, variables d'environnement, tout ce qui a du sens dans votre langue.

Production:

!   |      x      ##      |      |      x      x      !
! B |  /\  x HOV3 ##  <-  |  ->  |  ^^  x HOV3 x      !
! B |  \/  x HOV3 ##   |  |  |   |  ^^  x HOV3 x      !
!   |      x      ##      |      |      x      x      !
!   |      x      ##      |      |      x      x      !
!   |      |      ##      |      |      |      |      !
!   |      |      ##      |      |      |      |      !
!   |      |      ##      |      |      |      |      !
! B |  /\  | HOV3 ##  <-  |  ->  |  ^^  | HOV3 |      !
! B |  \/  | HOV3 ##   |  |  |   |  ^^  | HOV3 |      !
!   |      x      ##      |      |      x      x      !
! B |  /\  x HOV3 ##  <-  |  ->  |  ^^  x HOV3 x      !
! B |  \/  x HOV3 ##   |  |  |   |  ^^  x HOV3 x      !
!   |      x      ##      |      |      x      x      !
!   |      x      ##      |      |      x      x      !
!   |      |      ##      |      |      |      |      !
!   |      |      ##      |      |      |      |      !
!   |      |      ##      |      |      |      |      !
! B |  /\  | HOV3 ##  <-  |  ->  |  ^^  | HOV3 |      !
! B |  \/  | HOV3 ##   |  |  |   |  ^^  | HOV3 |      !
!   |      x      ##      |      |      x      x      !

Chaque caractère dénote 0,5 mètre de largeur et un kilomètre de longueur.

spécification

Marquage de voie

Pour chaque tronçon de route de 10 km, des marquages ​​sont peints aux kilomètres 2, 3, 9 et 10 (à partir du "haut" de la sortie). Les marques sont centrées dans la voie. À l'exception de la piste cyclable et de la médiane, toutes les voies ont une largeur de 3 mètres (6 caractères).

Les caractères ASCII en forme de losange et de flèche ne sont pas autorisés à la place des marquages ​​indiqués dans l'exemple de sortie.

• B: Piste cyclable. Bmarquage. 1,5 mètres (3 caractères) de large.
• T: Transit. Marquage au diamant
• H: Voie réservée aux véhicules très fréquentés. HOV3marquage
• Let R: Turning lane. Marquage des flèches
• P: Passing lane. Marquages ​​au curseur
• U: Voie sans restriction. Aucun marquage

Séparateurs (par ordre de priorité)

• Médiane: ##(indiquée par Mdans la chaîne d'entrée, remplace tout autre séparateur, y compris le fossé)
• Fossé (extrême gauche et extrême droite): !point d'exclamation
• Les voies réservées aux VMO alternent entre xet |tous les 5 km
• Ordinaire: |

Contraintes

Votre fonction ou programme doit:

• Imprimer sur STDOUT (cela signifie des équivalents de System.out.printpour Java, console.logpour JavaScript, etc.)
• Être capable d'imprimer de 1 à 9 voies avec 0 à 10 médianes
• Être capable d'imprimer jusqu'à 50 km de chaussée (50 lignes de sortie)
• Ne pas utiliser de failles standard
• La fin des espaces blancs n'est pas acceptable à l'exception d'une option \nà la fin de la sortie

Plus grande sortie possible: 3700 octets (74 caractères * 50 lignes).

Sortie la plus petite possible: 5 octets (avec entrée B, 1)

Hypothèses

• Aucune médiane adjacente (la sous MM- chaîne ne se produira pas)
• La deuxième ligne de marquage peut être coupée (par exemple si la longueur est de 9 ou 12 km)
• Les voies peuvent ne pas avoir de sens logique (n'importe quel ordre est possible, par exemple une voie de virage à droite à gauche de la route)

C'est le code-golf , donc le code le plus court (en octets) gagne!

Rubis, 245

Imprimez la voie divise si nécessaire, puis imprimez la voie.

Je ne m'attends pas à gagner.

->(n,i){i.times{|d,t|*e=''
g=e+%w{HOV3 ^^ B}
n.chars{|c|$><<(c==?M?'##':!t ??!:(t+c)[?H]&&d%10<5??x:?|)if(M=t!=?M)
$><<((e+[(%w{/\\ <- ->}+g)[v='TLRUHPB'.index(c)],(%w{\\/ \ | |\ }+g)[v]]+e*4)*2)[d%10].center(v>5?3:6)if(t=c)!=?M}
puts M ? e:?!}}

Changelog

245 étrangle stderr et divise les tableaux efficacement.

263 meilleure façon d'indexer le tableau

268 imprimez simplement chaque ligne, ne calculez pas une version canonique.

330 validation initiale

JavaScript (ES6), 316 octets

f=(x,n)=>{for(i=0;n>i++;){b=!(r=i%10)|r==3;y=[...`! ${[...x].join` | `} !`[o='replace'](/[\W] ?M [\W]?/g,'##')].map(c=>~(q='LPRTU'.indexOf(c))?` ${'<- |^^^^->| /\\\\/    '.substr(4*q+2*b,2)} `:c=='H'?'HOV3':c).join``;y=r&&r<6?y[o](/\| H/g,'x H')[o](/3 \|/g,'3 x'):y;console.log(b|r==2|r==9?y:y[o](/[^!\|x#]/g,' '))}}

Démo

Il devrait fonctionner dans Firefox et Edge au moment de la rédaction, Chrome / Opera nécessite l'activation de fonctionnalités expérimentales.

console.log = x => O.innerHTML += x + '\n';

f = (x, n) => {
  for (i = 0; n > i++;) {
    b = !(r = i % 10) | r == 3;
    y = [...
      `! ${[...x].join` | `} !` [o = 'replace'](/[\W] ?M [\W]?/g, '##')
    ].map(c => ~(q = 'LPRTU'.indexOf(c)) ? ` ${'<- |^^^^->| /\\\\/    '.substr(4*q+2*b,2)} ` : c == 'H' ? 'HOV3' : c).join ``;
    y = r && r < 6 ? y[o](/\| H/g, 'x H')[o](/3 \|/g, '3 x') : y;
    console.log(b | r == 2 | r == 9 ? y : y[o](/[^!\|x#]/g, ' '))
  }
}

// Snippet stuff
var demo = () => {
  O.innerHTML = '';
  document.forms[0].checkValidity() && f(document.getElementById('P').value, document.getElementById('N').valueAsNumber);
};

document.getElementById('P').addEventListener('change', demo);
document.getElementById('N').addEventListener('change', demo);

demo();

<form action='#'>
  <p>
    <label>Lane pattern:
      <input type=text pattern=^M?([BHLPRTU]M?)+$ maxlength=19 required id=P value=MLTPUMHUTBR>
    </label>
  </p>
  <p>
    <label>Kilometres:
      <input type=number id=N min=1 value=21 max=50 step=1 required>
    </label>
  </p>
  <pre><output id=O></output></pre>
</form>

05AB1E , 175 174 175 octets

ðTиDU'|TиX'BŽ5ES©ǝX„\/TbSDVè®ǝ€ºX4×"HOV3"®ǝX'<18SǝX„|-Yè®ǝøJDí'<'>:X'^®ǝ2×'#Tи2×'x5и'|5и«'!Tи)I.•o¤[‹‡•uŽDýSтì€ûŽe1ª904ûª8ª₄«ª‡•δ~¬]•2ôDí«Ž
ÿT∍S:ð.ø8ðì‚8:1ðì‚ð:SðT:èεI∍}øJ»

Assez mauvaise approche, mais ça marche et c'était amusant à faire. Peut certainement être joué au golf un peu plus, cependant.

+1 octet comme correction de bogue pour deux HHvoies adjacentes .

Essayez-le en ligne.

Explication:

Étape 1: Créez toutes les voies possibles avec la taille 10:

ðTи               # Push a space character, repeated 10 times as list
   DU             # And store a copy in variable `X`
'|Tи             '# Push "|", repeated 10 times as list
X                 # Push the list of spaces of variable `X`
 'B              '# Push a "B"
   Ž5E            # Push compressed integer 1289
      S           # Converted to a list of digits: [1,2,8,9]
       ©          # Store it in variable `®` (without popping)
        ǝ         # Replace the spaces in the pushed `X` with the "B" at these (0-based)
                  # indices
X                 # Push `X` again
 „\/              # Push string "\/"
    TbS           # Push 10, converted to binary, as list: [1,0,1,0]
       DV         # Store a copy in variable `Y`
         è        # Index each into this string: ["/","\","/","\"]
          ®       # Push list `®` again ([1,2,8,9])
           ǝ      # And replace the spaces with these characters
            €º    # And then mirror each line (" "→"  "; "/"→"/\"; "\"→"\/")
X                 # Push `X` again
 4×               # Extend each space to four spaces
   "HOV3"         # Push string "HOV3"
         ®ǝ       # And replace the spaces with this string at the indices of `®` again
X                 # Push `X` again
 '<              '# Push string "<"
   18S            # Push 18 as list: [1,8]
      ǝ           # Replace the spaces with "<" at those indices
       X          # Push `X` yet again
        „-|       # Push string "-|"
           Yè     # Use list `Y` ([1,0,1,0]) to index into this string: ["-","|","-","|"]
             ®ǝ   # And replace the spaces at the indices of `®` again
               ø  # Then zip-pair the two lists together
                J # And join each pair of characters to a string
Dí                # Create a copy and reverse each string
  '<'>:           # And replace all "<" with ">"
X'^®ǝ            '# Push `X` with the spaces at indices `®` replaced with "^" 
     2×           # Extend each character to size 2
'#Tи             '# Push "#", repeated 10 times as list
    2×            # And extend each character to size 2
'x5и             '# Push "x" repeated 5 times as list
    '|5и         '# Push "|" repeated 5 times as list
        «         # And merge the lists together
'!Tи             '# Push "!", repeated 10 times as list
)                 # And finally wrap all lists of the stack into one big list of lanes

Étape 2: Convertissez la chaîne d'entrée en index (que nous allons utiliser pour indexer dans la liste que nous avons créée à l'étape 1):

I                 # Push the input-string
 .•o¤[‹‡•         # Push compressed string "tlrpbhmu"
         u        # And uppercase it
ŽDý               # Push compressed integer 3567
   S              # Converted to a list of digits: [3,5,6,7]
    тì            # Prepend each with "100": ["1003","1005","1006","1007"]
      €û          # And palindromize each: ["1003001","1005001","1006001","1007001"]
Že1               # Push compressed integer 10201
   ª              # And append it to the list
904ûª             # Push 904 palindromized to "90409", and also append it to the list
8ª                # Append 8 to the list
₄Â                # Push 1000, and bifurcate it (short for Duplicate & Reverse copy)
  «               # Merge them together: "10000001"
   ª              # And also append it to the list
‡                 # Now transliterate all uppercase characters in the input to these numbers
•δ~¬]•            # Push compressed integer 1119188999
      2ô          # Split into parts of size 2: [11,19,18,89,99]
        Dí        # Create a copy, and reverse each item: [11,91,81,98,99]
          «       # And merge the lists together: [11,19,18,89,99,11,91,81,98,99]
Ž\nÿ              # Push compressed integer 19889
    T∍            # Extended to size 10: 1988919889
      S           # As a list of digits: [1,9,8,8,9,1,9,8,8,9]
:                 # Replace all [11,19,18,89,99,11,91,81,98,99] with [1,9,8,8,9,1,9,8,8,9]
                  # in the converted string
ð.ø               # Surround the string with spaces
8ðì               # Push 8 with a prepended space: " 8"
   ‚             # Bifurcate and pair: [" 8","8 "]
     8:           # And replace all those for 8 in the string
1ðì‚ð:           # Do the same for [" 1","1 "] → " "
S                 # Convert the string to a list of characters (digits and space)
 ðT:              # Replace the spaces for 10

Étape 3: nous utilisons ces indices pour indexer dans la liste des voies. Et puis nous convertissons cette liste de voies en sortie correcte, y compris en les étendant / les raccourcissant à la taille de l'entrée entière:

è                 # Index the indices in the integer-list into the lanes-list
 ε                # Map over each lane
  I               #  Push the second integer-input
   ∍              #  Extend/shorten each 10-sized lane to this input-size
 }ø               # After the map: zip/transpose; swapping rows/columns
   J              # Join inner list together to a single string
    »             # And then join each string by newlines
                  # (after which the result is output implicitly)

Voir cette astuce de mes 05AB1E (sections Comment les chaînes de Compresser ne font pas partie du dictionnaire? Et comment compresser les grands entiers? ) Pour comprendre pourquoi Ž5Eest 1289; .•o¤[‹‡•est "tlrpbhmu"; ŽDýest 10201; •δ~¬]•est 1119188999; Ž\nÿest 19889.