做些字母雨

54

字母雨

任务：

基本前提是打印出输入字符串，然后根据其在（不区分大小写）字母中的位置（0索引）垂直地重复每个字符A-Z。A在位置0处因此不重复，e在位置4处因此重复4次，P在位置15处因此重复15次，!不在位置处A-Z因此重复0次，等等。

为了清楚起见，超出范围的任何内容B-Zb-z（例如数字或特殊字符）将不会重复，因此只会出现在第一行。

这是代码高尔夫，因此每种语言中最短的解决方案是获胜者。

输入：

  • 输入将使用标准的可打印ASCII字符集，从32 到126 ~。
  • 输入字符串的长度为1个字符或更长。
  • 不会有任何前导或尾随空格。
  • 您可以将输入作为字符串（"hello"）或字符列表（["h", "e", "l", "l", "o"]）

例子：

输入的aaaa给出：

aaaa

输入的abcda给出：

abcda
 bcd
  cd
   d

输入Programming Puzzles & Code Golf!，得到：

Programming Puzzles & Code Golf!
Progr mming Puzzles   Code Golf
Progr mming Puzzles   Code Golf
Progr mming Puzzles    ode Golf
Progr mming Puzzles    o e Golf
Progr mming Puzzl s    o   Golf
Progr mming Puzzl s    o   Gol
Pro r mmin  Puzzl s    o    ol
Pro r mmin  Puzzl s    o    ol
Pro r mm n  Puzzl s    o    ol
Pro r mm n  Puzzl s    o    ol
Pro r mm n  Puzzl s    o    ol
Pro r mm n  Puzz  s    o    o
Pro r    n  Puzz  s    o    o
Pro r       Puzz  s    o    o
Pr  r       Puzz  s
 r  r        uzz  s
 r  r        uzz  s
             uzz  s
             uzz
             uzz
              zz
              zz
              zz
              zz
              zz

输入~|[abc<0>cba]|~，得到：

~|[abc<0>cba]|~
    bc   cb
     c   c

笔记：

  • 适用标准漏洞
  • 输出可以是字符串列表，但是：
  • 不允许多余的尾随换行符（\n可接受最后一行中的一行）
  • 输出可以是字符列表的列表，只要看起来像正在下雨的字符
  • 没有领先的换行符
  • 对于北欧用户，他们的“ AZ”字母中有一些多余的字母，可以随时为他们提供支持，但这并不是挑战的一部分
