打印升序/降序的拱门

28

我认为“拱形”是描述这种数字模式的最佳方法：

1234567887654321
1234567  7654321
123456    654321
12345      54321
1234        4321
123          321
12            21
1              1

正式定义的每一行都由数字1到9-n，(n-1)*2空格和数字9-n到1组成（其中n是当前行）。

您的任务是使用尽可能最短的代码编写一个小的脚本/程序，该脚本/程序在遵循以下限制的前提下打印上述模式：

  1. 您可能没有对整个模式进行硬编码。您最多只能对模式的一行进行硬编码。
  2. 您的程序必须在每行末尾打印换行符（\n或的任意组合\r）。

预备，准备，开始！

code-golf  ascii-art  number  kolmogorov-complexity 
— 内森·奥斯曼（Nathan Osman）
source
1
上一行还有其他小技巧，123456787654321因为它等于11111111^2 ;-)
— Egor Skriptunoff 2013年
3
@EgorSkriptunoff 11111111^2 == 123465787654321 != 1234567887654321（请注意重复8）
— Bob
这与“ 打印此钻石
— 彼得·泰勒
6
它看起来像个窗帘。
— 波动率

Answers:

9

杀伤人员地雷（18） 

k,⌽k←↑↑∘(1↓⎕D)¨⌽⍳8

说明：

  • 1↓⎕D：数字字符串（“ 0123456789”）减去其第一个元素
  • ↑∘(1↓⎕D)¨⌽⍳8：选择前[8..1]个字符（“ 12345678”，“ 1234567” ...）
  • ↑：格式为矩阵（用空格填充未使用的字符）
  • k,⌽k←：存储在中k，然后显示，k然后垂直镜像k
— 马里纳斯
source
4

Ruby：61个 50个字符

s="87654321";s.chars{|c|puts s.reverse+s;s[c]=" "}

样品运行：

bash-4.2$ ruby -e 's="87654321";s.chars{|c|puts s.reverse+s;s[c]=" "}'
1234567887654321
1234567  7654321
123456    654321
12345      54321
1234        4321
123          321
12            21
1              1
— 工作的人
source
4

Befunge-3 x 18 = 54

我觉得我必须做些真菌，因为我上次使用它已经太久了。这个问题感觉最适合该语言。

由于打印循环每个字符大约需要执行8个操作（计数样式有所不同），因此速度非常慢。 

80v >#v"12345678"<
>5 *^ >,#$:_$:1-:v
^2< 0p0+7\*48\_@#<
— 筱娜
source
4

JavaScript，71

s='1234567887654321',i=10;while(--i)console.log(s=s.split(i).join(' '))
— 史蒂夫沃尔利
source
s="1234567887654321";for(i=10;--i;)console.log(s=s.split(i).join(" "))对于70个字符，@ SteveWorley
— WallyWest
3

C，83个字符

main(a,b,n){
    for(a=12345678,n=1e8,b=n-a-1;a;a/=10)
        printf("%-8d%8d\n",a,b),
        b%=n/=10;
}
— 乌戈伦
source
3

蟒蛇2，75 62

它不会超越Volatility的答案，但是这是使用python可变字符串（bytearray）的另一种方法：

s=bytearray('1234567887654321')
for i in range(8):s[8-i:8+i]=i*'  ';print s

编辑

我找到了一个较短的版本，使用str.replace：

s='1234567887654321'
for c in s[8:]:print s;s=s.replace(c,' ')
— 巴蒂斯特·M。
source
3

Perl，41岁

加号-E开关。命令行上的字符总数：50

至少需要perl5版本10。

perl -E'say@!=1..8-$_,$"x(2*$_),reverse@!for-0..7'
— 阿蒙
source
我要说的是42，这是因为标准外观-E是程序的一字节加法。
— Timtech
3

Mathematica 92 85 67 54 51

方法＃1：（54个字符）使用行号，列号和距左右边缘的距离创建数组。

