Sfida:

Controlla se il numero dato forma number staircaseo meno

Input:

Un numero intero (maggiore di 0 e non decimale). NOTA: è possibile accettare input come stringa, matrice di cifre.

Produzione :

un valore di verità / falsità a seconda che il numero formi una scala o meno

Numero scala:

Una scala numerica è un numero intero che, quando letto da sinistra a destra:

Inizia con 1
che può essere seguito da 2
che può essere seguito da 3
e così via fino a n
quindi il numero scende a partire da n - 1
quindi n - 2
quindi n - 3
e così via fino a raggiungere 1

Nota :

La parte può essere utilizzata per indicare che se la lunghezza> è maggiore di 1. Se è l'ordine deve essere seguito così com'è. cioè: 12321

Esempio :

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

Nota :

L'input fornito sarà sempre un numero intero maggiore di 0 e non sarà un decimale. L'output deve essere un truthy or falsyvalore in base all'input

Restrizioni:

Questo è code-golf quindi vince il codice più breve in byte (per ogni linguaggio di programmazione).

— Muhammad Salman
fonte

2

Possiamo prendere l'input come un elenco di cifre? Come [1,2,3,4,5,6,7,8,9,1,0,1,1,1,0,9,8,7,6,5,4,3,2,1]per 123456789101110987654321?

— Mr. Xcoder

@ Mr.Xcoder: Preferirei se non lo facessi ma immagino che tu possa

— Muhammad Salman

C'è un limite superiore sull'ingresso?

— mypetlion il

@mypetlion: Non proprio, è alto quanto il tuo codice può supportare (esclusi quelli hardcoded e appositamente bassi). Normalmente il massimo che la tua lingua può supportare (ma non in questo caso)

— Muhammad Salman

Possiamo prendere una stringa di caratteri come input per una funzione? (o questo è solo un input accettabile per un programma completo?)

— Jonathan Allan

5

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)

Provalo online!

Prende ncome un charactero un integer; l'utilizzo characterfornirà risultati corretti per numeri interi che non possono essere mantenuti esattamente come 64 bitdouble .

Genera numeri di scale fino a quando non ne trova uno almeno quanto è lungo n, quindi verifica l'uguaglianza.

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)

— Giuseppe
fonte

La sostituzione function(n)con non n=scan();sarebbe più breve? (per numeri interi ovviamente)

— pajonk

@pajonk Suppongo di si. Ma dirò che lo prendo come una stringa, quindi questa risposta è corretta per input più grandi.

— Giuseppe,

3

Gelatina , 5 byte

ŒḄ€Vċ

Provalo online!

Avvertenza: molto lento (veloce per 1e 121)! Preparati DLa renderlo più veloce.

— Erik l'Outgolfer
fonte

3

JavaScript (ES6), 62 57 byte

Salvato 2 byte grazie a @ l4m2

Restituisce un valore booleano.

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

Provalo online!

Come?

A partire da k = 1 , cerchiamo k all'inizio e alla fine della stringa e ripetiamo in modo ricorsivo il processo sulla sottostringa centrale rimanente con k + 1 . La ricorsione si interrompe non appena non c'è più corrispondenza. L'input è un numero di scala se l'ultima sottostringa è uguale a k .

Esempio per 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

— Arnauld
fonte

55 byte . Assumi 0 come verità e null come falsa (non ha specificato esattamente se)

Hum non ho visto quell'ipotesi che non è valido. Siamo spiacenti

@ I'mnoone Nessun problema! È interessante notare che la rimozione m[0]==s&invece gli farebbe passare tutti i casi di test (ma fallirà comunque su altri come "123217").

— Arnauld,

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

— l4m2

2

Haskell , 55 54 byte

_{-1 byte grazie a Laikoni !}

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

Provalo online!

— ბიმო
fonte

2

Pyth, 13 12 byte

/mjk+Sd_Stdl

Salvataggio di un byte grazie a RK.
Provalo qui

Spiegazione

/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 vuoi davvero l'input come numero intero, puoi }Qmsjk+Sd_Stdinvece usarlo , ma questo è terribilmente lento.

puoi usare /invece di }Qcosì si completa automaticamente Qalla fine

— RK.

2

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

Provalo online!

— Dennis
fonte

2

C # (compilatore interattivo Visual C #) , 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);

Provalo online!

Spiegazione:

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?

— Kahzaar
fonte

In realtà, il Zip...Skipmetodo nel mio commento precedente non riesce [1,1], che dovrebbe tornare truese capisco le specifiche. L'ho cancellato.

— benj2240,

Grazie comunque! Non ho mai usato Zip prima, ma vedo ora come può essere utile.

— Kahzaar,

1

05AB1E , 9 8 byte

L€L€ûJså

Avvertenza: ESTREMAMENTE LENTO! Inseriscig all'inizio per accelerarlo.

Provalo online!

Spiegazione:

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?

Vecchia spiegazione:

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

Provalo online!

— Okx
fonte

Palindromizzare? Cosa fa questo? Perché come forse saprai le scale con 10+ non sono palindromi

— Yassin Hajaj

@YassinHajaj Palindromizza l'array, non la stringa

— Okx

Va bene grazie per l'informazione

— Yassin Hajaj,

@YassinHajaj gLη€ûJsåè un altro, dove puoi vedere la vettorializzazione della palindromizzazione usando €ûpalindromize ciascuna.

— Magic Octopus Urn

@okx gLη€ûJsåper un 8 byte che non fa esplodere TIO.

— Magic Octopus Urn

1

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

Provalo online!

— Lynn
fonte

Salva quattro accettando un numero intero se potremmo avere un errore dopo aver premuto long: TIO . A quel punto avremmo bisogno di un po 'di tempo e memoria!

— Jonathan Allan,

1

