Wyzwanie:

Sprawdź, czy podana liczba stanowi a, number staircaseczy nie

Wejście :

Liczba całkowita (większa niż 0 i nie dziesiętna). UWAGA: Dane wejściowe można traktować jako ciąg znaków, tablicę cyfr.

Wynik :

wartość prawda / fałsz w zależności od tego, czy liczba tworzy schody, czy nie

Liczba schodów:

Numer klatka schodowa jest liczbą całkowitą, gdy czytane od lewej do prawej:

• Zaczyna się od 1
• po którym może następować 2
• po którym może nastąpić 3
• i tak dalej n
• następnie liczba spada od n - 1
• następnie n - 2
• następnie n - 3
• i tak dalej, aż osiągnie 1

Uwaga :

Część może być używana do wskazania, że ​​jeśli długość> jest większa niż 1. Jeśli tak jest, należy postępować zgodnie z kolejnością. tj .: 12321

Przykład:

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

Uwaga :

Podane dane wejściowe zawsze będą liczbami całkowitymi większymi niż 0 i nie będą dziesiętne. Twój wynik musi być truthy or falsywartością zależną od danych wejściowych

Ograniczenia:

To jest golf golfowy, więc wygrywa najkrótszy kod w bajtach (dla każdego języka programowania).

R , 97 bajtów

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)

Wypróbuj online!

Przyjmuje njako a characterlub an integer; użycie characterda poprawne wyniki dla liczb całkowitych, których nie można dokładnie odczytać jako 64-bit double.

Generuje numery schodów, dopóki nie znajdzie jednego co najmniej tak długo, jak nto jest, a następnie sprawdza równość.

Równoważny:

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)

Galaretka , 5 bajtów

ŒḄ€Vċ

Wypróbuj online!

Ostrzeżenie: bardzo wolno (szybko 1i 121)! Przygotuj DLsię, aby przyspieszyć.

JavaScript (ES6), 62 57 bajtów

Zaoszczędzono 2 bajty dzięki @ l4m2

Zwraca wartość logiczną.

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

Wypróbuj online!

W jaki sposób?

Zaczynając od k = 1 , szukamy k na początku i na końcu łańcucha, i rekurencyjnie iterujemy proces na pozostałym środkowym podciągu z k + 1 . Rekursja kończy się, gdy tylko nie ma już żadnego dopasowania. Dane wejściowe to numer klatki schodowej, jeśli ostatni podciąg jest równy k .

Przykład dla 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 bajtów

_{-1 bajt dzięki Laikoni !}

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

Wypróbuj online!

Pyth, 13 12 bajtów

/mjk+Sd_Stdl

Zapisano bajt dzięki RK.
Wypróbuj tutaj

Wyjaśnienie

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

Jeśli naprawdę chcesz, aby dane wejściowe były liczbą całkowitą, możesz użyć }Qmsjk+Sd_Stdzamiast tego, ale jest to przerażająco powolne.

Python 2 , 69 bajtów

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

Wypróbuj online!

C # (interaktywny kompilator Visual C #) , 138 107 102 bajtów

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

Wypróbuj online!

Wyjaśnienie:

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 bajtów

L€L€ûJså

Ostrzeżenie: BARDZO WOLNY! Dodaj gdo początku, aby przyspieszyć.

Wypróbuj online!

Wyjaśnienie:

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?

Stare objaśnienie:

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

Wypróbuj online!

Python 2 , 77 bajtów

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

Wypróbuj online!

Stax , 14 bajtów

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

Uruchom i debuguj

Bardzo wolny dla większych liczb.

Attache , 57 55 46 bajtów

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

Wypróbuj online! Ach, to o wiele bardziej eleganckie.

Z Generate(49 bajtów):

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

Wyjaśnienie

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

Funkcja generacji po prostu tworzy Nnumer klatki schodowej. Następnie wyszukiwanie kończy się, gdy `>=:`#&_jest spełnione. Po rozwinięciu jest to:

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

Kończy się to, gdy długość danych wyjściowych funkcji generowania jest co najmniej długością wejść. W ten sposób generowany jest najmniejszy numer klatki schodowej co najmniej tak długi jak numer wejściowy. Tak więc, jeśli dane wejściowe to numer klatki schodowej, wynikiem będzie ten sam numer klatki schodowej, a w przeciwnym razie następny najdłuższy numer klatki schodowej. Jako taki wystarczy proste sprawdzenie z równością z oryginalnym wejściem, aby ustalić, czy był to numer klatki schodowej.

Attache, 55 bajtów

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

Wypróbuj online! Z planem rekurencji.

J , 40 bajtów

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

Wypróbuj online!

Nie jestem całkiem zadowolony z tego rozwiązania - dużo @i boks <.

SNOBOL4 (CSNOBOL4) , 109 bajtów

	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

Wypróbuj online!

Co ciekawe, zamiana '1'drugiego wiersza na 1powoduje awarię programu na wejściu 1.

K , 36 bajtów

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

Pobiera ciąg taki jak „12321” jako parametr.

Ta funkcja jest napisana jako długi łańcuch aplikacji funkcyjnych, jak w f g h x, więc czytaj komentarze od dołu, idąc w górę. {x+1}to lambda x: x+1x jest domyślną nazwą parametru. Sprawdź https://pastebin.com/cRwXJn7Z lub pomoc tłumacza dla znaczeń operatora.

Generujemy numer klatki schodowej nw środku przez {,/$(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

Cała funkcja {|/($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 bajtów

^{-6 dzięki @BMO!}

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

Wypróbuj online!

Perl 5 -lp , 49 bajtów

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

Wypróbuj online!

0 = prawda, wszystko inne = fałsz

Java 10, 142 bajty

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

Wypróbuj online.

Wyjaśnienie:

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 bajtów

Pobiera dane wejściowe jako ciąg.

Êõõ mê m¬øU

Spróbuj

Wyjaśnienie

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

Alternatywnie, 10 9 bajtów

To rozwiązanie, które może przyjmować dane wejściowe jako ciąg lub liczbę całkowitą, zwróci tablicę liczb dla prawdy lub, w końcu, wygeneruje błąd dla falsey, jeśli wcześniej nie okaleczy twojej przeglądarki. Używaj ostrożnie.

@¥Xê q}aõ

Spróbuj

Siatkówka , 45 43 bajtów

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

Wypróbuj online! Link zawiera przypadki testowe. Edycja: Zapisano 2 bajty dzięki @Leo. Wyjaśnienie:

$
;1

Zainicjuj ndo 1.

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

Podczas gdy szaczyna się i kończy na n:

$2;$.(_$1*

Usuń nz końców si przyrostu n.

^(.+);\1$

Sprawdź, czy nzostało.

Regex (PCRE) , 92 bajty

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

Wypróbuj online!

Jestem otwarty na wszelkie sugestie, aby to poprawić.

Dzięki następującym użytkownikom:

@Nooneishere
@LyricLy
@JoKing

Python 2 , 147 bajtów

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

Wypróbuj online!