Grid@Array[If[#2<9,#2,17-#2]/.x_/;x+#>9:>" "&,{8,16}]

方法2：（67个字符）填充不断缩短的范围。

Print@@@Table[Join[k = PadRight[Range@i, 8, " "], Reverse@k], {i, 8, 1, -1}];

方法3：（85个字符）有选择地填充数组的每一行。

从8个空格字符的列表开始。将位置1和16替换为“ 1”；在位置2和15等处替换“ 2”。

p = 0; q = 16;
Print @@@Reverse@Rest@NestList[ReplacePart[#, {++p -> p, q-- -> p}]&,Array[" "&,q], 8];

方法＃4：（86个字符）有选择地清空数组的每一行。

p=8;q=9;
Print@@@NestList[ReplacePart[#,{p---> " ",q++-> " "}]&,Join[k=Range@8,Reverse@k],7];

方法5：使用字符串（92个字符）

p=8;s="12345678";
Print[#,StringReverse@#]&/@NestList[StringReplace[#,ToString@p-- ->  " "]&,s,7];
— 戴维
source
那个新的很漂亮！如果可以的话，我会再次+1。:-)顺便说一句，您可以删除()，并替换#1为#：Grid@Array[If[#2<9,#2,17-#2]/.x_/;x+#>9:>" "&,{8,16}]
— Mr.Wizard
感谢您的提示。是的，Array有时可以制作漂亮的表，而无需添加迭代器。
— DavidC
3

PHP，68

（受HamZa的回答启发）

for($n=8;$n;$r[]=$n--)echo str_replace($r," ","1234567887654321\n");

发挥以下事实：PHP的str_replace可以接受用于搜索的数组和用于替换的字符串，它将用给定的字符串替换数组中的每个项目。每次迭代后，将当前数字添加到搜索数组，将其从下一个循环中删除。

实际代码示例：http : //ideone.com/9wVr0X

— 拉玛先生
source
hehe nice +1
— HamZa
似乎并没有在中间放置正确数量的空格
— 森·海菲尔德
@nathanhayfield：怎么样？第一线具有0位，第二个有2，然后如图4所示，6，8，等等
— 美洲驼先生
不是当我在writecodeonline.com/php
— 森·
那是因为输出没有包装在<pre>标签中。当解释为html文本时，空格将被折叠并且换行符将被忽略，但是如果您查看源代码，则会看到其他内容。
— 拉玛先生先生2013年
3

万宝龙 165

@0
08
>0
LN
--
@0
:LN
}0}0}0}0
..SAPSSD0A
{0
:PS
}0
~~09
..//
<<@0
\\>0
&0//
--@1
@020
&0/\&0
@1
:SA
@0
}0
>0!!
--00@1
@0++//
+O/\@1
+O
:SD
}0@0
\\>0\/
--/\+O
@0..+O

伪代码：

MB():
    for x in 8..1:
        LN(x)
LN(x):
    SA(x)
    PS(x)
    SD(x)
    print "\n"
PS(x):
    print " "*(8-x)*2
SA(x):
    for n in 1..x:
        print n
SD(x):
    for n in x..1:
        print n
— 斯帕
source
2

Python 2.x- 73 65 63 61个字符

c=1;s='87654321'
while c<9:print s[::-1]+s;s=' '*c+s[c:];c+=1
— 特里
source
2

PHP，76

for($i=9;$i>1;){$r[]=$i--;echo str_replace($r,' ','1234567887654321')."\r";}
— 哈姆扎
source
2

K，28

-1_a,'|:'a:8$'{-1_x}\,/$1+!8

。

k)-1_a,'|:'a:8$'{-1_x}\,/$1+!8
"1234567887654321"
"1234567  7654321"
"123456    654321"
"12345      54321"
"1234        4321"
"123          321"
"12            21"
"1              1"

