Für zwei gegebene Parameter Spurmuster und Straßenlänge , drucken Sie eine ASCII - Darstellung der Fahrspurmarkierungen für Straßen- und Verkehrsdienst der Straßen zu malen.

Beispiel Eingabe / Ausgabe

Eingabe:, BTHMLRPHU 21

Es ist mir egal, ob Sie zwei Parameter verwenden oder die Zahl an das Ende der Zeichenfolge anhängen, es ist eindeutig.

Die Eingabe kann von STDIN als Funktionsargument und Umgebungsvariablen erfolgen, was auch immer in Ihrer Sprache sinnvoll ist.

Ausgabe:

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

Jedes Zeichen entspricht einer Breite von 0,5 Metern und einer Länge von einem Kilometer.

Spezifikation

Fahrspurmarkierungen

Für jeden 10 km langen Straßenabschnitt werden Markierungen in den Kilometern 2, 3, 9 und 10 (von der "Oberseite" der Ausgabe) angebracht. Markierungen werden in der Spur zentriert. Mit Ausnahme der Fahrradspur und des Medians sind alle Spuren 3 Meter (6 Zeichen) breit.

ASCII-Rauten- und Pfeilzeichen sind anstelle der in der Beispielausgabe angegebenen Markierungen nicht zulässig.

• B: Radweg. BMarkierung. 1,5 Meter (3 Zeichen) breit.
• T: Transit. Diamantmarkierung
• H: Fahrzeugspur mit hoher Belegung. HOV3Markierung
• Lund R: Abbiegen. Pfeilmarkierung
• P: Überholspur. Caret-Markierungen
• U: Uneingeschränkte Fahrspur. Keine Markierungen

Trennzeichen (in der Reihenfolge ihrer Rangfolge)

• Median: ##(bezeichnet durch Min der Eingabezeichenfolge, ersetzt alle anderen Trennzeichen einschließlich Graben)
• Graben (ganz links und ganz rechts): !Ausrufezeichen
• HOV-Spuren wechseln zwischen xund |alle 5 km
• Normal: |

Einschränkungen

Ihre Funktion oder Ihr Programm muss:

• In STDOUT drucken (entspricht System.out.printJava, console.logJavaScript usw.)
• Sie können 1 - 9 Spuren mit 0 - 10 Medianwerten drucken
• Sie können bis zu 50 km Straße drucken (50 Zeilen Ausgabe).
• Verwenden Sie keine Standardlücken
• Der nachgestellte Leerraum ist mit Ausnahme eines optionalen Leerraums \nam Ende der Ausgabe nicht zulässig

Größtmögliche Ausgabe: 3700 Bytes (74 Zeichen * 50 Zeilen).

Kleinstmögliche Ausgabe: 5 Bytes (mit Eingabe B, 1)

Annahmen

• Keine benachbarten Mediane (Teilzeichenfolge tritt MMnicht auf)
• Die zweite Markierungslinie wird möglicherweise abgeschnitten (z. B. bei einer Länge von 9 oder 12 km).
• Spuren sind möglicherweise nicht logisch sinnvoll (jede Reihenfolge ist möglich, z. B. eine Rechtskurve links von der Straße)

Das ist Code-Golf , also gewinnt der kürzeste Code (in Bytes)!

Ruby, 245

Drucken Sie gegebenenfalls die Fahrspurunterteilungen aus und drucken Sie dann die Fahrspur aus.

Ich erwarte nicht zu gewinnen.

->(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:?!}}

Änderungsprotokoll

245 drosseln stderr und teilen Arrays effektiv.

263 bessere Möglichkeit, Array zu indizieren

268 drucke einfach jede Zeile aus, berechne keine kanonische Version.

330 Initial Commit

JavaScript (ES6), 316 Byte

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,' '))}}

Demo

Es sollte zum Zeitpunkt des Schreibens in Firefox und Edge funktionieren. Für Chrome / Opera müssen experimentelle Funktionen aktiviert sein.

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 Bytes

ð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»

Ziemlich schlechter Ansatz, aber es funktioniert und hat Spaß gemacht. Kann aber definitiv noch mehr golfen werden.

+1 Byte als Bugfix für zwei benachbarte HHSpuren.

Probieren Sie es online aus.

Erläuterung:

Schritt 1: Erstellen Sie alle möglichen Bahnen mit Größe 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

Schritt 2: Konvertieren Sie die Eingabezeichenfolge in Indizes (mit denen wir die in Schritt 1 erstellte Liste indizieren):

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

Schritt 3: Wir verwenden diese Indizes, um die Liste der Spuren zu indizieren. Und dann konvertieren wir diese Liste der Spuren in die richtige Ausgabe, einschließlich deren Erweiterung / Verkürzung auf die Größe der Ganzzahleingabe:

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

Sehen Sie diese 05AB1E Spitze von mir (Abschnitte Wie Kompresse Strings nicht Teil des Wörterbuchs? Und Wie große natürliche Zahlen komprimieren? ) Zu verstehen , warum Ž5Eist 1289; .•o¤[‹‡•ist "tlrpbhmu"; ŽDýist 10201; •δ~¬]•ist 1119188999; Ž\nÿist 19889.