Helloellolloloo Worldorldrldldd

50

编写一个程序，使用您输入的单词，然后将该单词添加到其本身的后面，减去第一个字母，然后重复执行，直到所有字母消失。例如，cat将变为catatt，并且hello将变为helloellolloloo。

输入
英文字母的26个字母中的任何一个。可能会有多个单词，并用空格分隔，应该将更改应用于每个单词。

输出输入
的单词，每个单词紧跟其后，第一个字母缺失，第二个字母缺失，依此类推，直到没有其他字母可添加为止。

更多示例：

ill eel 输出 illlll eelell

laser bat 输出 laserasersererr batatt

darth vader 输出 dartharthrththh vaderaderdererr

这是代码高尔夫，所以最短的代码获胜。

澄清：
您可以将输入或输出视为列表。您可以使用换行符而不是空格来分隔单词。您可以在输入中添加尾随空格。

code-golf string

— qazwsx
source

22

老实说，多字的事情有点烦人。它所做的只是需要拆分，将功能应用于每个单词，然后再次加入。它也很虚弱了很多esolangs的具有手动检查的空间

— 乔金

4

我们可以将输入作为单词列表输入，还是将其输出吗？

— Quintec

4

您需要处理多长的单词？

— MickyT

5

可以在输出中用换行符（而不是空格）分隔单词吗？

— JayCe

10

1.请使用新的配额（阵列I / O，尾随空格等）更新规格，2.以防任何现有解决方案可以利用它们节省字节。

— 粗野的

Answers:

34

Japt `-m`，6个 3字节

输入和输出是单词数组。

£sY

说明

        :For each word in the input array
£       :Map each letter at index Y
 sY     :  Slice the current word from index Y

— 毛茸茸
source

1

那真的很紧凑。真好！

— qazwsx

9

@qazwsx：现在50％以上紧凑！

— 毛茸茸的

1

£UTF-8中不是两个字节吗？

— 六。

7

@Vi，我在这里不使用UTF-8。

— 毛茸茸的

36

疯子，60 56字节

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

在线尝试！

需要尾随空格并打印前导空格。这两种方法都可以绕过，但最终以112个字节结尾。

说明

,[  Loop over each byte of input
  Tape: 32 w o r-32 d'
  >++++++++[-<----<++++>>]   Subtract 32 from the character and add 32 to the previous char
  Tape: 32 w o r d-32 0'
  <[>>]<   If the last character was a space
  Tape: 32 w o r d-32 0'
  or
  Tape: 32 w o r d' space-32
  [
    [<]>.   Move to the end of the word and print out the space
    [   Loop over each letter
      [-]    Remove the first letter (initially space)
      >[.>]  Print the rest of the word
      <[<]>  Move back to the first letter
    ]
    Tape: clear
  ]
,]  Get the next byte of input

— 乔·金
source

21

Haskell，36个 21字节

map$concat.scanr(:)""

在线尝试！

编辑：-15个字节，因为新的IO格式（单词列表而不是空格分隔的单词）

— 妮米
source

你可以通过替换剃掉5个字符scanr (:) ""用tails。

— Frerich Raabe

1

@FrerichRaabe：是的，但是那需要一个import Data.List将得分增加17个字节的。

— nimi

18

Perl `-p`，36 25 23字节

s!\b|\S!$'=~s/ .*//r!eg

在线尝试！

这是一个regsub。首先，它匹配所有单词边界或非空格字符：

[][H][e][l][l][o] [][W][o][r][l][d]

请注意，这些匹配项中的每一个都应替换为其余单词：

[→Hello][H→ello][e→llo][l→lo][l→o][o→] (...)

我们可以使用特殊变量来完成此操作，该变量$'存储了匹配后的字符串部分。但是，我们需要对其应用嵌套的regsub s/ .*//，以删除超过中第一个空格的所有内容$'，以消除输入中剩余的单词。

感谢@nwellnhof提供2个字节。

— 门把手
source

您可以替换[^ ]为\S。

— nwellnhof

17

Python 3，49个字节

d=lambda s:' '.join(n+d(n[1:])for n in s.split())

在线尝试！

这利用了以下事实："".split()返回一个空数组，从而充当递归中基本情况的检查。

— 卡梅伦·阿维克（Cameron Aavik）
source

17

果冻，3个字节

ḊƬ€

在线尝试！

不再需要Ks，因为现在允许数组输入/输出。

ḊƬ€
  €   For each word:
Ḋ       Remove the first letter
 Ƭ      until there are none left.

— Dylnan
source

我认为您需要ḊƬẎ)（或者ḊƬF)，如果愿意的话）。

— 暴民埃里克（Erik the Outgolfer）'18年