code-golf  string  alphabet 
— 街头小贩
source
2
是否可以接受一位领导 \n？
— 林恩
@Lynn，没有换行符，第一行应该是输入的字符串/字符列表-我将更新该帖子！
— streetster
18
FWIW，我认为它们看起来更像是冰柱，而不是雨
— Caird coinheringaahing 17-10-10
@cairdcoinheringaahing听起来几乎是喜庆的
— Pureferret
:( Just Nordic？
— 纯ASCII

Answers:

22

6502机器代码（C64），113字节

00 C0 20 FD AE 20 9E AD 85 FB 20 A3 B6 A0 00 84 FC B1 22 99 6F C1 C9 41 90 14 
C9 5B B0 04 E9 40 B0 0E C9 C1 90 08 C9 DB B0 04 E9 C0 B0 02 A9 00 99 6F C0 C5 
FC 30 02 85 FC C8 C4 FB D0 D3 A9 00 99 6F C1 A0 C1 A9 6F 20 1E AB A9 0D 20 D2 
FF A6 FC D0 01 60 C6 FC A0 00 B9 6F C1 F0 E6 BE 6F C0 D0 07 A9 20 99 6F C1 D0 
05 CA 8A 99 6F C0 C8 D0 E7

屏幕截图

在线演示

用法： sys49152,"[string]"例如sys49152,"Programming Puzzles & Code Golf!"。

重要：如果程序是从磁盘加载的（如在线演示中一样），请new首先发出命令！这是必需的，因为加载机器程序会浪费一些C64 BASIC指针。

注意：默认情况下，C64处于无小写字母的模式下-为了能够输入大小写混合的字符串，请先通过按SHIFT+ 切换到小写模式CBM。

说明

这是评论的反汇编清单：

         00 C0       .WORD $C000        ; load address
.C:c000  20 FD AE    JSR $AEFD          ; consume comma
.C:c003  20 9E AD    JSR $AD9E          ; evaluate expression
.C:c006  85 FB       STA $FB            ; store string length
.C:c008  20 A3 B6    JSR $B6A3          ; free string
.C:c00b  A0 00       LDY #$00           ; initialize counter
.C:c00d  84 FC       STY $FC            ; and number of "extra" lines
.C:c00f   .copyloop:                    
.C:c00f  B1 22       LDA ($22),Y        ; load next character
.C:c011  99 6F C1    STA .outbuf,Y      ; store to buffer
.C:c014  C9 41       CMP #$41           ; compare with 'a'
.C:c016  90 14       BCC .zerocount     ; smaller -> no repetition
.C:c018  C9 5B       CMP #$5B           ; compare with 'z'
.C:c01a  B0 04       BCS .checkupper    ; larger -> check for uppercase
.C:c01c  E9 40       SBC #$40           ; subtract 'a' ('a' - 1 and carry)
.C:c01e  B0 0E       BCS .cl_storecount ; and jump to store in repeat count
.C:c020   .checkupper:                  
.C:c020  C9 C1       CMP #$C1           ; compare with 'A'
.C:c022  90 08       BCC .zerocount     ; smaller -> no repetition
.C:c024  C9 DB       CMP #$DB           ; compare with 'Z'
.C:c026  B0 04       BCS .zerocount     ; larger -> no repetition
.C:c028  E9 C0       SBC #$C0           ; subtract 'A' ('A' - 1 and carry)
.C:c02a  B0 02       BCS .cl_storecount ; and jump to store in repeat count
.C:c02c   .zerocount:                   
.C:c02c  A9 00       LDA #$00           ; store 0 ...
.C:c02e   .cl_storecount:               
.C:c02e  99 6F C0    STA .repcount,Y    ; ... in repeat count
.C:c031  C5 FC       CMP $FC            ; compare with number of extra lines
.C:c033  30 02       BMI .cl_next       ; smaller -> go on with loop
.C:c035  85 FC       STA $FC            ; repeat count to number of extra lines
.C:c037   .cl_next:                     
.C:c037  C8          INY                ; next
.C:c038  C4 FB       CPY $FB            ; compare with string length
.C:c03a  D0 D3       BNE .copyloop      ; not yet reached? -> repeat
.C:c03c  A9 00       LDA #$00           ; terminate string in buffer
.C:c03e  99 6F C1    STA .outbuf,Y      ; with 0 byte
.C:c041   .outloop:                     
.C:c041  A0 C1       LDY #>.outbuf      ; output ...
.C:c043  A9 6F       LDA #<.outbuf      ; ...
.C:c045  20 1E AB    JSR $AB1E          ; ... string
.C:c048  A9 0D       LDA #$0D           ; and output ...
.C:c04a  20 D2 FF    JSR $FFD2          ; ... newline
.C:c04d  A6 FC       LDX $FC            ; load extra line count
.C:c04f  D0 01       BNE .ol_step       ; not zero -> go on
.C:c051  60          RTS                ; WE ARE DONE HERE ;)
.C:c052   .ol_step:                     
.C:c052  C6 FC       DEC $FC            ; decrease extra line count
.C:c054  A0 00       LDY #$00           ; initialize counter
.C:c056   .eraseloop:                   
.C:c056  B9 6F C1    LDA .outbuf,Y      ; load next character from buffer
.C:c059  F0 E6       BEQ .outloop       ; 0 byte? -> end of string, output
.C:c05b  BE 6F C0    LDX .repcount,Y    ; load repeat count for this characer
.C:c05e  D0 07       BNE .el_step       ; not 0 yet? -> jump to decrement
.C:c060  A9 20       LDA #$20           ; load code for space
.C:c062  99 6F C1    STA .outbuf,Y      ; store in current string position
.C:c065  D0 05       BNE .el_next       ; and jump to next loop iteration
.C:c067   .el_step:                     
.C:c067  CA          DEX                ; decrease repeat count ...
.C:c068  8A          TXA                ; ... and ...
.C:c069  99 6F C0    STA .repcount,Y    ; ... store back
.C:c06c   .el_next:                     
.C:c06c  C8          INY                ; increase counter ...
.C:c06d  D0 E7       BNE .eraseloop     ; and jump back to loop

