ASCII大金字塔

25

介绍

公元前2600年，人们正在建造金字塔。他们已经成为金字塔的基础，但不知道如何继续。因此，他们打电话给您寻求帮助。

建造金字塔的规则非常简单。对于上一层以上的层，您需要做的就是遵循此分步指南：

  1. 切掉上一层的边缘。

  2. 在/角色上方，必须有一个\角色，反之亦然。这适用于除边缘以外的每个字符。

  3. 最左边的字符始终是a /，最右边的字符始终是\。

让我们以金字塔的基础为例：

//\/\/\\

我们切掉边缘，留下：

 /\/\/\

我们将正斜杠更改为反斜杠，反之亦然：

 \/\/\/

最左边的字符始终是a /，最右边的字符始终是a \，因此我们将其更改为：

 //\/\\

我们将此层放在上一层：

 //\/\\
//\/\/\\

我们继续进行操作，直到到达顶部（看起来像/\）。因此，最终我们得到：

   /\
  //\\
 //\/\\
//\/\/\\

这是您需要输出的。

任务

给定金字塔的基础（长度大于3），输出整个金字塔。您可以放心地假设最左边的字符是/，最右边的字符是\。您还可以假设基础的长度始终是偶数。允许使用尾随空格。只要金字塔保持原位，也可以使用前导空间。允许使用1个尾随和1个前导换行符。

测试用例

Input: /\\\
Output:
 /\
/\\\

Input: //\\///\/\
Output:
    /\
   /\\\
  /\///\
 ///\\\/\
//\\///\/\

Input: /////////////\
Output:
      /\
     /\\\
    /////\
   /\\\\\\\
  /////////\
 /\\\\\\\\\\\ 
/////////////\

这是代码高尔夫球，因此以最少的字节提交为准！

code-golf  string  ascii-art 
— 阿德南
source
让我想起了基本的细胞自动机。也许这将成为一个有趣的未来挑战？
— DoctorHeckle

Answers:

9

果冻，28 26 2524 字节

QṚ,QyḊḊṖṖj@QµÐĿµJ’⁶ẋ⁸żYṚ

-4个字节感谢Dennis

食谱：

