Tam giác là một esolang mới được phát triển bởi ông Xcoder trong đó cấu trúc mã phải tuân theo một mẫu rất cụ thể:

• Đối với ndòng mã thứ, phải có chính xác các 2n-1ký tự của chương trình trên đó. Điều này gây ra hình dạng tam giác / hình chóp, với dòng đầu tiên chỉ có một ký tự và phần còn lại tăng theo gia số 2.
• Mỗi dòng phải được đệm bằng .s ở bên trái và bên phải, sao cho các ký tự được căn giữa trên các dòng của chúng và tất cả các dòng được đệm cùng một chiều dài. Nếul được định nghĩa là số lượng dòng trong chương trình, mỗi dòng trong chương trình phải có độ dài là2 * l - 1

Ví dụ: chương trình bên trái là hợp lệ, nhưng chương trình bên phải không phải là:

 Valid    |  Invalid  
          |
...A...   |  ABCDE
..BCD..   |  FGH
.EFGHI.   |  IJKLMN
JKLMNOP   |  OPQRS

Khi được đặt trong cấu trúc hợp lệ, tên trở nên rõ ràng.

Bài tập

Nhiệm vụ của bạn là lấy một chuỗi dòng đơn làm đầu vào, đại diện cho mã Tam giác và đầu ra nó được chuyển đổi thành mã hợp lệ như được mô tả ở trên.

Thông số kỹ thuật cho I / O:

• Đầu vào sẽ chỉ chứa các ký tự trong phạm vi 0x20 - 0x7e
• Độ dài của đầu vào luôn sẽ là một số vuông và do đó có thể chuyển được độc đáo.
• Bạn phải sử dụng dấu chấm cho phần đệm đầu ra, không phải cái gì khác.

Bạn có thể nhập và xuất thông qua bất kỳ phương pháp chấp nhận được . Đây là một golf-code nên mã ngắn nhất tính bằng byte sẽ thắng!

Các trường hợp thử nghiệm

input
----
output

g
----
g

PcSa
----
.P.
cSa

DfJ0vCq7G
----
..D..
.fJ0.
vCq7G

7xsB8a1Oqw5fhHX0
----
...7...
..xsB..
.8a1Oq.
w5fhHX0

QNYATbkX2sKZ6IuOmofwhgaef
----
....Q....
...NYA...
..TbkX2..
.sKZ6IuO.
mofwhgaef

ABCDEF"$%& G8"F@
----
...A...
..BCD..
.EF"$%.
& G8"F@

ab.c
----
.a.
b.c

_{Đối với những người biết về Tam giác, bạn sẽ nhận thấy từ trường hợp kiểm tra cuối cùng rằng các chuỗi không phải xử lý}

Hình tam giác , 127 byte

.......).......
......2)1......
...../)IL^.....
....f)rMD@_....
...)2)1/)IL^...
..f+`"'.'*"+E..
.DWReD)2s^)Its.
D+@sh+s+})10cJ.

Hãy thử trực tuyến!

Giải trình

Loại bỏ các ký tự tạo nên phần đệm, chúng tôi nhận được chương trình sau:

)2)1/)IL^f)rMD@_)2)1/)IL^f+`"'.'*"+EDWReD)2s^)ItsD+@sh+s+})10cJ

... Cái nào khá dài, phải không? Hãy chia nó thành từng mảnh.

Tạo số nguyên [0 trì len (đầu vào))

)2)1/)IL^f)r – Subprogram #1.
)            – Creates a new stack entry, equal to 0. This must precede any integer
               literal, because each character in '0123456789' isn't parsed on its
               own as a literal, but rather they are commands which multiply the ToS
               by 10 and add the value of their digit equivalent. 
 2           – ToS * 10 + 2 = 2.           || STACK: [2]
  )1         – The literal 1.              || STACK: [2, 1]
    /        – Division.                   || STACK: [1 / 2] = [0.5]
     )I      – Get the input at index 0.   || STACK: [0.5, input]
       L     – Length.                     || STACK: [0.5, len(input)]
        ^    – Exponentiation.             || STACK: [len(input) ** 0.5]
         f   – Trim decimals.              || STACK: [int(len(input) ** 0.5)] 
          )r – Create the list [0 .. ToS). || STACK: [[0 ... int(len(input) ** 0.5))]

Tạo các dấu chấm

MD@_)2)1/)IL^f+`"'.'*"+E – Subprogram #2.
MD                       – For each integer in the range, run some code on a separate
                           stack, preinitialised to two copies of the argument.
  @_                     – Increment and negate the ToS.
    )2)1/)IL^f           – The square root of the length of the input, again.
              +          – Add the two.
               `         – And cast the integer given to a string.
                "'.'*"+  – Prepends the literal "'.'*" to the string representation.
                       E – Evaluate as a Python expression (basically string repetition).

