从1到n的数字交织,相同的数字反转


34

一个简单的:

取小于1000 的正整数n,并输出从1n的整数与从n1的整数交织在一起。您必须连接数字,以便它们之间没有任何定界符出现。

测试用例:

n = 1
11

n = 4
14233241

n = 26
12622532442352262172081991810171116121513141413151216111710189198207216225234243252261

n = 100
110029939849759669579489399210911190128913881487158616851784188319822081218022792378247725762675277428732972307131703269336834673566366537643863396240614160425943584457455646554754485349525051515052495348544755465645574458435942604161406239633864376536663567346833693270317130722973287427752676257724782379228021812082198318841785168615871488138912901191109299389479569659749839921001

这是因此每种语言中以字节为单位的最短提交胜出。鼓励解释。

Answers:


16

JavaScript(ES6),30个字节

f=(n,k=1)=>n?f(n-1,k+1)+n+k:''

怎么样?

这非常简单,但是值得注意的是,字符串是从尾到头构建的。开头的空字符串会附加在最后,并允许将最终结果强制转换为字符串。

以下是的递归的详细信息f(4)

f(4) =                                            // initial call
f(4, 1) =                                         // applying the default value to k
f(3, 2) + 4 + 1 =                                 // recursive call #1
(f(2, 3) + 3 + 2) + 4 + 1 =                       // recursive call #2
((f(1, 4) + 2 + 3) + 3 + 2) + 4 + 1 =             // recursive call #3
(((f(0, 5) + 1 + 4) + 2 + 3) + 3 + 2) + 4 + 1 =   // recursive call #4
((('' + 1 + 4) + 2 + 3) + 3 + 2) + 4 + 1 =        // n = 0 --> end of recursion
'' + 1 + 4 + 2 + 3 + 3 + 2 + 4 + 1 =              // final sum
'14233241'                                        // final result

测试用例


10

Python 2,46个字节

lambda n:''.join(`x+1`+`n-x`for x in range(n))

感谢ovs 4个字节

在线尝试!

说明:

lambda n:''.join(`x+1`+`n-x`for x in range(n))
lambda n:                                      # anonymous lambda taking one parameter n
                 `x+1`+`n-x`                   # `x` is repr(x) which is equivalent to str(x) for integers less than INT_MAX
                            for x in range(n)  # integers x in [0, n)

1
Python 3中增加了两个字节:f'{x}{n-~-x}'
L3viathan '17

2
@ L3viathan这是3.6中新增的功能。
Mego

1
Python 3.6不是Python 3吗?
L3viathan '17

6
lambda n:''.join('x+1'+'n-x'for x in range(n))为46个字节。('用反引号代替列表理解中的内容)
ovs

6
@ovs嘿,您可以跳过反引号-> `\`x+1\``渲染至`x+1`
Rod


7

Bash,25个字节

printf %s`seq $1 -1 1|nl`

在线尝试!

打印顺序减少,行数增加,printf连接行

用空格分隔的20个字节:seq $ 1 -1 1 | nl | xargs


如果那是不可接受的,我可以再更改seq $1 -1 1|nl|tr -d ' \n\t'8个字节
marcosm

1
20字节提交无效。我赞成25字节提交。
Digital Trauma

正如Digital Trauma所说,20字节的解决方案是无效的。
暴民埃里克(Erik the Outgolfer)'17年

time printf %s'seq 1000000 -1 1|nl'; grep name /proc/cpuinfo real 0m7.985s user 0m6.092s sys 0m0.392s model name : Intel(R) Pentium(R) D CPU 3.00GHz model name : Intel(R) Pentium(R) D CPU 3.00GHz
marcosm '17

7

R,35个字节

n=scan();cat(rbind(1:n,n:1),sep="")

在线尝试

rbind(1:n,n:1)创建一个2行矩阵,第一行从1到n,第二行从n到1。该cat功能崩溃这个矩阵,向下读取每列。


1
请注意,这仅在交互模式下有效,并且要求用户n在命令行上输入(而不是通过stdin进行传递)。
Shadowtalker

@ssdecontrol是的,我认为通常是允许的,但是我在这里还很新,可能是错误的。
user2390246

我认为这是普遍接受的,但NB,正确的TIO运行它,你必须把在页脚字段输入(S)(它总是好的,包括一个链接!)tio.run/nexus/...
朱塞佩·

6

05AB1E6 5字节

使用rev建议的内置新交错方式保存字节

LÂ.ιJ

在线尝试!

说明

L        # range [1 ... input]
 Â       # create a reversed copy
  .ι     # interleave the lists
    J    # join

建议使用名称为rev的用户LÂ.ιJ
乔纳森·弗雷希

@JonathanFrech:我知道现在的共识是我们可以使用比挑战更新的功能,但是我通常不愿意编辑旧答案,因为新的内置功能可以更好地完成挑战。有很多答案可以通过这种方式加以改进:)
Emigna

好吧,我只是信使。可能@rev应该发布自己的答案。
乔纳森·弗雷奇

