Thử thách :

Kiểm tra xem số đã cho có hình thành number staircasehay không

Đầu vào :

Một số nguyên (lớn hơn 0 và không thập phân). LƯU Ý: Bạn có thể lấy đầu vào dưới dạng chuỗi, mảng các chữ số.

Đầu ra:

một giá trị trung thực / giả mạo tùy thuộc vào việc số đó có tạo thành cầu thang hay không

Cầu thang số:

Một cầu thang số là một số nguyên mà khi đọc từ trái sang phải:

• Bắt đầu với 1
• có thể theo sau bởi 2
• có thể theo sau bởi 3
• và cứ thế n
• sau đó số giảm dần bắt đầu từ n - 1
• sau đó n - 2
• sau đó n - 3
• và cứ như vậy cho đến khi nó đạt đến 1

Ghi chú :

Phần có thể được sử dụng để chỉ ra rằng nếu độ dài> lớn hơn 1. Nếu đó là thứ tự phải được tuân theo. tức là: 12321

Thí dụ :

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

Ghi chú :

Đầu vào đã cho sẽ luôn là số nguyên lớn hơn 0 và sẽ không phải là số thập phân. Đầu ra của bạn phải là một truthy or falsygiá trị tùy thuộc vào đầu vào

Những hạn chế :

Đây là mã golf để mã ngắn nhất tính theo byte (cho mỗi ngôn ngữ lập trình) sẽ thắng.

R , 97 byte

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)

Hãy thử trực tuyến!

Mất nnhư một characterhoặc một integer; việc sử dụng charactersẽ cho kết quả chính xác cho các số nguyên không thể được giữ chính xác dưới dạng 64 bit double.

Tạo số cầu thang cho đến khi tìm thấy ít nhất một lần n, sau đó kiểm tra sự bằng nhau.

Tương đương với:

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)

Thạch , 5 byte

ŒḄ€Vċ

Hãy thử trực tuyến!

Cảnh báo: Rất chậm (nhanh cho 1và 121)! Chuẩn bị DLđể làm cho nó nhanh hơn.

JavaScript (ES6), 62 57 byte

Đã lưu 2 byte nhờ @ l4m2

Trả về một boolean.

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

Hãy thử trực tuyến!

Làm sao?

Bắt đầu với k = 1 , chúng tôi tìm k ở đầu và cuối chuỗi và lặp lại quy trình trên chuỗi con giữa còn lại với k + 1 . Sự đệ quy dừng lại ngay khi không còn trận đấu nữa. Đầu vào là số cầu thang nếu chuỗi con cuối cùng bằng k .

Ví dụ cho 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    

Haskell , 55 54 byte

_{-1 byte nhờ Laikoni !}

f x=elem x[read$[1..z]++[z-1,z-2..1]>>=show|z<-[1..x]]

Hãy thử trực tuyến!

Bình thường, 13 12 byte

/mjk+Sd_Stdl

Đã lưu một byte nhờ RK.
Hãy thử nó ở đây

Giải trình

/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.

Nếu bạn thực sự muốn đầu vào là một số nguyên, bạn có thể sử dụng }Qmsjk+Sd_Stdthay thế, nhưng điều này chậm kinh khủng.

Python 2 , 69 byte

f=lambda s,n=1,t='1',u='':t+':'>s>t<s*f(s,n+1,t+`n+1`,`n`+u)or s==t+u

Hãy thử trực tuyến!

C # (Trình biên dịch tương tác Visual C #) , 138 107 102 byte

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);

Hãy thử trực tuyến!

Giải trình:

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?

05AB1E , 9 8 byte

L€L€ûJså

Cảnh báo: TUYỆT VỜI CHẬM! Thêm gvào đầu để tăng tốc nó.

Hãy thử trực tuyến!

Giải trình:

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?

Giải thích cũ:

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

Hãy thử trực tuyến!

Python 2 , 77 byte

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

Hãy thử trực tuyến!

Stax , 14 byte

Ç╗☻W╧ΩÆΘαφ←≤─♣

Chạy và gỡ lỗi nó

Rất chậm cho số lượng lớn hơn.

Tùy viên , 57 55 46 byte

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

Hãy thử trực tuyến! Ah, đó là thanh lịch hơn nhiều.

Với Generate(49 byte):

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

Giải trình

