Tarea

El prepend, append-Sequence se define de forma recursiva, así

• a (1) = 1
• a (n) = a (n-1) .n, si n es par
• a (n) = na (n-1), si n es impar

donde el . representa una concatenación de enteros.

Entonces, los primeros términos son: 1,12,312,3124,53124,531246,7531246,...Este es A053064 .

Su tarea es, dado un número entero a> 0 para volver n , tal que el n -ésimo elemento en el prepend, append-secuencia es igual a una y si hay tal n existe retorno 0, un número negativo o error fuera, etc.

Reglas

• La entrada puede tomarse como un entero, una cadena, una lista de caracteres / dígitos, etc.
• La salida puede imprimirse en STDOUT o devolverse (entero, cadena, etc. está bien)
• En una entrada no válida y en el caso de que no exista tal n , su programa puede hacer otra cosa que devolver un número entero positivo (por ejemplo, bucle para siempre, devolver 0, etc.)
• Puede optar por utilizar la indexación 0, pero la salida en caso de que no exista n no puede ser 0

Casos de prueba

1 -> 1
12 -> 2
21 -> 0
123 -> 0
312 -> 3
213 -> 0
211917151311975312468101214161820 -> 21
2119171513119753102468101214161820 -> 0
333129272523211917151311975312468101214161820222426283031 -> 0
999795939189878583817977757371696765636159575553514947454341393735333129272523211917151311975312468101214161820222426283032343638404244464850525456586062646668707274767880828486889092949698100 -> 100

JavaScript (ES6), 40 bytes

Toma la entrada como una cadena. Lanza un error de recursión si no se encuentra ningún índice.

f=(n,s=k='1')=>n==s?k:f(n,++k&1?k+s:s+k)

Manifestación

f=(n,s=k='1')=>n==s?k:f(n,++k&1?k+s:s+k)

console.log(f('1')) // 1
console.log(f('12')) // 2
console.log(f('312')) // 3
console.log(f('211917151311975312468101214161820')) // 21
console.log(f('999795939189878583817977757371696765636159575553514947454341393735333129272523211917151311975312468101214161820222426283032343638404244464850525456586062646668707274767880828486889092949698100')) // 100

C # (.NET Core) , 83, 80, 60 59 bytes

n=>{int i=0;for(var t="";t!=n;)t=++i%2<1?t+i:i+t;return i;}

Pruébalo en línea!

Toma la entrada como una cadena en una función lambda. 1 indexado. Devuelve el índice del valor de verdad o bucles infinitos para una "falsey"

Python 2 , 63 bytes

-1 byte gracias a @EriktheOutgolfer .

f=lambda x,i='1',j=2:i!=`x`and f(x,[i+`j`,`j`+i][j%2],j+1)or~-j

Pruébalo en línea!

Python 2 , 64 bytes

-18 bytes gracias a @officialaimm , ¡porque no me di cuenta de que se permitía el error!

x,i,j=input(),'1',1
while i!=x:j+=1;i=[i+`j`,`j`+i][j%2]
print j

Pruébalo en línea!

Python 2 , 82 bytes (no se repite para siempre)

Este regresa 0por entradas inválidas.

def f(n,t="",i=1):
 while len(t)<len(n):t=[t+`i`,`i`+t][i%2];i+=1
 print(n==t)*~-i

Pruébalo en línea!

Jalea , 12 bytes

Rs2ZU1¦ẎVµ€i

Pruébalo en línea!

Explicación:

Rs2ZU1¦ẎVµ€i
         µ€  Eval this link for each (automatic [1..n] range)
R             Range
 s2           Split in pieces of: 2
   Z          Zip
    U1¦       Only keep index: 1 of: Vectorized reverse
       Ẏ      Flatten 1-deep
        V     Concatenate string versions and eval
           i Find index of y in x (y = implicit input)

05AB1E , 14 bytes

$vDNÌNFs}«})Ik

Pruébalo en línea! o como un conjunto de pruebas

