Tại Hoa Kỳ , hai hướng giao thông đối diện trên một con đường được phân cách bằng một đường màu vàng đứt đoạn nếu được phép đi qua và hai đường màu vàng nếu không được phép đi qua.

(Chỉ một bên có thể được gạch ngang để cho phép đi qua phía đó và các đường màu vàng có thể có nghĩa là những thứ khác như làn đường trung tâm hoặc đảo ngược, nhưng chúng tôi không quan tâm đến bất kỳ trường hợp nào trong số đó.)

Viết một chương trình mà mất trong một chạy dài mã hóa chuỗi Pcho đi và Ncho không đi qua , và sau đó in ra phiên bản ASCII của con đường tương ứng. Ngoại trừ đường trung tâm, đường luôn có cùng một mẫu, có thể dễ dàng suy ra từ các ví dụ dưới đây.

Sẽ có một số thập phân dương trước mỗi Pvà Ntrong chuỗi đầu vào. Con số này xác định độ dài của khu vực đi qua hoặc không có khu vực đi qua của phần hiện tại của con đường.

Ví dụ

Một đầu vào 12Nsẽ tạo ra 12 cột không có đường đi qua (đường trung tâm tất cả =):

____________


============

____________

Một đầu vào của 12Psẽ tạo ra 12 cột đường đi qua ( - lặp lại đường trung tâm ):

____________


- - - - - - 

____________

Vượt qua và không vượt qua sau đó có thể được kết hợp, ví dụ 4N4P9N7P1N1P2N2Psẽ tạo ra:

______________________________


====- - =========- - - -=-==- 

______________________________

Đây là 4 cột không đi qua , rồi 4 đường chuyền , rồi 9 đường chuyền , v.v.

Lưu ý rằng vùng đi qua luôn bắt đầu bằng dấu gạch ngang ( -) ở phía ngoài cùng bên trái, không phải khoảng trắng ( ). Điều này là bắt buộc.

Chi tiết

• Đầu vào sẽ không bao giờ có hai Nvùng hoặc hai Pvùng liên tiếp. ví dụ 4P5Psẽ không bao giờ xảy ra
• Bạn không cần phải hỗ trợ thư mà không có số dương. Đồng bằng Psẽ luôn luôn 1P, đồng bằng Nsẽ luôn luôn 1N.
• Có thể có những khoảng trống kéo dài miễn là chúng không vượt quá cột cuối cùng của con đường. Có thể có một dòng mới tùy chọn.
• Thay vì một chương trình, bạn có thể viết một hàm lấy chuỗi được mã hóa có độ dài chạy và in hoặc trả về đường ASCII.
• Đưa đầu vào theo bất kỳ cách tiêu chuẩn nào (stdin, dòng lệnh, hàm arg).

Mã ngắn nhất tính bằng byte thắng. Tiebreaker là bài trước.

CJam, 38 byte

"_  - _":N3'=t:P;q~]2/e~z'
*"--"/"- "*

Làm thế nào nó hoạt động

Đầu tiên chúng ta gán cột đường đúng để biến Nvà Pvà sau đó chỉ cần đánh giá chuỗi đầu vào. Điều này để lại một cặp chiều dài và cột trên ngăn xếp. Chúng tôi nhóm chúng lại, chạy RLD trên đó để lấy các cột đầy đủ, hoán đổi để tham gia với chúng và cuối cùng, chuyển đổi liên tục --thành -.

:_  - _":N                    e# This is the no passing column. We assign it to N
          3'=t:P              e# Replace the '-' in N with '=" and assign it to P
                q~]2/         e# Read the input, evaluate it and then group it in pairs
                     e~       e# Run a run-length-decoder on the pairs
                       z'
*                             e# Transpose and join with new lines.
 "--"/                        e# Split on two continuous occurrence of -
      "- "*                   e# Join by an alternate "- "

Dùng thử trực tuyến tại đây

JavaScript (ES6), 114

Sử dụng chuỗi mẫu , 5 nguồn cấp dữ liệu có ý nghĩa phải được tính.

f=s=>(b=(s=s.replace(/(\d+)(.)/g,(x,n,b)=>(b<'P'?'=':'- ').repeat(n).slice(0,n))).replace(/./g,'_'))+`


${s}

`+b

rs , ký tự 252

Mặc dù điều này có thể không được tính bởi vì tôi đã thêm toán tử hội tụ như một sự lột xác của Retina của Martin Büttner một giờ trước ... Dù sao tôi cũng không thực sự ở đây để cạnh tranh. Thật thú vị khi thực hiện một giải pháp dựa trên regex cho việc này.

