Défi :

Vérifiez si le nombre donné forme number staircaseou non

Contribution :

Un entier (supérieur à 0 et non décimal). REMARQUE: vous pouvez prendre l'entrée sous forme de chaîne, tableau de chiffres.

Production :

une valeur véridique / fausse selon que le nombre forme ou non un escalier

Numéro escalier:

Un escalier numérique est un entier qui, lu de gauche à droite:

• Commence par 1
• qui peut être suivi de 2
• qui peut être suivi de 3
• et ainsi de suite jusqu'à n
• alors le nombre descend à partir de n - 1
• alors n - 2
• alors n - 3
• et ainsi de suite jusqu'à ce qu'il atteigne 1

Remarque :

La partie peut être utilisée pour indiquer que si la longueur> est supérieure à 1. Si c'est le cas, l'ordre doit être suivi tel quel. soit: 12321

Exemple :

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

Remarque :

L'entrée donnée sera toujours un entier supérieur à 0 et ne sera pas une décimale. Votre sortie doit être une truthy or falsyvaleur en fonction de l'entrée

Restrictions:

C'est le code-golf donc le code le plus court en octets (pour chaque langage de programmation) gagne.

R , 97 octets

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)

Essayez-le en ligne!

Prend n comme un characterou un integer; l'utilisation characterdonnera des résultats corrects pour les entiers qui ne peuvent pas être conservés avec précision en 64 bits double.

Génère des numéros d'escalier jusqu'à ce qu'il en trouve un au moins aussi long n, puis teste l'égalité.

Équivalent à:

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)

Gelée , 5 octets

ŒḄ€Vċ

Essayez-le en ligne!

Attention: très lent (rapide pour 1et 121)! Préparez-vous DLà le rendre plus rapide.

JavaScript (ES6), 62 57 octets

Sauvegardé 2 octets grâce à @ l4m2

Renvoie un booléen.

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

Essayez-le en ligne!

Comment?

En commençant par k = 1 , nous recherchons k au début et à la fin de la chaîne, et itérons récursivement le processus sur la sous-chaîne médiane restante avec k + 1 . La récursivité s'arrête dès qu'il n'y a plus de correspondance. L'entrée est un numéro d'escalier si la dernière sous-chaîne est égale à k .

Exemple pour 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 octets

_{-1 octet merci à Laikoni !}

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

Essayez-le en ligne!

Pyth, 13 12 octets

/mjk+Sd_Stdl

Un octet enregistré grâce à RK.
Essayez-le ici

Explication

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

Si vous voulez vraiment que l'entrée soit un entier, vous pouvez l'utiliser à la }Qmsjk+Sd_Stdplace, mais c'est horriblement lent.

Python 2 , 69 octets

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

Essayez-le en ligne!

C # (Visual C # Interactive Compiler) , 138 107 102 octets

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

Essayez-le en ligne!

Explication:

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 octets

L€L€ûJså

Avertissement: EXTRÊMEMENT LENT! Ajouterg au début pour l'accélérer.

Essayez-le en ligne!

Explication:

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?

Ancienne explication:

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

Essayez-le en ligne!

Python 2 , 77 octets

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

Essayez-le en ligne!

Stax , 14 octets

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

Exécuter et déboguer

Très lent pour les grands nombres.

Attaché , 57 55 46 octets

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

Essayez-le en ligne! Ah, c'est beaucoup plus élégant.

Avec Generate(49 octets):

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

Explication

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

La fonction de génération crée simplement le Nnuméro de l'escalier. Ensuite, cette recherche se termine une fois `>=:`#&_satisfaite. Développé, c'est:

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

Ainsi, cela se termine une fois que la longueur de la sortie de la fonction de génération est au moins celle des entrées. Ainsi, cela génère le plus petit numéro d'escalier au moins aussi longtemps que le numéro d'entrée. Ainsi, si l'entrée est un numéro d'escalier, le résultat sera le même numéro d'escalier, sinon le numéro d'escalier le plus long suivant. En tant que tel, une simple vérification avec égalité à l'entrée d'origine est suffisante pour déterminer s'il s'agissait ou non d'un numéro d'escalier.

Attaché, 55 octets

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

Essayez-le en ligne! Avec plan ol 'récursivité.

J , 40 octets

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

Essayez-le en ligne!

Je ne suis pas tout à fait satisfait de ce soluiton - beaucoup de @boxe <.

SNOBOL4 (CSNOBOL4) , 109 octets

	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

Essayez-le en ligne!

Curieusement, le remplacement '1'dans la deuxième ligne par 1entraîne l'échec du programme à l'entrée de 1.

K , 36 octets

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

Prend une chaîne telle que "12321" comme paramètre.

Cette fonction est écrite comme une longue chaîne d'applications de fonction, comme dans f g h x, alors lisez les versions commentées à partir du bas, en remontant. {x+1}est lambda x: x+1, x est un nom de paramètre par défaut. Consultez https://pastebin.com/cRwXJn7Z ou l'aide de l'interprète pour les significations de l'opérateur.

Nous générons le numéro d'escalier avec nau milieu par {,/$(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

Toute la fonction {|/($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 octets

^{-6 grâce à @BMO!}

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

Essayez-le en ligne!

Perl 5 -lp , 49 octets

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

Essayez-le en ligne!

0 = véridique, tout le reste = fausse

Java 10, 142 octets

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

Essayez-le en ligne.

Explication:

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 octets

Prend l'entrée sous forme de chaîne.

Êõõ mê m¬øU

Essayez-le

Explication

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

Alternative, 10 9 octets

Cette solution, qui peut prendre l'entrée sous la forme d'une chaîne ou d'un entier, retournera un tableau de nombres pour véridique ou, éventuellement, lancera une erreur pour falsey, si elle ne paralyse pas votre navigateur avant cela. Utiliser avec précaution.

@¥Xê q}aõ

Essayez-le

Rétine , 45 43 octets

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

Essayez-le en ligne! Le lien inclut des cas de test. Edit: sauvé 2 octets grâce à @Leo. Explication:

$
;1

Initialiser nà 1.

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

Alors que scommence et se termine par n:

$2;$.(_$1*

Supprimer nà la fin de set incrémenter n.

^(.+);\1$

Testez s'il nreste.

Regex (PCRE) , 92 octets

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

Essayez-le en ligne!

Je suis ouvert à toutes suggestions pour améliorer cela.

Merci aux utilisateurs suivants:

@Nooneishere
@LyricLy
@JoKing

Python 2 , 147 octets

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

Essayez-le en ligne!