Este é um número de escada?

15

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.

code-golf  math  number  decision-problem 
— Muhammad Salman
fonte
2
Podemos considerar a entrada como uma lista de dígitos? Gosta [1,2,3,4,5,6,7,8,9,1,0,1,1,1,0,9,8,7,6,5,4,3,2,1]de 123456789101110987654321?
— Mr. Xcoder
@ Mr.Xcoder: Eu preferiria se você não fez, mas eu acho que você pode
— Muhammad Salman
Existe um limite superior na entrada?
— mypetlion
@mypetlion: Não realmente, é tão alto quanto o seu código pode suportar Normalmente, o maior seu idioma pode suportar (mas não neste caso) (excluindo os de baixa hardcoded e propositadamente.)
— Muhammad Salman
Podemos usar uma sequência de caracteres como entrada para uma função? (ou é esta entrada apenas aceitável para um programa completo?)
— Jonathan Allan

Respostas:

5

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)

— Giuseppe
fonte
Não substituindo function(n)com n=scan();ser mais curto? (para números inteiros, é claro)
— pajonk
@ pajonk Suponho que sim. Mas eu vou dizer que estou usando isso como uma string, então esta resposta está correta para entradas maiores.
— Giuseppe
3

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
— Arnauld
fonte
55 bytes . Suponha 0 como truthy e nulo como Falsas (ele não exatamente especificar o fez)
Hum, eu não vi esse palpite inválido. Desculpe
@ I'mnoone Não se preocupe! Curiosamente, a remoção m[0]==s&faria com que passasse em todos os casos de teste (mas ainda falharia em outros como "123217").
— Arnauld
f=(s,k=1)=>(m=s.match(`^${k}(.*)${k}$`))?f(m[1],k+1):s==k?
— L4m2
2

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.

você pode usar em /vez de concluir }Qautomaticamente Qno final
— RK.
2

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?
— Kahzaar
fonte
Na verdade, o Zip...Skipmétodo no meu comentário anterior falha [1,1], o que deve retornar truese eu entender as especificações. Eu o apaguei.
— benj2240
Obrigado mesmo assim! Eu nunca usei o Zip antes, mas agora vejo como ele pode ser útil.
— Kahzaar 01/05/19
1

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!

— Okx
fonte
Palindromizar? O que isso faz? Porque, como você pode saber as escadas com 10+ há palíndromos
— Yassin Hajaj
@YassinHajaj Palindromises a matriz, não a cadeia de caracteres
— Okx
Tudo bem, obrigado pela informação
— Yassin Hajaj
O @YassinHajaj gLη€ûJsåé outro, onde você pode ver a vetorização da palindromização usando €ûcada palindromização.
— Magic Octopus Urn
@okx gLη€ûJsåpor um byte de 8 bytes que não explode o TIO.
— Magic Octopus Urn
1

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!

— Lynn
fonte
Salve quatro aceitando um número inteiro, se pudermos errar uma vez que atingimos longs: TIO . De qualquer maneira, precisaríamos de bastante tempo e memória!
— Jonathan Allan
1

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.

— Conor O'Brien
fonte
1

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.

— Giuseppe
fonte
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]
— uryga
fonte
0

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!

— Esolanging Fruit
fonte
Teoricamente 12345678910987654321, se você for capaz de construir uma lista com tantos elementos.
— Esolanging Fruit
@ BMO eu sabia que tinha que haver uma maneira de fazer isso. Obrigado
— Esolanging Fruit
@BMO seu golf é realmente óbvio em retrospectiva ...
— Esolanging Fruit
Também é muito próximo, eu sugeriria isso como uma melhoria se ainda não o publicasse (não vi o seu até publicar o meu).
— ბიმო
0

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
— Kevin Cruijssen
fonte
0

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

— Shaggy
fonte
0

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.

— Neil
fonte
Acho que seus \ds podem tornar-se .e poupar dois bytes
— Leo
-1

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!

A saída não precisa ser as strings truee falsesim os valores de verdade e falsey. 1e 0iria funcionar por exemplo
— dylnan 30/0418
@ dylnan: Acabei de ler isso, obrigado. Ainda golfe (muito a percorrer)
Você não poderia simplesmente usar em s[0]vez de startswith? Erros são permitidos e você pode dizer 'saídas 1 para escada, qualquer outra coisa (incluindo nada) [desde que stderrr é ignorado] para não escada'.
— NoOneIsHere
@NoOneIsHere: boa ideia. aparentemente codificação durante o sono não é tal uma boa idéia graças
1
Sua solução de 138 bytes sempre retorna False, já que gnão é 1. Você provavelmente deve testar estas soluções antes de publicá-las ...
— Jo Rei
Ao utilizar nosso site, você reconhece que leu e compreendeu nossa Política de Cookies e nossa Política de Privacidade.
Licensed under cc by-sa 3.0 with attribution required.