{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?

Hàm tạo chỉ đơn giản là tạo số Nthứ tự cầu thang. Sau đó, tìm kiếm này chấm dứt một lần `>=:`#&_được thỏa mãn. Mở rộng, đây là:

 `>=:`#&_
 (`>= : `#) & _      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] }

Vì vậy, điều này chấm dứt một khi độ dài của đầu ra của hàm tạo ít nhất là chiều dài của đầu vào. Do đó, điều này tạo ra số cầu thang nhỏ nhất ít nhất bằng số đầu vào. Do đó, nếu đầu vào là số cầu thang, kết quả sẽ là cùng số cầu thang và nếu không là số cầu thang dài nhất tiếp theo. Như vậy, một kiểm tra đơn giản với sự bằng nhau với đầu vào ban đầu là đủ để xác định xem đó có phải là số cầu thang hay không.

Tùy viên, 55 byte

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

Hãy thử trực tuyến! Với kế hoạch đệ quy ol '.

J , 40 byte

1#.[:(<-:"_1<@([:;>:<@":@-|@i:)@<:@#\)":

Hãy thử trực tuyến!

Tôi không hoàn toàn hài lòng với soluiton này - rất nhiều @môn quyền anh <.

SNOBOL4 (CSNOBOL4) , 109 byte

	N =INPUT
	X =L ='1'
C	R =LT(SIZE(L R),SIZE(N)) X R	:F(O)
	X =X + 1
	L =L X	:(C)
O	OUTPUT =IDENT(L R,N) 1
END

Hãy thử trực tuyến!

Thật kỳ lạ, thay thế '1'trong dòng thứ hai bằng cách 1khiến chương trình bị lỗi ở đầu vào của 1.

K , 36 byte

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

Lấy một chuỗi như "12321" làm tham số.

Hàm này được viết dưới dạng một chuỗi dài các ứng dụng chức năng, như trong f g h x, vì vậy hãy đọc các phiên bản nhận xét từ phía dưới, đi lên. {x+1}là lambda x: x+1, x là một tên param mặc định. Hãy xem https://pastebin.com/cRwXJn7Z hoặc trợ giúp của thông dịch viên để biết ý nghĩa của nhà điều hành.

Chúng tôi tạo ra số cầu thang nở giữa bằng {,/$(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

Toàn bộ chức năng {|/($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]

Haskell , 64 60 58 byte

^{-6 cảm ơn @BMO!}

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

Hãy thử trực tuyến!

Perl 5 -lp , 49 byte

$i++while s/^$i//;$i-=2;$i--while s/^$i//;$_||=$i

Hãy thử trực tuyến!

0 = sự thật, bất cứ điều gì khác = giả

Java 10, 142 byte

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;}}

Hãy thử trực tuyến.

Giải trình:

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

Japt, 11 byte

Đưa đầu vào dưới dạng một chuỗi.

Êõõ mê m¬øU

Thử nó

Giải trình

                :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?

Thay thế, 10 9 byte

Giải pháp này, có thể lấy đầu vào là một chuỗi hoặc một số nguyên, sẽ trả về một dãy số cho sự thật hoặc cuối cùng, đưa ra một lỗi cho falsey, nếu nó không làm tê liệt trình duyệt của bạn trước đó. Sử dụng cẩn thận.

@¥Xê q}aõ

Thử nó

Võng mạc , 45 43 byte

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

Hãy thử trực tuyến! Liên kết bao gồm các trường hợp thử nghiệm. Chỉnh sửa: Đã lưu 2 byte nhờ @Leo. Giải trình:

$
;1

Khởi nđến 1.

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

Trong khi sbắt đầu và kết thúc bằng n:

$2;$.(_$1*

Xóa ntừ cuối svà tăng n.

^(.+);\1$

Kiểm tra xem ncòn lại.

Regex (PCRE) , 92 byte

^(1|\d(?=1|9)|[2-79](?=8)|[2-68](?=7)|[2-57](?=6)|[2346](?=5)|[235](?=4)|[24](?=3)|3(?=2))+$

Hãy thử trực tuyến!

Tôi sẵn sàng cho bất kỳ đề xuất để cải thiện điều này.

Nhờ những người dùng sau:

@Nooneishere
@LyricLy
@JoKing

Python 2 , 147 byte

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

Hãy thử trực tuyến!