.C:c06f   .repcount:
.C:c06f              .RES $100          ; 256 bytes for repeat count
.C:c16f   .outbuf:
.C:c16f              .RES $100          ; 256 bytes as buffer for output
— 费利克斯·帕尔门（Felix Palmen）
source
3
c64机器代码。我印象深刻
— Dschoni '17
@Dschoni谢谢，但这仍然是简单的代码（对我来说很有趣！）–您应该看一下演示现场，以获得真正令人印象深刻的C64作品；）
— Felix Palmen
如果我们继续得到这些，我们可能希望设置指向JavaScript C64模拟器的链接，以便人们可以看到它们运行。
— trlkly
1
@trlkly我的提交中有这样的链接，请单击“在线演示”;）
— Felix Palmen
14

05AB1E，13 12字节

,εDlAsk×}ζ»,

在线尝试！

说明

,             # print input
 ε      }     # apply to each char in input
  D           # duplicate
   l          # convert to lower case
    Ask       # get index of current char in the lower case alphabet
       ×      # repeat the char that many times
         ζ    # transpose with space as filler
          »,  # join on newlines and print
— 艾米尼亚
source
32
是否需要以小写字母获取char的索引？就是Ask这样
— Uriel
8

Pyth，12 10 9字节

.tm+*xGr0

测试套件。

说明：

.tm+*xGr0dddQ   Expanded program with autofilled input variable
  m      dddQ    For each character d in the input:
       r0d     get its lowercase variant
     xG        and return its 0-based index in the alphabet 
                   (-1 if not found, for special chars)
                (empty string for A/a and special characters)
    *     d    that many of the corresponding character
   +       d   and one more for good measure (because x is 0-indexed)
.t             Transpose it and fill blanks with spaces

12个字节：

j.t*VmxGr0d

（以换行符结尾）

测试套件。

说明：

j.t*VmxGr0d
QQ              Expanded program with autofilled input variable
Q               print the input verbatim
     m    dQ    For each character d in the input:
        r0      get its lowercase variant
      xG        and return its 0-based index in the alphabet 
                    (-1 if not found, for special chars)
   *V       Q   multiply the corresponding characters in (the second autofilled input)
                 by their alphabet indices we just calculated
                 (empty string for A/a and special characters)
 .t             Transpose it and fill blanks with spaces
j               Join the result on newlines
— 史蒂文·H
source
输出可以是人物的名单列表，只要它看起来像下雨字符 -因此你不需要j
— Xcoder先生
啊，你是对的！我之所以保留它，是因为12字节的版本逐字打印一行，而且我无法混合这样的格式，而且我忘了现在所有东西都在移调中，我可以删除它。谢谢！
— 史蒂文H.
8

Python 3，83个字节

f=lambda s,k=65:[*{*s}-{' '}]and[s]+f([[' ',c][91>ord(c.upper())>k]for c in s],k+1)

在线尝试！接受字符列表。返回字符列表。

Python 2，90个字节

f=lambda s,k=65:s.strip()and s+'\n'+f(''.join([' ',c][91>ord(c.upper())>k]for c in s),k+1)

在线尝试！取一个字符串。返回一个字符串。

— 林恩
source
7

Mathematica，115 89个字节

它需要作为input一个字符的列表 [{"a", "b", "c", "d", "a"}]和输出字符的列表的列表 