Stax , 14 byte

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

Esegui ed esegui il debug

Molto lento per numeri più grandi.

— Multi
fonte

1

9 byte

— wastl

Leggero cambiamento per 7 byte

— ricorsivo

E uno veloce a 8 byte

— ricorsivo

1

Attache , 57 55 46 byte

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

Provalo online! Ah, è molto più elegante.

Con Generate(49 byte):

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

Spiegazione

{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 funzione di generazione crea semplicemente il Nnumero della scala. Quindi, questa ricerca termina una volta `>=:`#&_soddisfatta. Espanso, questo è:

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

Quindi, questo termina quando la lunghezza dell'uscita della funzione di generazione è almeno quella degli ingressi. Pertanto, questo genera il numero di scala più piccolo almeno finché il numero di input. Pertanto, se l'input è un numero di scala, il risultato sarà lo stesso numero di scala e in caso contrario il numero di scala più lungo successivo. Come tale, un semplice controllo con uguaglianza all'input originale è sufficiente per determinare se fosse o meno un numero di scala.

Attache, 55 byte

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

Provalo online! Con piano o ricorsione.

— Conor O'Brien
fonte

1

J , 40 byte

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

Provalo online!

Non sono abbastanza contento di questo soluiton - molto @e boxe <.

— Galen Ivanov
fonte

1

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

Provalo online!

Curiosamente, la sostituzione '1'nella seconda riga con 1causa il fallimento del programma nell'input di 1.

— Giuseppe
fonte

1

K , 36 byte

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

Accetta una stringa come "12321" come parametro.

Questa funzione è scritta come una lunga catena di applicazioni funzionali, come in f g h x, quindi leggi le versioni commentate dal basso, salendo. {x+1}è lambda x: x+1, x è un nome param predefinito. Dai un'occhiata a https://pastebin.com/cRwXJn7Z o l'aiuto dell'interprete per i significati dell'operatore.

Generiamo il numero della scala con nal centro per {,/$(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

L'intera funzione {|/($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]

— uryga
fonte

0

Haskell , 64 60 58 byte

^{-6 grazie a @BMO!}

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

Provalo online!

— Esolanging Fruit
fonte

Teoricamente funziona per 12345678910987654321, se sei in grado di costruire un elenco con così tanti elementi.

— Esolanging Fruit

@BMO sapevo che doveva esserci un modo per farlo. Grazie

— Esolanging Fruit il

@BMO Il tuo golf è davvero evidente col senno di poi ...

— Esolanging Fruit

È anche molto vicino, l'avrei suggerito come un miglioramento se non l'avessi già pubblicato (non ho visto il tuo fino a quando non ho pubblicato il mio).

— ბიმო

0

Perl 5 `-lp` , 49 byte

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

Provalo online!

0 = verità, qualsiasi altra cosa = falsa

— Xcali
fonte

0

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

Provalo online.

Spiegazione:

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

— Kevin Cruijssen
fonte

0

Japt, 11 byte

Accetta l'input come stringa.

Êõõ mê m¬øU

Provalo

Spiegazione

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

Questa soluzione, che può accettare input come una stringa o un numero intero, restituirà una matrice di numeri per verità o, alla fine, genererà un errore per falsa, se prima non paralizza il browser. Usare con cautela.

@¥Xê q}aõ

Provalo

— ispido
fonte

0

Retina , 45 43 byte

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

Provalo online! Il link include casi di test. Modifica: salvato 2 byte grazie a @Leo. Spiegazione:

$
;1

Inizializzazione na 1.

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

Mentre sinizia e termina con n:

$2;$.(_$1*

Elimina ndalle estremità di se incrementa n.

^(.+);\1$

Verifica se nè rimasto.

— Neil
fonte

Penso che i tuoi messaggi \dpossano diventare .e salvarti due byte

— Leone,

0

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

Provalo online!

Sono aperto a qualsiasi suggerimento per migliorare questo.

— Neil
fonte

-1

Grazie ai seguenti utenti:

@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

Provalo online!

L'uscita non deve essere le corde truee false, ma i valori truthy e Falsey. 1e 0funzionerebbe ad esempio

— dylnan il

@dylnan: l'ho appena letto, grazie. Ancora golf (molto da fare)

Non potresti semplicemente usare s[0]invece di startswith? Gli errori sono consentiti e si può dire "output 1 per stair, qualsiasi altra cosa (incluso niente) [poiché stderrr viene ignorato] per non-stair".

— NoOneIsHere

@NoOneIsHere: buona idea. apparentemente programmare durante il sonno non è una buona idea grazie

1

La tua soluzione a 138 byte restituisce sempre False, poiché gnon è mai 1. Dovresti probabilmente testare queste soluzioni prima di pubblicarle ...

— Jo King,

È questo un numero di scala?

Sfida:

Input:

Produzione :

Numero scala:

Nota :

Esempio :

Nota :

Restrizioni:

R , 97 byte

Gelatina , 5 byte

JavaScript (ES6), 62 57 byte

Come?

Haskell , 55 54 byte

Pyth, 13 12 byte

Spiegazione

Python 2 , 69 byte

C # (compilatore interattivo Visual C #) , 138 107 102 byte

05AB1E , 9 8 byte

Python 2 , 77 byte

Stax , 14 byte

Attache , 57 55 46 byte

Spiegazione

Attache, 55 byte

J , 40 byte

SNOBOL4 (CSNOBOL4) , 109 byte

K , 36 byte

Haskell , 64 60 58 byte

Perl 5 -lp , 49 byte

Java 10, 142 byte

Japt, 11 byte

Spiegazione

Alternativa, 10 9 byte

Retina , 45 43 byte

Regex (PCRE) , 92 byte

Python 2 , 147 byte

Perl 5 `-lp` , 49 byte