Triangularity 는 Mr. Xcoder 가 개발 한 새로운 esolang 으로 코드 구조는 매우 특정한 패턴을 따라야합니다.

• 세 n번째 코드 줄 2n-1에는 프로그램의 문자 가 정확히 있어야 합니다. 이로 인해 삼각형 / 피라미드 모양이 발생합니다. 첫 번째 줄에는 문자가 하나만 있고 나머지는 2 씩 증가합니다.
• 각 줄은 .왼쪽과 오른쪽에 s 로 채워야 하므로 문자가 줄 중앙에 있고 모든 줄이 같은 길이로 채워집니다. l프로그램에서 줄 수로 정의 된 경우 프로그램의 각 줄 길이는2 * l - 1

예를 들어 왼쪽의 프로그램은 유효하지만 오른쪽의 프로그램은 유효하지 않습니다.

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

유효한 구조로 배치되면 이름이 분명해집니다.

직무

귀하의 작업은 삼각 코드를 나타내는 단일 행 문자열을 입력으로 사용하여 위에서 설명한대로 유효한 코드로 변환하여 출력하는 것입니다.

I / O 사양 :

• 입력은 범위 내의 문자 만 포함합니다 0x20 - 0x7e
• 입력의 길이는 항상 제곱 수이므로 멋지게 채울 수 있습니다.
• 출력 패딩에는 점이 아닌 다른 것을 사용해야합니다.

허용되는 방법을 통해 입력 및 출력 할 수 있습니다 . 이것은 코드 골프 이므로 바이트 단위 의 가장 짧은 코드가 이깁니다!

테스트 사례

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

_{Triangularity를 ​​아는 사람들에게는 마지막 테스트 사례에서 문자열을 처리 할 필요가 없다는 것을 알 수 있습니다}

삼각 , 127 바이트

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

온라인으로 사용해보십시오!

설명

패딩을 구성하는 문자를 제거하면 다음과 같은 프로그램이 나타납니다.

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

... 어느 것이 꽤 길고, 맞습니까? 그것을 조각으로 나누자.

정수 생성하기 [0… √len (input))

)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))]

점 생성

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).

앞면의 문자 다듬기

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.

끝에있는 문자 다듬기

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.

루프를 끝내고 예쁘게 인쇄

})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 바이트

라인 배열을 출력합니다.

ò@°T¬v1Ãû.

사용해보십시오 | 모든 테스트 사례 확인

외식

ò@     Ã       :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

독창적 인 솔루션

ʬÆsTT±X+°XÃû.

시도 해봐

Ê                  :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

껍질 , 15 바이트

Ṡzö`JR2tR'.ṡCİ1

온라인으로 사용해보십시오!

설명

Ṡ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 바이트

Magic Octopus Urn 덕분에 바이트 절약

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

온라인으로 사용해보십시오!

설명

ā                    # 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

파이썬 2 , 83 바이트

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

온라인으로 사용해보십시오!

젤리 ,  22  19 바이트

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

문자 목록 (행) 목록을 리턴하는 모나드 링크

온라인으로 사용해보십시오!

어떻게?

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"]

자바 스크립트 (ES7), 82 78 바이트

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

테스트 사례

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@'))

댓글

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 바이트

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

온라인으로 사용해보십시오!

MATL , 21 바이트

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

온라인으로 사용해보십시오!

설명

'DfJ0vCq7G'예를 들어 입력 을 고려하십시오 . 스택 내용은 쉼표로 구분되어 있으며 맨 위 요소는 마지막입니다. 2D 배열의 행은 세미콜론을 구분 기호로 사용합니다.

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']

클린 , 107 94 89 88 바이트

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

@[]1

온라인으로 사용해보십시오! 사용법 예 : @[]1 ['ABCDEF"$%& G8"F@'].

하스켈 , 84 68 바이트

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

온라인으로 사용해보십시오!

사용법 예 : []%1 $ "abcd"행 목록을 생성합니다 [".a.","bcd"].

펄, 56 52 바이트

포함 +3을 위해-p

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

STDIN에 입력하십시오 (원칙적으로 최종 개행은 없지만 빈 입력에만 중요합니다)

빨강 , 227203 바이트

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

온라인으로 사용해보십시오!

언 골프 드 :

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

망막 , 88 72 71 바이트

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

온라인으로 사용해보십시오! 편집 : @MartinEnder 덕분에 12 13 바이트가 절약되었습니다. 설명:

S1`

첫 번째 캐릭터를 자신의 라인으로 분할하여 볼을 굴립니다.

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

각 줄을 이전 줄보다 두 자 길게 자릅니다.

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

각 줄의 첫 번째 절반을 왼쪽으로 패드하여 효과적으로 가운데에 맞 춥니 다.

P'.`.+

모든 줄을 오른쪽으로 채 웁니다.

숯 , 21 19 바이트

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

온라인으로 사용해보십시오! 링크는 자세한 버전의 코드입니다. 편집 :을 발견하여 2 바이트를 저장했습니다 SquareRoot. 설명:

ＵＢ.                 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

파이썬 2 , 84 바이트

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

온라인으로 사용해보십시오!

클린 , 123 바이트

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)'.']]

온라인으로 사용해보십시오!

루비 , 73 66 바이트

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

온라인으로 사용해보십시오!

-5 바이트 : 문자열 배열을 인쇄하지 않고 반환

-2 바이트 : 미리 선언 z하지 않고 제자리에 선언

언 골프 드 :

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

r=q-1내가 취할 수 있도록 변수를 선언 s[r*r...q*q]하면 정확히 0 바이트 가 절약됩니다.

.center패딩 대신 수동으로 사용 하면 0 바이트가 절약되지만 더 좋아집니다.

Stax , 19 바이트

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

실행 및 디버깅

ASCII 상응 :

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