使三角计划有效


19

三角性是Xcoder 先生开发的一种新的esolang ,其代码结构必须遵循非常特定的模式:

  • 对于第nth行代码,其上必须完全2n-1有程序的字符。这将导致三角形/金字塔形,第一行仅包含一个字符,其余行以2为增量增加。
  • 每行.的左侧和右侧都必须用s 填充,以使字符以其行为中心,并且所有行都应填充为相同的长度。如果l定义为程序中的行数,则程序中的每一行的长度必须为2 * l - 1

例如,左侧的程序有效,而右侧的程序无效:

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

当布置在有效结构中时,该名称变得显而易见。

任务

您的任务是将单个行字符串作为代表Triangularity代码的输入,并将其输出转换为有效代码,如上所述。

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

对于那些了解三角关系的人,您会从最后一个测试用例中注意到,不必处理字符串



13
我意识到这可能是徒劳的,但是下选民会在乎解释他们的投票吗?我想尽一切可能改善挑战。
Caird coinheringaahing

前导或尾随的换行符可以接受吗?
Arnauld

@Arnauld是的,开头和结尾的空格非常好。
Caird coinheringaahing

行列表好吗?
Xcoder先生18年

Answers:


19

三角形,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.

您是否必须为“。”计分字节?字符是否由语言的内在函数规定?
JDL

@JDL是的,没有它们,程序将无法正确运行,因此我必须将它们包括在字节数中:-)
Xcoder先生,18年

您是否需要“修剪小数”,以确保输入的长度一定是平方?您还应该能够获得杆J的末端并输出一系列线。但是,如果最后一行的末尾需要填充.空白,不知道是否可以为您节省任何费用。
毛茸茸的

1
@Shaggy 1)是的,这f是必需的,因为range无法接受浮点参数(即使使用.0)2)J由于填充原因,摆脱掉并不会节省任何字节,因此我选择了更漂亮的输出格式。
Xcoder先生18年

8

Japt15 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

7

外壳,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.

7

05AB1E20 19 18字节

感谢魔术章鱼缸节省了一个字节

ā·<£õ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

ÅÉ可能有帮助吗?
魔术章鱼缸

g;ÅÉ£Rvy'.N×.ø}r»什么?但这不是因为那是不对的。
魔术章鱼缸

@MagicOctopusUrn:ÅÉ如果我们能找到2字节的底行长度,那肯定会有所帮助。我不知道是否可以。也可能是合并它的另一种方式。
Emigna

@MagicOctopusUrn:我之前有相同的解决方案,只是我使用了相同的解决方案,)R而不是r不保存任何字节:/
Emigna

我试图找到一种方法来“逆向循环”以仅在发生时打印,但是对此没有任何想法。
魔术章鱼缸


5

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

5

JavaScript(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 = (                       // 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

[次要]'/ n'符号成为顶部代码块中的实际换行符-为清楚起见,请转义它:)
G0BLiN

@ G0BLiN这是周围的其他方法:这确实在golfed代码,这与在ungolfed版本为清楚起见转义换行符替换文字换行。:)
Arnauld

哈,我开玩笑了,然后... :-)
G0BLiN


2

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

2

干净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@']



1

Perl,56 52字节

包括+3用于-p

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

在STDIN上提供输入(原则上不带最终换行符,但这仅对空输入有效)


1
根据PCG规则-p仅花费1个字节
mik,

@mik仅当代码不包含时'。但是此代码可以,因此需要将其放入一个文件(或在命令行中转义),与普通#!行相比,该文件需要额外的3个字符。因此,在这种情况下+3(正常的代码,你会看到我确实只算+p
吨Hospel

1

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

1

视网膜88 72 71字节

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

在线尝试!编辑:由于@MartinEnder,节省了12 13字节。说明:

S1`

将第一个字符分成自己的一行以使球滚动。

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

砍每一行比上一行长两个字符。

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

左垫每行的前半部分,有效地使它们居中。

P'.`.+

右击所有行。


1

木炭21 19字节

UB.F₂Lθ«P✂θXι²X⊕ι²↙

在线尝试!链接是详细版本的代码。编辑:通过发现保存2个字节SquareRoot。说明:

UB.                 Set the background fill to `.`
      θ             (First) input
     L              Length
    ₂               Square root
   F   «            Loop over implicit range
            ι   ι   Current value
               ⊕    Incremented
             ²   ²  Literal 2
           X  X     Power
         ✂θ         Slice the (first) input string
        P           Print without moving the cursor
                  ↙ Move down left

:/ 几乎可以用,但是木炭似乎有点马车。我认为行得通吗?
ASCII码,仅ASCII

仅限@ASCII ...这是什么黑魔法?
尼尔,

填充基本上检查空字节(即,用于绘制任何内容的空白处的字符),因此您可以绘制具有空字节的多边形(如果它甚至可以正常工作,则__>)并填充它。显然,这并不是完全正确的,因为出于某种原因您甚至可以在填充之前就实际看到空字节> _>
纯ASCII码,

应该在下一次拉取时可以正常工作
纯ASCII码



0

红宝石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]保存零个字节。

使用.center手动代替填充也可以节省零字节,但我更喜欢。


By using our site, you acknowledge that you have read and understand our Cookie Policy and Privacy Policy.
Licensed under cc by-sa 3.0 with attribution required.