Desafio:

Verifique se o número fornecido forma number staircaseou não

Entrada :

Um número inteiro (maior que 0 e não decimal). NOTA: Você pode receber a entrada como sequência, matriz de dígitos.

Resultado :

um valor de verdade / falsidade, dependendo se o número forma uma escada ou não

Escada numérica:

Uma escada numérica é um número inteiro que, quando lido da esquerda para a direita:

• Começa com 1
• que pode ser seguido por 2
• que pode ser seguido por 3
• e assim por diante até n
• então o número desce começando em n - 1
• então n - 2
• então n - 3
• e assim por diante até atingir 1

Nota :

A parte pode ser usada para indicar que, se length> for maior que 1. Se for, a ordem deverá ser seguida como está. ou seja: 12321

Exemplo:

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

Nota :

A entrada fornecida sempre será um número inteiro maior que 0 e não será um decimal. Sua saída deve ser um truthy or falsyvalor, dependendo da entrada

Restrições:

Este é o código-golfe, pelo que o código mais curto em bytes (para cada linguagem de programação) vence.

R , 97 bytes

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)

Experimente online!

Toma ncomo um characterou um integer; O uso characterfornecerá resultados corretos para números inteiros que não podem ser mantidos com precisão como 64 bits double.

Gera números de escadas até encontrar um pelo menos enquanto né, depois testa a igualdade.

Equivalente a:

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)

Gelatina , 5 bytes

ŒḄ€Vċ

Experimente online!

Aviso: muito lento (rápido para 1e 121)! Anexe antes DLpara torná-lo mais rápido.

JavaScript (ES6), 62 57 bytes

Guardado 2 bytes graças a @ l4m2

Retorna um booleano.

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

Experimente online!

Quão?

Começando com k = 1 , procuramos k no início e no final da sequência e iteramos recursivamente o processo na sub-sequência do meio restante com k + 1 . A recursão pára assim que não há mais correspondência. A entrada é um número de escada se a última sub-corda for igual a k .

Exemplo para 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 bytes

_{-1 byte graças a Laikoni !}

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

Experimente online!

Pitão, 13 12 bytes

/mjk+Sd_Stdl

Guardou um byte graças a RK.
Experimente aqui

Explicação

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

Se você realmente deseja a entrada como um número inteiro, pode usar }Qmsjk+Sd_Std, mas isso é terrivelmente lento.

Python 2 , 69 bytes

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

Experimente online!

C # (Compilador interativo do Visual C #) , 138 107 102 bytes

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

Experimente online!

Explicação:

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 bytes

L€L€ûJså

Aviso: EXTREMAMENTE LENTO! Adicione gao início para acelerar.

Experimente online!

Explicação:

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?

Explicação antiga:

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

Experimente online!

Python 2 , 77 bytes

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

Experimente online!

Stax , 14 bytes

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

Execute e depure

Muito lento para números maiores.

Anexo , 57 55 46 bytes

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

Experimente online! Ah, isso é muito mais elegante.

Com Generate(49 bytes):

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

Explicação

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

A função de geração simplesmente cria o Nnúmero da escada. Então, essa pesquisa termina assim que `>=:`#&_for satisfeita. Expandido, é o seguinte:

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

Portanto, isso termina quando o comprimento da saída da função de geração é pelo menos o das entradas. Assim, isso gera o menor número de escada pelo menos enquanto o número de entrada. Portanto, se a entrada for um número de escada, o resultado será o mesmo número de escada e, caso contrário, o próximo número de escada mais longo. Assim, uma verificação simples com igualdade da entrada original é suficiente para determinar se era ou não um número de escada.

Anexo, 55 bytes

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

Experimente online! Com plano de recursão.

J , 40 bytes

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

Experimente online!

Eu não estou muito feliz com este soldado - muito @e boxe <.

SNOBOL4 (CSNOBOL4) , 109 bytes

	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

Experimente online!

Curiosamente, substituir '1'na segunda linha por 1faz com que o programa falhe na entrada de 1.

K , 36 bytes

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

Leva uma string como "12321" como parâmetro.

Essa função é escrita como uma longa cadeia de aplicativos funcionais, como em f g h x, portanto, leia as versões comentadas de baixo para cima. {x+1}é lambda x: x+1, x é um nome de parâmetro padrão. Consulte https://pastebin.com/cRwXJn7Z ou a ajuda do intérprete para obter os significados dos operadores.

Geramos o número da escada com nno meio {,/$(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

Toda a função {|/($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 bytes

^{-6 graças a @BMO!}

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

Experimente online!

Perl 5 -lp , 49 bytes

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

Experimente online!

0 = verdade, qualquer outra coisa = falsy

Java 10, 142 bytes

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

Experimente online.

Explicação:

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

Japonês, 11 bytes

Recebe a entrada como uma sequência.

Êõõ mê m¬øU

Tente

Explicação

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

Alternativa, 10 9 bytes

Essa solução, que pode receber a entrada como uma string ou um número inteiro, retornará uma matriz de números para a verdade ou, eventualmente, lançará um erro para o falsey, se não danificar seu navegador antes disso. Use com cuidado.

@¥Xê q}aõ

Tente

Retina , 45 43 bytes

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

Experimente online! O link inclui casos de teste. Editar: salvou 2 bytes graças ao @Leo. Explicação:

$
;1

Inicialize npara 1.

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

Enquanto scomeça e termina com n:

$2;$.(_$1*

Excluir ndas extremidades se incrementar n.

^(.+);\1$

Teste se nresta.

Regex (PCRE) , 92 bytes

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

Experimente online!

Estou aberto a sugestões para melhorar isso.

Graças aos seguintes usuários:

@Nooneishere
@LyricLy
@JoKing

Python 2 , 147 bytes

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

Experimente online!