这是楼梯号码吗？

15

挑战：

检查给定数量的形成number staircase与否

输入：

整数（大于0而不是十进制）。注意：您可以将输入作为字符串，数字数组。

输出：

真/假值，具体取决于数字是否形成阶梯

数字楼梯：

一数楼梯的是，从左向右读时的整数：

  • 从1开始
  • 随后可能是2
  • 随后可能是3
  • 直到 n
  • 然后数字从n-1开始下降
  • 然后n-2
  • 然后n-3
  • 依此类推，直到达到1

注意 ：

的可以是部分被用于表明，如果长度>大于1如果它是顺序必须遵循原样。即：12321

范例：

12321                          ---> true
12345654321                    ---> true
9                              ---> false
1                              ---> true
2                              ---> false
123421                         ---> false
112312318901323                ---> false
123456789101110987654321       ---> true

注意 ：

给定的输入将始终是大于0的整数，并且不是十进制。您的输出必须是一个truthy or falsy值，具体取决于输入

限制条件：

这是代码高尔夫球，因此以字节为单位（针对每种编程语言）的最短代码为准。

code-golf  math  number  decision-problem 
— 穆罕默德·萨勒曼
source
2
我们可以将输入作为数字列表吗？像[1,2,3,4,5,6,7,8,9,1,0,1,1,1,0,9,8,7,6,5,4,3,2,1]为123456789101110987654321？
— Xcoder先生18年
@ Mr.Xcoder：如果您没有，我更愿意，但我想您可以
— Muhammad Salman
输入有上限吗？
— mypetlion 18'Apr
@mypetlion：并非如此，它可以支持您的代码（不包括硬编码和特意为低的代码）。通常，您的语言可以支持的最高语言（但在这种情况下不支持）
— Muhammad Salman
我们可以将字符串作为函数的输入吗？（或者这是完整程序的唯一可接受输入？）
— Jonathan Allan

Answers:

5

R，97字节

function(n)"if"(n>1,{while({T=T+1;x=paste(c(1:T,T:2-1),collapse="");nchar(x)<nchar(n)})0;x==n},T)

在线尝试！

取n为a character或an integer; character对于无法精确保留为64位的整数，使用会给出正确的结果double。

生成楼梯编号，直到找到至少与该编号一样长n的编号，然后测试是否相等。

相当于：

function(n)
    if(n > 1){
        T <- T + 1
        x <- paste(c(1:T,T:2-1),collapse="")
        while(nchar(x) < nchar(n)){
            T <- T + 1
            x <- paste(c(1:T,T:2-1),collapse="")
        }
        return(x == n)
    } else
        return(TRUE)

— 朱塞佩
source
会不会更换function(n)有n=scan();短？（当然是整数）
— pajonk
@pajonk我想是这样。但是我会说我将其作为字符串使用，因此此答案对于较大的输入是正确的。
— 朱塞佩
3

JavaScript（ES6），62 57字节

@ l4m2节省了2个字节

返回一个布尔值。

f=(s,k=1)=>(m=s.match(`^${k}(.*)${k}$`))?f(m[1],k+1):s==k

在线尝试！

怎么样？

从k = 1开始，我们在字符串的开头和结尾处寻找k，然后用k + 1递归地迭代剩余的中间子字符串上的过程。一旦没有匹配项，递归就会停止。如果最后一个子字符串等于k，则输入为阶梯数。

s =“ 1234321”的示例：

 k | s         | match     | s == k 
---+-----------+-----------+--------
 1 | "1234321" | 1(23432)1 | no     
 2 | "2343"    | 2(343)2   | no     
 3 | "343"     | 3(4)3     | no     
 4 | "4"       | null      | yes
— Arnauld
source
55个字节。假设0为真实，而null为虚假（他没有完全指定他是否做了）
哼，我没有发现那是无效的猜测。抱歉
@我不担心！有趣的是，删除m[0]==s&它会使它通过所有测试用例（但在其他测试用例上仍然失败"123217"）。
— Arnauld
f=(s,k=1)=>(m=s.match(`^${k}(.*)${k}$`))?f(m[1],k+1):s==k？
— l4m2
2

Pyth，13 12字节

/mjk+Sd_Stdl

多亏了RK，节省了一个字节。
在这里尝试

说明

/mjk+Sd_Stdl
 m         lQ   For each d up to the length of the (implicit) input...
    +Sd_Std     ... get the list [1, 2, ..., d, d-1, ..., 1]...
  jk            ... concatenated.
/               Count how many times the input appears.

如果您确实希望输入为整数，则可以改用输入}Qmsjk+Sd_Std，但这太慢了。

您可以使用/，而不是}Q使之自动填充Q在最后
— RK。
2

