弦之塔

22

给定文本字符串，将其输出为“塔”。

字符串的每个片段（形式为0:n）都重复5*n一次，因此第一个字符重复5次，然后第一个和第二个重复10次，依此类推。

例子：

'hello' ->

['h']  
['h']  
['h']  
['h']  
['h']  
['h', 'e']  
['h', 'e']  
['h', 'e']  
['h', 'e']  
['h', 'e']  
['h', 'e']  
['h', 'e']  
['h', 'e']  
['h', 'e']  
['h', 'e']  
['h', 'e', 'l']  
['h', 'e', 'l']  
['h', 'e', 'l']  
['h', 'e', 'l']  
['h', 'e', 'l']  
['h', 'e', 'l']  
['h', 'e', 'l']  
['h', 'e', 'l']  
['h', 'e', 'l']  
['h', 'e', 'l']  
['h', 'e', 'l']  
['h', 'e', 'l']  
['h', 'e', 'l']  
['h', 'e', 'l']  
['h', 'e', 'l']  
['h', 'e', 'l', 'l']  
['h', 'e', 'l', 'l']  
['h', 'e', 'l', 'l']  
['h', 'e', 'l', 'l']  
['h', 'e', 'l', 'l']  
['h', 'e', 'l', 'l']  
['h', 'e', 'l', 'l']  
['h', 'e', 'l', 'l']  
['h', 'e', 'l', 'l']  
['h', 'e', 'l', 'l']  
['h', 'e', 'l', 'l']  
['h', 'e', 'l', 'l']  
['h', 'e', 'l', 'l']  
['h', 'e', 'l', 'l']  
['h', 'e', 'l', 'l']  
['h', 'e', 'l', 'l']  
['h', 'e', 'l', 'l']  
['h', 'e', 'l', 'l']  
['h', 'e', 'l', 'l']  
['h', 'e', 'l', 'l']  
['h', 'e', 'l', 'l', 'o']  
['h', 'e', 'l', 'l', 'o']  
['h', 'e', 'l', 'l', 'o']  
['h', 'e', 'l', 'l', 'o']  
['h', 'e', 'l', 'l', 'o']  
['h', 'e', 'l', 'l', 'o']  
['h', 'e', 'l', 'l', 'o']  
['h', 'e', 'l', 'l', 'o']  
['h', 'e', 'l', 'l', 'o']  
['h', 'e', 'l', 'l', 'o']  
['h', 'e', 'l', 'l', 'o']  
['h', 'e', 'l', 'l', 'o']  
['h', 'e', 'l', 'l', 'o']  
['h', 'e', 'l', 'l', 'o']  
['h', 'e', 'l', 'l', 'o']  
['h', 'e', 'l', 'l', 'o']  
['h', 'e', 'l', 'l', 'o']  
['h', 'e', 'l', 'l', 'o']  
['h', 'e', 'l', 'l', 'o']  
['h', 'e', 'l', 'l', 'o']  
['h', 'e', 'l', 'l', 'o']  
['h', 'e', 'l', 'l', 'o']  
['h', 'e', 'l', 'l', 'o']  
['h', 'e', 'l', 'l', 'o']  
['h', 'e', 'l', 'l', 'o']  


'cat' ->

['c']  
['c']  
['c']  
['c']  
['c']  
['c', 'a']  
['c', 'a']  
['c', 'a']  
['c', 'a']  
['c', 'a']  
['c', 'a']  
['c', 'a']  
['c', 'a']  
['c', 'a']  
['c', 'a']  
['c', 'a', 't']  
['c', 'a', 't']  
['c', 'a', 't']  
['c', 'a', 't']  
['c', 'a', 't']  
['c', 'a', 't']  
['c', 'a', 't']  
['c', 'a', 't']  
['c', 'a', 't']  
['c', 'a', 't']  
['c', 'a', 't']  
['c', 'a', 't']  
['c', 'a', 't']  
['c', 'a', 't']  
['c', 'a', 't']

规则：

您可以将每个图层输出为字符列表，也可以仅将它们连接在一起的字符串输出。

code-golf  string  number 
— 陈惠拉拉拉拉
source
欢迎来到PPCG！很好的挑战。
— 朱塞佩
我试图清理格式并更好地解释了挑战。我理解挑战正确吗？
— Rɪᴋᴇʀ
2
我们可以将输入作为字符列表吗？
— JayCe
5
我们可以像这样输出字符串的二维数组[["c","c","c","c","c"],["ca","ca","ca","ca","ca","ca","ca","ca","ca","ca"],...]吗？
— 粗野的
3
前导或尾随换行符的输出是否可以接受？我们可以假设输入不包含换行符吗？
— 冗余