@EriktheOutgolfer我不这么认为。每个单词在输出中

— 均由

1

我不确定是否可以声明，因为数组是嵌套的，问题中未指定任何内容来允许它。

— 暴民埃里克（Erik the Outgolfer）'18年

15

APL（Dyalog），19 9字节

{⌽∊,\⌽⍵}¨

感谢@ H.PWiz慢跑我的大脑

之所以可行，是因为APL中的所有字符串都是字符数组。

{⌽∊,\⌽⍵}¨ 
        ¨ - for each string
      ⍵} - string argument - ex. "hello"
     ⌽ - reverse - "olleh"
   ,\ - scan magic - "o" "ol" "oll" "olle" "olleh"
  ∊ - enlist(join together) "oolollolleolleh"
{⌽ - reverse - "helloellolloloo"

— 金泰克
source

15

JavaScript（ES6），33个字节

@ShieruAsakoto节省了1个字节

I / O格式：字数组。

a=>a.map(g=w=>w&&w+g(w.slice(1)))

在线尝试！

JavaScript（ES6），35个字节

I / O格式：字数组。

a=>a.map(w=>w.replace(/./g,"$&$'"))

在线尝试！

— Arnauld
source

2

44：s=>s.replace(/\S+/g,g=s=>s&&s+g(s.slice(1)))

— Shieru Asakoto

1

感谢您今天的“新鲜事”；从不知道$'（或$<backtick>）。

— 粗野的

13

R， 82 75 67字节

write(sapply(x<-scan(,""),substring,1:(y=max(nchar(x))),y),1,y,,"")

在线尝试！

由于有了JayCe，节省了几个字节

用换行符分隔输出。

该sapply(...)表达式生成适当子字符串的矩阵/列向量，并""根据需要填充。write然后y按行打印矩阵元素，并用分隔它们""。

— 朱塞佩
source

4

抱着一个困婴儿打高尔夫球稍后会添加说明。

— 朱塞佩

2

如果字词的长度受到限制，例如99个字符或〜1e6，则可以用...substring,1:1e6,1e6)...或类似的形式敲掉一堆字节

— MickyT

2

如果可以用换行符分隔单词：tio。我已经在评论中问过这一点。可以使用@MickyT的评论

— JayCe

@JayCe 在合并MickyT的建议之前看起来可能是67个字节

— 朱塞佩

8

brainfuck，94 93个字节

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

在线尝试！

多亏了Nitrodon节省了一个字节-打高尔夫球.[-]>[.>]<[<]>了[.>]<[<]>[-]>。

说明

[[[ (dynamic) tape layout: ... NUL STR ... STR CHR FLG BUF SPC NUL ... ]]]

load a 32 into SPC
-[-[-<]>>+<]>-

while FLG
<<+[

 read a word
 [
  clear FLG; read CHR
  [-]<,
  copy CHR to BUF (using FLG as a temporary)
  [->+>+<<]>[-<+>]
  subtract SPC from BUF and save SPC
  >>[-<->>+<]
  move tape layout one to the right
  <
 ]

 strip trailing space; set FLG to true
 << [>>+<<[-]]
 to STR's first character
 <[<]>
 print word in all reduced forms
 [
  [.>]<[<]>[-]>
 ]

 print SPC; move to FLG
 >>>>.<<
]

在线尝试！

归因

Esolang的Brainfuck 常数集合用于初始空间负荷。

— 乔纳森·弗雷奇
source

这似乎没有终止。那是故意的吗？

— Jo King

1

@JoKing是的。在某些实现中，它将超出磁带限制，错误退出。

— 乔纳森·弗雷希

6

05AB1E，5个字节

€.síJ

在线尝试！

说明

€.s        # push suffixes of each
   í       # reverse each
    J      # join suffixes

— 艾米尼亚
source

1

令人讨厌的5字节替代方法：（í€ηJí因为前缀是1字节内置而不是2字节，如后缀；但是仍然需要附加的反向操作，但是在开始时，因此字节数保持为5）。

— 凯文·克鲁伊森

6

Vim，47个字节（38个按键）

从您的输入作为Vim缓冲区的唯一行开始。

:s/<Space>/\r/g<CR>ggqaywPlxqqb99@aj0q99@bgg99J

说明

这会将每个单词放在自己的行上，遍历每行，然后重新将它们全部合并。如果单词长于99个字符或输入的单词长于99个，则中断。