C＃（Visual C＃中交互式编译器），138个 107 102字节

bool t(List<int>s)=>s.Select((j,i)=>s[0]==1&&s.Last()==1&&(i==0||j+1==s[i-1]||j-1==s[i-1])).All(x=>x);

在线尝试！

说明： 

bool t(List<int>s)=>
    s.Select((j,i) =>         //iterate over each item and store the return value
        s[0]==1&&s.Last()==1  //does the sequence start and end with 1?
        &&                    //AND
        (i==0                 //is it the first item?
        ||                    //OR
        j+1==s[i-1]           //is the item 1 greater than the previous?
        ||                    //OR
        j-1==s[i-1])          //is the item 1 smaller than the previous?
    ).All(x=>x);              //did all pass the criteria?
— 卡哈扎尔
source
实际上，Zip...Skip我之前的评论中的方法在上失败[1,1]，true如果我了解规范，该方法应该返回。我已经删除了
— benj2240 '18年
不管怎么说，还是要谢谢你！我以前从未使用过Zip，但现在知道了它如何有用。
— 卡哈扎尔
1

05AB1E，9 8字节

L€L€ûJså

警告：极慢！添加g到开始加快步伐。

在线尝试！

说明：

L           1..input
 €L         for each element, map to 1..element 
   €û       palindromize each element
     J      join each element from a list to a string
      så    is the input in that list?

旧说明：

F           For [0 .. input] map over
 NL          Push 1..i
   û         Palindromize
    J        Join
     ¹       First input
      Q      Equal?
       }   end loop
        O  Sum.

在线尝试！

— 奥克斯
source
Palindromize？这是做什么的？因为您可能知道10+的楼梯上没有回文
— Yassin Hajaj 18'Apr 30'18
@YassinHajaj它将数组而不是字符串palindromise
— Okx
好的，谢谢您的信息
— Yassin Hajaj '18
@YassinHajaj gLη€ûJså是另一个，您可以在其中使用€ûpalindromize分别看到palindromization的向量化。
— 魔术章鱼缸
@okx gLη€ûJså表示不会炸毁TIO的8字节。
— 魔术章鱼缸
1

Python 2，77个字节

lambda s,r=range:s in[''.join(map(str,r(1,k+2)+r(k,0,-1)))for k in r(len(s))]

在线尝试！

— 林恩
source
如果我们遇到长整数TIO可能会出错，则接受一个整数来保存四个。到那时我们还是需要一些时间和记忆！
— 乔纳森·艾伦'18
1

附件，57 55 46字节

