Giới thiệu

Các đang Parsons chỉ là một cách đơn giản để mô tả sự thay đổi sân trong một tác phẩm âm nhạc, cho dù một lưu ý là cao hơn hoặc thấp hơn so với trước đó.

Ngay cả khi bạn không nhớ các giai điệu, bạn vẫn có thể nhớ khá nhiều nếu một nốt nhạc tăng hoặc giảm, do đó mã Parsons có thể giúp bạn xác định nhạc bằng công cụ tìm kiếm.

Sự miêu tả

Mỗi biến thể được đại diện bởi một ký tự duy nhất, đó là một trong những điều sau đây:

• Rnếu ghi chú giống với ghi chú trước (viết tắt của " R epeat" )
• Unếu ghi chú cao hơn ghi chú trước (viết tắt của " U p" )
• Dnếu ghi chú thấp hơn ghi chú trước (viết tắt của " D own" )

Các ghi chú ban đầu được viết là *.

Thí dụ

Dưới đây là một ví dụ về mã Parsons (bắt đầu của "Ode to Joy" ):

*RUURDDDDRUURDR

Bạn thực sự có thể hình dung nó, như thế này:

      *-*                    
     /   \                   
    *     *                  
   /       \                 
*-*         *         *-*    
             \       /   \   
              *     *     *-*
               \   /         
                *-*          

Chúng tôi sẽ gọi đó là một đường viền từ bây giờ.

Các quy tắc để vẽ các đếm như vậy được coi là tự giải thích bằng ví dụ trên.

Thử thách

Bây giờ đến thử thách thực sự.

Viết chương trình, đưa ra một đường viền làm đầu vào, xuất mã Parsons tương ứng của nó.

Bạn không được yêu cầu vẽ đường viền, nhưng thực tế thì ngược lại.
Từ đường viền, tìm mã Parsons gốc.

Quy tắc

• Các quy tắc thông thường để chơi golf mã được áp dụng
• Chương trình ngắn nhất về số byte thắng
• Đầu vào là một đường viền và đầu ra phải là mã Parsons hợp lệ
• Chi tiết về khoảng trắng thêm cho đầu vào là không liên quan, hãy làm bất cứ điều gì tốt nhất cho bạn
• Bạn không được phép mã hóa cứng, bằng cách này hay cách khác, các phần của đầu ra và / hoặc chương trình sử dụng khoảng trắng thừa do quy tắc trước đó

Ghi chú

• Điều này có thể hữu ích để thử nghiệm
• Mã Parsons tương ứng cho *là*
• Một chuỗi rỗng không phải là một đường viền hợp lệ
• Mã Parsons luôn bắt đầu bằng*

Pyth - 28 25 27 25 byte

2 tạm biệt nhờ @Jakube.

s+\*@L"RDU"-VFtBxR\*%2C.z

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

CJam, 21 byte