Answers:

12

R，48个字节

function(s)substring(s,1,rep(x<-1:nchar(s),x*5))

在线尝试！

返回字符串列表。

— 朱塞佩
source
我错过了这里明显的高尔夫！不错的解决方案，我尝试了不同的方法，但到目前为止，所有方法都比这更长。
— JayCe
8

05AB1E，6个字节

ηā5*ÅΓ

在线尝试！

返回字符串列表。

说明

     ÅΓ # Run-length decode...
η       # ... the prefixes of the input
 ā5*и   # ... with the length range multiplied by 5 -- [5, 10, 15, 20, 25]
— 卡尔多
source
@KevinCruijssen感谢您的注意！我不应该在没有喝咖啡的早晨
— 去打
1
使用游程长度解码可节省3个字节：ηā5*ÅΓ
— Adnan
@Adnan Brilliant，谢谢！我认为它应该得到自己的回答，但是您已将字节数减少了33％...如果您决定自己发布它，我将恢复为原始解决方案。
— Kaldo
尼斯一个，我不得不ηvyg5*Fy=为8
— 魔术八达通瓮城
6

TI-Basic（TI-84 Plus CE），29字节（27个令牌）

For(A,1,length(Ans
For(B,1,5A
Disp sub(Ans,1,A
End
End

说明：

For(A,1,length(Ans # 9 bytes, 8 tokens: for A from 1 to the length of the string
For(B,1,5A         # 8 bytes, 8 tokens:  5*A times
Disp sub(Ans,1,A   # 9 bytes, 8 tokens:   Print the first A characters of the string 
End                # 2 bytes, 2 tokens:  end loop
End                # 1 byte,  1 token:  end loop
— 比萨184
source
6

视网膜，15字节

.
$.>`*5*$($>`¶

在线尝试！链接包括测试用例。说明：

.

匹配字符串中的每个字符。

$.>`*5*$($>`¶

$`是匹配项的前缀。然后，Retina提供两个修饰符，>将其修饰为在连续匹配之间的字符串上下文中，同时.采用长度。因此，我们从后缀的前缀开始，该前缀等同于包含其前缀的匹配项。与重叠匹配相比，这节省了2个字节。$(然后，用换行符将其连接起来，5*重复一次，然后再$.>`重复一次，重复次数由其长度指定。

— 尼尔
source
6

Cubix， 44  40字节

i.!?@UBqwW_#/>u...;B^...?qo;;q*n5;oN/./)

在线尝试！

这仍然有很多禁忌措施，但比以前要好一些。

作为一个非常简短的描述，从输入中抓取一个字符并测试EOI（-1），如果是则暂停。然后将堆栈反转。获取堆栈上的项目数，然后乘以-5。将其放到堆栈底部并清理。循环遍历堆栈，打印，直到负数。打印换行符，增加数字，如果0减零，则反转堆栈并再次从输入开始，否则循环遍历堆栈，打印，直到负数...

看起来像

      i . !
      ? @ U
      B q w
W _ # / > u . . . ; B ^
. . . ? q o ; ; q * n 5
; o N / . / ) . . . . .
      . . .
      . . .
      . . .

在线观看

— 米奇
source
5

JavaScript，48 46字节

（感谢@redundancy）

编辑：作者澄清了，这个答案现在无效，但是我将在这里保持不变。

返回多行字符串的数组。

s=>[...s].map(c=>(q+=c).repeat(5*++i),i=q=`
`)

尝试一下

f = s=>[...s].map(c=>(q+=c).repeat(5*++i),i=q=`
`);

console.log( f("hello").join`` );
展开摘要

潜在策略：

它对我没有多大帮助，但也许有人可以使用此功能：

在（0索引）行处的字符数i为floor(sqrt(2/5*i+1/4)+1/2)，在JavaScript中称为(.4*i+.25)**.5+.5|0。

对于长度的字符串n，有n*(n+1)*5/2线。

也许： s=>{for(i=0;(n=(.4*i+++.25)**.5+.5|0)<=s.length;)console.log(s.slice(0,n))}

— 马特
source
1
假设您的输出格式符合挑战，那么您可以保存2个字节，如此处所示：在线尝试！
— 冗余
3

外壳，8字节

ΣzoR*5Nḣ

在线尝试！

说明

Σz(R*5)Nḣ  -- example input: "ab"
        ḣ  -- non-empty prefixes: ["a","ab"]
 z(   )N   -- zip with [1..]
    *5     -- | multiply by 5
   R       -- | replicate
           -- : [["a","a","a","a","a"],["ab","ab","ab","ab","ab","ab","ab","ab","ab","ab"]]
Σ          -- concat: ["a","a","a","a","a","ab","ab","ab","ab","ab","ab","ab","ab","ab","ab"]
— ბიმო
source
3

Haskell，46 43 42字节

f s=do n<-[1..length s];take n s<$[1..n*5]

在线尝试！

可悲地inits要求import Data.List，所以

import Data.List
((<$)<*>(>>[1..5])=<<).inits

45字节更长。

编辑：-1字节感谢@BWO。

— 妮米
source
3

木炭，11字节

Ｆ⊕ＬθＥ×⁵ι…θι

在线尝试！链接是详细版本的代码。输出包括零长度子串的0个重复。说明：

   θ          Input string
  Ｌ           Length
 ⊕            Incremented
Ｆ             Loop over implicit range
      ⁵       Literal 5
       ι      Current index
     ×        Multiply
    Ｅ         Map over implicit range
         θ    Input string
          ι   Current index
        …     Chop to length
              Implicitly print each string on its own line
— 尼尔
source
3

PowerShell，40 20 25字节

由于AdmBorkBork指出了规格，疯狂的+5个字节使得分减少了一半

$args|%{,($s+=$_)*5*++$i}

在线尝试！

通过展开输入。通过向其自身添加下一个字符来构建字符串，然后将其转换为一个元素数组，然后重复其5*i次数，从而工作。

— 维斯卡
source
1
param是非常昂贵的。尽量避免它
— MAZZY
@mazzy Dang，尝试保存索引而不是char本身使我误入歧途。谢谢。
— Veskah
@AdmBorkBork哈哈，哎呀。现在应该修复
— Veskah
2

MATL，12字节

f"G@:)@5*1X"

在线尝试！

f               % Get the indices of input i.e. range 1 to length(input)
 "              % For loop over that
   G            % Push input string
    @           % Push current loop index
     :          % Range 1 to that
      )         % Index at those positions (substring 1 to i)
       @5*      % Multiply loop index by 5
          1X"   % Repeat the substring that many times rowwise
                % Results collect on the stack and are 
                %  implicitly output at the end
— sundar-恢复莫妮卡
source
2

V，17个字节

òïç$îî/6Ä
Hl$xòxú

期望输入没有换行符，而输出具有多余的换行符。

如果输入/输出违反质询规范，则可以删除此条目。

在线尝试！

21字节

òïç$îî/6Ä
Hl$xòxíîî/ò

期望输入没有换行符，但是输出只有一个前导和尾随的换行符。

说明

不同的子字符串用两个连续的换行符分隔，因此逐行复制仅适用于与regex匹配的行$\n\n。

当Ä提供复制命令（）时，例如6Ä（我认为），它会在粘贴n时间之前删除当前行，因此似乎只附加了n - 1副本。

ò         | recursively...
 ï        | . append newline
  ç       | . globally search lines matching...
   $îî    | . . compressed version of $\n\n regex
      /6Ä | . . duplicate to create 6 copies
H         | . go to first line
 l        | . move cursor right 1 char
          | . . if current line is 1 char long, errors out of recursion
  $x      | . delete 1 char from end of current line
    ò     | ...end
     x    | delete extra 1-char substring
      ú   | sort so that newlines rise to top
— 冗余
source
1

Perl 6，25个字节

{(1..*X*5)RZxx[\~] .comb}

在线尝试！

返回字符串列表列表的匿名代码块。

如果您希望将其作为一维数组，则可以flat像这样在前面附加：

{flat (1..*X*5)RZxx[\~] .comb}

在线尝试！

说明：

{                       }  # Anonymous code block
                   .comb   # Split the string into a list of characters
              [\~]         # Triangular reduce the list of characters with the concatenate operator
          RZxx             # Multiply each list by:
 (1..*X*5)                 # A sequence of 5,10,15 etc.

或者， 

{($+=5)xx*RZxx[\~] .comb}

在线尝试！

同样适用于相同数量的字节。

— 乔·金
source
1

Japt，10个字节

等待确认输出格式是否可接受（如果不接受，则为+2字节）。

å+ £T±5 ÇX

尝试一下

— 毛茸茸
source
输出对我来说看起来很合理，做得很好。
— Nit
1

JavaScript，76个字节

s=>{for(i=1;i<=s.length;i++)for(j=0;j<5*i;j++)console.log(s.substring(0,i))}


f=s=>{for(i=1;i<=s.length;i++)for(j=0;j<5*i;j++)console.log(s.substring(0,i))}

f("cat")
展开摘要

— 梅杜
source
您好，欢迎来到PPCG。
— 乔纳森·弗雷希
i=1;i<=s.length;i++可以i=0;++i<=s.length;。
— 乔纳森·弗雷希
1

第四（gforth），48个字节

: f 1+ 1 do i 5 * 0 do dup j type cr loop loop ;

在线尝试！

说明

  1. 从1到字符串长度循环
  2. 对于每次迭代：
    1. 循环（5 *循环索引）次
    2. 从开始到外循环索引打印字符串

代码说明

: f                \ start a new word definiton
  1+ 1             \ set up to the loop paramers from 1 to str-length
  do               \ start a counted loop
    i 5 * 0 do     \ start a second counted loop from 0 to 5*index - 1
      dup j        \ duplicate the string address and set the length to the outer index
      type         \ print character from start of string to loop index
      cr           \ output a newline
    loop           \ end inner counted loop
  loop             \ end outer counted loop
;                  \ end word definition
— Reffu
source
1

Java 10、120 92 90 89字节

s->{for(int j=1,i=1;i<=s.length();i+=++j>i*5?j=1:0)System.out.println(s.substring(0,i));}

-28个字节，感谢@OlivierGrégoire。
-1个字节感谢@ceilingcat。

在线尝试。

说明：

s->{                      // Method with String parameter and no return-type
  for(int j=1,            //  Repeat-integer, starting at 1
      i=1;i<=s.length()   //  Loop `i` in the range [1,length_input]
      ;                   //    After every iteration:
       i+=++j>i*5?        //     Increase `j` by 1 first with `++j`
                          //     If `j` is now larger than `i` multiplied by 5:
           j=1            //      Increase `i` by 1, and reset `j` to 1
          :               //     Else:
           0)             //      Leave `i` the same by increasing it with 0
    System.out.println(   //   Print with trailing newline:
      s.substring(0,i));} //    The prefix of size `i`
— 凯文·克鲁伊森
source
1
92位元组：s->{for(int i=1,j=1;i<=s.length();i+=j++<i*5?0:+(j=1))System.out.println(s.substring(0,i));}
— OlivierGrégoire18年
@OlivierGrégoire谢谢！通过更改使用>=和?j=1:0而不是<和，我已经可以再打2个字节?0:+(j=1)。
— 凯文·克鲁伊森
好！我试图摆脱它，但是我一直遇到编译问题。没想到要恢复条件。做得好！;）
— OlivierGrégoire18年
@ceilingcat谢谢
— Kevin Cruijssen
1

brainfuck，40个字节

++++++++++>,[>>+++++[<<[<]>[.>]>>+<-]<,]

在线尝试！

[Tape: 10 (newline), [characters], 0, rowcounter]

++++++++++> 10 (newline)
,[          for each input character
  >>+++++     add 5 to number of rows
  [           for each row
    <<[<]       go to start
    >[.>]       print newline and all previous characters
    >>+         add 1 to next rowcounter cell
    <-          decrement current rowcounter cell
  ]
  <,          input next character
]
— 多里安
source
1

APL（Dyalog Unicode），14 字节SBCS

{↑(5×⍳≢⍵)/,\⍵}

在线尝试！

我的第一个APL帖子，所以如果您有任何建议请告诉我

怎么运行的：

{↑(5×⍳≢⍵)/,\⍵}
          ,\⍵  - Prefixes of the input
         /      - Repeated
     ⍳≢⍵        - By a list of indices the same length as the input
   5×           - Times 5
 ↑              - Separate into rows
— 坦率
source
↑并不是真正地分成几行，而是将[列表列表]合并到[矩阵的行]中，或者从技术上讲，以降低depth为代价提高排名。
— 阿达姆（Adám）
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.