{GenerateFirst[N@Join@Bounce@1&`:,`>=:`#&_]=_}

在线尝试！啊，这要优雅得多。

带Generate（49个字节）：

{g@Generate[{g@_>=#_2}&_]=_}g:=N@Join@Bounce@1&`:

说明

{GenerateFirst[N@Join@Bounce@1&`:,`>=:`#&_]=_}
{                                            }   anonymous lambda, argument: _
 GenerateFirst[                  ,        ]      find the first element satisfying...
               N@Join@Bounce@1&`:                    this generation function
                                  `>=:`#&_           and this condition
                                           =_    is it equal to the input?

生成功能仅创建N第楼梯号。然后，该搜索一旦`>=:`#&_满足就终止。展开后，这是：

 `>=:`#&_
 (`>= : `#) & _      NB. remember _ is the input
                     NB. also, f:g is f[...Map[g, args]]
 { #_1 >= #_2 } & _
 { Size[_1] >= Size[_2] } & _
 { Size[_1] >= Size[the original input] }
 [n] -> { Size[n] >= Size[input] }

因此，一旦生成函数的输出长度至少等于输入的长度，则此操作终止。因此，这产生至少与输入数字一样长的最小阶梯数。因此，如果输入的是楼梯号，则结果将是相同的楼梯号，否则将是下一个最长的楼梯号。这样，与原始输入相等的简单检查足以确定它是否为阶梯数。

附件，55个字节

0&{If[#_2>#g[_],$[_+1,_2],_2=g!_]}g:=N@Join@Bounce@1&`:

在线尝试！计划ol'递归。

— 科纳·奥布莱恩
source
1

K，36个字节

{|/($x)~/:{,/$(1+!x),1+1_|!x}'1+!#x}

将诸如“ 12321”之类的字符串作为参数。

该函数被编写为一连串的函数应用程序，如中的所示f g h x，因此请从底部开始阅读注释版本。 {x+1}是lambda x: x+1，x是默认的参数名称。查看 https://pastebin.com/cRwXJn7Z或解释器的帮助以了解操作员的含义。

我们通过以下方式生成n中间的楼梯编号{,/$(1+!x),1+1_|!x}：

{,/                      / join all the chars
   $                     / tostring each number
     (1+!x)              / take the range [0..x-1]; add 1 to each
            ,            / concat
             (1+1_|!x)}  / take the range [0..x-1]; reverse it; drop 1; add 1 to each

整个功能{|/($x)~/:{,/$(1+!x),1+1_|!x}'1+!#x}：

{|/                                   / any_is_true
   ($x)~/:                            / match the string with each of the generated staircases
          {,/$(1+!x),1+1_|!x}'        / make staircase number of each of the numbers
                                      / (note: the x in the inner lambda shadows the outer x)
                              1+!#x}  / take the range [1..length of the string, inclusive]
— 乌里加
source
0

哈斯克尔，64 60 58字节

-6感谢@BMO！

elem.show<*>(`take`[[1..n]++[n-1,n-2..1]>>=show|n<-[1..]])

在线尝试！

— 硕果累累
source
理论上适用于 12345678910987654321，如果您能够构建具有这么多元素的列表，则。
— Esolanging Fruit '18
@BMO我知道必须有一种方法可以做到这一点。谢谢
— 硕果累累'18
@BMO 您的高尔夫事后真的很明显……
— Esolanging Fruit '18
它也非常接近，如果我还没有发布，我会建议它做为一种改进（直到我发布了我的才看到你的）。
— ბიმო
0

Java 10，142个字节

s->{int n=1,l,f=1;try{for(;;s=s.substring(l=(n+++"").length(),s.length()-l))if(!s.matches(n+".*"+n)&!s.equals(n+""))f=0;}finally{return f>0;}}

在线尝试。

说明：

s->{                 // Method with String parameter and boolean return-type
  int n=1,           //  Stair integer, starting at 1
      l,             //  Length integer to reduce bytes
      f=1;           //  Result-flag, starting at 1
  try{for(;;         //  Loop until an error occurs
          s=s.substring(l=(n+++"").length(),s.length()-l))
                     //    After every iteration: remove `n` from the sides of the String
        if(!s.matches(n+".*"+n)
                     //   If the current String with the current `n` isn't a stair
           &!s.equals(n+""))
                     //   And they are also not equal (for the middle)
          f=0;       //    Set the flag to 0
   }finally{         //  After the error (StringOutOfBoundsException) occurred:
      return f>0;}}  //   Return whether the flag is still 1
— 凯文·克鲁伊森
source
0

Japt，11个字节

将输入作为字符串。

Êõõ mê m¬øU

尝试一下

说明

                :Implicit input of string U
Ê               :Length of U
 õ              :Range [1,Ê]
  õ             :Range [1,el] for each element
    mê          :Map & palidromise
       m¬       :Map & join
         øU     :Contains U?

另类，10 9个字节

该解决方案可以将输入形式为字符串或整数，并且如果不破坏浏览器，则将为真值返回一个数字数组，或者最终为假返回错误。请谨慎使用。

@¥Xê q}aõ

尝试一下

— 毛茸茸
source
0

视网膜，45 43字节

$
;1
+`^(.+)(.*)\1;\1$
$2;$.(_$1*
^(.+);\1$

在线尝试！链接包括测试用例。编辑：由于@Leo，节省了2个字节。说明：

$
;1

初始化n为1。

+`^(.+)(.*)\1;\1$

虽然s开始于和结束于n：

$2;$.(_$1*

n从末尾删除s并递增n。

^(.+);\1$

测试是否n剩余。

— 尼尔
source
我认为您的\ds可以成为.您并为您节省了两个字节
— Leo
-1

感谢以下用户： 

@Nooneishere
@LyricLy
@JoKing

Python 2 147字节

g=s=input()
f=1
o='1'==s[0]
while`f`==s[0]:s=s[len(`f`):];f+=1
f-=2
o&=`f`==s[0]
while s and`f`==s[0]:s=s[len(`f`):];f-=1
o&=f==0
o|=g=='1'
print o

在线尝试！

输出不必是字符串true，false而可以是true和false值。1并0可以工作，例如
— dylnan '18
@dylnan：我刚刚读了，谢谢。仍然打高尔夫球（还有很多事情
您不能只使用s[0]代替startswith吗？错误是允许的，您可以说“楼梯的输出为1，其他任何内容（不包含任何内容）（由于忽略了stderrr），对于非楼梯而言”。
— NoOneIsHere
@NoOneIsHere：好主意。显然，在睡眠时进行编码不是一个好主意
1
您的138字节解决方案始终返回False，因为g它永远不会返回1。您可能应该在发布这些解决方案之前对其进行测试 ...
— Jo King
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.