Herausforderung :

Überprüfen Sie, ob die angegebene Nummer eine bildet number staircaseoder nicht

Eingabe:

Eine Ganzzahl (größer als 0 und nicht dezimal). ANMERKUNG: Sie können Eingaben als Zeichenfolge oder als Array von Ziffern vornehmen.

Ausgabe :

Ein wahrer / falscher Wert, der davon abhängt, ob die Zahl eine Treppe bildet oder nicht

Anzahl Treppe:

Eine Zahlentreppe ist eine Ganzzahl, die von links nach rechts gelesen wird:

• Beginnt mit 1
• Darauf kann 2 folgen
• Darauf kann 3 folgen
• und so weiter bis n
• dann steigt die Zahl ab n - 1
• dann n - 2
• dann n - 3
• und so weiter bis es 1 erreicht

Hinweis :

Das kann Teil wird verwendet , wenn die Länge , um anzuzeigen , dass> größer als 1. Wenn die Reihenfolge beachtet werden muß , wie es ist. dh: 12321

Beispiel

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

Hinweis :

Die angegebene Eingabe ist immer eine Ganzzahl größer als 0 und keine Dezimalzahl. Ihre Ausgabe muss ein truthy or falsyWert sein, der von der Eingabe abhängt

Beschränkungen :

Dies ist Code-Golf, so dass der kürzeste Code in Bytes (für jede Programmiersprache) gewinnt.

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)

Probieren Sie es online!

Nimmt nals ein characteroder ein integer; using characterliefert korrekte Ergebnisse für Ganzzahlen, die nicht genau als 64-Bit-Zahl angegeben werden können double.

Erzeugt so lange Treppenhausnummern, bis mindestens eine gefunden nwird, und prüft dann auf Gleichheit.

Gleichwertig:

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)

Gelee , 5 Bytes

ŒḄ€Vċ

Probieren Sie es online!

Achtung: Sehr langsam (schnell für 1und 121)! Bereite dich DLdarauf vor, es schneller zu machen.

JavaScript (ES6), 62.57 Byte

2 Bytes gespart dank @ l4m2

Gibt einen Booleschen Wert zurück.

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

Probieren Sie es online!

Wie?

Beginnend mit k = 1 suchen wir am Anfang und am Ende des Strings nach k und wiederholen den Vorgang für den verbleibenden mittleren Teilstring rekursiv mit k + 1 . Die Rekursion stoppt, sobald keine Übereinstimmung mehr vorhanden ist. Die Eingabe ist eine Treppennummer, wenn der letzte Teilstring gleich k ist .

Beispiel für 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 Danke an Laikoni !}

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

Probieren Sie es online!

Pyth, 13 12 Bytes

/mjk+Sd_Stdl

Dank RK ein Byte gespeichert.
Probieren Sie es hier aus

Erläuterung

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

Wenn Sie die Eingabe wirklich als Ganzzahl wünschen, können Sie sie }Qmsjk+Sd_Stdstattdessen verwenden, dies ist jedoch erschreckend langsam.

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

Probieren Sie es 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);

Probieren Sie es online!

Erläuterung:

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å

Warnung: EXTREM LANGSAM! gZum Anfang addieren , um es zu beschleunigen.

Probieren Sie es online!

Erläuterung:

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?

Alte Erklärung:

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

Probieren Sie es 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))]

Probieren Sie es online!

Stax , 14 Bytes

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

Führen Sie es aus und debuggen Sie es

Sehr langsam für größere Zahlen.

Attache , 57 55 46 Bytes

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

Probieren Sie es online! Ah, das ist viel eleganter.

Mit Generate(49 Bytes):

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

Erläuterung

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

Die Generierungsfunktion erstellt einfach die Nth Treppenhausnummer. Dann wird diese Suche beendet, sobald sie `>=:`#&_erfüllt ist. Erweitert ist dies:

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

Dies endet also, sobald die Länge der Ausgabe der Erzeugungsfunktion mindestens der der Eingaben entspricht. Dadurch wird die kleinste Treppennummer generiert, die mindestens so lang ist wie die eingegebene Nummer. Wenn es sich bei der Eingabe um eine Treppennummer handelt, ist das Ergebnis dieselbe Treppennummer und ansonsten die nächstlängste Treppennummer. Daher ist eine einfache Überprüfung mit Gleichheit zur ursprünglichen Eingabe ausreichend, um festzustellen, ob es sich um eine Treppennummer handelt oder nicht.

Attache, 55 Bytes

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

Probieren Sie es online! Mit dem Plan der Rekursion.

J , 40 Bytes

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

Probieren Sie es online!

Ich bin nicht ganz glücklich mit dieser Lösung - viel @und Boxen <.

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

Probieren Sie es online!

Seltsamerweise führt das Ersetzen '1'in der zweiten Zeile mit zum 1Fehlschlagen des Programms bei der Eingabe von 1.

K , 36 Bytes

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

Nimmt einen String wie "12321" als Parameter.

Diese Funktion ist wie in einer langen Kette von Funktionsanwendungen geschrieben. f g h xLesen Sie daher die kommentierten Versionen von unten nach oben. {x+1}ist lambda x: x+1, x ist ein Standard-Parametername. Lesen Sie https://pastebin.com/cRwXJn7Z oder die Hilfe des Interpreters, um die Bedeutung des Operators zu erfahren.

Wir generieren die Treppennummer mit nin der Mitte durch {,/$(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

Die ganze Funktion {|/($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 danke an @BMO!}

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

Probieren Sie es online!

Perl 5 -lp , 49 Bytes

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

Probieren Sie es online!

0 = wahr, alles andere = falsch

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

Probieren Sie es online aus.

Erläuterung:

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 Bytes

Übernimmt die Eingabe als Zeichenfolge.

Êõõ mê m¬øU

Versuch es

Erläuterung

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

Alternativ 10 9 Bytes

Diese Lösung, die Eingaben als Zeichenfolge oder Ganzzahl annehmen kann, gibt ein Array von Zahlen für die Richtigkeit zurück oder gibt schließlich einen Fehler für die Falschmeldung aus, wenn Ihr Browser zuvor nicht lahmgelegt wird. Mit Vorsicht verwenden.

@¥Xê q}aõ

Versuch es

Retina , 45 43 Bytes

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

Probieren Sie es online! Link enthält Testfälle. Bearbeiten: 2 Bytes dank @Leo gespeichert. Erläuterung:

$
;1

Initialisiere nauf 1.

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

Während sbeginnt und endet mit n:

$2;$.(_$1*

Löschen Sie nvon den Enden sund erhöhen Sie n.

^(.+);\1$

Testen Sie, ob nnoch etwas übrig ist.

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

Probieren Sie es online!

Ich bin offen für Vorschläge, um dies zu verbessern.

Vielen Dank an folgende Benutzer:

@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

Probieren Sie es online!