Compito

Il prepend, append-Sequence è definito in modo ricorsivo, in questo modo

• a (1) = 1
• a (n) = a (n-1) .n, se n è pari
• a (n) = na (n-1), se n è dispari

dove la . rappresenta una concatenazione di numeri interi.

Quindi i primi termini sono: 1,12,312,3124,53124,531246,7531246,...questo è A053064 .

Il vostro compito è, dato un numero intero a> 0 per tornare n , tale che l' n -esimo elemento nella prepend, accodamento sequenza è uguale a una e se tale n esiste ritorno 0, un numero negativo o errore su etc.

Regole

• L'input può essere preso come numero intero, stringa, elenco di caratteri / cifre ecc.
• L'output può essere stampato su STDOUT o restituito (numero intero, stringa ecc. Va bene)
• In caso di input non valido e nel caso in cui non esista n , il programma può fare qualsiasi cosa tranne restituire un numero intero positivo (es. Loop per sempre, ritorno 0 ecc.)
• È possibile scegliere di utilizzare l'indicizzazione 0, ma l'output nel caso in cui non esista n non può essere 0

Casi test

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

JavaScript (ES6), 40 byte

Accetta l'input come stringa. Genera un errore di ricorsione se non viene trovato alcun indice.

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

dimostrazione

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 byte

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

Provalo online!

Prende l'input come stringa in una funzione lambda. 1-indicizzati. Restituisce l'indice del valore per verità, o esegue ripetutamente cicli per una "falsità"

Python 2 , 63 byte

-1 byte grazie a @EriktheOutgolfer .

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

Provalo online!

Python 2 , 64 byte

-18 byte grazie a @officialaimm , perché non ho notato errori consentiti!

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

Provalo online!

Python 2 , 82 byte (non esegue il ciclo per sempre)

Questo restituisce 0input non validi.

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

Provalo online!

Gelatina , 12 byte

Rs2ZU1¦ẎVµ€i

Provalo online!

Spiegazione:

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 byte

$vDNÌNFs}«})Ik

Provalo online! o come una suite di test

Spiegazione

0 indicizzato .
Restituisce -1 se l'ingresso non è nella sequenza.

$                 # 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 byte

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

Legge da stdin e restituisce il valore dell'indice (implicitamente stampato). Cicli infiniti quando il valore non è nella sequenza. Fè di default FALSEche viene lanciato 0quando usato in aritmetica.

Provalo online!

Mathematica, 135 byte

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~#&

Gelatina ,  19 18  15 byte

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

Un collegamento monadico che prende e restituisce numeri interi.

Provalo online!(molto lento - impiega circa 50 secondi su TIO solo per confermare che 3124è all'indice 4)

Per una versione molto più veloce usa il 18 byte precedente (controlla solo fino alla lunghezza dell'input, che è sufficiente).

Come?

+ḂḶṚ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 byte

Questo si ripete all'infinito per casi non validi, quindi non li ho inclusi nel link di test.

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

Test Suite.

In modo divertente, è più lungo con una chiusura:

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}

Test Suite.

Haskell , 115 85 byte

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

Provalo online!

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

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

Provalo online!

Non restituisce nulla se non trovato.

Haskell, 75 71 57 byte

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

Prende ncome una stringa.

Provalo online!