@JonathanFrech:我并不是说这是责备。Rev建议编辑时做得正确,因为编辑现有答案比发布新答案要好。至少在提出建议时,我真的应该会更好地解决旧的答案。
Emigna

4

CJam,10个字节

ri,:)_W%]z

在线尝试!

说明

ri   e# Read input and convert to integer N.
,    e# Turn into range [0 1 ... N-1].
:)   e# Increment to get [1 2 ... N].
_W%  e# Duplicate and reverse the copy.
]    e# Wrap both in an array to get [[1 2 ... N] [N ... 2 1]]
z    e# Transpose to get [[1 N] [2 N-1] ... [N-1 2] [N 1]]
     e# This list is printed implicitly at the end of the program,
     e# but without any of the array structure (so it's essentially flattened,
     e# each number is converted to a string and then all the strings
     e# are joined together and printed).

4

Ruby,29个字节

->n{n.times{|x|$><<x+1<<n-x}}

说明:

->n{n.times{|x|                # x in range [0..n-1]
               $><<            # output on console
                   x+1<<n-x}}  # x+1, then n-x

在线尝试!


4

空格,71字节

   
 
 	
		 
 			
  
 
	   	
	    
 	
 	 
	 
 	
 	   	
	  	 
 
	 	

 


在线尝试!

说明

sssn  ; push 0 - seed the stack with 0 (this will be our 1->n counter, a)
sns   ; dup
tntt  ; getnum - read n (stored on the heap)
sns   ; dup
ttt   ; retr - pull n onto the stack (this will be our n->1 counter, b)
nssn  ; label 'loop'
snt   ; swap - bring a to the top
ssstn ; push 1
tsss  ; add - increment a
sns   ; dup
tnst  ; putnum - output a as a number
snt   ; swap - bring b to the top
sns   ; dup
tnst  ; putnum - output b as a number
ssstn ; push 1
tsst  ; sub - decrement b
sns   ; dup
ntstn ; jez 'exit' if b is 0
nsnn  ; jmp 'loop'

需要第一对指令来正确设置堆栈,Whitespace的输入命令将写入堆栈,因此我们需要将b(输入值)复制回堆栈。我们从a = 0开始,因为它声明0而不是1(节省一个字节)要短一些,并且我们只需要对递增指令进行重新排序即可。之后,我们仅循环并递增a,输出a,输出b,将b减1,直到b达到0(在减量后检查)。


如果您删除了所有尾随空白,则可能会打得更多:P
cat

4

Haskell,65 48 47字节

感谢Laikoni,节省了1个字节:

f n=show=<<(\(l,r)->[l,r])=<<zip[1..][n,n-1..1]

感谢nimi,节省了6个字节:

f n=show=<<(\(l,r)->[l,r])=<<zip[1..n][n,n-1..1]

先前的答案和解释:

f n=concatMap show$concatMap(\(l,r)->[l,r])(zip[1..n][n,n-1..1])

这里已经有了更好的Haskell答案,但是我对Haskell和代码高尔夫都是陌生的,所以我也可以发布它:)

此函数将列表[1..n]反向压缩,形成一个元组列表。

[(1,n),(2,n-1),(3,n-2)..(n,1)]

然后它用于concatMap将lambda映射到该元组列表,从而生成列表列表...

[[1,n],[2,n-1],[3,n-2]..[n,1]]

...并将其串联。

[1,n,2,n-1,3,n-2..n,1]

然后,final concatMap映射show到该列表并将其连接为单个字符串。

f 26 "12622532442352262172081991810171116121513141413151216111710189198207216225234243252261"


2
infix函数=<<与(在monad列表中)相同concatMapf n=show=<<(\(l,r)->[l,r])=<<zip[1..n][n,n-1..1]
nimi

1
1)您当前的解决方案只有48个字节。2)你可以删除n[1..n]网上试试吧!
Laikoni '17

1)当当偏离一错误... 2)好电话!
丹·安布罗焦

3

Pyth,7个字节

jksC_BS

在线尝试:演示

说明:

jksC_BSQ   implicit Q (=input number) at the end
      SQ   create the range [1, ..., Q]
    _B     bifurcate by inversion, this gives [[1, ..., Q], [Q, ..., 1]]
  sC       zip and flatten result
jk         join to a string


3

Perl 6,20个字节

{[~] 1..*Z~($_...1)}

测试一下

输入100000,大约需要10秒钟,包括编译和打印输出。

展开:

{                # bare block lambda with implicit parameter 「$_」

  [~]            # reduce using concatenation operator 「&infix:«~»」
                 # (shorter than 「join '',」)

    1 .. *       # Range from 1 to infinity

    Z~           # zip using concatenation operator

    ( $_ ... 1 ) # deduced sequence starting at the input
                 # going down to 1
}

Z~需要~,因为否则产生清单将与空间字符串化的列表。

无需将范围限制为从1开始,因为Z在任何输入列表用完时都会停止。
这样可以节省两个字节(后面需要一个空格$_


3

Java 61字节

(int n)->{for(int i=0;i<n;System.out.print(i+1+""+(n-i++)));}

2
另外,欢迎来到PPCG!:)
Stewie Griffin