您可以将其推广为36： {-1_a,'|:'a:(#*m)$'m:{-1_x}\,/$1+!x}

k){-1_a,'|:'a:(#*m)$'m:{-1_x}\,/$1+!x} 5
"1234554321"
"1234  4321"
"123    321"
"12      21"
"1        1"
q)k){-1_a,'|:'a:(#*m)$'m:{-1_x}\,/$1+!x} 15
"123456789101112131415514131211101987654321"
"12345678910111213141  14131211101987654321"
"1234567891011121314    4131211101987654321"
"123456789101112131      131211101987654321"
"12345678910111213        31211101987654321"
"1234567891011121          1211101987654321"
"123456789101112            211101987654321"
"12345678910111              11101987654321"
"1234567891011                1101987654321"
"123456789101                  101987654321"
"12345678910                    01987654321"
"1234567891                      1987654321"
"123456789                        987654321"
"12345678                          87654321"
"1234567                            7654321"
"123456                              654321"
"12345                                54321"
"1234                                  4321"
"123                                    321"
"12                                      21"
"1                                        1"
— 马丁
source
2

Javascript，67个字符

受史蒂夫沃利（Steveworley）的回答启发（如果可以的话，我会发表评论）：

程式码片段

a='1234567887654321\n',b='',c=10;while(--c)b+=a=a.split(c).join(' ')
<a href="#" onclick="javascript:document.getElementById('output').innerHTML = b;">Display</a>
<pre id="output">...</pre>
展开摘要

最后一个换行符的存在确实遵循规则。

更新：通过删除括号（运算符优先级）削减2个字符，并通过删除不需要的空格削减1个字符

似乎这很困扰我，因为无论我尝试通过对一组代码进行非硬编码来缩短或简化的方法有多少种，其长度都保持不变，直到我让下面写的“我认为这很重要”规则适用为止。

（如果将打印视为在chrome控制台中执行打印后返回的内容）

— 索菲α2329
source
看起来不像其他答案，数字在右列未对齐。
— AL
@AL如果您读了协合btw的输出，则不需要警报。
— Sophiα2329
要对齐右列，join的字符串参数中应该有1个空格而不是2个空格。如果有2个空格，则在基于Chrome的浏览器警报中正确对齐。
— Qwertiy 2014年
我更新了您的帖子（应接受编辑），以在没有JS警报的摘要中显示结果，在这种情况下，只需要一个空格。
— AL
2

Brainfuck：542字节

-[----->+<]>--.+.+.+.+.+.+.+..-.-.-.-.-.-.-.>++++++++++.[->+++++
<]>-.+.+.+.+.+.+.+[-->+<]>++++..----[->++<]>-.-.-.-.-.-.-.>++++++++++.[->+++++
<]>-.+.+.+.+.+.[-->+<]>+++++....-----[->++<]>.-.-.-.-.-.>++++++++++.[->+++++
<]>-.+.+.+.+.--[--->++<]>--......-----[->++<]>-.-.-.-.-.>++++++++++.[->+++++
<]>-.+.+.+.-[--->++<]>--........++[-->+++<]>+.-.-.-.>++++++++++.[->+++++
<]>-.+.+.[--->++<]>--..........++[-->+++<]>.-.-.>++++++++++.[->+++++
<]>-.+.--[--->++<]>............[-->+++<]>++.-.>++++++++++.[->+++++
<]>-.-[--->++<]>..............[-->+++<]>+.
— 氯化钠
source
1

Mathematica，59岁

61使用我自己的想法：

Grid[Clip[#~Join~Reverse@#&@Range@8,{1,9-#},{," "}]&~Array~8]

或59，从戴维的答案中借用：

Grid@Array[Join[k=PadRight[Range[9-#],8," "],Reverse@k]&,8]
— 向导先生
source
根据您的输入，我只是使用Grid节省了4个字符。
— DavidC
1

哈斯克尔，84

某人改进的起点：

mapM_ putStrLn[let l=take(8-i)"12345678"++replicate i ' 'in l++reverse l|i<-[0..7]]

最有可能的部分是使l++reverse l观点变得自由，让我们摆脱let-statement，但是我会发现was ap，这需要导入。

— 筱娜
source
1

PostScript：105个字符

在PS中，字符串处理并不容易，但是可以使代码相对简单：

0 1 7{(1234567887654321)dup
8 3 index sub(              )0 6 -1 roll 2 mul getinterval putinterval =}for

版本稍长一些，为120个字符，但是可以通过将第二行开头的8替换为1到9范围内的任何数字来生成不同的数字弧：

/D{dup}def/R{repeat}def/P{=print}def
8 D -1 1{1 1 index{D P 1 add}R pop 2 copy sub{(  )P}R D{D P 1 sub}R pop()=}for pop
— 杜比先生
source
很高兴看到我不是唯一一个喜欢PostScript的人。
— AJMansfield
1

K 20

{x,'|:'x:|x$,\$1+!x}    

q)k){x,'|:'x:|x$,\$1+!x}8    
"1234567887654321"    
"1234567  7654321"    
"123456    654321"    
"12345      54321"    
"1234        4321"      
"123          321"    
"12            21"    
"1              1"
— ppp
source
1

TSQL 148

编辑：根据manatwork的建议降至148，并调整为ORDER BY。

可读性：

WITH t AS(
    SELECT 1n, CAST(1 AS VARCHAR(MAX)) o
 UNION ALL
    SELECT n+1,o+CHAR(n+49)
    FROM t
    WHERE n<8
)
SELECT o  + SPACE(16-2*n) + REVERSE(o)
FROM t
ORDER BY 1 DESC

打高尔夫球：

WITH t AS(SELECT 1n,CAST(1AS VARCHAR(MAX))o UNION ALL SELECT 1+n,o+CHAR(n+49)FROM t WHERE n<8)SELECT o+SPACE(16-2*n)+REVERSE(o)FROM t ORDER BY 1DESC

输出：

1234567887654321
1234567  7654321
123456    654321
12345      54321
1234        4321
123          321
12            21
1              1
— 舒适地
source
1
好东西。但是，您能否也以计数153个字符的格式发布？无论如何，您可以使用数字1而不是'1'立即cast插入的字符串来保留2个字符varchar。这给了我149个字符：with t as(select 1n,cast(1as varchar(max))o union all select n+1,o+char(n+49)from t where n<8)select o+space(16-2*n)+reverse(o)from t order by o desc。
— manatwork 2013年
@manatwork：我无法复制153号，因为我一直在降低。不过应用了您的建议。谢谢！
— comfortablydrei
1

哈斯克尔，79

r n x|x>n=' '|True=x
t="87654321"
main=mapM(putStrLn.(`map`("12345678"++t)).r)t

这可以通过用替换字符> n来实现' '，其中字符n源自“ 87654321”（恰好是要执行替换的字符串的尾部）。

— 乔伊·亚当斯（Joey Adams）
source
1

PHP：61个字符（如果用真实的ASCII换行符替换\ n，则为60个字符）

（灵感来自GigaWatt和HamZa的回答）

for($n=9;$n;$r[$n--]=" ")echo strtr("1234567887654321\n",$r);

http://ideone.com/FV1NXu

— 布韦比
source
1

的PowerShell：38

打高尔夫球的代码

8..1|%{-join(1..$_+"  "*(8-$_)+$_..1)}

演练

8..1|%{...将}8到1的整数传递给ForEach-Object循环。
-join(... )将嵌套代码的输出连接到没有定界符的单个字符串中。
1..$_输出循环中从1到当前整数的整数。
+" "*(8-$_)在输出中添加一个双倍空格乘以8与当前整数之间的差。
+$_..1将从当前整数降到1的整数添加到输出中。

— 伊齐
source
1

带lambdas的JavaScript，147

(s="12345678")[r="replace"](/./g,i=>s[r](RegExp(".{"+(i-1)+"}$"),Array(i*2-1).join(" ")))[r](/\d{1,8} */g,m=>m+(Array(m%10+1).join(m%10+1)-m)+"\n")

可以在Firefox中检查。

— Qwertiy
source
1

CJam，22个字符

这不是有效的答案（因为语言是在问题之后发展起来的），也不是最短的答案，但是这里有：

8,{S*_,9-~,:)\_2$W%N}%

在这里在线尝试

— 优化器
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.