qN/:.e>(o2%:i"DRXU"f=

Gấp các dòng ( :) bằng cách vector hóa (. ) một thao tác tối đa theo ký tự e>. Vì chỉ có một ký tự không phải khoảng trắng trong mỗi cột, nên cột này sẽ là kết quả, vì không gian có mã ASCII nhỏ hơn tất cả các ký tự không phải không gian có thể in.

Bỏ di chuyển và in dấu hoa thị đầu tiên (o, sau đó ánh xạ mọi 2%char ( ) còn lại sang UDRsử dụng lập chỉ mục mô-đun.

Giải pháp cũ (29 byte)

'*qN/z2%'*f#0+2ew);::-"RDU"f=

qN/được dòng đầu vào. zchuyển đổi ma trận ký tự này. 2%giảm từng hàng lẻ. '*f#tìm thấy chỉ số của dấu hoa thị trong mỗi hàng. 0+2ew);được tất cả các cặp chỉ số liên tiếp. ::-tính khác biệt của họ, và "RDU"f=bản đồ chúng để thư (thông qua chỉ mục mô-đun: 0 → R, 2 → U, -2 ≡ 1 → D). Các hàng đầu '*chuẩn bị dấu hoa thị.

EDIT : Tôi đã thay đổi 2ewđể 0+2ew);làm việc xung quanh CJam không xử lýew (các lát cắt liên tiếp) trong các danh sách quá ngắn. Điều này làm cho mã làm việc cho chuỗi đầu vào *.

Hãy thử nó ở đây , hoặc xem nó trong hành động:

Python 3, 129 108 98 86 byte

Có lẽ có một số cách để chơi golf này, nhưng tôi thích rằng tôi đã hạ nó xuống một dòng.

Chỉnh sửa: Hiện đang sử dụng''.translate()

Chỉnh sửa: Rất cám ơn wnnmaw .

Chỉnh sửa: Tôi đã thay đổi định dạng đầu vào thành một chuỗi các chuỗi thay vì một chuỗi được phân tách bằng dòng mới để lưu byte. Ngoài ra, trong lần chỉnh sửa cuối cùng, tôi đã trộn lẫn Uvà Rvì vậy tôi đã sửa nó.

lambda a:'*'+"".join(('UR'[j<'/']+'D')[j>'/']for l in zip(*a)for j in l if j in'-/\\')

Đầu vào phải là một chuỗi các chuỗi. Đối với ví dụ trên, cái này trông giống như:

["      *-*                    ","     /   \                   ","    *     *                  ","   /       \                 ","*-*         *         *-*    ","             \       /   \   ","              *     *     *-*","               \   /         ","                *-*          "]

Ung dung:

def f(a):
    s = ''
    for c in zip(*a):           # transpose
        for d in c:             # for each letter in column c
            if e in "-/\\":     # if that letter is either -,/,\
                if e < '/':     # if < '/' (same as if == '-')
                    s += "R"
                elif e > '/':   # if > '/' (same as if == '\')
                    s += "D"
                else:           # if == '/'
                    s += "U"
        return "*" + s          # in the code we ''.join() it all together
                                # in this ungolfing, we add to an empty string

Ruby, 87 byte

Yêu cầu dấu cách trong đầu vào sao cho tất cả các dòng có cùng độ dài.

$><<?*+$<.readlines.map(&:chars).transpose.join.gsub(/./,{?-=>:R,?/=>:U,?\\=>:D}).strip

Japt, 38 byte 40 41 45 46 48

Đã lưu 2 byte nhờ @ETHproductions

'*+U·y £Yu ?"RUD"g1+(XrS c -47 g):P} q

Nếu có lệnh trim, nó sẽ chỉ có 38 byte; -; sẽ thêm lời giải thích khi tôi chơi golf xong. Đây :Pkhông phải là chương trình cố tỏ ra buồn cười, thực ra đây là chương trình bỏ qua các nhân vật không quan trọng.

Dùng thử trực tuyến

Haskell, 89 byte

import Data.List
m '/'="U"
m '-'="R"
m '\\'="D"
m _=""
('*':).(>>=(>>=m)).transpose.lines

Ví dụ sử dụng:

*Main> ('*':).(>>=(>>=m)).transpose.lines $ "      *-*                    \n     /   \\                   \n    *     *                  \n   /       \\                 \n*-*         *         *-*    \n             \\       /   \\   \n              *     *     *-*\n               \\   /         \n                *-*          "
"*RUURDDDDRUURDR"

*Main> ('*':).(>>=(>>=m)).transpose.lines $ "*"
"*"

Chuyển đổi đầu vào và thay thế các ký tự // -/ \bằng các chuỗi đơn "U"/ "R"/ "D". Tất cả các ký tự khác được thay thế bằng các chuỗi trống "", sau đó biến mất bằng cách nối tất cả mọi thứ. Cuối cùng, chuẩn bị dấu hoa thị *.

Toán học, 103 byte

"*"<>(Differences@Position[Thread@Characters@StringSplit[#,"
"],"*"][[;;,2]]/.{-2->"U",0->"R",2->"D"})&

Khá ngắn gọn, coi đây là một thách thức xử lý chuỗi.

JavaScript (ES6) 90

Một chức năng ẩn danh. Nó quét chuỗi đầu vào char bằng char, đưa vào vị trí trong dòng hiện tại. Làm điều này, nó xây dựng một mảng đầu ra U D Rcho thuê / \ -ở đúng nơi

c=>[...c].map(c=>c>'*'?t[i++]=c>'/'?'D':c<'/'?'R':'U':c<' '?i=0:++i,t=['*'],i=0)&&t.join``

Matlab, 62 byte

r=@(s)[85-(s<14)*3-(s>59)*17,''];@(p)r(sum(p(:,2:2:end)-32))

Điều này đòi hỏi đầu vào phải là một hình chữ nhật (cùng số lượng ký tự trong mỗi hàng). Ví dụ

    ['      *-*                    ';    '     /   \                   ';    '    *     *                  ';    '   /       \                 ';    '*-*         *         *-*    ';    '             \       /   \   ';    '              *     *     *-*';    '               \   /         ';    '                *-*          '];

Giải trình

sum(p(:,2:2:end)-32)        % exctract every second column, substract 32 (spaces->zeros) 
                            % and sum column wise (results in a vector of 3 different values)
[85-(s<14)*3-(s>59)*17,'']  % map each of the values to the corresponding value of the letter and convert back to characters