:s/<Space>/\r/g<CR> 取代用新行空格（\r）
gg 将光标置于第一行的开头
qa开始录制宏一：
- yw 其余单词
- P 把它放在光标后面
- lx 删除后一个单词的第一个字母
- q停止录制宏一
qb开始记录宏b：
- 99@a执行宏一 99倍（介绍了字符）
- j0 将光标置于下一行的开头
- q停止录制宏b
99@b执行宏b九十九次（引入字数限制）
gg 将光标置于第一行
99J 加入（再次一字涨停）以下99线与空间

对于另外2个字节（2个击键），您可以将字数限制扩展到999。另外4个字节，9999等。

— 尚宾
source

6

外壳，6个 4字节

^{感谢乔纳森·艾伦（Jonathan Allan） -2个字节（将输入作为列表）！}

moΣṫ

在线尝试！

说明

将输入作为字符串列表并映射以下功能：

Σṫ  -- example argument: "abc"
 ṫ  -- tails: ["abc","bc","c"]
Σ   -- concat: "abcbcc"

— ბიმო
source

可能不再需要split＆join，目前在注释中有这样的说明。

— 乔纳森·艾伦，

5

视网膜0.8.2，15字节

 
¶
.
$&$%'
¶

在线尝试！注意：尾随空格。说明：

¶

在空格上分割。

.
$&$%'

在每个字母后添加后缀。的%，我们只获得了这个词的后缀手段。

¶

加入空格。

— 尼尔
source

5

Pepe，167153字节

REEerEeeEeeeeeRrEEEEerEEEEEeerEErEEeerreErEEeErreEREEEEEEEreereErEerEEEErEEeerrEEreRRErEEEEreREEreeereReeRerEEEEEErEEEeerreEerEEeerEEEEerEEeEreereErEeree

在线尝试！

— u_n已定义
source

5

16位x86汇编代码，24个字节

     47             inc    di
     B020           mov    al,20h
l1:  3806           cmp    [si],al
     7212           jb     l5 ;less means end of string
     7401           je     l2  ;equal means space was seen
     4F             dec    di ;overwrite extra space
l2:  E80300         call   l3
     46             inc    si ;move to next character in word
     75F1           jne    l1
l3:  56             push   si
l4:  3806           cmp    [si],al
     A4             movsb      ;copy character
     77FB           ja     l4  ;until either zero or space is seen
     5E             pop    si
l5:  C3             ret

调用si =指向源字符串的指针，di =指向输出缓冲区的指针。
源字符串需要一个零字节来结束。
代码在16位，32位或64位中相同（si / di变为esi / edi或rsi / rdi）。
由于扩展了调用，所以32位代码要大两个字节。
64位代码仍要大三字节，因为rsi / rdi的inc / dec会吸引一个前缀（但如果知道它们在32位内存空间内，则可以再次使用esi / edi以避免这种损失）。

— 彼得·弗里
source

4

MATL，18 16字节

"@gXH"HX@Jh)]0&h

输入是单词的单元格数组。在线尝试！

说明

"         % Implicit input: cell array of strings. For each cell
  @g      %   Push content of current cell, that is, a word
  XH      %   Copy into clipboard H
  "       %   For each letter
    H     %     Push word
    X@    %     Push iteration index
    Jh)   %     Index from that until the end into current word
  ]       %   End
  0       %   Push 0. Will be cast to char. Char(0) is displayed as space
  &h      %   Concatenate horizontally all elements so far. Implicit display

— 路易斯·门多
source

4

K4 / K（oK），9个字节

解：

,/'(1_)\'

在线尝试！

说明：

,/'(1_)\' / the solution
        ' / apply to each
       \  / scan
   (  )   / do this together
    1_    / drop first
,/'       / flatten (,/) each (')

— 街头小贩
source

4

C ++（clang），174字节

#include<map>
#include<string.h>
std::string r(std::string w){while(auto x=strchr(w.c_str(),32))return r(w.substr(0,x-w.c_str()))+" "+r(x+1);return w!=""?w+r(w.substr(1)):w;}

在线尝试！

这是我的第一次提交，我不知道是否返回字符串而不是打印它是可以的:)

— QJot
source

2

欢迎来到PPCG！是的，可以返回一个字符串。希望你坚持！

— Jo King

您可以使用不等式运算符的对称性删除空格，从而节省一个字节- return w!=""?可以是return""!=w?。

— 乔纳森·弗雷希

4

Stax，3个字节

m|]

运行并调试

说明：

m   Map over the lines
 |] Get all suffixes (suffices?)
    Implicit flatten and output

— 浪费
source

关于就足够了：en.wiktionary.org/wiki/suffices#Etymology_2

— chambln

3

木炭，14字节

⪫Ｅ⪪Ｓ ⭆ι✂ιμＬι¹

