Tantangan:

Periksa apakah nomor yang diberikan membentuk number staircaseatau tidak

Memasukkan :

Integer (lebih besar dari 0 dan bukan desimal). CATATAN: Anda dapat mengambil input sebagai string, array digit.

Keluaran:

nilai kebenaran / kepalsuan tergantung pada apakah nomor membentuk tangga atau tidak

Tangga nomor:

Sebuah tangga nomor integer yang, ketika membaca dari kiri ke kanan:

• Mulai dengan 1
• yang dapat diikuti oleh 2
• yang dapat diikuti oleh 3
• dan seterusnya sampai n
• maka jumlahnya turun mulai dari n - 1
• lalu n - 2
• lalu n - 3
• dan seterusnya hingga mencapai 1

Catatan :

Bagian boleh digunakan untuk menunjukkan bahwa jika panjang> lebih besar dari 1. Jika itu urutan harus diikuti apa adanya. yaitu: 12321

Contoh:

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

Catatan :

Input yang diberikan akan selalu berupa bilangan bulat lebih besar dari 0 dan tidak akan berupa desimal. Output Anda harus berupa truthy or falsynilai tergantung pada input

Pembatasan:

Ini adalah kode-golf sehingga kode terpendek dalam byte (untuk setiap bahasa pemrograman) menang.

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)

Cobalah online!

Diambil nsebagai a characteratau a integer; menggunakan characterakan memberikan hasil yang benar untuk bilangan bulat yang tidak dapat dipegang secara tepat sebagai 64-bit double.

Menghasilkan nomor tangga sampai menemukan setidaknya selama nini, kemudian menguji kesetaraan.

Setara dengan:

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)

Jelly , 5 byte

ŒḄ€Vċ

Cobalah online!

Peringatan: Sangat lambat (cepat untuk 1dan 121)! Tambahkan DLuntuk membuatnya lebih cepat.

JavaScript (ES6), 62 57 byte

Disimpan 2 byte berkat @ l4m2

Mengembalikan boolean.

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

Cobalah online!

Bagaimana?

Dimulai dengan k = 1 , kita mencari k di awal dan di akhir string, dan secara berulang mengulangi proses pada sub-string tengah yang tersisa dengan k + 1 . Rekursi berhenti segera setelah tidak ada kecocokan lagi. Input adalah nomor tangga jika sub-string terakhir sama dengan k .

Contoh untuk 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 terima kasih kepada Laikoni !}

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

Cobalah online!

Pyth, 13 12 byte

/mjk+Sd_Stdl

Menyimpan satu byte berkat RK.
Coba di sini

Penjelasan

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

Jika Anda benar-benar menginginkan input sebagai integer, Anda dapat menggunakannya }Qmsjk+Sd_Std, tetapi ini sangat lambat.

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

Cobalah online!

C # (Visual C # Interactive Compiler) , 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);

Cobalah online!

Penjelasan:

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å

Peringatan: SANGAT LAMBAT! Menambahkang ke awal untuk mempercepatnya.

Cobalah online!

Penjelasan:

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?

Penjelasan Lama:

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

Cobalah online!

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

Cobalah online!

Stax , 14 byte

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

Jalankan dan debug itu

Sangat lambat untuk jumlah yang lebih besar.

Attache , 57 55 46 byte

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

Cobalah online!Ah, itu jauh lebih elegan.

Dengan Generate(49 byte):

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

Penjelasan

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

Fungsi generasi hanya membuat Nnomor tangga. Kemudian, pencarian ini berakhir setelah `>=:`#&_puas. Diperluas, ini adalah:

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

Jadi, ini berakhir setelah panjang output fungsi generasi setidaknya dari input. Dengan demikian, ini menghasilkan nomor tangga terkecil setidaknya selama nomor input. Jadi, jika input adalah nomor tangga, hasilnya akan menjadi nomor tangga yang sama, dan sebaliknya nomor tangga terpanjang berikutnya. Dengan demikian, pemeriksaan sederhana dengan kesetaraan ke input asli sudah cukup untuk menentukan apakah itu nomor tangga.

Attache, 55 byte

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

Cobalah online! Dengan rencana rekursi.

J , 40 byte

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

Cobalah online!

Saya tidak cukup senang dengan soluiton ini - banyak @dan tinju <.

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

Cobalah online!

Anehnya, mengganti '1'di baris kedua dengan 1menyebabkan program gagal pada input 1.

K , 36 byte

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

Mengambil string seperti "12321" sebagai parameter.

Fungsi ini ditulis sebagai rantai panjang aplikasi fungsi, seperti pada f g h x, jadi baca versi komentar dari bawah, naik. {x+1}adalah lambda x: x+1, x adalah nama param standar. Lihat https://pastebin.com/cRwXJn7Z atau bantuan penerjemah untuk makna operator.

Kami menghasilkan nomor tangga dengan ndi tengah dengan {,/$(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

Seluruh fungsi {|/($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 terima kasih kepada @BMO!}

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

Cobalah online!

Perl 5 -lp , 49 byte

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

Cobalah online!

0 = benar, apa pun = salah

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

Cobalah online.

Penjelasan:

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

Mengambil input sebagai string.

Êõõ mê m¬øU

Cobalah

Penjelasan

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

Alternatif, 10 9 byte

Solusi ini, yang dapat mengambil input sebagai string atau integer, akan mengembalikan array angka untuk jujur ​​atau, akhirnya, membuat kesalahan untuk falsey, jika tidak melumpuhkan browser Anda sebelum itu. Gunakan dengan hati-hati.

@¥Xê q}aõ

Cobalah

Retina , 45 43 byte

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

Cobalah online! Tautan termasuk kasus uji. Sunting: Disimpan 2 byte berkat @Leo. Penjelasan:

$
;1

Inisialisasi nke 1.

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

Saat sdimulai dan diakhiri dengan n:

$2;$.(_$1*

Hapus ndari ujung sdan selisih n.

^(.+);\1$

Tes apakah nmasih ada.

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))+$

Cobalah online!

Saya terbuka untuk semua saran untuk meningkatkan ini.

Berkat pengguna berikut:

@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

Cobalah online!