我们允许匿名函数,因此(int n)->{//for loop}应该在这里工作。
内森·美林

那个更好吗?
cheemcheem

2
是的 您可能会将您System.out.print()放在for循环的最后一个语句中,但是由于您使用了i两次(因此需要在表达式中增加它),因此它变得很复杂。
内森·美林

我将打印内容放入循环中,并在最后一个可能的位置将i递增,然后通过测试用例进行检查以确保其有效,谢谢@NathanMerrill
cheemcheem

3

果冻,5个字节

RṚĖVV

在线尝试!

怎么运行的

RṚĖVV  Main link. Argument: n

R      Range; yield [1, ..., n].
 Ṛ     Reverse; yield [n, ..., 1].
  Ė    Enumerate; yield [[1, n], ..., [n, 1]].
   V   Eval; convert each flat array to a string, interpret it as a Jelly program,
       and yield the output. This concatenates the integers in each pair, yielding
       a flat array of integers
    V  Repeat the previous step, concatenating the intgegers from before.


2

Clojure,61个字节

#(let[a(range 1(+ 1 %))](apply str(interleave a(reverse a))))

从字面上看是做什么的。我相信可以通过一个不那么琐碎的解决方案来解决它。

在线观看


2

Aceto25 22字节

)&
pX`=
(pl0
id@z
r}Z)

说明:

我们读取一个整数并将其放在两个堆栈中。

id
r}

一方面,我们调用range_up(Z),另一方面,调用range_down(),z然后设置一个捕获标记,以便以后可以返回到该位置:

  @z
  Z)

然后,我们检查当前堆栈是否为空,如果是,则退出:

 X`=
  l0

否则,我们将从两个纸堆中打印并跳回到捕捉标记:

)&
p
(p

2

R,41个字节

pryr::f(for(i in 1:x){cat(i);cat(x-i+1)})

pryr::f()创建一个需要一个输入的函数。循环1:x并打印的每个元素1:x以及的每个元素x:1。打印到STDOUT。


+1,很好地使用pryr
Shadowtalker,

@ssdecontrol几乎替代了function(x):)
JAD


2

MATL,13 11 9字节

@Luis节省了2个字节

:tPv1eVXz

MATL Online上尝试

说明

        % Implicitly grab input as a number, N
:       % Create an array from 1..N
tP      % Create a reversed copy
v       % Vertically concatenate the two
1e      % Reshape it into a row vector
V       % Convert to a string
Xz      % Remove whitespace and implicitly display

@LuisMendo啊!我以为有一个删除空白但找不到的功能。谢谢!
Suever

2

PHP,36 35 29字节

for(;$argn;)echo++$i,$argn--;

感谢JörgHülsermann,节省了一个字节。
感谢克里斯多夫,节省了六个字节。


3
嗯... for(;$argn;)echo++$i,$argn--;
克里斯托夫(Christoph)

2

Scala,43个字节

这不是最好的,但这是我第一次打高尔夫。

n=>1.to(n).foldLeft("")((s,x)=>s+x+(n-x+1))

2

V,20字节

ywo1@"­ñykPjñkògJ

在线尝试!

说明:

yw                    ' Copy the input number (for looping later)
  o1                 ' Insert a 1 under the input (on a newline)
     @"               ' [Copy register] number of times
       ­ñ      ñ       ' Do the thing inside of this loop
        ykP           ' Copy the current line and line above it, and paste above both
           j        ' decrement the current (top) number, and increment the one below
               k      ' Go to the top line
                ògJ   ' recursively join all of the lines

2

Cubix,17个字节

....1I>sO)su.@?(O

在线尝试!

小结:

    . .
    . .
1 I > s O ) s u
. @ ? ( O . . .
    . .
    . .

1入,读入输入(I),然后进入循环,该循环交换堆栈的顶部,输出,递增,交换,输出堆栈的顶部,递减,如果堆栈的顶部为0,则停止。



2

MathGolf,5个字节

{îkï-

在线尝试!

说明:

{      Run a for loop over implicit input
 î     Push 1 based index of loop
  k    Push inputted number
   ï-  Subtract 0 based index of loop
       Implicitly output all this joined together

1
我已经能够找到13个节目长度为5的其中产生相同的结果:╒{ïí,╒{ïk,╒{íï-╒{kï-╒{┐í,╒{┐k,╒x{î\ {îïí,{îïk,{îíï-{îkï-{î┐í,{î┐k,。但是,我找不到任何长度为4或更短的程序。我还没有进行完整的搜索,但是5个字节对于MathGolf来说是最佳选择。
maxb


2

鼠标2002年32 30个字节

-2有条件地移动到循环的开始(z.^ ... )而不是(... z.0>^)

?n:n.z:(z.^a.1+a:a.!z.!z.1-z:)

在线尝试!

说明:

?n:                                 ~ get input and store in n
   n.z:                             ~ copy n into z
       (z.^                         ~ stop if z equals 0
           a.1+a:                   ~ add 1 to a
                 a.!                ~ print a
                    z.!             ~ print z
                       z.1-z:)      ~ substract 1 from z

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.