Cắt tỉa các nhân vật ở phía trước

DWReD)2s^)It – Subprogram #3.
D            – Duplicate the result of the expression above.
 W           – Wrap the whole intermediate stack to an array.
  Re         – Reverse the stack and dump the contents separately onto the stack.
    D        – Duplicate the result.
     )2      – Push the literal 2.
       s^    – Swap and perform exponentiation.
         )It – Push the input and trim the characters before that index.

Cắt tỉa các nhân vật ở cuối

sD+@sh+s+ – Subprogram #4.
s         – Swap the top two elements on the stack.
 D+       – Double. Push twice and add.
   @      – Increment.
    sh    – Swap the top two elements and trim the characters after that index.
      +   – Append the first set of dots.
       s+ – And prepend the second set of dots.

Kết thúc vòng lặp và in ấn đẹp

})10cJ – Subprogram #5.
}      – End the loop.
 )10   – Push the literal 10.
    c  – Convert from code-point to character (yields '\n').
     J – And join the result by newlines.

Japt , 15 14 10 byte

Xuất ra một loạt các dòng.

ò@°T¬v1Ãû.

Hãy thử nó | Kiểm tra tất cả các trường hợp kiểm tra

Giải thích

ò@     Ã       :Partition at characters where the following function returns true
  °T           :  Increment T (initially 0)
    ¬          :  Square root
     v1        :  Divisible by 1?
               :(Or, in other words, split after every character with a 1-based index that's a perfect square)
        û.     :Centre pad each element with .s to the length of the longest element

Giải pháp gốc

ʬÆsTT±X+°XÃû.

Thử nó

Ê                  :Length of input
 ¬                 :Square root
  Æ        à       :Range [0,ʬ) and pass each X through a function
   s               :  Slice input
    T              :    from index T, initially 0
     T±X+°X        :    to index T incremented by X plus X incremented
            û.     :Centre pad each element with .s to the length of the longest element

Husk , 15 byte

Ṡzö`JR2tR'.ṡCİ1

Hãy thử trực tuyến!

Giải trình

Ṡzö`JR2tR'.ṡCİ1  Implicit input, say s = "DfJ0vCq7G".
             İ1  List of odd positive integers: [1,3,5,7,..
            C    Cut s to those lengths: x = ["D","fJ0","vCq7G"]
           ṡ     Reversed indices of x: y = [3,2,1]
Ṡz               Zip x and y using this function:
                  Arguments are a string and a number, e.g. r = "fJ0" and n = 2.
        R'.       n copies of '.': ".."
       t          Drop first element: "."
     R2           Two copies of this: [".","."]
  ö`J             Join by r: ".fJ0."
                 Result is ["..D..",".fJ0.","vCq7G"]; implicitly print on separate lines.

05AB1E , 20 19 18 byte

Đã lưu một byte nhờ Magic Octopus Urn

ā·<£õKRvy'.N×.ø}r»

Hãy thử trực tuyến!

Giải trình

ā                    # push the list [1 ... len(input)]
 ·<                  # multiply each by 2 and decrement each, making a list of odd numbers
   £                 # split the input into chunks of these sizes
    õK               # remove empty strings
      R              # reverse list
       vy      }     # for each y in the list
             .ø      # surround it with
         '.N×        # "." (dot) repeated N times, where N is the current iteration index
                r    # reverse the stack
                 »   # join stack by newlines

Python 2 , 83 byte

i=input();u=int(len(i)**.5)
for t in range(u):g="."*(u+~t);print g+i[t*t:][:t-~t]+g

Hãy thử trực tuyến!

Thạch ,  22  19 byte

J²‘Ṭœṗ⁸Ṛz”.Zµṙ"JC$Ṛ

Một liên kết đơn âm trả về một danh sách các danh sách các ký tự (các dòng)

Hãy thử trực tuyến!

Làm sao?

J²‘Ṭœṗ⁸Ṛz”.Zµṙ"JC$Ṛ - Link: list of characters e.g. "DfJ0vCq7G"
J                   - range of length               [1,2,3,4,5,6,7,8,9]
 ²                  - square (vectorises)           [1,4,9,16,25,36,49,64,81]
  ‘                 - increment                     [2,5,10,17,26,37,50,65,82]
   Ṭ                - untruth (1s at those indices) [0,1,0,0,1,0,0,0,0,1,0,0,0,0,0,0,1,...]
      ⁸             - chain's left argument         "DfJ0vCq7G"
    œṗ              - partition at indexes          ["D","fJ0","vCq7G"]
       Ṛ            - reverse                       ["vCq7G","fJ0","D"]
         ”.         - literal '.'                   '.'
        z           - transpose with filler         ["vfD","CJ.","q0.","7..","G.."]
           Z        - transpose                     ["vCq7G","fJ0..","D...."]
            µ       - start a new monadic chain
                 $  - last two links as a monad:
               J    -   range of length             [1,2,3]
                C   -   complement (vectorises)     [0,-1,-2]
              "     - zip with:
             ṙ      -   rotate left by              ["vCq7G",".fJ0.","..D.."]
                  Ṛ - reverse                       ["..D..",".fJ0.","vCq7G"]

JavaScript (ES7), 82 78 byte

f=(s,k=1-s.length**.5*2,p='')=>s&&f(s.slice(0,k),k+2,p+'.')+`
`+p+s.slice(k)+p

Các trường hợp thử nghiệm

f=(s,k=1-s.length**.5*2,p='')=>s&&f(s.slice(0,k),k+2,p+'.')+`
`+p+s.slice(k)+p

console.log(f('g'))
console.log(f('PcSa'))
console.log(f('DfJ0vCq7G'))
console.log(f('7xsB8a1Oqw5fhHX0'))
console.log(f('QNYATbkX2sKZ6IuOmofwhgaef'))
console.log(f('ABCDEF"$%& G8"F@'))

Đã bình luận

f = (                       // f = recursive function taking:
  s,                        //   s = input string
  k = 1 - s.length**.5 * 2, //   k = additive inverse of the length of the base
  p = ''                    //   p = padding string
) =>                        //
  s &&                      // if s is not empty:
    f(                      //   do a recursive call with:
      s.slice(0, k),        //     s without the last -k characters
      k + 2,                //     the updated base length (2 less characters)
      p + '.'               //     the updated padding string
    ) +                     //   end of recursive call()
    `\n` +                  //   append a line feed
    p +                     //   append the left padding string
    s.slice(k) +            //   append the last -k characters of s
    p                       //   append the right padding string

05AB1E , 25 byte

gÅÉ£õKð'ø‡.c¶¡ζøð'.‡'øð‡»

Hãy thử trực tuyến!

MATL , 21 byte

tnX^eRP&1ZvGyg(46y~(!

Hãy thử trực tuyến!

Giải trình

Hãy xem xét đầu vào 'DfJ0vCq7G'là một ví dụ. Nội dung ngăn xếp được hiển thị cách nhau bằng dấu phẩy, với phần tử trên cùng cuối cùng. Các hàng trong một mảng 2D sử dụng dấu chấm phẩy làm dấu phân cách.

t      % Implicit input: string. Duplicate
       % STACK: 'DfJ0vCq7G',
                'DfJ0vCq7G'
nX^    % Number of elements. Square root
       % STACK: 'DfJ0vCq7G',
                3
e      % Reshape with that many rows (in column major order)
       % STACK: ['D0q';
                 'fv7';
                 'JCG']
R      % Upper triangular part: set elements below diagonal to char(0)
       % (displayed as space)
       % STACK: ['D0q';
                 ' v7';
                 '  G']
P      % Flip vertically
       % STACK: ['  G';
                 ' v7';
                 'D0q']
&1Zv   % Reflect vertically
       % STACK: ['  G';
                 ' v7';
                 'D0q';
                 ' v7';
                 '  G']
G      % Push input again
       % STACK: ['  G';
                 ' v7';
                 'D0q';
                 ' v7';
                 '  G'],
                'DfJ0vCq7G'
yg     % Duplicate from below and convert to logical. This gives true for
       % for nonzero chars (the entries where input chars will be written)
       % STACK: ['  G';
                 ' v7';
                 'D0q';
                 ' v7';
                 '  G'],
                'DfJ0vCq7G',
                [0 0 1;
                 0 1 1;
                 1 1 1;
                 0 1 1;
                 0 0 1]
(      % Assignment indexing: write values at those positions
       % STACK: ['  v';
                 ' fC';
                 'DJq';
                 ' 07';
                 '  G']
46     % Push 46, which is ASCII for '.'
       % STACK: ['  v';
                 ' fC';
                 'DJq';
                 ' 07';
                 '  G'],
                 46
y~     % Duplicate from below and apply logical negate. This gives true
       % for char(0) (the entries where '.' will be written)
       % STACK: ['  G';
                 ' v7';
                 'D0q';
                 ' v7';
                 '  G'],
                46
                [1 1 0;
                 1 0 0;
                 0 0 0;
                 1 0 0;
                 1 1 0]
(      % Assignment indexing: write value at those positions
       % STACK: ['..G';
                 '.v7';
                 'D0q';
                 '.v7';
                 '..G'],
!      % Transpose. Implicit display
       % STACK: ['..D..';
                 '.fJ0.';
                 'vCq7G']

Sạch , 107 94 89 88 byte

import StdEnv
@s _[]=s
@s n r= @([['.':l]++['.']\\l<-s]++[take n r])(n+2)(drop n r)

@[]1

Hãy thử trực tuyến! Ví dụ sử dụng : @[]1 ['ABCDEF"$%& G8"F@'].

Haskell , 84 68 byte

[]%1
(s%n)[]=s
(s%n)r=(['.':l++"."|l<-s]++[take n r])%(n+2)$drop n r

Hãy thử trực tuyến!

Ví dụ sử dụng: []%1 $ "abcd"mang lại danh sách các dòng [".a.","bcd"].

Perl, 56 52 byte

Bao gồm +3cho-p

#!/usr/bin/perl -p
$_=("."x y///c**.5)=~s%.%$'@{[$&x/$`$`./g]}$'
%rg

Cung cấp đầu vào trên STDIN (về nguyên tắc không có dòng mới, nhưng điều đó chỉ quan trọng đối với đầu vào trống)

Màu đỏ , 227 203 byte

f: func[s][l: to-integer(length? s)** 0.5
n: 0 foreach m parse s[collect[(r: []repeat i l[append r reduce['keep i * 2 - 1
charset[not{Я}]]])r]][v: copy""insert/dup v"."l - n: n + 1 print rejoin[v m v]]]

Hãy thử trực tuyến!

Ung dung:

f: func[s][
l: to-integer (length? s) ** 0.5
n: 0
foreach m parse s [ 
    collect [
        (r: []
        repeat i l [ append r reduce [
            'keep i * 2 - 1 charset [ not{Я} ]]])
    r ]] 
    [v: copy ""
    insert/dup v "." l - n: n + 1
    print rejoin [v m v]]
]

Võng mạc , 88 72 71 byte

S1`
+m`^(.)+¶(?>(?<-1>.)+)..(?!¶)
$&¶
P^'.m`^.(?=(..)*)(?<-1>.)*
P'.`.+

Hãy thử trực tuyến! Chỉnh sửa: Đã lưu 12 13 byte nhờ @MartinEnder. Giải trình:

S1`

Tách nhân vật đầu tiên thành dòng riêng của nó để có được quả bóng lăn.

+m`^(.)+¶(?>(?<-1>.)+)..(?!¶)
$&¶

Cắt mỗi dòng hai ký tự dài hơn ký tự trước.

P^'.m`^.(?=(..)*)(?<-1>.)*

Đệm trái nửa đầu của mỗi dòng, tập trung chúng một cách hiệu quả.

P'.`.+

Phải pad tất cả các dòng.

Than , 21 19 byte

ＵＢ.Ｆ₂Ｌθ«Ｐ✂θＸι²Ｘ⊕ι²↙

Hãy thử trực tuyến! Liên kết là phiên bản dài dòng của mã. Chỉnh sửa: Đã lưu 2 byte bằng cách khám phá SquareRoot. Giải trình:

ＵＢ.                 Set the background fill to `.`
      θ             (First) input
     Ｌ              Length
    ₂               Square root
   Ｆ   «            Loop over implicit range
            ι   ι   Current value
               ⊕    Incremented
             ²   ²  Literal 2
           Ｘ  Ｘ     Power
         ✂θ         Slice the (first) input string
        Ｐ           Print without moving the cursor
                  ↙ Move down left

Python 2 , 84 byte

s=input()
l=int(len(s)**.5)
for i in range(l):print s[i*i:][:i-~i].center(l*2-1,'.')

Hãy thử trực tuyến!

Sạch sẽ , 123 byte

import StdEnv
?n l#(a,b)=splitAt n l
|b>[]=[a: ?(n+2)b]=[a]
$s#s= ?1s
=[c++l++c\\l<-s&i<-[1..],c<-[repeatn(length s-i)'.']]

Hãy thử trực tuyến!

Ruby , 73 66 byte

->s{(1..z=s.size**0.5).map{|q|s[q*q-2*q+1...q*q].center 2*z-1,?.}}

Hãy thử trực tuyến!

-5 byte: Trả về một chuỗi các chuỗi thay vì in chúng

-2 byte: Khai báo z tại chỗ thay vì trước thời hạn

Ung dung:

->s{
  (1..z=s.size**0.5).map{|q|   # Map the range [1,sqrt(s.size)]
    s[q*q-2*q+1...q*q]         # To the relevant portion of s,
      .center 2*z-1, ?.        #   padded left and right with . characters
  }
}

Khai báo một biến r=q-1để tôi có thể lấys[r*r...q*q] lưu chính xác các byte bằng không.

Sử dụng .centerthay vì đệm thủ công cũng tiết kiệm không byte, nhưng tôi thích nó hơn.

Stax , 19 byte

╚└÷2╬#►o┴X≡¥ΩåV∙¬?♥

Chạy và gỡ lỗi nó

Tương đương ASCII:

z;%|q{Hv,:/~]+F|Cm0]'.R