在线尝试！注意：尾随空格。链接是详细版本的代码。说明：

   Ｓ            Input string
  ⪪             Split on spaces
 Ｅ              Map over each word
      ι         Current word
     ⭆          Map over each character and join
        ι       Current word
         μ      Current index
           ι    Current word
          Ｌ     Length
            ¹   Literal 1
       ✂        Slice
⪫               Join with spaces
                Implicitly print

— 尼尔
source

3

C（gcc），79个字节

f(s,t)char*s,*t;{for(;*s;printf("%.*s",*s^32?t?t-s:~0:1,s),s++)t=strchr(s,32);}

在线尝试！

— 腹肌
source

3

点 `-s`，11字节

J_@>,#_Mq^s

从stdin中获取以空格分隔的单词列表。在线尝试！

说明

             s is space (implicit)
        q    Read a line of stdin
         ^s  Split it on spaces
       M     Map this lambda function to each word:
 _            The word...
  @>          sliced starting at index...
    ,#_       range(len(word))
              This creates len(word) slices ["word" "ord" "rd" "d"]
J             Join those into a single string
             The resulting list of modified words is printed; the -s flag uses space
             as the separator

— DLosc
source

3

Ruby，42个字节

->s{s.map{|a|(w=a.b).chars{a[0]='';w<<a}}}

在线尝试！

— 国标
source

3

Python 2，63个字节

lambda s:' '.join(map(g,s.split()))
g=lambda s:s and s+g(s[1:])

在线尝试！

— 场
source

在我的计算机（mac OS）上为64字节。

— aydinugur 18/09/21

3

画布，6 个字节

±［±］⇵］

在这里尝试！

5个字节的疯狂输出格式

— 宰马
source

3

C＃，111个 90字节

b=>string.Join(" ",(b.Split(' ').Select(x=>string.Concat(x.Select((y, i)=>x.Substring(i))))))

在线尝试！

通过将输入和输出更改为数组，我节省了一些字节：

b=>b.Select(x=>string.Concat(x.Select((y,i)=>x.Substring(i)))).ToArray()

在线尝试！

— LiefdeWen
source

3

K（oK），17 13字节

{,/|:'|,\|x}'

在线尝试！

前缀匿名功能；输入被视为字符串列表，而字符串列表又是字符列表。

感谢@streetster 4个字节。

怎么样：

{,/|:'|,\|x}' //Main function, argument x → ("ill";"eel")
            ' // For each element of the argument
         |x}  // Flip it. x → ("lli";"lee")
       ,\     // Concatenate each element, keeping intermediates. x → (("l";"ll";"lli");("l";"le";"lee")
      |       // Flip it again. x → (("lli";"ll";"l");("lee";"le";"l"))
   |:'        // Now flip each element. x → (("ill";"ll";"l");("eel";"el";"l"))
{,/           // Concatenation scan. x → ("illlll";"eelell")

— J·萨莱
source

您可以返回列表，也可以查看我的确定解决方案

— streetster

@streetster哦，太好了。我仍在学习K，因此我的解决方案不会像我想要的那么短或那么优雅。感谢您的注意！

— J.Sallé18年

在反向之前展平允许您省略“ reverse-each”，将其减小到10个字节： {|,/,\|x}'

— hoosierEE

3

普通Lisp，179字节

(defun r(s)(cond((endp s)nil)((eql(first s)#\Space)(princ " ")(r(rest s)))(t(q s)(r(rest s)))))(defun q (l)(cond((eql(first l)#\Space)t)((endp l)t)(t(princ(first l))(q(rest l)))))

在线尝试！

这是我第一次尝试打高尔夫球，欢迎任何修改

— 罗恩
source

您好，欢迎来到PPCG。删除空格可以节省29个字节。

— 乔纳森·弗雷希

@Johnathan Frech，谢谢我刚刚更新，没有空格

— JRowan

我想您错过了四个多余的空间。

— 乔纳森·弗雷希

您很可能也可以使用car代替first和cdr代替rest进一步进行提交。

— 乔纳森·弗雷希

不，现在好了，哈哈，也许病了回来，后来把它弄乱了。我现在只是学习口齿不清，现在我的老师说不要使用汽车和cdr，所以在我这样做的时候他们就不在我的脑海里了

— JRowan

3

Lua，70个字节

for i=1,#arg do x=arg[i]for i=1,#x do io.write(x:sub(i))end print()end

在线尝试！

说明

Lua中的参数存储在arg从索引1开始的表中。一元运算符#返回表的大小，函数s:sub(a,b)基于s由整数定界的字符串返回子字符串a和b，如果b不通过将返回字符串的其余部分。

我不得不使用io.write()而不是print()避免换行，并且print()出于相反的原因在末尾添加了。

— 马西奥·梅代罗斯（Marcio Medeiros）
source

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.