(\d+\D)/#\1
+(\d*)#(?:(((((((((9)|8)|7)|6)|5)|4)|3)|2)|1)|0)(?=\d*\D)/\1\1\1\1\1\1\1\1\1\1\2\3\4\5\6\7\8\9\10#
\d(?=\d*#N)/=
(^|(?<=\D))\d(?=\d*#P)/-
+(?<=-)\d\d(?=\d*#P)/ -
(?<=-)\d(?=\d*#P)/ 
#\D/
((?:(=|-| ))+)/A\1\n\n\n\1\n\nA\1\n
+(A_*)(.)/\1_
A/

Tôi đã nhận được dòng 2 từ câu trả lời Retina của Martin cho Ngôn ngữ lập trình qua các năm .

Giải trình

(\d+\D)/#\1
+(\d*)#(?:(((((((((9)|8)|7)|6)|5)|4)|3)|2)|1)|0)(?=\d*\D)/\1\1\1\1\1\1\1\1\1\1\2\3\4\5\6\7\8\9\10#

Điều này không có nhiều phép thuật. Xem câu trả lời tôi liên kết ở trên để biết thêm.

Về cơ bản, với đầu vào 4N4P9N7P1N1P2N2P, đây sẽ là kết quả:

4444#N4444#P999999999#N7777777#P1#N1#P22#N22#P

Kế tiếp:

\d(?=\d*#N)/=

Điều này thay thế các số trước ký hiệu không đi qua (N) bằng các dấu bằng. Kết quả với đầu vào trước:

====#N4444#P=========#N7777777#P=#N1#P==#N22#P

Điều này:

(^|(?<=\D))\d(?=\d*#P)/-

thay thế số đầu tiên trước ký hiệu đi qua (P) bằng dấu gạch đầu tiên. Kết quả:

====#N-444#P=========#N-777777#P=#N-#P==#N-2#P

Hai dòng tiếp theo tiếp tục cùng một mẫu:

+(?<=-)\d\d(?=\d*#P)/ -
(?<=-)\d(?=\d*#P)/ 

Dòng đầu tiên thay thế phần còn lại của dòng bằng mẫu dấu gạch ngang. Cái thứ hai xử lý một số lẻ; nó thay thế dấu gạch ngang cuối cùng theo sau là một số nguyên duy nhất (chẳng hạn -5) bằng dấu gạch ngang dấu cách ( -). Bây giờ, đầu ra là:

====#N- - #P=========#N- - - -#P=#N-#P==#N- #P

Bây giờ mọi thứ đang bắt đầu rơi vào vị trí. Dòng tiếp theo:

#\D/

chỉ cần loại bỏ #Nvà #P.

((?:(=|-| ))+)/A\1\n\n\n\1\n\nA\1\n
+(A_*)(.)/\1_

thiết lập các dấu gạch dưới ở trên và dưới để cung cấp:

A______________________________


====- - =========- - - -=-==- 

A______________________________

Cuối cùng, chúng tôi xóa A:

A/

Haskell, 165 byte

k 'N'="="
k _="- "
d c=c>'/'&&c<':'
p[]=[]
p s=take(read$takeWhile d s)(cycle$k a)++p r where(a:r)=dropWhile d s
f s=unlines[q,"\n",p s,"",q]where q=map(\x->'_')$p s

Chạy ví dụ ( ftrả về một chuỗi, vì vậy để hiển thị tốt hơn in nó):

*Main> putStr $ f "4N4P9N7P1N1P2N2P"
______________________________


====- - =========- - - -=-==- 

______________________________

Cách thức hoạt động: ptrả về đường giữa bằng cách phân tích cú pháp chuỗi đầu vào và nối chuỗi số ký hiệu đã cho được tìm thấy bởi hàm tra cứu k. Hàm chính ftham gia một danh sách năm phần tử với các dòng mới, bao gồm dòng trên cùng (mỗi char của dòng giữa được thay thế bởi _), một dòng mới, dòng giữa, một dòng trống và dòng dưới cùng (giống như trên cùng).

Python 3, 169 168 byte. (167 với Python 2)

p,s='',str.split
for _ in s('N '.join(s('P '.join(s(input(),'P')),'N'))):
 v=int(_[:-1]);p+=['='*v,('- '*v)[:v]][_[-1]=='P']
l=len(p)
u='_'*l
print(u+'\n'*3+p+'\n\n'+u)

Khá vô dụng:

p=''
for i in'N '.join('P '.join(input().split('P')).split('N')).split():

  v=int(i[:-1])         # Get the number from the input section

  if i[-1]=='N':        # Check the letter (last char) from the input section
      p+=('='*v)        # Repeat `=` the number from input (v)
  else:
      p+=('- '*v)[:v]   #Repeat `- ` v times, then take first v chars (half)
l=len(p)                #Get the length of the final line markings
print('_'*l+'\n\n\n'+p+'\n\n'+'_'*l)

print('_'*l                          # Print _ repeated the length of p
           +'\n\n\n'                 # 3 new lines
                    +p+              # print out p (the markings)
                       '\n\n'        # 2 new lines
                             +'_'*l) # Print _ repeated the length of p

for i in
        'N '.join(
                  'P '.join(
                            input().split('P'))
                                               .split('N'))
                                                           .split():
                            # Split the input into items of list at P
                  # Join together with P and ' '
                                                # Split at N...
         # Join with N and ' '
                                                           # Split at space
# Loop through produced list

Hãy thử trực tuyến tại đây .

Python 2, 136 byte

Đáng ngạc nhiên, nhập khẩu redường như thực sự có giá trị ở đây.

import re
s=""
for x,y in re.findall("(\d+)(.)",input()):s+=(("- ","==")[y=="N"]*int(x))[:int(x)]
t="_"*len(s);print t+"\n"*3+s+"\n"*2+t

PHP, 187 byte

preg_match_all('/(\d+)(\w)/',$argv[1],$m,2);
$o='';
foreach($m as $p)
    $o.=str_replace('--','- ',str_repeat($p[2]<'P'?'=':'-',$p[1]));
$a=preg_replace('/./','_',$o);
echo("$a\n\n\n$o\n\n$a\n");

Mã có thể nằm trên một dòng duy nhất; nó được hiển thị ở đây trên nhiều dòng để dễ đọc hơn (khoảng trắng và dòng mới được sử dụng để định dạng không được tính).

Hai byte có thể được lưu bằng cách không in dòng mới. Có thể lưu thêm năm byte bằng cách sử dụng các ký tự dòng mới thực sự trênecho() :

echo("$a


$o

$a");

Sáu byte bổ sung có thể được lưu bằng cách bỏ qua việc khởi tạo $o ( $o='';) nhưng điều này sẽ kích hoạt một thông báo. Thông báo có thể được loại bỏ bằng cách chạy tập lệnh bằng dòng lệnh:

$ php -d error_reporting=0 <script_name> 4N4P9N7P1N1P2N2P

Chúng mang đến 174 byte.

Hồng ngọc 137 135 byte

Không phải là ngắn nhất tôi có thể đến, nhưng gần với tốt nhất. Một phần mượn từ câu trả lời của Trình tối ưu hóa.

require'scanf'
N='_  = _'
P='_  - _'
a=[]
scanf('%d%c'){|l,t|a+=[eval(t).chars]*l}
puts (a.shift.zip(*a).map(&:join)*?\n).gsub'--','- '

Ung dung:

require 'scanf'

N = '_  = _'
P = '_  - _'
columns = [] # array of columns
# scan stdin for a number followed by a single char
scanf('%d%c') do |length, type|
  columns += [eval(type).chars] * length
done

# Convert to an array of rows, and join into a string
rows = columns.shift.zip(*columns).map(&:join)
str = rows * "\n" # join lines

# Replace '--' by '- ' and print
puts str.gsub(/--/, '- ')

C, 155 byte

main(l,v,k,n,x,s,c)char*s,**v,c;{for(l=6;l--;puts(s))for(s=v[1];*s;s+=k)for(x=sscanf(s,"%d%c%n",&n,&c,&k);n--;)putchar(l%5?l^2?32:c^78?++x&1?45:32:61:95);}

Dễ đọc hơn:

main(l,v,k,n,x,s,c)
    char*s,**v,c;
{
    for(l=6;l--;puts(s))
        for(s=v[1];*s;s+=k)
            for(x=sscanf(s,"%d%c%n",&n,&c,&k);n--;)
                putchar(l%5?l^2?32:c^78?++x&1?45:32:61:95);
}

Vòng lặp bên ngoài đếm các dòng từ 5 đến 0.

Vòng lặp giữa lặp lại trên các phần của chuỗi được mã hóa:

4N4P9N7P1N1P2N2P
4P9N7P1N1P2N2P
9N7P1N1P2N2P
7P1N1P2N2P
1N1P2N2P
1P2N2P
2N2P
2P
string is empty - exit

Vòng lặp bên trong giải mã một phần, như, 7P , và lặp lại số lần cần thiết (ví dụ 7).

Mỗi lần lặp in một char. Giá trị của charđược mô tả bởi mã l%5?l^2?32:c^78?++x&1?45:32:61:95:

• Nếu số dòng là 5 hoặc 0, in 95 ( _)
• Mặt khác, nếu số dòng không bằng 2, hãy in một khoảng trắng
• Mặt khác, nếu ký hiệu là 'N', hãy in 61 ( =)
• Mặt khác, tăng x1 (nó được khởi tạo thành 2 by sscanf)
• Nếu lẻ, in 45 ( -), khác in 32 (dấu cách)

Scala, 163 byte

(s:String)=>{val r=(("\\d+(P|N)"r) findAllIn(s) map(r=>{val l=r.init.toInt;if(r.last=='N')"="*l else ("- "*l).take(l)})).mkString;val k="_"*r.length;s"$k\n\n\n$r\n\n$k"}

Lần thử đầu tiên, có thể được đánh gôn thêm.

Ruby, 94 byte

Mượn gsub'--','- 'ý tưởng từ câu trả lời của 14mRh4X0r . Tôi nghĩ rằng câu trả lời là thú vị hơn, mặc dù điều này ngắn hơn.

f=->x{n=?_*x.gsub!(/(\d+)(.)/){($2==?P??-:?=)*$1.to_i}.size
"#{n}


#{x.gsub'--','- '}

#{n}"}

Kiểm tra:

f=->x{n=?_*x.gsub!(/(\d+)(.)/){($2==?P??-:?=)*$1.to_i}.size
"#{n}


#{x.gsub'--','- '}

#{n}"}

puts f['4N4P9N7P1N1P2N2P']

Sản xuất:

______________________________


====- - =========- - - -=-==- 

______________________________

hãy để tôi đưa vào phiên bản MATLAB của tôi

MATLAB (267 b)

function d=p(V,a),j=numel(V)-1;if (a==0),d=0;return; end,d=(V(a)-48+10*p(V,a-1))*(V(a)<64);fprintf('%c%.*s%c%.*s',(a>=j)*10,(a==j|a==1)*eval(strcat(regexprep(V,'[NP]','+'),48)),ones(99)*'_',(a<3)*10,(V(a+1)>64)*d,repmat((V(a+1)==78)*'=='+(V(a+1)==80)*'- ',[1 99]));end

đầu vào

Một chuỗi được định dạng ascii được nối bởi một khoảng trắng (vì không có kết thúc chuỗi '\ 0' trong matlab

ví dụ V = '12N13P'

đầu ra

mô hình đại diện của con đường

_________________________


============- - - - - - -

_________________________

chức năng

hàm phải được gọi từ đuôi-1 (ký tự trống bị loại bỏ)

ví dụ : p (V, chữ số (V) -1)

Mô phỏng

thử trực tuyến tại đây

R, 132 byte

Không hài lòng lắm với điều này, nhưng nó có một chút thú vị để làm :) Đã cố gắng để thoát khỏi nhiều gsubs, nhưng những nỗ lực của tôi là vô ích. Tôi nghi ngờ có một cách tốt hơn để làm điều này.

cat(rbind(nchar(a<-scan(,'',t=gsub('PN','P N',gsub('NP','N P',chartr('- =','PPN',scan(,'',sep='|')[4]))))),substring(a,1,1)),sep='')

• scanlấy các chuỗi từ STDIN và lấy chuỗi thứ 4. Lưu ý rằng các dòng trống yêu cầu một khoảng trắng (hoặc một cái gì đó) trong chúng để quét để tiếp tục nhận đầu vào.

  "==== - - ========= - - - - = - == -"

• Nó thay thế =s với Ns, -và vớiP s.

  "NNNNPPPPNNNNNNNNNPPPPPPPNPNNPP"

• Sau đó, nó chèn một khoảng trắng giữa mỗi NPvàPN

  "NNNN PPPP NNNNNNNNN PPPPPPP NP NN PP"

• Quá trình quét phân tách chuỗi trên khoảng trắng

  "NNNN" "PPPP" "NNNNNNNNN" "PPPPPPP" "N" "P" "NN" "PP"

• Độ dài chuỗi sau đó được ràng buộc ( rbind) với ký tự đầu tiên của mỗi chuỗi

  4 4 9 7 1 1 2 2
  "N" "P" "N" "P" "N" "P" "N" "P"

• Các mảng sau đó là đầu ra bằng cách sử dụng cat.

Chạy thử nghiệm

cat(rbind(nchar(a<-scan(,'',t=gsub('PN','P N',gsub('NP','N P',chartr('- =','PPN',scan(,'',sep='|')[4]))))),substring(a,1,1)),sep='')
1: ____________
2:  
3:  
4: ============
5:  
6: ____________
7: 
Read 6 items
Read 1 item
12N
> 
> cat(rbind(nchar(a<-scan(,'',t=gsub('PN','P N',gsub('NP','N P',chartr('- =','PPN',scan(,'',sep='|')[4]))))),substring(a,1,1)),sep='')
1: ____________
2:  
3:  
4: - - - - - - 
5:  
6: ____________
7: 
Read 6 items
Read 1 item
12P
> cat(rbind(nchar(a<-scan(,'',t=gsub('PN','P N',gsub('NP','N P',chartr('- =','PPN',scan(,'',sep='|')[4]))))),substring(a,1,1)),sep='')
1: ______________________________
2:  
3:  
4: ====- - =========- - - -=-==- 
5:  
6: ______________________________
7: 
Read 6 items
Read 8 items
4N4P9N7P1N1P2N2P