Explicación

0 indexado .
Devuelve -1 si la entrada no está en la secuencia.

$                 # push 1 and input
 v                # for each y,N (element, index) in input do:
  D               # duplicate top of stack
   NÌ             # push N+2
     NF }         # N times do:
       s          # swap the top 2 elements on the stack
         «        # concatenate the top 2 elements on the stack
          })      # end loop and wrap in a list
            Ik    # get the index of the input in this list

R , 73 bytes

p=paste0;n=scan(,'');l='';while(l!=n){F=F+1;l="if"(F%%2,p(F,l),p(l,F))};F

Lee desde stdin y devuelve el valor del índice (impreso implícitamente). Bucles infinitos cuando el valor no está en la secuencia. Fes por defecto, FALSEque se convierte 0cuando se usa en aritmética.

Pruébalo en línea!

Mathematica, 135 bytes

s=t={};x=1;While[x<5!,{s~AppendTo~#&,s~PrependTo~#&}[[x~Mod~2+1]]@x;AppendTo[t,FromDigits@Flatten[IntegerDigits/@s]];x++];t~Position~#&

Jalea ,  19 18  15 bytes

+ḂḶṚm2;RḤ$ṁµ€Vi

Un enlace monádico que toma y devuelve enteros.

Pruébalo en línea! (Muy lento: tarda unos 50 segundos en TIO solo para confirmar que3124está en el índice4)

Para una versión mucho más rápida, use el byte anterior de 18 (solo verifica la longitud de la entrada, que es suficiente).

¿Cómo?

+ḂḶṚm2;RḤ$ṁµ€Vi - Link: number, v
           µ€   - perform the monadic link to the left for €ach k in [1,2,3,...v]
                -                 (v can be big, lots of k values makes it slow!)
 Ḃ              -   modulo k by 2  = 1 if odd 0 if even
+               -   add to k = k+isOdd(k)
  Ḷ             -   lowered range = [0,1,2,...,k+isOdd(k)]
   Ṛ            -   reverse = [k+isOdd(k),...,2,1,0])
    m2          -   modulo slice by 2 = [k+isOdd(k),k+isOdd(k)-2,...,3,1]
         $      - last two links as a monad:
       R        -   range(k) = [1,2,3,...,k]
        Ḥ       -   double = [2,4,6,...,2k]
     ;          - concatenate = [k+isOdd(k),k+isOdd(k)-2,...,3,1,2,4,6,...,2k]
         ṁ      - mould like range(k) = [k+isOdd(k),k+isOdd(k)-2,...,3,1,2,4,6,...,k-isOdd(k)]
                -   (this is a list of the integers to be concatenated for index k)
             V  - evaluate as Jelly code (yields a list of the concatenated integers)
              i - first index of v in that (or 0 if not found)

Swift 4 , 92 bytes

Esto se repite infinitamente para casos no válidos, por lo que no los incluí en el enlace de prueba.

func f(x:String){var i="1",j=1;while i != x{j+=1;i=[i+String(j),String(j)+i][j%2]};print(j)}

Banco de pruebas.

Divertidamente, es más largo con un cierre:

var f:(String)->Int={var i="1",j=1;while i != $0{j+=1;i=[i+String(j),String(j)+i][j%2]};return j}

Banco de pruebas.

Haskell , 115 85 bytes

s=read.(show=<<)
f 1=1
f x|odd x=s[x,f$x-1]
f x=s[f$x-1,x]
g x=[n|n<-[1..],x==f n]!!0

Pruébalo en línea!

Perl 5 , 54 + 1 (-n) = 55 bytes

$a=++$,%2?$,.$a:$a.$,while length$a<length;say/$a/&&$,

Pruébalo en línea!

No devuelve nada si no se encuentra.

Haskell, 75 71 57 bytes

f n=[i|i<-[1..],(show=<<reverse[1,3..i]++[2,4..i])==n]!!0

Toma ncomo una cuerda.

Pruébalo en línea!