Thread[PadRight[Table[#,Max@Position[Alphabet[]/."a"->#,#|ToLowerCase@#]]&/@#]/. 0->" "]&

在线尝试！

来自Misha Lavrov的-26字节

来自user202729的-5个字节

但是，如果您想查看测试用例中的输出，请尝试使用此（128字节）代码
在线尝试！

— J42161217
source
对于未来的读者：“此答案仅适用于Mathematica ...”部分有点误导，问题是Mathematica仅在笔记本（REPL）模式下支持Unicode字符。在脚本模式下，它仅理解ASCII和已转换为ASCII的特殊字符（例如，∞（3个字节）-> \[Infinity]（11个字节））。
— user202729
@ user202729好的，我会编辑并向人们发送邮件，以阅读您的评论
— 谢谢
Mathematica的高尔夫建议（脚本模式）：（\[Infinity]11个字节）可以替换为Infinity（8个字节）或\:221e（6个字节）。最后一个是不带名称的特殊字符的默认表示。（尽管不是主要部分）
— user202729
我们可以Infinity完全避免。问题部分是If[(d=Min@Position[Alphabet[],If[UpperCaseQ@#,ToLowerCase@#,#]])==∞,1,d]，我们可以将其更改为Max@Position[Alphabet[]/."a"->#,#|ToLowerCase@#]。（在列表中进行搜索{#,b,c,d,...,y,z}，我们保证#至少会找到它一次。）
— Misha Lavrov
@MishaLavrov非常好。修复！
— J42161217
5

Python 2中，111 106 99 98 97 87 93字节

s=input()
i=65
while s.strip():print s;s=''.join([' ',c][91>ord(c.upper())>i]for c in s);i+=1

在线尝试！

— 场
source
while可以替换exec为保存几个字节，i可以以65开始保存多个字节以达到87字节
— Rod
OP表示不允许多余的尾随换行符，但是当输入不包含z或时，您的代码将打印其中的几个Z。
— 林恩
@Lynn固定，我忘了仔细检查exec更改...
— TFeld
5

C＃（.NET Core），162字节

s=>{string A="abcdefghijklmnopqrstuvwxyz",r=s;for(int i=-1;++i<s.Max(A.IndexOf);)r+='\n'+string.Concat(s.Select(c=>A.IndexOf(char.ToLower(c))>i?c:' '));return r;}

在线尝试！

— 内山山
source
2
欢迎使用PPCG，并且是一个很好的第一答案。您可以使用一些技巧来缩短代码。这是您的代码的更高级版本：在线尝试！。
— 伊恩H.17年
感谢您的评论，我以为我的代码必须是可执行的，因此我以这种假设为基础！感谢您的评论和指导。
— Nejosan
2
如果您想找到有关在C＃中打高尔夫球的更多技巧，请查看此文章，或查看现有的C＃答案。打高尔夫球快乐！
— 伊恩·
好答案。继续前进:)
— aloisdg说莫妮卡（Monica）将于
1
嗨，欢迎来到PPCG！很好的第一答案，尤其是现在已经打高尔夫球了。向我+1。顺便说一句，当前为180个字节，而不是162个。using System.Linq;不幸的是，必需的导入是强制添加到字节数中的（或者您应该Max将System.Linq.Max和更改Select为System.Linq.Max，这将比using System.Linq;一次简单地增加。）再次欢迎您，并祝您逗留愉快。哦，我看到了@IanH。已经提到了C＃中的高尔夫技巧。阅读所有语言的打高尔夫球技巧也可能很有趣。
— 凯文·克鲁伊森
4

Perl 5，43个字节

41个字节的代码+ 2个-nl。

$c=A;print,s/$c|[^a-z]/ /gi,$c++while/\S/

在线尝试！

— 唐·黑斯廷斯
source
1
环为[_0-9]个字符，也许s/["-$c]/ /gi和-l不需要
— 纳乌艾尔乌Fouilleul
@NahuelFouilleul啊，是的，我对测试用例的反应太快了。它们应该添加到OP中！：） 谢谢！+4 :(
— Dom Hastings
我的建议对32到126之间的任何字符都无效（非大于Z的Alpha）
— Nahuel Fouilleul
@NahuelFouilleul无法找到满足所有要求的更短方法...我会继续比赛...
— Dom Hastings
4

JavaScript（ES6），87 78 76字节

-9个字节，感谢@RickHitchcock。
-2个字节感谢@Neil。

f=(s,i=10)=>s.trim()&&s+`
`+f(s.replace(/./g,c=>parseInt(c,36)>i?c:" "),i+1)

将输入作为字符串并返回一个尾随换行符。

测试用例

显示代码段

— 贾斯汀·马里纳（Justin Mariner）
source
76个字节（尾随一个新行）： f=(s,i=10)=>s.trim()&&s+'newline'+f(s.replace(/./g,c=>parseInt(c,36)-i?c:" "),i+1)
— Rick Hitchcock
@RickHitchcock对于包含数字的输入字符串，这似乎无限循环：在线尝试！。但是，逐步更改为的想法s确实很好。
— 贾斯汀·马里纳
啊，好点。可以将其固定为2个字节：parseInt(c,36)-i>0
— Rick Hitchcock
1
@RickHitchcock您能不能parseInt(c,36)>i代替保存2个字节？
— 尼尔
@尼尔，du。贾斯汀：尼尔说了什么。
— 瑞克·希区柯克
4

R，118114字节

function(a)while(grepl("[^ ]",a)){F=F+1;cat(a,"\n");for(j in c("[^a-zA-Z]",letters[F],LETTERS[F]))a=gsub(j," ",a)}

感谢@Giuseppe为这4个字节

在线尝试！

简短说明：

function(a)
    while(grepl("[^ ]",a)){ #As long as the string is not just spaces.
        F=F+1 #Increment letter counter (F is FALSE, hence 0 by default)
        cat(a,"\n") #Print string
        for(j in c("[^a-zA-Z]",letters[F],LETTERS[F])) #Get rid of non-letters, and the current letter in lower and upper case
             a=gsub(j," ",a)
    }
— 浮游动物
source
哦，等等，潜在的问题：如果a所有空格都不会打印出任何内容...但是您可以将while条件更改为grepl()|!F比原始答案还短一个字节的条件。
— 朱塞佩
4

[R ，125个 123字节

远远超出了Plannapus

for(i in 1:max(p<-pmax(1,match(tolower(S<-el(strsplit(scan(,""),''))),letters),na.rm=T)))cat(ifelse(p<i," ",S),'\n',sep='')

在线尝试！

使用单行尾换行符输出到stdout并从中读取stdin()。

让我们分解一下：

S <- el(strsplit(scan,""))            # split the string to characters

m <- match(tolower(S),letters)        # 1-based index in letters (lowercase a-z)
p <- pmax(1,m,na.rm=T)                # parallel max, replaces NA (non-alphabet) or 0 with 1
for(i in 1:max(p)){                   # iterate
 cat(                                 # print
  ifelse(p<1,' ',S),                  # the corresponding letter in S if p>=1, space otherwise
  '\n',sep='')                        # newline, and no spaces between chars
}

替代答案，106字节

function(S)for(i in 1:max(p<-pmax(1,match(tolower(S),letters),na.rm=T)))cat(ifelse(p<i,' ',S),'\n',sep='')

在线尝试！

功能; 打印到stdout，但这基本上是我上面的回答，要求接受一个字符列表而不是拆分字符串，所以我感觉这是“作弊”。另外，plannapus使用正则表达式的方法非常简洁！

— 朱塞佩
source
3

Japt，15 14 11 10字节

第一次使用Japt的新字符串填充方法的机会，因此仍有改进的空间。

y_ùZInZu c

试试吧

说明

字符串的隐式输入U。

y_

U通过函数的每一列，Z当前元素（在此情况下为字母）在哪里。

InZu c

转换Z为大写（u），获取其字符代码（c），然后减去（u）64（I）。

ùZ

Z用其自身填充起点，直到达到该长度。

另类

y_ùZ9aZn36

试试吧

— 毛茸茸
source
但不能更改ùZ，以p保存A B ......没关系，这是真正聪明的...
— ETHproductions
@ETHproductions：我尝试了几次p（编辑历史记录中可能有1个），但ù最终还是赢了。
— 毛茸茸的
3

Haskell中，137个 136 127 119字节

import Data.Char
p c=last$0:[k|k<-[0..25],k+65==ord(toUpper c)]
f s=[[last$c:[' '|i>p c]|c<-s]|i<-[0..maximum$map p s]]

在线尝试！

相当长，但我想不出什么办法进一步缩短它。我觉得必须比if-then语法短一些，但我看不到。

编辑：感谢@streetster帮助我剃光了一个字节！起初我没有使用它toUpper是因为导入的成本，Data.Char但是我忘了它还提供ord了比导入短得多的导入fromEnum

编辑2：感谢@Laikoni减少了另外6个字节并确定了我现在已修复的错误。我使用26而不是25，因为我忘记了Haskell数组是包含在内的。然后我发现我可以使用last，而不是head这将允许我使用0:，而不是++[0]。

编辑3：再次感谢Laikoni这8个字节。我实际上已经忘记了那个空间。由于某种原因，Sublime Text会在没有它的情况下翻转出来，我忘记将其删除。我不知道允许使用行列表，我应该更仔细地阅读规则。

— 用户1472751
source
1
您可以小写输入，以避免必须先检查AZ和az然后进行修改吗？
— streetster
@streetster在haskell中，toLower和toUpper函数需要导入Data.Char，它花费的char数比保存的字符数多。TIO
— user1472751 '10 -10-10
1
您可能想看看Haskell打高尔夫球的技巧。例如if i>p c then ' ' else c可以缩短为last$c:[' '|i>p c]。
— Laikoni '17
还有两件事：里面没有多余的空间，[k | 并且允许返回行列表，因此您不需要unlines。最后，您可能对我们的Haskell聊天室感兴趣。
— Laikoni '17
3

Excel VBA，110字节

匿名VBE立即窗口功能，该功能将输入作为Variant\String范围内的预期类型，[A1]并使用它使VBE立即窗口中的字母下雨。

?[A1]:For i=1To 26:For j=1To[Len(A1)]:c=Mid([A1],j,1):d=Asc(UCase(c)):?IIf((d>64+i)*(d<91),c," ");:Next:?:Next

样品I / O

[A1]="qwertyuiop[]ASDFGHJKL:'zxcvbnm,./"
?[A1]:For i=1To 26:For j=1To[Len(A1)]:c=Mid([A1],j,1):d=Asc(UCase(c)):?IIf((d>64+i)*(d<91),c," ");:Next:?:Next
qwertyuiop[]ASDFGHJKL:'zxcvbnm,./
qwertyuiop   SDFGHJKL  zxcvbnm   
qwertyuiop   SDFGHJKL  zxcv nm   
qwertyuiop   SDFGHJKL  zx v nm   
qwertyuiop   S FGHJKL  zx v nm   
qw rtyuiop   S FGHJKL  zx v nm   
qw rtyuiop   S  GHJKL  zx v nm   
qw rtyuiop   S   HJKL  zx v nm   
qw rtyuiop   S    JKL  zx v nm   
qw rtyu op   S    JKL  zx v nm   
qw rtyu op   S     KL  zx v nm   
qw rtyu op   S      L  zx v nm   
qw rtyu op   S         zx v nm   
qw rtyu op   S         zx v n    
qw rtyu op   S         zx v      
qw rtyu  p   S         zx v      
qw rtyu      S         zx v      
 w rtyu      S         zx v      
 w  tyu      S         zx v      
 w  tyu                zx v      
 w   yu                zx v      
 w   y                 zx v      
 w   y                 zx        
     y                 zx        
     y                 z         
                       z
— 泰勒·斯科特
source
野蛮！！！它接缝你也可以让?A1:...
— LS_ᴅᴇᴠ
不幸的是，@LS_ᴅᴇᴠ []表示应将包含的字符串求值到工作簿中/作为工作簿的对象，因此[A1]调用可能不会减少为A1-否则将不会接受并打印范围中的初始输入[A1]；相反，这只会留下一个空行，并且所有后续行都将被打印出来
— Taylor Scott
Ups，您是对的...没注意到这一点！
— LS_ᴅᴇᴠ
3

PHP，69 78 77 85 + 1字节

for($c=A;!$c[1]&&~trim($s=&$argn);$s=eregi_replace("[^".++$c."-Z]"," ",$s))echo"$s
";

需要PHP <7。与管道一起运行-nR或在线尝试。

— 提图斯
source
@Shaggy感谢您指出。现在完成了。
— 泰特斯
为+1 $c=A;!$c[1];$c++。好东西！可悲的是extraneous trailing newlines are not allowed (single \n on final line is acceptable)。因此，对于所有不包含的字符串，它都会失败z。
— 克里斯托夫（Christoph）
1
@Christoph已修复
— Titus
2

Ruby，70 67 74字节

f=->s{puts s;(?b..?z).each{|c|s.gsub! /[^#{c}-z]/i,' ';puts s if s=~/\S/}}

感谢@TuukkaX指出可以删除一些括号（-3字节）

不幸的是，由于原始版本无法处理“ z”，因此我不得不添加7个字节。

调用它：

f.call('The quick brown fox jumps over the lazy dog!')
The quick brown fox jumps over the lazy dog!
The quick brown fox jumps over the l zy dog
The quick  rown fox jumps over the l zy dog
The qui k  rown fox jumps over the l zy dog
The qui k  rown fox jumps over the l zy  og
Th  qui k  rown fox jumps ov r th  l zy  og
Th  qui k  rown  ox jumps ov r th  l zy  og
Th  qui k  rown  ox jumps ov r th  l zy  o
T   qui k  rown  ox jumps ov r t   l zy  o
T   qu  k  rown  ox jumps ov r t   l zy  o
T   qu  k  rown  ox  umps ov r t   l zy  o
T   qu     rown  ox  umps ov r t   l zy  o
T   qu     rown  ox  umps ov r t     zy  o
T   qu     rown  ox  u ps ov r t     zy  o
T   qu     row   ox  u ps ov r t     zy  o
T   qu     r w    x  u ps  v r t     zy
T   qu     r w    x  u  s  v r t     zy
T    u     r w    x  u  s  v r t     zy
T    u       w    x  u  s  v   t     zy
T    u       w    x  u     v   t     zy
     u       w    x  u     v         zy
             w    x        v         zy
             w    x                  zy
                  x                  zy
                                     zy
                                     z
— 尼尔·斯莱特
source
可以删除lambda定义处的括号。+1。
— Yttsi
2

Oracle SQL，186字节

假设该字符串将t在column 的表中v：

WITH a(s,l)AS(SELECT v,64 FROM t UNION ALL SELECT REGEXP_REPLACE(s,'[^'||CHR(l+1)||'-Z]',' ',1,0,'i'),l+1 FROM a WHERE l<90)SELECT LISTAGG(RTRIM(s),CHR(10))WITHIN GROUP(ORDER BY l)FROM a

SQL小提琴

Oracle 11g R2架构设置：

CREATE TABLE t ( v ) AS
SELECT '~|[abc<0>cba]|~' FROM DUAL
/

查询1：

WITH a(s,l)AS(
  SELECT v,64 FROM t
UNION ALL
  SELECT REGEXP_REPLACE(s,'[^'||CHR(l+1)||'-Z]',' ',1,0,'i'),l+1
  FROM a
  WHERE l<90
)
SELECT LISTAGG(RTRIM(s),CHR(10))WITHIN GROUP(ORDER BY l)
FROM a

结果：

|      LISTAGG(RTRIM(S),CHR(10))WITHINGROUP(ORDERBYL) |
|-----------------------------------------------------|
| ~|[abc<0>cba]|~                                     |
|    abc   cba                                        |
|     bc   cb                                         |
|      c   c                                          |
— MT0
source
2

Haskell，98个字节

p c=sum[length[a..c]|a:e<-["B[","b{"],[c]<e]
f s=[[last$c:[' '|i>p c]|c<-s]|i<-[0..maximum$p<$>s]]

在线尝试！

用法示例：f "[Abc]"产生以下行的列表：["[Abc]"," bc "," c "]。使用putStr.unlines.f $ "[Abc]"了漂亮的印刷输出：

[Abc]
  公元前
   C

部分受 Now 启发，直接基于user1472751的Haskell答案。

以前的方法（100 99字节）

f s=[h|i<-[0..26],h<-[[(c:concat[c<$[a..c]|[a,e]<-["B[","b{"],c<e]++cycle" ")!!i|c<-s]],any(>' ')h]

在线尝试！

— 莱科尼
source
2

PowerShell中，122个 127字节

param($a)$a;(1..25|%{$i=$_;(-join([char[]]$a|%{(' ',$_)[$_-match'[a-z]'-and[math]::Max(0,($_-bor32)-96-$i)]})).TrimEnd()})-ne''

在线尝试！

短暂地感谢PowerShell如何在[char]和之间动态转换[int]，但长期以来却由于删除了多余的空格以及计算是输出空格还是字符的原因。

错误修复感谢beatcracker。

— AdmBorkBork
source
不幸的是，这在~|[abc<0>cba]|~测试用例上失败了。试试这个：param($a)$a;(1..25|%{$i=$_;(-join([char[]]$a|%{(' ',$_)[$_-match'[a-z]'-and[math]::Max(0,($_-bor32)-96-$i)]})).TrimEnd()})-ne''
— Beatcracker
@beatcracker好抓住。这是处理比较的聪明方法。谢谢！
— AdmBorkBork
2

爪哇8，151个 147 144 143 139字节

s->{String x="\n"+s;for(int i=64,t;++i<91;)for(char c:x.toCharArray())s+=(t=c&~32)>64&t<91&t>i|c<11?c:" ";return s.replaceAll("\\s+$","");}

说明：

在这里尝试。

s->{                   // Method with String as both parameter and return-type
  String x="\n"+s;     //  Temp-String (equal to leading new-line + input)
  for(int i=64,        //  Index-integer `i` (starting at 64)
          t;           //  Temp-integer
      ++i<91;)         //  Loop (1) from 'A' (65) to 'Z' (90) (inclusive)
    for(char c:x.toCharArray())
                       //   Inner loop (2) over the character of the array
      s+=(t=c&~32)>64  //    If the current character as uppercase is larger than 'A'
         &t<91         //    and smaller or equal to 'Z'
         &t>i          //    and larger than the current index
         |c<11?        //    or the current character is a new-line
          c            //     Append the current character to `s`
         :             //    Else:
          " ";         //     Append a space to `s` instead
                       //   End of inner loop (2) (implicit / single-line body)
                       //  End of loop (1) (implicit / single-line body)
  return s             //  Return the result,
    .replaceAll("\\s+$",""); 
                       //   after we've removed all trailing spaces and new-lines
}                      // End of method
— 凯文·克鲁伊森
source
2

q，42 37字节

{(+)max[m]$(m:1+mod[.Q.a?(_)x]26)#'x}

-5感谢街头霸王！

旧解决方案+说明：

{(+)max[m]$'(m:1+mod[.Q.a?lower x;26])#'x}


{                                        }  / lambda func
                     .Q.a?lower x           / get lowercase of input (ignores non-alpha values) and find (?) their index in "a...z" (.Q.a). non-alpha values return `26`
                 mod[.Q.a?lower x;26]       / get mod 26 of each index, this returns 0 where index is 26
            (m:1+mod[.Q.a?lower x;26])      / add 1 and assign to m
            (m:1+mod[.Q.a?lower x;26])#'x   / m and x conform, so we can take (#) m copies of each (') x at corresponding indices
    max[m]$'(m:1+mod[.Q.a?lower x;26])#'x   / get max of m, and pad each ($') of right-side list to that length
 (+)                                        / transpose the char matrix
— 乱涂
source
1
{(+)max[m]$(m:1+mod[.Q.a?(_)x]26)#'x}对于37岁，我不记得我在创建问题时是如何解决的，尽管可能非常相似！
— 街头小贩
@streetster，谢谢！更新。我不知道k _，所以我输入lower了q解释器并得到了k){$[~t&77h>t:abs@@x;.z.s'x;19<t;.z.s@. x;~t in 10 11h;'`type;_x]}。所以给我的答案在Q哈哈
— 乱写
1

SOGL V0.12，12 11 个字节

ā,{Z⁴UW1Χ∙┼

在这里尝试！

说明：

ā            push an empty array
 ,{          for each character in the input, pushing it
   Z           push the uppercase alphabet
    ⁴          push a duplicate of the character
     U         uppercase it
      W        find its index in that alphabet
       1Χ      get the maximum of that and 1
         ∙     repeat the character that many times
          ┼    append horizontally to that array
— 宰马
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.