QṚ,QyḊḊṖṖj@QµÐĿµJ’⁶ẋ⁸żYṚ - one argument: input()
Q  Q       Q             - set of Left=input(): "/\"
 Ṛ                       - reverse Left: "\/"
  ,                      - Left-pair-Right: ["\/","/\"]
     ḊḊṖṖ                - dequeue Left twice, then pop twice: input()[2:-2]
    y                    - translate Right with mapping in Left: swaps internal slashes
         j@              - join Right with separator Left (@ swaps operands)
            µ  µ         - chain separators to form a 1,1,1 chain of chains
             ÐĿ          - loop while results are unique and collect them
                J        - yield [1,...,len(Left=input())]
                 ’       - decrement: [0,....len(input())-1]
                  ⁶      - " "
                   ẋ     - repeat Left Right times: ["", " ", ...]
                    ⁸ż   - zip Right and Left (⁸ is the link's Left argument):
                                ...pads the loop results
                      Y  - joins Left with line-feeds
                       Ṛ - reverse Left

（配以柠檬水，这些金字塔适合口渴的工人）

在TryItOnline上制作自己的斜线金字塔，或尝试所有OP建议的品尝者

— 乔纳森·艾伦
source
11

Pyth- 27 26字节

按OP中给出的操作减少，直到重复，空白行就是这种情况。

j_.e+*kdb.ujXtPtPNK"\/")_K

测试套件。

— 马尔蒂森
source
8

Python 2，78个字节

f=lambda s,p='\n':(s[2:]and f('/%s\\'%s.translate('/\\'*128)[2:-2],p+' '))+p+s

输出字符串的递归函数。金字塔的每一层都附加到递归调用中，并位于其上方。p以换行符开头的前缀获得一个更多的空间来制作三角形。通过交换斜杠，截去前两个符号以及将其夹在左右斜杠中来生成下一层。

Python 3中可以通过做保存一个字节*99的translate，作为长度-256的要求被放弃了。

— 异或
source
巧妙使用翻译，但我们不必打印吗？
— 乔纳森·艾伦，
@JonathanAllan并非默认情况下，您只需要按照挑战说明进行输出即可。
— xnor
6

哈斯克尔，98 94 90 85字节

q=init.tail
s '/'='\\'
s _='/'
t#""=t++"\\\n"
t#l=(' ':t)#(s<$>q l)++t++l#""
("/"#).q

使用示例（注意：在Haskell中，文字字符串内的反斜杠必须转义 \\）：

*Main> putStr $ (("/"#).q) "//\\\\///\\/\\"
    /\
   /\\\
  /\///\
 ///\\\/\
//\\///\/\

简单的递归方法：#通过映射完成工作s，这会翻转/\在内部元素上和来完成。附加参数t跟踪缩进级别，并在每个递归调用上以空格扩展。

注意：#（-> l#""）的第二个递归调用直接跳转到基本情况，这只是添加的一种简短方法l，\和一个换行符，即它取代++l++"\\\n"。

编辑：@xnor保存5个字节。谢谢！

— 妮米
source
l++"\\\n"看起来像l#""。
— xnor
1
交换字符串中两个字符的一种有趣方法s是[c|x<-s,c<-"ab",c/=x]。
— xnor
@xnor：我已经尝试了很多方法来摆脱第二个问题++"\\\n"，但是错过了这个。谢谢！
— nimi
6

Python 3， 108 104 101 94 91 89 88字节

b,f='\/';p=lambda t,n='\n':(t[2:]and p(f+''.join(map({f:b,b:f}.get,t[2:-2]))+b,n+' '))+n+t

-7字节感谢XNOR（让我知道我们没有打印！）
-3感谢XNOR字节（以函数声明的声明外[D'OH]）
-1感谢字节丹尼斯（替换f,b='/\\'用b,f='\/'）

在ideone上进行测试。注意：输入已针对双反斜杠进行了调整（即使原始字符串以奇数个反斜杠结尾也无法使用）。

— 乔纳森·艾伦
source
您可以f,b='/\\'在函数外部共同声明。
— xnor
@xnor谢谢，我无法计数^^
— 乔纳森·艾伦
5

JavaScript（ES6），91 86字节

f=
(s,t=`
`)=>s[2]?f(`/${s.slice(2,-2).replace(/./g,c=>c>`/`?`/`:`\\`)}\\`,t+` `)+t+s:t+s
;
<input placeholder=Basis oninput=o.textContent=f(this.value)><pre id=o>
展开摘要

输出包括一个换行符。

— 尼尔
source
3

Ruby，80个字节

f=->s{s[-3]>?!&&f[" "+s.gsub(/^( *\/).|.(.$)?/){$1||$2||($&>?/??/:?\\)}]
puts s}

不打高尔夫球

f = ->s{
  s[-3] > ?! &&
    f[" " + s.gsub(/^( *\/).|.(.$)?/) {
      $1 || $2 || ($& > ?/ ? ?/ : ?\\)
    }]
  puts s
}

在ideone上查看：http：//ideone.com/HN0l0Y

— 约旦
source
我的身体不好，没f在体内看到
— Cyoce
3

批处理，137字节

@echo off
if %1==/\ goto g
set s=%1
set s=\%s:~2,-2%/
set s=%s:/=-%
set s=%s:\=/%
set s=%s:-=\%
call %0 %s% "%~2 "
:g
echo %~2%1

方便地使用%~2和%1意味着我不必在上花费字节setlocal。说明：由于Batch不会对空字符串执行替换，因此我们必须设置具有“错误”边缘的下一层，然后将其作为字符串替换的一部分进行更正。

— 尼尔
source
2

BASH（sed + sort）71 66字节

sed -rne':l;p;y|\\|1|;y|/|\\|;y|1|/|;th;:h;s|\\.(.*)./| /\1\\|;tl'|sort   
sed -rne':l;p;y|\\/|1\\|;y|1|/|;th;:h;s|\\.(.*)./| /\1\\|;tl'|sort

输入来自标准输入。
例：

echo '//\\' |sed -rne':l;p;y|\\|1|;y|/|\\|;y|1|/|;th;:h;s|\\.(.*)./| /\1\\|;tl'|sort

 /\
/\\\

说明：
-n-禁止自动打印
:l -和 tl分支回到起点，如果这条线是其他的东西比/\
p -打印此行
y|\\/|1\\|;y|1|/|-替换\用1，/用\，然后1用/
th;:h-测试和跳同一个地方，因此，只有在未来替代得到测试后来
s|\\.(.*)./| /\1\\|-替代削减，每边与公寓外面有两个{space}/和\
sort- space来之前，/所以这让一切都在正确的顺序

— 赖利
source
2

05AB1E，42 38 36字节

Dg;<FÐgÍ©£R®ÍN-£„/\‡'/ðN>׫«R'\«}r»

在线尝试！

说明：

# Read the input to the stack, loop for 0 .. len(input) / 2 - 1
Dg;<F
# Save the layer by pushing a copy on the stack, then push
# len(layer) - 2 to both the top of the stack and register_c
     ÐgÍ©
# a = pop(); b = pop(); push(b[0:a].reverse())
# This removes the last 2 characters and reverses
         £R
# push(register_c - 2 - N)
           ®ÍN-
# a = pop(); b = pop(); push(b[0:a])
# This removes the leading spaces and the first two slashes
               £
# Push "/\" and "\/" to the stack.
                 „/\Â
# Transliterate the slashes
                     ‡
# Add N+1 spaces and a / to the end of the (reversed) current layer
                      '/ðN>׫«
# Reverse the layer and add a \ to the end.
                              R'\«
# End the loop
                                  }
# Reverse the stack and join it with newlines. It is implicitly printed.
                                   r»

（感谢Emigna指出了DD -> Ð和DR -> Â）。

— 鲁德斯
source
Dg;GDðK¦¦¨¨„/\‡'\«R'/«ðN׫R}r»保存7个字节。
— Emigna
对我而言，这看起来完全不同，我认为您应该添加自己的答案:)。
— 鲁斯
1

出发300 276字节

package main
import(."regexp";."os")
func p(b string)string{
s:=MustCompile(`((\s*.)(\S*)(\S))`).FindStringSubmatch(b)
if s[3]!=""{r:=""
for _,c:=range s[3][1:len(s[3])-1]{r+=`\/`[c/64:c/46]}
return p(" "+s[2]+r+`\`)+s[1]+"\n"}
return s[1]+"\n"}
func main(){print(p(Args[1]))}

长版：

package main

import (
    "regexp"
    "os"
)

func pyramid(base string) string {
    m := regexp.MustCompile(`^((\s*\S)(\S*)(\S))\s*`).FindStringSubmatch(base)
    if len(m[3]) > 0 {
        reversed := ""
        for _, c := range m[3][1:len(m[3]) - 1] {
            if c == '/' {
                reversed += `\`
            } else {
                reversed += `/`
            }
        }
        return pyramid(" " + m[2] + reversed + m[4]) + m[1] + "\n"
    }
    return m[1] + "\n"
}

func main() {
    print(pyramid(os.Args[1]))
}
— 罗兰·伊利格（Roland Illig）
source
import(."regexp";."os")保存2个字节
— Sefa
@Sefa谢谢，我从中挤出了另外22个字节。
— 罗兰·伊利格
1

Perl，53 52字节

包括+1的 -p

使用STDIN上的输入运行，例如

./pyramid.pl <<< '//\\///\/\'

pyramid.pl：

#!/usr/bin/perl -p
s%^( *)/.(.*)..%"$1 \\$2/
"=~y|\\/|/\\|r.$&%e&&redo
— 吨·霍斯佩尔
source
1

05AB1E，31个字节

Dg;GDðK¦¦¨¨„/\‡'\«R'/«ðN׫R}r»

说明

Dg;G                        }    # for N in [1..len(input)/2-1]
    D                            # make a copy of previous layer
     ðK                          # remove all spaces
       ¦¦¨¨                      # remove first 2 and last 2 chars
           „/\‡                 # replace '/' with '\' and vice versa
                '\«              # add a backslash at the end
                   R             # reverse
                    '/«          # ad a slash at the end
                       ðN׫      # add N spaces
                           R     # reverse back
                             r»  # reverse stack and join on newline
                                 # implicitly print

在线尝试

— 艾米尼亚
source
1

> <> ，186 179 175 171字节

0&v &+1&<
  >i:0)?^~&2,:&v
v'/'~v?:-1<  }0<
o    >84*o^-$;?=@:&:&}:~<
\&::&{:@+$}1+[{l1-$-2*:&1+{
>}1-:?!v$:l2%?!vo
^o'/'v?~e  (*5a<
^o'\'< &   >~]a'\'oo{1+:^
  {$1- >:?!^

哦，这绝对是我最大的回答。

仍有可能要做一些高尔夫球运动（底部区域非常浪费）

在线尝试

— 龙卷风
source
0

Powershell，142个字节

function s($s){if($s.Trim()-eq'/\'){return $s}
$n=$s-replace'\\','#'-replace'/','\'-replace'#','/'-replace'\\.(.*)./',' /$1\'
(s($n))+"`n$s"
}
— 奥利弗·拉纳（Oliver Rahner）
source
0

C＃，250个字节

s=>{int j=s.Length/2,i=0;var l=new string[j];l[j-1]=s;while(++i<j){var n=l[j-i].Trim().Substring(1,l[j-i].Trim().Length-2);l[j-i-1]=new string(' ',i)+"/"+n.Replace("/","#").Replace(@"\","/").Replace("#",@"\").Substring(1,n.Length-2)+@"\";}return l;};

绝对可以打高尔夫球，但是我的大脑已经死了，所以我决定暂时保留它。

— 致命编码器
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.